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