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; }