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 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 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();
}
/// <summary>
/// Initializes the channel with the given socket, using
/// the given encoding for messages.
/// </summary>
public StringChannel(ReactiveClient socket, Encoding encoding)
{
this.socket = socket;
this.encoding = encoding;
Receiver = from data in socket.Receiver
let body = socket.Receiver.TakeWhile(b => b != (byte)'\n')
select Encoding.UTF8.GetString(body.ToEnumerable().ToArray());
}
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_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();
}
}
/// <summary>
/// Creates SyncServerClient client object.
/// </summary>
public SyncServerClient()
{
_client = new ReactiveClient("api.syncano.com", 8200, stream =>
{
_ssl = new SslStream(stream);
_ssl.AuthenticateAsClient("api.syncano.com");
return(_ssl);
});
_newBytesSubscription = _client.Receiver.SubscribeOn(TaskPoolScheduler.Default).Subscribe(AddNewByte);
_messagesSubscription = _messagesObservable.SubscribeOn(TaskPoolScheduler.Default).Subscribe(OnNewMessage);
_every10seconds = Observable.Interval(TimeSpan.FromSeconds(10)).SubscribeOn(TaskPoolScheduler.Default).Subscribe(_ => OnEvery10Seconds());
}
public void when_disposing_then_complete_observables()
{
var socket = new ReactiveClient("127.0.0.1", 1055);
bool receiverCompleted = false;
bool senderCompleted = false;
socket.Receiver.Subscribe(x => { }, () => receiverCompleted = true);
socket.Sender.Subscribe(x => { }, () => senderCompleted = true);
socket.Dispose();
Assert.True(receiverCompleted);
Assert.True(senderCompleted);
}
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);
}
}
private static void SubscribeJson <T>(IObserver <T> observer,
string url,
IDictionary <string, string> parameters,
IProgress <Tuple <long, long> > progress = null)
{
var subscriptionKey = Guid.NewGuid();
var observable = ReactiveClient.Get <T>(url, parameters, progress);
var disposal = observable.Finally(() => CleanupSubscription(subscriptionKey)).Subscribe(observer);
lock (SyncRoot)
{
CurrentSubscriptions.Add(subscriptionKey, disposal);
}
}
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();
}
/// <summary>
/// Initializes the channel with the given socket, using
/// the default UTF8 encoding for messages.
/// </summary>
public StringChannel(ReactiveClient socket)
: this(socket, Encoding.UTF8)
{
}
static void Main(string[] args)
{
var client = new ReactiveClient();
Console.ReadKey();
}
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); };
});
}
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_disconnecting_disconnected_then_throws()
{
var client = new ReactiveClient("127.0.0.1", 1055);
Assert.Throws<InvalidOperationException>(() => client.Disconnect());
}
public void when_client_created_then_it_is_disconnected()
{
var client = new ReactiveClient("127.0.0.1", 1055);
Assert.False(client.IsConnected);
}
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();
}
