public static IExplicitBytesClient CreateClient(Binding binding, Guid uuid, string address)
{
var bindingInfo = EndpointMapper.WcfToRpc(address);
bindingInfo.EndPoint = CanonizeEndpoint(bindingInfo);
var client = new ExplicitBytesClient(uuid, bindingInfo);
//NOTE: applying any authentication on local IPC greatly slows down start up of many simulatanious service
bool skipAuthentication = binding.Authentication == RPC_C_AUTHN.RPC_C_AUTHN_NONE && bindingInfo.Protseq == RpcProtseq.ncalrpc;
if (skipAuthentication)
{
client.AuthenticateAsNone();
}
else
{
client.AuthenticateAs(null, binding.Authentication == RPC_C_AUTHN.RPC_C_AUTHN_NONE
? ExplicitBytesClient.Anonymous
: ExplicitBytesClient.Self,
binding.Authentication == RPC_C_AUTHN.RPC_C_AUTHN_NONE
? RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_NONE
: RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
binding.Authentication);
}
return client;
}
public ServiceEndpoint(Binding binding, Type contractType, string address, Guid uuid)
{
_binding = binding;
_serializer = _binding.Serializer;
_contractType = contractType;
_address = address;
_uuid = uuid;
}
public static IExplicitBytesServer CreateHost(Binding binding, string address, Guid uuid)
{
var host = new ExplicitBytesServer(uuid);
var endpointBinding = EndpointMapper.WcfToRpc(address);
string endPoint = CanonizeEndpoint(endpointBinding);
host.AddProtocol(binding.ProtocolTransport, endPoint, binding.MaxConnections);
host.AddAuthentication(binding.Authentication);
return host;
}
public ServiceEndpoint AddServiceEndpoint(Type contractType, Guid uuid, Binding binding, string address)
{
var uri = new Uri(address, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
address = _baseAddress + address;
}
var endpoint = base.CreateEndpoint(contractType, binding, address, uuid);
_endpointDispatchers.Add( new RpcEndpointDispatcher(_service,endpoint, false, _serviceCtx.SynchronizationContext));
return endpoint;
}
public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, string address)
{
var uri = new Uri(address, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
address = _baseAddress + address;
}
var uuid = EndpointMapper.CreateUuid(address, contractType);
bool expectDuplexInitialization = false;
var service = AttributesReader.GetServiceContract(contractType);
if (service.CallbackContract != null)
{
expectDuplexInitialization = true;
}
RpcTrace.TraceEvent(TraceEventType.Start, "Start adding service endpoint for {0} at {1}",contractType,address);
var endpoint = base.CreateEndpoint(contractType, binding, address, uuid);
_endpointDispatchers.Add(new RpcEndpointDispatcher(_service, endpoint, expectDuplexInitialization));
return endpoint;
}
private void Open(Type typeOfService, string serverAddress, Binding binding, string session,
SynchronizationContext syncContext)
{
this.SynchronizationContext = syncContext;
_typeOfService = typeOfService;
_serverAddress = serverAddress;
_binding = binding;
_session = session;
var contract = AttributesReader.GetServiceContract(_typeOfService);
Debug.Assert(contract.CallbackContract != null);
//BUG: should be used only for non polling HTTM, all others should go via provided single channel
var address = _serverAddress + _session.Replace("-", "");
_callbackServer = new CallbackServiceHost(this, address, _behaviour);
_callbackServer.AddServiceEndpoint(contract.CallbackContract, new Guid(_session), _binding, address);
_callbackServer.Open();
}
//TODO: implement polling duplex
//TODO: implement single channell duplex
//context.CreateClientStub(_typeOfService);
// Tasks.Factory.StartNew((x) =>
// {
// while (!_disposed)
// {
// var request = new MessageRequest {Callback = true};
// var stream = new MemoryStream();
// _serializer.WriteObject(stream, request);
// var result = _client.Execute(stream.ToArray());
// var response = (MessageResponse)_serializer.ReadObject(new MemoryStream(result),
// typeof (MessageResponse));
// context.Invoke(response);
// }
// });
internal void Initialize(Type typeOfService, string serverAddress, Binding binding, string session, SynchronizationContext syncContext)
{
if (!_started)
{
Open(typeOfService, serverAddress, binding, session, syncContext);
}
_started = true;
}
protected ServiceEndpoint CreateEndpoint(Type contractType, Binding binding, string address, Guid uuid)
{
var uri = new Uri(address, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
address = _baseAddress + address;
}
var endpoint = new ServiceEndpoint(binding, contractType, address, uuid);
return endpoint;
}
