source: branches/3.3-Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.Contracts/3.3/WcfSettings.cs @ 4423

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion
//#define USE_MSG_BINDING
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel.Channels;
using System.ServiceModel;
using System.Security.Cryptography.X509Certificates;
using System.Net;
using System.ServiceModel.Description;
using HeuristicLab.Tracing;

namespace HeuristicLab.Hive.Contracts {
  public static class WcfSettings {
    public const string SlaveServiceName = "SlaveService";
    public const string ServerConsoleServiceName = "ServerConsoleService";
    public const string ClientServiceName = "ClientService";
    public const string ClientStreamedServiceName = "ClientServiceStreamed";

    public const int DefaultPort = 9000;
    
    /// <summary>
    /// Gets a pre-defined binding using TCP for secure transport.
    /// </summary>
    /// <returns>A binding type of <see cref="NetTcpBinding"/></returns>
    public static Binding GetBinding() {
#if USE_MSG_BINDING
      NetTcpBinding binding = new NetTcpBinding(SecurityMode.Message);
#else
      NetTcpBinding binding = new NetTcpBinding();
#endif
      binding.MaxBufferSize = int.MaxValue;
      binding.MaxReceivedMessageSize = int.MaxValue;
      binding.ReaderQuotas.MaxArrayLength = int.MaxValue;
      binding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
      binding.CloseTimeout = new TimeSpan(0, 5, 0);
      binding.ReceiveTimeout = new TimeSpan(0, 5, 0);
      binding.SendTimeout = new TimeSpan(0, 5, 0);
      return binding;
    }

    public static Binding GetStreamedBinding() {
#if USE_MSG_BINDING
      NetTcpBinding binding = new NetTcpBinding(SecurityMode.Message);
#else
      NetTcpBinding binding = new NetTcpBinding();
#endif
      binding.TransferMode = TransferMode.Streamed;
      binding.MaxReceivedMessageSize = int.MaxValue;
      binding.ReaderQuotas.MaxArrayLength = int.MaxValue;
      binding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
      binding.CloseTimeout = new TimeSpan(0, 5, 0);
      binding.ReceiveTimeout = new TimeSpan(0, 5, 0);
      binding.SendTimeout = new TimeSpan(0, 5, 0);
      //Disabling security mode, for the moment
      binding.Security.Mode = SecurityMode.None;
      
      return binding;
    }

//    /// <summary>
//    /// Defines the used certificate for authentification located in a certification store.
//    /// </summary>
//    /// <param name="svchost">A service for which this certificate is applicable.</param>
//    public static void SetServiceCertificate(ServiceHost svchost) {
//#if USE_MSG_BINDING
//      svchost.Credentials.ServiceCertificate.SetCertificate(
//        StoreLocation.LocalMachine,
//        StoreName.My,
//        X509FindType.FindBySubjectName,
//        SERVERCERT);
//#endif
//    }

    /// <summary>
    /// Gets the currently active IP address.
    /// <remarks>If more than one IP connections is active, the first one will be used.</remarks>
    /// </summary>
    /// <returns></returns>
    public static IPAddress GetActiveIP() {
      return System.Net.NetworkInformation.IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections()[0].LocalEndPoint.Address;
    }

    /// <summary>
    /// Gets the default port used for HIVE services.
    /// </summary>
    /// <returns></returns>
    public static int GetDefaultPort() {
      return DefaultPort;
    }
    
    /// <summary>
    /// This method changes the endpoint-address while preserving the identity-certificate defined in the config file
    /// </summary>
    public static void SetEndpointAddress(ServiceEndpoint endpoint, string hostAddress) {
      EndpointAddressBuilder builder = new EndpointAddressBuilder(endpoint.Address);
      UriBuilder uriBuilder = new UriBuilder(builder.Uri);
      uriBuilder.Host = hostAddress;
      builder.Uri = uriBuilder.Uri;
      endpoint.Address = builder.ToEndpointAddress();
    }

    /// <summary>
    /// Securely disposes a WCF client proxy object
    /// </summary>
    /// <param name="obj"></param>
    public static void DisposeWcfClient(ICommunicationObject obj) {
      if (obj != null) {
        if (obj.State != CommunicationState.Faulted &&
            obj.State != CommunicationState.Closed) {
          try { obj.Close(); }
          catch (CommunicationObjectFaultedException) { obj.Abort(); }
          catch (TimeoutException) { obj.Abort(); }
          catch (Exception e) {
            obj.Abort();
            Logger.Error(e);
          }
        } else
          obj.Abort();
      }
    }

  }

  /// <summary>
  /// This class verifies the certificate defined by <see cref="SetServerCertificate"></see> method. Normally,
  /// the verification process is managed by the underlying operating system.
  /// </summary>
  /// <remarks>
  /// WARNUNG: Dieser Code wird nur für Testzertifikate benötigt, wie sie beispielsweise von makecert erstellt werden.
  /// Sie sollten diesen Code nicht in einer Produktionsumgebung verwenden.
  /// </remarks>
  /*
  public class PermissiveCertificatePolicy {
    string subjectName;
    static PermissiveCertificatePolicy currentPolicy;
    PermissiveCertificatePolicy(string subjectName) {
      this.subjectName = subjectName;
      ServicePointManager.ServerCertificateValidationCallback +=
          new System.Net.Security.RemoteCertificateValidationCallback(RemoteCertValidate);
    }

    public static void Enact(string subjectName) {
      currentPolicy = new PermissiveCertificatePolicy(subjectName);
    }

    bool RemoteCertValidate(object sender, X509Certificate cert, X509Chain chain, System.Net.Security.SslPolicyErrors error) {
      if (cert.Subject == subjectName) {
        return true;
      }
      return false;
    }
  }             */
}