private static void Main(string[] args) { Thread.Sleep(10000); var containerBuilder = new ContainerBuilder(); var builder = new ServiceHostClientBuilder(containerBuilder).UseRpcForTransfer(); using (var host = builder.Build()) { ITransportClient client = host.Container.Resolve <ITransportClientFactory>() .CreateClient(new ServerAddress("127.0.0.1", 8008)); //ITransportClient client = container.Resolve<ITransportClientFactory>() // .DecorationFactory(container.Resolve<ISerializer>()) // .CreateClient(new ServerAddress("127.0.0.1", 8007)); RemoteCallData sendMessage = new RemoteCallData { ServiceId = "base/fastdfs", Parameters = new Dictionary <string, object> { { "message", 12 }, { "myout", 122 } } }; RemoteCallBackData result = client.SendAsync(sendMessage).Result; Console.Write(result.Result.ToString()); Console.ReadLine(); } }
public TransportMongo(string tempDir, string url) { if (!FileSystemHelper.SafeDeleteDirectory(tempDir)) { Debug.WriteLine("failed delete temp dir"); } var pcktsDir = Path.Combine(tempDir, "pckts"); var tempPcktsDir = Path.Combine(tempDir, "tmp_pckts"); this._packetManager = new PacketManager(new PacketManagerSettings(pcktsDir, tempPcktsDir)); var transportSettings = new TransportSettings() { PacketSizeLimits = new SendMessageSizeLimits { Min = 0, Max = 1 * 1024 * 1024, //Max = 100, } }; var agentInfoService = new TransportAgentInfoService(new RealComputerIdentityProvider()); this.TransportClient = new TransportClient(agentInfoService, _packetManager); var cnfsDir = Path.Combine(tempDir, "conf"); var tempcnfsDir = Path.Combine(tempDir, "conf_pckts"); var confStore = new ConfigurationStore(cnfsDir, tempcnfsDir); confStore.Subscribe(new TestOnConfigUpdate()); this.SenderWorker = new TransportSenderWorker(_packetManager, agentInfoService, confStore, url, transportSettings, new SendStateStore()); CancellationTokenSource cs = new CancellationTokenSource(); }
/// <summary> /// Odoberie instanciu ktora obsluhovala prijateho / akceptovaneho klienta ktory ukoncil spojenie /// </summary> /// <param name="contract">Contract obsluhujuci akceptovaneho klienta</param> private void InternalRemoveSpecifiedContract(ITransportClient contract) { //overime instaniu if (contract == null) { return; } lock (this) { //zalofujeme this.InternalTrace(TraceTypes.Info, "Pocet klientov: pred odobratim dalsieho {0}", this.m_contracts.Count); //odoberieme contract this.m_contracts.Remove(contract); //create event about remove client this.OnTransportClientRemoved(new TransportClientEventArgs(contract)); //zalogujeme this.InternalTrace(TraceTypes.Info, "Pocet klientov: po odobrati dalsieho {0}", this.m_contracts.Count); } //ukoncime inicializovany contract if (contract != null) { contract.Dispose(); contract = null; } }
/// <summary> /// Ukonci vsetky contracty pred ukoncim celeho servera /// </summary> protected virtual void InternalStopAllContract() { //ukoncime beziace contracty lock (this) { for (int i = this.m_contracts.Count - 1; i > -1; i--) { try { //ziskame pristup ITransportClient contract = this.m_contracts[i]; //ukoncime contract this.InternalStopContract(contract); //remove contract this.InternalRemoveContract(contract); } catch (Exception ex) { //chybu ignorujeme } } } }
public static VaspClient Create( VaspInformation vaspInfo, VaspContractInfo vaspContractInfo, string handshakePrivateKeyHex, string signaturePrivateKeyHex, IEthereumRpc nodeClientEthereumRpc, IWhisperRpc nodeClientWhisperRpc, IEnsProvider ensProvider, ISignService signService, ITransportClient transportClient) { var handshakeKey = ECDH_Key.ImportKey(handshakePrivateKeyHex); var vaspClient = new VaspClient( handshakeKey, signaturePrivateKeyHex, vaspContractInfo, vaspInfo, nodeClientEthereumRpc, nodeClientWhisperRpc, ensProvider, transportClient, signService); return(vaspClient); }
protected override void Load(ContainerBuilder builder) { _fakeEnsProvider = new FakeEnsProvider(); _signService = new WhisperSignService(); _whisperRpc = new WhisperRpc(new Web3(_appSettings.WhisperRpcUri), new WhisperMessageFormatter()); _ethereumRpc = new EthereumRpc(new Web3(_appSettings.EthereumRpcUri)); _transportClient = new TransportClient(_whisperRpc, _signService, new WhisperMessageFormatter()); var vaspInformationBuilder = new VaspInformationBuilder(_ethereumRpc); var(vaspInfo, vaspContractInfo) = vaspInformationBuilder.Create( _appSettings.VaspSmartContractAddress); var originator = VaspClient.Create( vaspInfo, vaspContractInfo, _appSettings.HandshakePrivateKeyHex, _appSettings.SignaturePrivateKeyHex, _ethereumRpc, _whisperRpc, _fakeEnsProvider, _signService, _transportClient); builder.RegisterInstance(vaspInfo); builder.RegisterInstance(vaspContractInfo); builder.RegisterInstance(originator); builder.RegisterType <TransactionsManager>() .SingleInstance() .AsSelf() .AutoActivate(); base.Load(builder); }
public HandlerMessages(ITransportClient transportClient, IHandlerResponseFromServer handlerResponseFromServer, IClientInfo clientInfo) { _transportClient = transportClient; _clientInfo = clientInfo; handlerResponseFromServer.MessageReceived += OnMessageReceived; handlerResponseFromServer.ConnectedToChat += OnConnectedToChat; }
public TransportBootstrap Init(string tempDir) { if (!FileSystemHelper.SafeDeleteDirectory(tempDir)) { Debug.WriteLine("failed delete temp dir"); } var pcktsDir = Path.Combine(tempDir, "pckts"); var tempPcktsDir = Path.Combine(tempDir, "tmp_pckts"); var packetManager = new PacketManager(new PacketManagerSettings(pcktsDir, tempPcktsDir)); var transportSettings = new TransportSettings() { PacketSizeLimits = new SendMessageSizeLimits { Min = 0, Max = TransportConstants.DefaultMaxClientPacketSize, } }; string url = "http://localhost:5002/dhu/transport/exchange"; this.transportClient = new TransportClient(packetManager, transportSettings); var agentInfoService = new TransportAgentInfoService(new RealComputerIdentityProvider()); var cnfsDir = Path.Combine(tempDir, "conf"); var tempcnfsDir = Path.Combine(tempDir, "conf_pckts"); var confStore = new ConfigurationStore(cnfsDir, tempcnfsDir); confStore.Subscribe(new TestOnConfigUpdate()); this.senderWorker = new TransportSenderWorker(packetManager, agentInfoService, confStore, url, transportSettings, new SendStateStore()); return(this); }
private void InstantiateTransportClient() { _client = new WebsocketTransportClient(webSocket: _websocket, connectionId: TestContext.CurrentContext.Test.Name); // test systems are slow, so give twice the normal amount of time _client.ConnectionOpenTimeout = new TimeSpan(_client.ConnectionOpenTimeout.Ticks * 2); }
public ElasticsearchClientSettings( NodePool nodePool, ITransportClient connection, SourceSerializerFactory sourceSerializer, IPropertyMappingProvider propertyMappingProvider) : base(nodePool, connection, sourceSerializer, propertyMappingProvider) { }
private void PublishButton_Click(object sender, RoutedEventArgs e) { string value = textBox.Text; if (_transportClient == null) { _transportClient = new CrossProcessTransportClient(); } if (comboBox.SelectedIndex == 0) { //var ribbon = _eventAggregator.GetEvent<RibbonClickTransportEvent>(); //ribbon.Publish(value); _transportClient.Publish("NoSubscriber", value); } if (comboBox.SelectedIndex == 1) { //var ribbon = _eventAggregator.GetEvent<ShortcutTransportEvent>(); //ribbon.Publish(value); _transportClient.Publish("Event1", value); } if (comboBox.SelectedIndex == 2) { //var ribbon = _eventAggregator.GetEvent<ContextChangedTransportEvent>(); //ribbon.Publish(value); _transportClient.Publish("Event2", value); } }
public VaspSessionService() { _fakeEnsProvider = new FakeEnsProvider(); _signService = new WhisperSignService(); _whisperRpc = new WhisperRpc(new Web3(_whisperRpcUrl), new WhisperMessageFormatter()); _ethereumRpc = new EthereumRpc(new Web3(_ethereumRpcUrl)); _transportClient = new TransportClient(_whisperRpc, _signService, new WhisperMessageFormatter()); }
public void RegisterListeningClient(ITransportClient transportClient) { if (_listeningClientsSet.Contains(transportClient)) { return; } _listeningClientsSet.Add(transportClient); }
public static async Task <CacheClientProxy> GetClientAsync(ITransportClient transport) { var rpcClient = new RPCClient(transport); var proxy = await rpcClient.CreateProxyAsync <CacheClientProxy>().ConfigureAwait(false); Core.Status.AttachChild(rpcClient, proxy); return(proxy); }
/// <summary> /// Prepis a rozsirenie prijatia / akceptovania klienta /// </summary> /// <param name="e">TcpClientEventArgs</param> protected override void OnTcpClientReceived(TcpClientEventArgs e) { //base volanie na vytvorenie eventu base.OnTcpClientReceived(e); //overime ci je mozne pridat dalsieho klienta if (this.InternalCheckContracts()) { try { //pridame instaniu servera ITransportClient contract = this.InternalCreateContract(e.Client); //validate contract if (contract != null && contract.IsConnected) { //namapujeme event oznamujuci odhlasenie klienta contract.DisconnectedEvent += new EventHandler(contract_DisconnectedEvent); //pridame contract this.InternalCreateContract(contract); //create event about new client this.OnTransportClientAdded(new TransportClientEventArgs(contract)); } else { //ukoncime inicializovany contract if (contract != null) { contract.Dispose(); contract = null; } } } catch (Exception ex) { //chybu ignorujeme this.InternalTrace(TraceTypes.Error, "Interna chyba pri udalostiach spojenych z pridavanim pripojeneho klienta. {0}", ex.Message); } } else { try { //zalogujeme this.InternalTrace(TraceTypes.Verbose, "Ukoncovanie akceptovaneho klienta..."); //ziskame pristup TcpClient client = e.Client; client.Close(); } catch (Exception) { //ignorujeme } } }
public ApplicationClient(ApiTypes apiType, byte sessionId, ISessionClient sc, IFrameClient fc, ITransportClient tc) { ApiType = apiType; SessionId = sessionId; SessionClient = sc; FrameClient = fc; TransportClient = tc; BindLayers(); }
/// <summary> /// Initialize this class /// </summary> /// <param name="client">Client</param> public TransportClientEventArgs(ITransportClient client) { if (client == null) { throw new ArgumentNullException("client"); } this.Client = client; }
private void Unsubscribe_Click(object sender, RoutedEventArgs e) { if (_transportClient == null) { _transportClient = new CrossProcessTransportClient(); } // var theEvent = _eventAggregator.GetEvent<TransportEvent<string>>(); //theEvent.Unsubscribe(OnEvent); _transportClient.Unsubsribe(OnEvent); }
private void Subsribe_Click(object sender, RoutedEventArgs e) { if (_transportClient == null) { _transportClient = new CrossProcessTransportClient(); } //var theEvent = _eventAggregator.GetEvent<ShortcutTransportEvent>(); //theEvent.Subscribe(OnEvent); _transportClient.Subscribe("Event2", OnEvent); }
private void Unsubscribe_Click(object sender, RoutedEventArgs e) { //var theEvent = _eventAggregator.GetEvent<ContextChangedTransportEvent>(); //theEvent.Unsubscribe(OnEvent); if (_transportClient == null) { _transportClient = new CrossProcessTransportClient(); } _transportClient.Unsubsribe(OnEvent); }
public override void SetUp() { base.SetUp(); _websocket = null; _connection = null; _client = null; _fayeServerProcess = new ThinServerProcess(thinPort: THIN_SERVER_PORT, workingDirectory: WorkingDirectory); _socatInterceptor = null; }
public FayeClient(IWebSocket socket, string connectionId = "standard") : base(messageCounter: FIRST_MESSAGE_INDEX) { _connectionId = connectionId; _transportClient = new WebsocketTransportClient(socket, connectionId); _advice = DefaultAdvice; _transportConnection = null; _logger = LoggerFetcher.GetLogger(connectionId, this); }
public void RegisterClient(string key, ITransportClient client) { if (!_clients.Contains(key)) { _clients.Add(key, client); } else { _clients[key] = client; } }
public void JoinBackground(ITransportClient client) { double avgBytesPerSec = 0; var lastTime = DateTime.MinValue; var buffer = new byte[0]; Envelope envelope; long envelopeSize; unsafe { envelopeSize = sizeof(Envelope); } this.storeReader.Seek(this.interval); while (true) { if (this.storeReader.MoveNext(out envelope)) { var length = this.storeReader.Read(ref buffer); this.exporter.Throttle.Reset(); try { client.WriteMessage(envelope, buffer); if (lastTime > DateTime.MinValue /* at least second message */) { if (this.maxBytesPerSecond < long.MaxValue) { // throttle to arbitrary max BPS var elapsed = (envelope.OriginatingTime - lastTime).TotalSeconds; var bytesPerSec = (envelopeSize + length) / elapsed; double smoothingFactor = 1.0 / (this.bytesPerSecondSmoothingWindowSeconds / elapsed); avgBytesPerSec = (bytesPerSec * smoothingFactor) + (avgBytesPerSec * (1.0 - smoothingFactor)); if (bytesPerSec > this.maxBytesPerSecond) { var wait = (int)(((avgBytesPerSec / this.maxBytesPerSecond) - elapsed) * 1000.0); if (wait > 0) { Thread.Sleep(wait); } } } } lastTime = envelope.OriginatingTime; } finally { // writers continue upon failure - meanwhile, remote client may reconnect and resume based on replay interval this.exporter.Throttle.Set(); } } } }
public HandlerConnection(IClientInfo clientInfo, ITransportClient transportClient, IHandlerResponseFromServer handlerResponseFromServer) { _clientInfo = clientInfo; _transportClient = transportClient; handlerResponseFromServer.ClientConnected += OnClientConnected; handlerResponseFromServer.AnotherClientConnected += OnAnotherClientConnected; handlerResponseFromServer.AnotherClientDisconnected += OnAnotherClientDisconnected; handlerResponseFromServer.ReceivedInfoAboutAllClients += OnReceivedInfoAboutAllClients; InfoClientsAtChat = new Dictionary <string, bool>(); }
public HandlerChats(ITransportClient transportClient, IHandlerConnection handlerConnection, IHandlerResponseFromServer handlerResponseFromServer, IClientInfo clientInfo) { _handlerConnection = handlerConnection; _clientInfo = clientInfo; _transportClient = transportClient; handlerResponseFromServer.AddedChat += OnAddedChat; handlerResponseFromServer.AddedClientsToChat += OnAddedClientsToChat; handlerResponseFromServer.RemovedClientsFromChat += OnRemovedClientsFromChat; handlerResponseFromServer.ResponseNumbersChats += OnResponseNumbersChats; handlerResponseFromServer.ReceivedInfoAboutAllClients += OnReceivedInfoAboutAllClients; handlerResponseFromServer.RemovedChat += OnRemovedChat; }
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var host = parameters["Host"]; if (host == null || host == Factory.SkipInstanceValue) { Core.Log.Warning("Skipping transport instance by Host value."); return(null); } var strPort = parameters["Port"]; if (strPort == null || strPort == Factory.SkipInstanceValue) { Core.Log.Warning("Skipping transport instance by Port value."); return(null); } var port = strPort.ParseTo(0); var timeout = parameters["Timeout"].ParseTo(20000); var serializerMimeType = parameters["SerializerMimeType"]; var socketsPerClient = parameters["SocketsPerClient"].ParseTo <byte>(1); var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } var lclient = new DefaultTransportClient(host, port, socketsPerClient, serializer) { InvokeMethodTimeout = timeout }; ITransportClient client = lclient; Core.Log.LibDebug("Creating a new DefaultTransportClient with parameters:"); Core.Log.LibDebug("\tHost: {0}", host); Core.Log.LibDebug("\tPort: {0}", port); Core.Log.LibDebug("\tSocketsPerClient: {0}", socketsPerClient); if (serializerMimeType == null) { return(client); } Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } return(client); }
public async Task <object> AddNodeAsync(ITransportClient transport, params object[] args) { Core.Log.LibVerbose("Adding Node and initializing"); var client = new RPCClient(transport); var node = await client.CreateProxyAsync <NodeProxy>().ConfigureAwait(false); var response = await node.InitAsync(args).ConfigureAwait(false); Items.Add(new NodeClient(node)); Core.Log.LibVerbose("Node was initializated and added to the collection."); return(response); }
/// <summary> /// Ukonci contract pred ukoncenim celeho servera /// </summary> /// <param name="contract">Contract ktory chceme ukoncit</param> protected virtual void InternalStopContract(ITransportClient contract) { //ukoncime klienta if (!contract.IsDisposed) { if (contract.IsRun) { //odoberieme event oznamujuci odhlasenie klienta contract.DisconnectedEvent -= new EventHandler(contract_DisconnectedEvent); contract.Stop(); } } }
internal ClientOptions( string applicationId, UniqueId applicationInstanceId, ITransportClient transport, IProtocolImplementation protocol, IMarshallerProvider marshaller, IEnumerable <ProvidedServiceDefinition> services) { ApplicationId = applicationId; ApplicationInstanceId = applicationInstanceId; Transport = transport; Marshaller = marshaller; Protocol = protocol; Services = new List <ProvidedServiceDefinition>(services); ServicesDictionary = Services.ToDictionary(x => (x.Id, x.Alias), x => x); }
/// <summary> /// Odoberie contract klienta ktory sa odpojil. Prepis metody by mal zabezpecit volanie base.InternalRemoveContract(ITransportClient contrat); /// </summary> /// <param name="contrat">Contract ktory vykonaval obsluhu klienta ktory zrusil spojenie</param> protected virtual void InternalRemoveContract(ITransportClient contrat) { //odstranime klienta this.InternalRemoveSpecifiedContract(contrat); }
/// <summary> /// Prida instanciu ktora obsluhuje prijateho / akceptovaneho klienta /// </summary> /// <param name="contract">Contract obsluhujuci akceptovaneho klienta</param> private void InternalCreateContract(ITransportClient contract) { //overime instaniu if (contract == null || contract.IsRun == false || contract.IsDisposed) return; lock (this) { //pridame dalsi contract do kolekcia this.m_contracts.Add(contract); #if DEBUG ConsoleLogger.WriteLine("Pocet klientov: po prijati dalsieho {0}", this.m_contracts.Count); #endif } }
/// <summary> /// Odoberie instanciu ktora obsluhovala prijateho / akceptovaneho klienta ktory ukoncil spojenie /// </summary> /// <param name="contract">Contract obsluhujuci akceptovaneho klienta</param> private void InternalRemoveSpecifiedContract(ITransportClient contract) { //overime instaniu if (contract == null) return; lock (this) { //zalofujeme this.InternalTrace(TraceTypes.Info, "Pocet klientov: pred odobratim dalsieho {0}", this.m_contracts.Count); //odoberieme contract this.m_contracts.Remove(contract); //zalogujeme this.InternalTrace(TraceTypes.Info, "Pocet klientov: po odobrati dalsieho {0}", this.m_contracts.Count); } //ukoncime inicializovany contract if (contract != null) { contract.Dispose(); contract = null; } }
/// <summary> /// Ukonci contract pred ukoncenim celeho servera /// </summary> /// <param name="contract">Contract ktory chceme ukoncit</param> protected virtual void InternalStopContract(ITransportClient contract) { //ukoncime klienta if (!contract.IsDisposed) if (contract.IsRun) { //odoberieme event oznamujuci odhlasenie klienta contract.DisconnectedEvent -= new EventHandler(contract_DisconnectedEvent); contract.Stop(); } }
public UdpTransport(ITransportClient transportClient) { _transportClient = transportClient; }