public void when_reconnecting_then_raises_connected() { // Server has to be on another process for the reconnect // behavior to succeed in tests. var server = Process.Start(@".\..\..\..\Sample\ReactiveServer\bin\Debug\ReactiveServer.exe"); try { var client = new ReactiveClient("127.0.0.1", 1055); client.ConnectAsync().Wait(); Assert.True(client.IsConnected); client.Disconnect(); var connected = false; client.Connected += (sender, args) => connected = true; client.ConnectAsync().Wait(); Assert.True(connected); Assert.False(client.IsConnected); } finally { server.Kill(); } }
public void Connect() { // Connect _client = new ReactiveClient(_address, _rconPort); // Setup IObservable message recievr var messages = from header in _client.Receiver.Buffer(4) // read packet length let length = BitConverter.ToInt32(header.ToArray(), 0) // calc. packet length let body = _client.Receiver.Take(length).ToEnumerable().ToArray() // read body select header.ToArray().Concat(body).ToArray(); // return original packet // Setup events for on new TCP message messages.SubscribeOn(TaskPoolScheduler.Default).Subscribe(message => OnClientMessage(message)); // Connection event & connect _client.Connected += Client_Connected; _client.ConnectAsync(); _outputFunction($"Connecting to {_address}:{_rconPort}..."); Timer timer = null; timer = new Timer((obj) => { CheckForConnection(); timer.Dispose(); }, null, 5000, Timeout.Infinite); }
public void Connect(string ipaddress, string spreadsheetName) { _spreadsheetName = spreadsheetName; var client = new ReactiveClient(ipaddress, 2112); Protocol = new StringChannel(client); Protocol.Receiver.Subscribe(ReceiveMessage); client.Disconnected += ClientOnDisconnected; client.Connected += ClientOnConnected; //Lock this object so that client cannot send a message while receiving one. lock (this) { try { client.ConnectAsync().Wait(); } catch { MessageBox.Show("Could not connect to server! Check that the server is running and that you typed the ip correctly.", "Disconnect", MessageBoxButtons.OK, MessageBoxIcon.Information); ClientDisconnected?.Invoke(); } } }
public bool Start() { try { if (!IsActive) { #region WCF client var address = new EndpointAddress(new Uri("net.tcp://localhost:26760/ScpRootHubService")); var binding = new NetTcpBinding { TransferMode = TransferMode.Streamed, Security = new NetTcpSecurity { Mode = SecurityMode.None } }; var factory = new ChannelFactory <IScpCommandService>(binding, address); _rootHub = factory.CreateChannel(address); #endregion #region Feed client var rootHubFeedChannel = new ScpNativeFeedChannel(_rxFeedClient); rootHubFeedChannel.Receiver.SubscribeOn(TaskPoolScheduler.Default).Subscribe(buffer => { if (buffer.Length <= 0) { return; } OnFeedPacketReceived(new ScpHidReport(buffer)); }); _rxFeedClient.ConnectAsync(); #endregion if (_rootHub != null) { _xmlMap.LoadXml(_rootHub.GetXml()); _xmlMapper.Initialize(_xmlMap); } else { Log.Error("Couldn't initialize XML mapper"); } IsActive = true; } } catch (Exception ex) { Log.ErrorFormat("Unexpected error: {0}", ex); } return(IsActive); }
public void when_connected_then_can_exchange_fixed_length_messages() { var serverReceives = new List <string>(); var clientReceives = new List <string>(); var server = new ReactiveListener(1055); server.Start(); Func <IObservable <byte>, IObservable <string> > parse = socket => from header in socket.Buffer(4) let length = BitConverter.ToInt32(header.ToArray(), 0) let body = socket.Take(length) select Encoding.UTF8.GetString(body.ToEnumerable().ToArray()); Func <string, byte[]> convert = s => { var body = Encoding.UTF8.GetBytes(s); var header = BitConverter.GetBytes(body.Length); var payload = header.Concat(body).ToArray(); return(payload); }; server.Connections.Subscribe(socket => { Console.WriteLine("Server socket created: {0}", socket.GetHashCode()); parse(socket.Receiver).Subscribe( x => serverReceives.Add(x.Trim()), e => Console.WriteLine("Server socket error: {0}", e.Message), () => Console.WriteLine("Server socket completed")); socket.SendAsync(convert("Welcome!")).Wait(); }); var client = new ReactiveClient("127.0.0.1", 1055); Console.WriteLine("Client socket created: {0}", client.GetHashCode()); client.ConnectAsync().Wait(); parse(client.Receiver).Subscribe( x => clientReceives.Add(x.Trim()), e => Console.WriteLine("Client socket error: {0}", e.Message), () => Console.WriteLine("Client socket completed")); client.SendAsync(convert("Hello")).Wait(); Thread.Sleep(100); Assert.Equal(1, serverReceives.Count); Assert.Equal(1, clientReceives.Count); Assert.Equal("Welcome!", clientReceives[0]); Assert.Equal("Hello", serverReceives[0]); server.Dispose(); }
public void when_connected_then_can_exchange_fixed_length_messages() { var serverReceives = new List<string>(); var clientReceives = new List<string>(); var server = new ReactiveListener(1055); server.Start(); Func<IObservable<byte>, IObservable<string>> parse = socket => from header in socket.Buffer(4) let length = BitConverter.ToInt32(header.ToArray(), 0) let body = socket.Take(length) select Encoding.UTF8.GetString(body.ToEnumerable().ToArray()); Func<string, byte[]> convert = s => { var body = Encoding.UTF8.GetBytes(s); var header = BitConverter.GetBytes(body.Length); var payload = header.Concat(body).ToArray(); return payload; }; server.Connections.Subscribe(socket => { Console.WriteLine("Server socket created: {0}", socket.GetHashCode()); parse(socket.Receiver).Subscribe( x => serverReceives.Add(x.Trim()), e => Console.WriteLine("Server socket error: {0}", e.Message), () => Console.WriteLine("Server socket completed")); socket.SendAsync(convert("Welcome!")).Wait(); }); var client = new ReactiveClient("127.0.0.1", 1055); Console.WriteLine("Client socket created: {0}", client.GetHashCode()); client.ConnectAsync().Wait(); parse(client.Receiver).Subscribe( x => clientReceives.Add(x.Trim()), e => Console.WriteLine("Client socket error: {0}", e.Message), () => Console.WriteLine("Client socket completed")); client.SendAsync(convert("Hello")).Wait(); Thread.Sleep(100); Assert.Equal(1, serverReceives.Count); Assert.Equal(1, clientReceives.Count); Assert.Equal("Welcome!", clientReceives[0]); Assert.Equal("Hello", serverReceives[0]); server.Dispose(); }
public bool Start() { try { if (!IsActive) { #region WCF client var address = new EndpointAddress(new Uri("net.tcp://localhost:26760/ScpRootHubService")); var binding = new NetTcpBinding { TransferMode = TransferMode.Streamed, Security = new NetTcpSecurity { Mode = SecurityMode.None } }; var factory = new ChannelFactory <IScpCommandService>(binding, address); _rootHub = factory.CreateChannel(address); #endregion #region Feed client var rootHubFeedChannel = new ScpNativeFeedChannel(_rxFeedClient); rootHubFeedChannel.Receiver.SubscribeOn(TaskPoolScheduler.Default).Subscribe(buffer => { if (buffer.Length <= 0) { return; } ScpHidReport report; using (var ms = new MemoryStream(buffer)) { BinaryFormatter formatter = new BinaryFormatter(); report = (ScpHidReport)formatter.Deserialize(ms); } OnFeedPacketReceived(report); }); _rxFeedClient.ConnectAsync(); #endregion IsActive = true; } } catch (Exception ex) { Log.ErrorFormat("Unexpected error: {0}", ex); } return(IsActive); }
public void when_calling_dispose_after_disconnect_then_work() { using (var server = new ReactiveListener(1055)) { var client = new ReactiveClient("127.0.0.1", 1055); server.Start(); client.ConnectAsync().Wait(); client.Disconnect(); client.Dispose(); } }
public void when_connecting_then_raises_connected() { using (var server = new ReactiveListener(1055)) { var client = new ReactiveClient("127.0.0.1", 1055); var connected = false; client.Connected += (sender, args) => connected = true; server.Start(); client.ConnectAsync().Wait(); Assert.True(client.IsConnected); Assert.True(connected); } }
public void Connect() { // Connect Client = new ReactiveClient(IP, RconPort); // Setup IObservable message recievr IObservable<byte[]> messages = from header in Client.Receiver.Buffer(4) // read packet length let length = BitConverter.ToInt32(header.ToArray(), 0) // calc. packet length let body = Client.Receiver.Take(length).ToEnumerable().ToArray() // read body select header.ToArray().Concat(body).ToArray(); // return original packet // Setup events for on new TCP message messages.SubscribeOn(TaskPoolScheduler.Default).Subscribe(message => OnClientMessage(message)); // Connection event & connect Client.Connected += Client_Connected; Client.ConnectAsync(); }
static void Main(string[] args) { var client = new ReactiveClient("localhost", 41337); var protocol = new ProtobufChannel <Person>(client); protocol.Receiver.SubscribeOn(TaskPoolScheduler.Default).Subscribe(person => { if (person != null) { Console.WriteLine("Person {0} {1} received", person.FirstName, person.LastName); } }); client.ConnectAsync().Wait(); var p1 = new Person() { FirstName = "Fritz", LastName = "Phantom" }; var p2 = new Person() { FirstName = "Tom", LastName = "Turbo" }; protocol.SendAsync(p1); protocol.SendAsync(p2); var m1 = new Manager() { FirstName = "U.N.", LastName = "Owen", Salary = 10000 }; protocol.SendAsync(m1); Console.ReadLine(); }
public static void Start(string ip = "", Action <string> logger = null) { bool isTimeout = false; bool isSuccess = false; Task.Run(async delegate { await Task.Delay(10000); isTimeout = true; if (!isSuccess) { connectionHandler?.Invoke(false); } }); Task.Run(delegate { if (string.IsNullOrEmpty(ip)) { UdpClient udpClient = new UdpClient { EnableBroadcast = true }; string HostName = Dns.GetHostName(); IPAddress[] ipaddress = Dns.GetHostAddresses(HostName); foreach (IPAddress ip4 in ipaddress.Where(ipv4 => ipv4.AddressFamily == AddressFamily.InterNetwork)) { Console.WriteLine(ip4.ToString()); var data = Encoding.UTF8.GetBytes("PING"); logger?.Invoke("Pinging broadcast: " + ip4.ToString().Substring(0, ip4.ToString().LastIndexOf('.')) + ".255"); udpClient.Send(data, data.Length, ip4.ToString().Substring(0, ip4.ToString().LastIndexOf('.')) + ".255", PortPinger); } var from = new IPEndPoint(0, 0); while (true) { var recvBuffer = udpClient.Receive(ref from); string msg = Encoding.UTF8.GetString(recvBuffer); Console.WriteLine(msg); if (msg.Equals("PONG")) { logger?.Invoke("Scanner Found"); break; } } if (isTimeout) { return; } client = new ReactiveClient(from.Address.ToString(), PortServer); } else { client = new ReactiveClient(ip, PortServer); } List <byte> buffer = new List <byte>(); client.Receiver.Subscribe(sdata => { buffer.Add(sdata); if (buffer.Count > 7) { if (buffer[buffer.Count - 8] == 69 && buffer[buffer.Count - 7] == 78 && buffer[buffer.Count - 6] == 68 && buffer[buffer.Count - 5] == 79 && buffer[buffer.Count - 4] == 70 && buffer[buffer.Count - 3] == 77 && buffer[buffer.Count - 2] == 83 && buffer[buffer.Count - 1] == 71) { Recieved(buffer.GetRange(0, buffer.Count - 8).ToArray()); buffer.Clear(); } } }); client.ConnectAsync(); client.Connected += delegate { Send("PING"); isSuccess = true; logger?.Invoke("Scanner Connected"); }; client.Disconnected += delegate { connectionHandler?.Invoke(false); }; }); }
/// <summary> /// Connects SyncServerClient to Syncano SyncServer. /// </summary> /// <returns>Task performing connection operation.</returns> public Task Connect() { return(_client.ConnectAsync()); }
public void when_client_reconnects_then_can_exchange_fixed_length_messages() { var serverReceives = new List<string>(); var clientReceives = new List<string>(); var messageLength = 32; var server = new ReactiveListener(1055); server.Start(); Func<IObservable<byte>, IObservable<string>> parse = socket => from message in socket.Buffer(messageLength) select Encoding.UTF8.GetString(message.ToArray()); Func<string, byte[]> convert = s => { return Encoding.UTF8.GetBytes(new string(' ', messageLength - s.Length) + s); }; server.Connections.Subscribe(socket => { Console.WriteLine("Server socket created: {0}", socket.GetHashCode()); parse(socket.Receiver).Subscribe( x => serverReceives.Add(x.Trim()), e => Console.WriteLine("Server socket error: {0}", e.Message), () => Console.WriteLine("Server socket completed")); socket.SendAsync(convert("Welcome!")).Wait(); }); var client = new ReactiveClient("127.0.0.1", 1055); Console.WriteLine("Client socket created: {0}", client.GetHashCode()); client.ConnectAsync().Wait(); parse(client.Receiver).Subscribe( x => clientReceives.Add(x.Trim()), e => Console.WriteLine("Client socket error: {0}", e.Message), () => Console.WriteLine("Client socket completed")); client.SendAsync(convert("Hello")).Wait(); Thread.Sleep(1200); // Give it time to detect the disconnection from the server. while (client.IsConnected) client.SendAsync(new byte[1]); Assert.Throws<InvalidOperationException>(() => client.SendAsync(convert("World")).Wait()); client.Disconnect(); client.Dispose(); var tcp = new TcpClient("127.0.0.1", 1055); var bytes = convert("World"); tcp.GetStream().Write(bytes, 0, bytes.Length); //client = new TcpClientSocket("127.0.0.1", 1055); //// Reconnect ansd send one more string. //client.ConnectAsync().Wait(); //client.SendAsync(convert("World")).Wait(); Thread.Sleep(1200); //while (serverReceives.Count < 2) // Thread.Sleep(100); // Fails :( Assert.Equal("World", serverReceives.Last()); client.Dispose(); server.Dispose(); }
public void when_client_reconnects_then_can_exchange_fixed_length_messages() { var serverReceives = new List <string>(); var clientReceives = new List <string>(); var messageLength = 32; var server = new ReactiveListener(1055); server.Start(); Func <IObservable <byte>, IObservable <string> > parse = socket => from message in socket.Buffer(messageLength) select Encoding.UTF8.GetString(message.ToArray()); Func <string, byte[]> convert = s => { return(Encoding.UTF8.GetBytes(new string(' ', messageLength - s.Length) + s)); }; server.Connections.Subscribe(socket => { Console.WriteLine("Server socket created: {0}", socket.GetHashCode()); parse(socket.Receiver).Subscribe( x => serverReceives.Add(x.Trim()), e => Console.WriteLine("Server socket error: {0}", e.Message), () => Console.WriteLine("Server socket completed")); socket.SendAsync(convert("Welcome!")).Wait(); }); var client = new ReactiveClient("127.0.0.1", 1055); Console.WriteLine("Client socket created: {0}", client.GetHashCode()); client.ConnectAsync().Wait(); parse(client.Receiver).Subscribe( x => clientReceives.Add(x.Trim()), e => Console.WriteLine("Client socket error: {0}", e.Message), () => Console.WriteLine("Client socket completed")); client.SendAsync(convert("Hello")).Wait(); Thread.Sleep(1200); // Give it time to detect the disconnection from the server. while (client.IsConnected) { client.SendAsync(new byte[1]); } Assert.Throws <InvalidOperationException>(() => client.SendAsync(convert("World")).Wait()); client.Disconnect(); client.Dispose(); var tcp = new TcpClient("127.0.0.1", 1055); var bytes = convert("World"); tcp.GetStream().Write(bytes, 0, bytes.Length); //client = new TcpClientSocket("127.0.0.1", 1055); //// Reconnect ansd send one more string. //client.ConnectAsync().Wait(); //client.SendAsync(convert("World")).Wait(); Thread.Sleep(1200); //while (serverReceives.Count < 2) // Thread.Sleep(100); // Fails :( Assert.Equal("World", serverReceives.Last()); client.Dispose(); server.Dispose(); }