public void DisposeError()
{
var listener = new TcpRosListener(0);
listener.AcceptAsync().Subscribe(
x => Console.WriteLine("new socket = {0}", x.RemoteEndPoint),
ex => Console.WriteLine("accept error = {0}", ex.Message));
int port = listener.EndPoint.Port;
listener.Dispose();
Console.WriteLine("Press Any Key 3");
Console.ReadKey();
var client3 = new TcpRosClient();
try
{
client3.ConnectAsync("localhost", port).Wait();
}
catch (AggregateException ex)
{
Console.WriteLine("agg={0}", ex.Message);
}
}
internal void AddListener(string topic, TcpRosListener listener)
{
if (_tcpRosListener.ContainsKey(topic))
{
throw new InvalidOperationException("Already registered listener.");
}
_tcpRosListener.Add(topic, listener);
}
/// <summary>
/// Create a ROS Topic Publisher
/// </summary>
/// <typeparam name="TMessage"> Topic Message Type </typeparam>
/// <param name="topicName"> Topic Name </param>
/// <param name="latching"> true: send the latest published message when subscribed topic </param>
/// <returns> Publisher </returns>
public Task <Publisher <TMessage> > PublisherAsync <TMessage>(string topicName, bool latching = false)
where TMessage : IMessage, new()
{
if (_disposed)
{
throw new ObjectDisposedException("Node");
}
if (_topicContainer.HasPublisher(topicName))
{
throw new InvalidOperationException(topicName + " is already created.");
}
_logger.InfoFormat("Create Publisher: {0}", topicName);
var publisher = new Publisher <TMessage>(topicName, NodeId, latching);
_topicContainer.AddPublisher(publisher);
publisher.Disposing += DisposePublisherAsync;
var tcpRosListener = new TcpRosListener(0);
_slaveServer.AddListener(topicName, tcpRosListener);
var acceptDisposable = tcpRosListener.AcceptAsync()
.Do(_ => _logger.Debug("Accepted for Publisher"))
.Subscribe(socket => publisher.AddTopic(socket),
ex => _logger.Error("Accept Error", ex));
_publisherDisposables.Add(topicName, acceptDisposable);
var tcs = new TaskCompletionSource <Publisher <TMessage> >();
_logger.Debug("RegisterPublisher");
_masterClient
.RegisterPublisherAsync(NodeId, topicName, publisher.MessageType, _slaveServer.SlaveUri)
.ContinueWith(task =>
{
_logger.Debug("Registered Publisher");
if (task.Status == TaskStatus.RanToCompletion)
{
publisher.UpdateSubscribers(task.Result);
tcs.SetResult(publisher);
}
else if (task.Status == TaskStatus.Faulted)
{
_logger.Error("RegisterPublisher: Failure", task.Exception.InnerException);
tcs.SetException(task.Exception.InnerException);
}
});
return(tcs.Task);
}
public void Initialize()
{
Ros.MasterUri = new Uri("http://localhost:11311/");
Ros.HostName = "localhost";
var topicContainer = new TopicContainer();
topicContainer.AddPublisher(new Publisher<std_msgs.String>("/test_topic", "test"));
var tcpListener = new TcpRosListener(0);
_slaveServer = new SlaveServer("test", 0, topicContainer);
_slaveServer.AddListener("/test_topic", tcpListener);
}
public void Initialize()
{
Ros.MasterUri = new Uri("http://localhost:11311/");
Ros.HostName = "localhost";
var topicContainer = new TopicContainer();
topicContainer.AddPublisher(new Publisher <std_msgs.String>("/test_topic", "test"));
var tcpListener = new TcpRosListener(0);
_slaveServer = new SlaveServer("test", 0, topicContainer);
_slaveServer.AddListener("/test_topic", tcpListener);
}
public void StartService(string serviceName, IService service)
{
ServiceName = serviceName;
_listener = new TcpRosListener(0);
_disposable = _listener.AcceptAsync()
.Subscribe(
socket => CreateNewServiceInstance(service, socket),
ex =>
{
_logger.Error("ServiceServer: Accept Error", ex);
Dispose();
}, Dispose);
}
public void Initialize()
{
Ros.MasterUri = new Uri("http://localhost:11311/");
Ros.HostName = "localhost";
Ros.TopicTimeout = 3000;
Ros.XmlRpcTimeout = 3000;
_container = new TopicContainer();
var listener = new TcpRosListener(0);
_slaveServer = new SlaveServer("test", 0, _container);
_slaveServer.AddListener("test", listener);
_slaveClient = new SlaveClient(_slaveServer.SlaveUri);
}
public void Initialize()
{
Ros.MasterUri = new Uri("http://localhost:11311/");
Ros.HostName = "localhost";
Ros.TopicTimeout = 3000;
Ros.XmlRpcTimeout = 3000;
_container = new TopicContainer();
var listener = new TcpRosListener(0);
_slaveServer = new SlaveServer("test", 0, _container);
_slaveServer.AddListener("test", listener);
_slaveClient = new SlaveClient(_slaveServer.SlaveUri);
}
public void AcceptAsync_Success()
{
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var scheduler = new TestScheduler();
MAsyncSocketExtensions.AcceptAsObservableSocketEndPoint =
(t1, t2) => scheduler.CreateHotObservable(OnNext(10, sock));
var observer = scheduler.CreateObserver <Socket>();
var client = new TcpRosListener(0);
var result = client.AcceptAsync().Subscribe(observer);
scheduler.AdvanceTo(10);
observer.Messages.Is(OnNext(10, sock));
}
public void AcceptAsync_Success()
{
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var scheduler = new TestScheduler();
MAsyncSocketExtensions.AcceptAsObservableSocketEndPoint =
(t1, t2) => scheduler.CreateHotObservable(OnNext(10, sock));
var observer = scheduler.CreateObserver<Socket>();
var client = new TcpRosListener(0);
var result = client.AcceptAsync().Subscribe(observer);
scheduler.AdvanceTo(10);
observer.Messages.Is(OnNext(10, sock));
}
public void MultipleConnection()
{
var listener = new TcpRosListener(0);
listener.AcceptAsync().Subscribe(
x => Console.WriteLine("new socket = {0}", x.RemoteEndPoint),
ex => Console.WriteLine("accept error = {0}", ex.Message));
int port = listener.EndPoint.Port;
var client1 = new TcpRosClient();
client1.ConnectAsync("localhost", port)
.ContinueWith(t => Console.WriteLine("task.ex={0}", t.Exception));
var client2 = new TcpRosClient();
client2.ConnectAsync("localhost", port)
.ContinueWith(t => Console.WriteLine("task.ex={0}", t.Exception));
var client3 = new TcpRosClient();
client3.ConnectAsync("localhost", port)
.ContinueWith(t => Console.WriteLine("task.ex={0}", t.Exception));
}
public void SendAndReceive()
{
var listener = new TcpRosListener(0);
listener.AcceptAsync()
.Do(_ => Console.WriteLine("Connected"))
.Subscribe(s => new TcpRosClient(s).ReceiveAsync()
.Subscribe(data => Console.WriteLine("Received:{0}", data)));
int port = listener.EndPoint.Port;
Console.WriteLine("Press Any Key 3");
Console.ReadKey();
var client3 = new TcpRosClient();
client3.ConnectAsync("localhost", port).Wait();
var sendData = new byte[] { 1, 0, 0, 0, 1 };
client3.SendAsync(sendData).Wait();
}
public void Receive_Error()
{
var listener = new TcpRosListener(0);
listener.AcceptAsync()
.Do(_ => Console.WriteLine("Connected"))
.Subscribe(s =>
{
new TcpRosClient(s).ReceiveAsync()
.Subscribe(data => Console.WriteLine("Received:{0}", data),
ex => Console.WriteLine("Received Error: {0}", ex.Message));
Thread.Sleep(TimeSpan.FromSeconds(3));
s.Close(); //3秒待って閉じる。
},
ex => Console.WriteLine("Receive Error = {0}", ex.Message));
int port = listener.EndPoint.Port;
var client3 = new TcpRosClient();
client3.ConnectAsync("localhost", port).Wait();
var sendData = new byte[] { 1, 0, 0, 0, 1 };
client3.SendAsync(sendData).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
try
{
client3.SendAsync(sendData).Wait();
}
catch (Exception ex)
{
Console.WriteLine("Send Error:{0}", ex.Message);
}
}
internal void AddListener(string topic, TcpRosListener listener)
{
if(_tcpRosListener.ContainsKey(topic))
{
throw new InvalidOperationException("Already registered listener.");
}
_tcpRosListener.Add(topic, listener);
}
