/// <summary>
/// Prints the host information.
/// </summary>
/// <param name="host">The host.</param>
public static void PrintHostInfo(this ServiceHostBase host)
{
var T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
var serviceAssembly = Assembly.GetExecutingAssembly();
logger.Debug("");
logger.Debug("************************************************************************************************");
logger.Debug("\t{0}", ConfigurationHelper.ServiceCommonName);
logger.Debug("\tVersion {0}", serviceAssembly.GetName().Version);
logger.Debug("");
logger.Debug("\tAnnouncing to cloud @ {0}", ConfigurationHelper.CloudAnnounce);
logger.Debug("\tProbing the cloud @ {0}", ConfigurationHelper.DiscoEndpoint);
logger.Debug("");
logger.Debug("\tService Help Page : {0}", ConfigurationHelper.ServiceHelpPage);
logger.Debug("\tRegister Domain Objects : {0}", ConfigurationHelper.HasRegisterDomainObjects);
logger.Debug("\tMEX Enabled : {0}", ConfigurationHelper.EnableMex);
logger.Debug("\tSecure MEX Enabled : {0}", ConfigurationHelper.SecureMex);
logger.Debug("\tSession Validation : {0}", ConfigurationHelper.IsSessionValidationActive);
logger.Debug("\tAnnouncement Delay : {0}", ConfigurationHelper.AnnounceDelay);
logger.Debug("\tRegister Metadata : {0}", ConfigurationHelper.RegisterServiceMetadata);
logger.Debug("\tRestful : {0}", ConfigurationHelper.IsRestful);
if (BigD.Configuration.ConfigurationHelper.CouchDbDatabase != null)
{
logger.Debug("");
logger.Debug("\tDatabase Info:");
logger.Debug("\t\tProtocol : {0}", BigD.Configuration.ConfigurationHelper.CouchDbProtocol);
logger.Debug("\t\tHost : {0}", BigD.Configuration.ConfigurationHelper.CouchDbHost);
logger.Debug("\t\tPort : {0}", BigD.Configuration.ConfigurationHelper.CouchDbPort);
logger.Debug("\t\tDatabase : {0}", BigD.Configuration.ConfigurationHelper.CouchDbDatabase);
logger.Debug("\t\tUser : {0}", BigD.Configuration.ConfigurationHelper.CouchDbUser);
}
logger.Debug("");
logger.Debug("************************************************************************************************");
}
/// <summary>
/// Registers the service metadatas.
/// </summary>
/// <param name="host"></param>
/// <param name="lst">The LST.</param>
private static void RegisterServiceMetadatas(this ServiceHostBase host, IEnumerable <CloudContract> lst)
{
var T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
if (!ConfigurationHelper.RegisterServiceMetadata)
{
return;
}
logger.Debug("Registering {0} Metadata...", ConfigurationHelper.ServiceCommonName);
foreach (var data in lst)
{
try
{
var res = DiscoPortal
.CloudContracts
.SaveCloudContract(data);
logger.Debug("=> Metadata registration succeeded for [{0}].", res.Id);
}
catch (Exception ex)
{
logger.Debug("Error Registering {0}.", data.Id);
logger.Debug(ex.GetCombinedMessages());
}
}
}
/// <summary>
/// Prints the termination.
/// </summary>
/// <param name="host">The host.</param>
public static void PrintTermination(this ServiceHostBase host)
{
var T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
logger.Debug("");
logger.Debug("************************************************************************************************");
logger.Debug(" {0} Terminated.", ConfigurationHelper.ServiceCommonName);
logger.Debug("************************************************************************************************");
logger.Debug("");
}
/// <summary>
/// Adds the mex endpoints.
/// </summary>
/// <param name="host">The service host.</param>
public static void AddMexEndpoints(this ServiceHostBase host)
{
Type T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
var mexBehavior = host.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (mexBehavior == null)
{
mexBehavior = new ServiceMetadataBehavior();
host.Description.Behaviors.Add(mexBehavior);
}
logger.Debug("Checking possible MEX endpoints...");
foreach (Uri baseAddress in host.BaseAddresses)
{
logger.Debug("\tAdding endpoint {0}", baseAddress.AbsoluteUri);
if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(),
"mex");
}
if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
if (ConfigurationHelper.SecureMex)
{
mexBehavior.HttpsGetEnabled = true;
mexBehavior.HttpsGetUrl = baseAddress;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(),
"mex");
}
}
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
if (!ConfigurationHelper.SecureMex)
{
mexBehavior.HttpGetEnabled = true;
mexBehavior.HttpGetUrl = baseAddress;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex");
}
}
if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(),
"mex");
}
}
}
private static void GenerateHealthEndpoint(ServiceHostBase serviceHostBase)
{
//HealthCheck için adres tanımını dinamik olarak yapıyoruz. Örnek: http://localhost:12348/ConfigurationService.svc/HealthCheck/
var address = serviceHostBase.BaseAddresses[0].AbsoluteUri + "/HealthCheck";
var serviceEndpoint = new ServiceEndpoint(new ContractDescription("IHealthCheckService", "http://tempuri.org/"));
ContractDescription contractDescription = null;
var implementedContracts = serviceHostBase
.GetType()
.GetProperty("ImplementedContracts", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
if (implementedContracts != null)
{
var contractDic = (Dictionary <string, ContractDescription>)implementedContracts.GetValue(serviceHostBase, null);
foreach (var contract in contractDic.Values)
{
if (contract.ConfigurationName == typeof(IHealthCheckableService).FullName)
{
contractDescription = contract;
break;
}
}
}
if (contractDescription == null) //IHealthCheckService implemente edilmemişse
{
return;
}
serviceEndpoint.Contract = contractDescription;
serviceEndpoint.Binding = new WebHttpBinding();
serviceEndpoint.EndpointBehaviors.Add(new WebHttpBehavior());
serviceEndpoint.Name = "HealthCheckEndPoint";
serviceEndpoint.Address = new EndpointAddress(address);
serviceHostBase.AddServiceEndpoint(serviceEndpoint);
}
/// <summary>
/// Prints the listening endpoints.
/// </summary>
/// <param name="host">The host.</param>
public static void PrintListeningEndpoints(this ServiceHostBase host)
{
var T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
var serviceAssembly = Assembly.GetExecutingAssembly().GetName();
var publisherName = serviceAssembly.Name;
// Iterate through the endpoints contained in the ServiceDescription
logger.Debug("Active Service Endpoints:");
var lst = new List <CloudContract>();
foreach (var se in host.Description.Endpoints)
{
logger.Debug("Endpoint:\n");
logger.Debug("\tAddress:\t{0}", se.Address);
logger.Debug("\tBinding:\t{0}", se.Binding);
logger.Debug("\tContract:\t{0}", se.Contract.Name);
foreach (var behavior in se.Behaviors)
{
logger.Debug("Behavior: {0}\n", behavior);
}
var newId = String.Format("{0}:{1}", se.Address, se.Contract.Name);
lst.Add(new CloudContract()
{
Id = newId,
ContractName = String.Format("{0}", se.Contract.Name),
Binding = String.Format("{0}", se.Binding),
Address = String.Format("{0}", se.Address),
Publisher = publisherName,
RegistrationTimeStamp = DateTime.UtcNow,
CommonName = ConfigurationHelper.ServiceCommonName,
AdditionalInfoUri = ConfigurationHelper.ServiceHelpPage
});
}
host.RegisterServiceMetadatas(lst);
logger.Debug("************************************************************************************************");
logger.Debug(" {0} Listening...", ConfigurationHelper.ServiceCommonName);
logger.Debug("************************************************************************************************");
}
protected override void InsertItem(int index, ChannelDispatcherBase item)
{
if (_service != null)
{
if (_service.State == CommunicationState.Closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(_service.GetType().ToString()));
}
_service.OnAddChannelDispatcher(item);
}
base.InsertItem(index, item);
}
private static void GenerateHealthEndpoint(ServiceHostBase serviceHost)
{
var implementedContracts = serviceHost
.GetType()
.GetProperty("ImplementedContracts", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
if (implementedContracts != null)
{
var contractDic = (Dictionary <string, ContractDescription>)implementedContracts.GetValue(serviceHost, null);
foreach (var contract in contractDic.Values)
{
if (serviceHost.Description.Endpoints.Any())
{
continue;
}
if (contract.ConfigurationName == typeof(IHealthCheckService).FullName)
{
var serviceEndpoint = new ServiceEndpoint(contract,
new WebHttpBinding(),
new EndpointAddress(serviceHost.BaseAddresses[0]));
serviceEndpoint.Behaviors.Add(new WebHttpBehavior());
serviceHost.AddServiceEndpoint(serviceEndpoint);
}
}
}
}
