//public XmlRpcValue stickaroundyouwench = null;
public PendingConnection(XmlRpcClient client, Subscription s, string uri, XmlRpcValue chk)
{
this.client = client;
this.chk = chk;
parent = s;
RemoteUri = uri;
}
public List<String> publisher_update_task( String api, String topic, List<string> pub_uris)
{
XmlRpcValue l = new XmlRpcValue();
l.Set(0, api);
l.Set(1, "");
//XmlRpcValue ll = new XmlRpcValue();
//l.Set(0, ll);
for(int i = 0; i < pub_uris.Count; i++)
{
XmlRpcValue ll = new XmlRpcValue(pub_uris[i]);
l.Set(i + 1, ll);
}
XmlRpcValue args = new XmlRpcValue();
args.Set(0, "master");
args.Set(1, topic);
args.Set(2, l);
XmlRpcValue result = new XmlRpcValue(new XmlRpcValue(), new XmlRpcValue(), new XmlRpcValue(new XmlRpcValue())),
payload = new XmlRpcValue();
Ros_CSharp.master.host = api.Replace("http://","").Replace("/","").Split(':')[0];
Ros_CSharp.master.port = int.Parse( api.Replace("http://", "").Replace("/", "").Split(':')[1]);
Ros_CSharp.master.execute("publisherUpdate", args, result, payload, false );
return new List<string>(new []{"http://ERIC:1337"});
}
public void service_update_task(String api, String service, String uri)
{
XmlRpcValue args = new XmlRpcValue();
args.Set(0, "master");
args.Set(1, service);
args.Set(2, uri);
XmlRpcValue result = new XmlRpcValue(new XmlRpcValue(), new XmlRpcValue(), new XmlRpcValue(new XmlRpcValue())),
payload = new XmlRpcValue();
Ros_CSharp.master.host = api.Replace("http://", "").Replace("/", "").Split(':')[0];
Ros_CSharp.master.port = int.Parse(api.Replace("http://", "").Replace("/", "").Split(':')[1]);
Ros_CSharp.master.execute("publisherUpdate", args, result, payload, false);
}
/// <summary>
/// Gets all currently published and subscribed topics and adds them to the topic list
/// </summary>
/// <param name="topics"> List to store topics</param>
/// <returns></returns>
public static bool getTopics(ref TopicInfo[] topics)
{
List<TopicInfo> topicss = new List<TopicInfo>();
XmlRpcValue args = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
args.Set(0, this_node.Name);
args.Set(1, "");
if (!execute("getPublishedTopics", args, result, payload, true))
return false;
topicss.Clear();
for (int i = 0; i < payload.Size; i++)
topicss.Add(new TopicInfo(payload[i][0].Get<string>(), payload[i][1].Get<string>()));
topics = topicss.ToArray();
return true;
}
public override bool check()
{
XmlRpcValue chk = new XmlRpcValue();
bool res = client.IsConnected;
if (res == false)
Console.WriteLine("DEAD MASTER DETECTED!");
else
{
res &= client.ExecuteCheckDone(chk);
}
if (client.ExecuteCheckDone(chk))
{
return true;
}
return false;
}
/// <summary>
/// Get a list of all published topics
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public void getPublishedTopics([In][Out] IntPtr parms, [In][Out] IntPtr result)
{
XmlRpcValue res = XmlRpcValue.Create(ref result), parm = XmlRpcValue.Create(ref parms);
List <List <String> > publishedtopics = handler.getPublishedTopics("", "");
res.Set(0, 1);
res.Set(1, "current system state");
XmlRpcValue listofvalues = new XmlRpcValue();
int index = 0;
foreach (List <String> l in publishedtopics)
{
XmlRpcValue value = new XmlRpcValue();
value.Set(0, l[0]); //Topic Name
value.Set(1, l[1]); // Topic type
listofvalues.Set(index, value);
index++;
}
res.Set(2, listofvalues);
}
internal SubscribeParamResponse(XmlRpcValue[]?a)
{
if (a is null ||
a.Length != 3 ||
!a[0].TryGetInteger(out int code) ||
!a[1].TryGetString(out string statusMessage))
{
MarkError();
return;
}
base.responseCode = code;
StatusMessage = statusMessage;
if (base.responseCode == StatusCode.Error)
{
return;
}
ParameterValue = a[2];
}
public static List <string> list()
{
List <string> ret = new List <string>();
XmlRpcValue parm = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
parm.Set(0, this_node.Name);
if (!master.execute("getParamNames", parm, result, payload, false))
{
return(ret);
}
if (result.Size != 3 || result[0].GetInt() != 1 || result[2].Type != XmlRpcValue.ValueType.TypeArray)
{
EDB.WriteLine("Expected a return code, a description, and a list!");
return(ret);
}
for (int i = 0; i < payload.Size; i++)
{
ret.Add(payload[i].GetString());
}
return(ret);
}
public void getInfo(XmlRpcValue info)
{
lock (publisher_links_mutex)
{
//EDB.WriteLine("SUB: getInfo with " + publisher_links.Count + " publinks in list");
foreach (PublisherLink c in publisher_links)
{
//EDB.WriteLine("PUB: adding a curr_info to info!");
XmlRpcValue curr_info = new XmlRpcValue();
curr_info.Set(0, (int)c.ConnectionID);
curr_info.Set(1, c.XmlRpc_Uri);
curr_info.Set(2, "i");
curr_info.Set(3, c.TransportType);
curr_info.Set(4, name);
//EDB.Write("PUB curr_info DUMP:\n\t");
//curr_info.Dump();
info.Set(info.Size, curr_info);
}
//EDB.WriteLine("SUB: outgoing info is of type: " + info.Type + " and has size: " + info.Size);
}
}
private bool UnregisterService(string service)
{
XmlRpcValue args = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
args.Set(0, ThisNode.Name);
args.Set(1, service);
args.Set(2, string.Format("rosrpc://{0}:{1}", Network.Host, connectionManager.TCPPort));
bool unregisterSuccess = false;
try
{
unregisterSuccess = Master.Execute("unregisterService", args, result, payload, false);
}
catch
{
// ignore exception during unregister
}
return(unregisterSuccess);
}
/// <summary>
/// Deletes a parameter from the parameter server.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static async Task <bool> Del(string key)
{
string mappedKey = Names.Resolve(key);
XmlRpcValue parm = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
parm.Set(0, ThisNode.Name);
parm.Set(1, mappedKey);
if (!await Master.ExecuteAsync("deleteParam", parm, result, payload, false).ConfigureAwait(false))
{
return(false);
}
lock (gate)
{
subscriptions.Remove(mappedKey);
cachedValues.Remove(mappedKey);
}
return(true);
}
public bool RequestTopic(string topic, XmlRpcValue protos, ref XmlRpcValue ret)
{
foreach (var proto in protos)
{
if (proto.Type != XmlRpcType.Array)
{
this.logger.LogError("requestTopic protocol list was not a list of lists");
return(false);
}
if (proto[0].Type != XmlRpcType.String)
{
this.logger.LogError("requestTopic received a protocol list in which a sublist did not start with a string");
return(false);
}
string proto_name = proto[0].GetString();
if (proto_name == "TCPROS")
{
var tcpRosParams = new XmlRpcValue("TCPROS", Network.Host, ConnectionManager.Instance.TCPPort);
ret.Set(0, 1);
ret.Set(1, "");
ret.Set(2, tcpRosParams);
return(true);
}
if (proto_name == "UDPROS")
{
this.logger.LogWarning("Ignoring topics with 'UDPROS' as protocol");
}
else
{
this.logger.LogWarning("An unsupported protocol was offered: [{0}]", proto_name);
}
}
this.logger.LogError("No supported protocol was provided");
return(false);
}
ReadOnlyCollection <TopicTuple> CreateTuple(XmlRpcValue root)
{
if (!root.TryGetArray(out XmlRpcValue[] objTuples))
{
MarkError();
return(Empty);
}
List <TopicTuple> result = new();
foreach (var objTuple in objTuples)
{
if (!objTuple.TryGetArray(out XmlRpcValue[] tuple) ||
tuple.Length != 2 ||
!tuple[0].TryGetString(out string topic) ||
!tuple[1].TryGetArray(out XmlRpcValue[] tmpMembers))
{
MarkError();
return(Empty);
}
string[] members = new string[tmpMembers.Length];
for (int i = 0; i < members.Length; i++)
{
if (!tmpMembers[i].TryGetString(out string member))
{
MarkError();
return(Empty);
}
members[i] = member;
}
result.Add(new TopicTuple(topic, members));
}
result.Sort();
return(result.AsReadOnly());
}
private void PublisherUpdateCallback(XmlRpcValue parm, XmlRpcValue result)
{
string topic = parm[1].GetString();
List <string> publicationUris = parm[2].Select(x => x.GetString()).ToList();
this.logger.LogDebug($"PublisherUpdateCallback for topic '{topic}' with URIs: {string.Join(", ", publicationUris)}");
var pubUpdateTask = PubUpdate(topic, publicationUris);
pubUpdateTask.WhenCompleted().WhenCompleted().Wait();
if (pubUpdateTask.HasCompletedSuccessfully() && pubUpdateTask.Result)
{
XmlRpcManager.ResponseInt(1, "", 0)(result);
}
else
{
const string error = "Unknown error while handling XmlRpc call to pubUpdate";
this.logger.LogError(error);
XmlRpcManager.ResponseInt(0, error, 0)(result);
}
}
/// <summary>
/// Unregister an existing subscriber
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public void unregisterSubscriber([In][Out] IntPtr parms, [In][Out] IntPtr result)
{
XmlRpcValue res = XmlRpcValue.Create(ref result), parm = XmlRpcValue.Create(ref parms);
String caller_id = parm[0].GetString();
String topic = parm[1].GetString();
String caller_api = parm[2].GetString();
Console.WriteLine("UNSUBSCRIBING: " + caller_id + " : " + caller_api);
int ret = handler.unregisterSubscriber(caller_id, topic, caller_api);
res.Set(0, ret);
res.Set(1, "unregistered " + caller_id + "as provder of " + topic);
//throw new Exception("NOT IMPLEMENTED YET!");
//XmlRpcValue args = new XmlRpcValue(this_node.Name, topic, XmlRpcManager.Instance.uri),
// result = new XmlRpcValue(),
// payload = new XmlRpcValue();
//master.execute("unregisterSubscriber", args, ref result, ref payload, false);
//return true;
}
/// <summary>
/// Returns list of all publications
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public void getPublications([In][Out] IntPtr parms, [In][Out] IntPtr result)
{
XmlRpcValue res = XmlRpcValue.Create(ref result);
res.Set(0, 1); //length
res.Set(1, "publications"); //response too
XmlRpcValue response = new XmlRpcValue(); //guts, new value here
//response.Size = 0;
List <List <String> > current = handler.getPublishedTopics("", "");
for (int i = 0; i < current.Count; i += 2)
{
XmlRpcValue pub = new XmlRpcValue();
pub.Set(0, current[0]);
current.RemoveAt(0);
pub.Set(1, current[0]);
current.RemoveAt(0);
response.Set(i, pub);
}
res.Set(2, response);
}
private void PublisherUpdateCallback(XmlRpcValue parm, XmlRpcValue result)
{
var pubs = new List <string>();
for (int idx = 0; idx < parm[2].Count; idx++)
{
pubs.Add(parm[2][idx].GetString());
}
var pubUpdateTask = PubUpdate(parm[1].GetString(), pubs);
pubUpdateTask.WhenCompleted().WhenCompleted().Wait();
if (pubUpdateTask.IsCompletedSuccessfully && pubUpdateTask.Result)
{
XmlRpcManager.ResponseInt(1, "", 0)(result);
}
else
{
const string error = "Unknown error while handling XmlRpc call to pubUpdate";
this.logger.LogError(error);
XmlRpcManager.ResponseInt(0, error, 0)(result);
}
}
public static bool get <T> (string key, ref Dictionary <string, T> dict, bool cached = false)
{
XmlRpcValue val = new XmlRpcValue();
if (!safeGet(key, ref val))
{
return(false);
}
if (val.Type != XmlRpcValue.ValueType.TypeStruct)
{
return(false);
}
dict = new Dictionary <string, T> (val.asStruct.Count);
foreach (KeyValuePair <string, XmlRpcValue> pair in val.asStruct)
{
dict.Add(pair.Key, pair.Value.Get <T> ());
}
return(true);
}
public bool requestTopic(string topic, XmlRpcValue protos, ref XmlRpcValue ret)
{
for (int proto_idx = 0; proto_idx < protos.Size; proto_idx++)
{
XmlRpcValue proto = protos[proto_idx];
if (proto.Type != XmlRpcValue.ValueType.TypeArray)
{
EDB.WriteLine("requestTopic protocol list was not a list of lists");
return(false);
}
if (proto[0].Type != XmlRpcValue.ValueType.TypeString)
{
EDB.WriteLine(
"requestTopic received a protocol list in which a sublist did not start with a string");
return(false);
}
string proto_name = proto[0].Get <string>();
if (proto_name == "TCPROS")
{
XmlRpcValue tcp_ros_params = new XmlRpcValue("TCPROS", network.host, ConnectionManager.Instance.TCPPort);
ret.Set(0, 1);
ret.Set(1, "");
ret.Set(2, tcp_ros_params);
return(true);
}
if (proto_name == "UDPROS")
{
EDB.WriteLine("IGNORING UDP GIZNARBAGE");
}
else
{
EDB.WriteLine("an unsupported protocol was offered: [{0}]", proto_name);
}
}
EDB.WriteLine("The caller to requestTopic has NO IDEA WHAT'S GOING ON!");
return(false);
}
public static bool kill(string node)
{
var cl = clientForNode(node);
if (cl == null)
{
return(false);
}
XmlRpcValue req = new XmlRpcValue(), resp = new XmlRpcValue(), payl = new XmlRpcValue();
req.Set(0, ThisNode.Name);
req.Set(1, $"Node '{ThisNode.Name}' requests shutdown.");
var respose = cl.Execute("shutdown", req);
if (!respose.Success || !XmlRpcManager.Instance.ValidateXmlRpcResponse("shutdown", respose.Value, payl))
{
return(false);
}
return(true);
}
public bool NegotiateConnection(string xmlrpc_uri)
{
int protos = 0;
XmlRpcValue tcpros_array = new XmlRpcValue(), protos_array = new XmlRpcValue(), Params = new XmlRpcValue();
tcpros_array.Set(0, "TCPROS");
protos_array.Set(protos++, tcpros_array);
Params.Set(0, this_node.Name);
Params.Set(1, name);
Params.Set(2, protos_array);
string peer_host = "";
int peer_port = 0;
if (!network.splitURI(xmlrpc_uri, ref peer_host, ref peer_port))
{
EDB.WriteLine("Bad xml-rpc URI: [" + xmlrpc_uri + "]");
return(false);
}
XmlRpcClient c = new XmlRpcClient(peer_host, peer_port);
if (!c.IsConnected || !c.ExecuteNonBlock("requestTopic", Params))
{
EDB.WriteLine("Failed to contact publisher [" + peer_host + ":" + peer_port + "] for topic [" + name +
"]");
c.Dispose();
return(false);
}
#if DEBUG
EDB.WriteLine("Began asynchronous xmlrpc connection to http://" + peer_host + ":" + peer_port + "/ for topic [" + name +
"]");
#endif
PendingConnection conn = new PendingConnection(c, this, xmlrpc_uri, Params);
lock (pending_connections_mutex)
{
pending_connections.Add(conn);
}
XmlRpcManager.Instance.addAsyncConnection(conn);
return(true);
}
private static bool safeGet <T>(string key, ref T dest, object def = null)
{
try
{
XmlRpcValue v = getParam(key);
if (v == null)
{
if (def == null)
{
return(false);
}
dest = (T)def;
return(true);
}
dest = v.Get <T>();
return(true);
}
catch
{
return(false);
}
}
public bool requestTopic(string topic, XmlRpcValue protos, ref XmlRpcValue ret)
{
for (int proto_idx = 0; proto_idx < protos.Count; proto_idx++)
{
XmlRpcValue proto = protos[proto_idx];
if (proto.Type != XmlRpcType.Array)
{
ROS.Error()($"[{ThisNode.Name}] requestTopic protocol list was not a list of lists");
return(false);
}
if (proto[0].Type != XmlRpcType.String)
{
ROS.Error()($"[{ThisNode.Name}] requestTopic received a protocol list in which a sublist did not start with a string");
return(false);
}
string proto_name = proto[0].GetString();
if (proto_name == "TCPROS")
{
var tcpRosParams = new XmlRpcValue("TCPROS", Network.host, ConnectionManager.Instance.TCPPort);
ret.Set(0, 1);
ret.Set(1, "");
ret.Set(2, tcpRosParams);
return(true);
}
if (proto_name == "UDPROS")
{
ROS.Warn()($"[{ThisNode.Name}] Ignoring topics with UdpRos as protocol");
}
else
{
ROS.Warn()($"[{ThisNode.Name}] An unsupported protocol was offered: [{proto_name}]");
}
}
ROS.Error()($"[{ThisNode.Name}] No supported protocol was provided");
return(false);
}
public static bool get <T> (string key, ref List <T> list, bool cached = false)
{
XmlRpcValue val = new XmlRpcValue();
if (!safeGet(key, ref val))
{
return(false);
}
if (val.Type != XmlRpcValue.ValueType.TypeArray)
{
return(false);
}
list = new List <T> (val.Size);
for (int i = 0; i < val.Size; i++)
{
list.Add(val [i].Get <T> ());
}
return(true);
}
/// <summary>
/// Get a list of all published topics
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public XmlRpcValue getPublishedTopics()
{
XmlRpcValue res = new XmlRpcValue();
List <List <String> > publishedtopics = handler.getPublishedTopics("", "");
res.Set(0, 1);
res.Set(1, "current system state");
XmlRpcValue listofvalues = new XmlRpcValue();
int index = 0;
foreach (List <String> l in publishedtopics)
{
XmlRpcValue value = new XmlRpcValue();
value.Set(0, l[0]); //Topic Name
value.Set(1, l[1]); // Topic type
listofvalues.Set(index, value);
index++;
}
res.Set(2, listofvalues);
return(res);
}
public XmlRpcValue getBusStats()
{
var publish_stats = new XmlRpcValue();
var subscribe_stats = new XmlRpcValue();
var service_stats = new XmlRpcValue();
int pidx = 0;
lock ( advertisedTopicsMutex )
{
publish_stats.SetArray(advertisedTopics.Count);
foreach (Publication t in advertisedTopics)
{
publish_stats.Set(pidx++, t.GetStats());
}
}
int sidx = 0;
lock ( subcriptionsMutex )
{
subscribe_stats.SetArray(subscriptions.Count);
foreach (Subscription t in subscriptions)
{
subscribe_stats.Set(sidx++, t.getStats());
}
}
// TODO: fix for services
service_stats.SetArray(0); //service_stats.Size = 0;
var stats = new XmlRpcValue();
stats.Set(0, publish_stats);
stats.Set(1, subscribe_stats);
stats.Set(2, service_stats);
return(stats);
}
/// <summary>
/// Manually update the value of a parameter
/// </summary>
/// <param name="key">Name of parameter</param>
/// <param name="value">Value to update param to</param>
public static void Update(string key, XmlRpcValue value)
{
if (value == null)
{
return;
}
key = Names.Clean(key);
List <ParamDelegate> callbacks = null;
lock (gate)
{
if (!cachedValues.ContainsKey(key))
{
cachedValues.Add(key, value);
}
else
{
cachedValues[key] = value;
}
if (!subscriptions.TryGetValue(key, out callbacks))
{
return;
}
callbacks = new List <ParamDelegate>(callbacks); // create isolation copy to execute callbacks outside lock
}
if (callbacks != null)
{
foreach (var cb in callbacks)
{
cb(key, value);
}
}
}
public T param <T> (string param_name, T default_val)
{
if (!hasParam(param_name))
{
return(default_val);
}
try
{
XmlRpcValue v = Param.getParam(param_name);
if (v == null || !v.Valid)
{
return(default_val);
}
return(v.Get <T> ());
}
catch
{
return(default_val);
}
return(default_val);
}
public static List <string> List()
{
var ret = new List <string>();
var parm = new XmlRpcValue();
var result = new XmlRpcValue();
var payload = new XmlRpcValue();
parm.Set(0, ThisNode.Name);
if (!Master.execute("getParamNames", parm, result, payload, false))
{
return(ret);
}
if (result.Count != 3 || result[0].GetInt() != 1 || result[2].Type != XmlRpcType.Array)
{
ROS.Warn()("Expected a return code, a description, and a list!");
return(ret);
}
for (int i = 0; i < payload.Count; i++)
{
ret.Add(payload[i].GetString());
}
return(ret);
}
public ReturnStruct registerSubscriber(String caller_id, String topic, String topic_type, String caller_api)
{
reg_manager.register_subscriber(topic, caller_id, caller_api);
if (!topic_types.ContainsValue(topic_type))
{
topic_types.Add(topic, topic_type);
}
List <String> puburis = publishers.get_apis(topic);
ReturnStruct rtn = new ReturnStruct();
rtn.statusMessage = String.Format("Subscribed to [{0}] ", topic);
rtn.statusCode = 1;
rtn.value = new XmlRpcValue();
rtn.value.Set(0, new XmlRpcValue());
for (int i = 0; i < puburis.Count(); i++)
{
XmlRpcValue tmp = new XmlRpcValue(puburis[i]);
rtn.value.Set(i, tmp);
}
return(rtn);
}
public static async Task <IList <string> > List()
{
var ret = new List <string>();
var parm = new XmlRpcValue();
var result = new XmlRpcValue();
var payload = new XmlRpcValue();
parm.Set(0, ThisNode.Name);
if (!await Master.ExecuteAsync("getParamNames", parm, result, payload, false).ConfigureAwait(false))
{
return(ret);
}
if (result.Count != 3 || result[0].GetInt() != 1 || result[2].Type != XmlRpcType.Array)
{
logger.LogWarning("Expected a return code, a description, and a list!");
return(ret);
}
for (int i = 0; i < payload.Count; i++)
{
ret.Add(payload[i].GetString());
}
return(ret);
}
/// <summary>
/// Returns list of all publications
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public XmlRpcValue getPublications()
{
XmlRpcValue res = new XmlRpcValue();
res.Set(0, 1); //length
res.Set(1, "publications"); //response too
XmlRpcValue response = new XmlRpcValue(); //guts, new value here
//response.Size = 0;
List <List <String> > current = handler.getPublishedTopics("", "");
for (int i = 0; i < current.Count; i += 2)
{
XmlRpcValue pub = new XmlRpcValue();
pub.Set(0, current[0]);
current.RemoveAt(0);
pub.Set(1, current[0]);
current.RemoveAt(0);
response.Set(i, pub);
}
res.Set(2, response);
return(res);
}
/// <summary>
/// Notify subscribers of an update??
/// </summary>
/// <param name="parms"></param>
/// <param name="result"></param>
public void pubUpdate([In][Out] XmlRpcValue parms, [In][Out] XmlRpcValue result)
{
//throw new Exception("NOT IMPLEMENTED YET!");
//mlRpcValue parm = XmlRpcValue.Create(ref parms);
//List<string> pubs = new List<string>();
//for (int idx = 0; idx < parm[2].Size; idx++)
// pubs.Add(parm[2][idx].Get<string>());
//if (pubUpdate(parm[1].Get<string>(), pubs))
// XmlRpcManager.Instance.responseInt(1, "", 0)(result);
//else
//{
// EDB.WriteLine("Unknown Error");
// XmlRpcManager.Instance.responseInt(0, "Unknown Error or something", 0)(result);
//}
//EDB.WriteLine("TopicManager is updating publishers for " + topic);
//Subscription sub = null;
//lock (subs_mutex)
//{
// if (shutting_down) return false;
// foreach (Subscription s in subscriptions)
// {
// if (s.name != topic || s.IsDropped)
// continue;
// sub = s;
// break;
// }
//}
//if (sub != null)
// return sub.pubUpdate(pubs);
//else
// EDB.WriteLine("got a request for updating publishers of topic " + topic +
// ", but I don't have any subscribers to that topic.");
//return false;
}
public bool NegotiateConnection(string xmlRpcUri)
{
int protos = 0;
XmlRpcValue tcpros_array = new XmlRpcValue(), protos_array = new XmlRpcValue(), Params = new XmlRpcValue();
tcpros_array.Set(0, "TCPROS");
protos_array.Set(protos++, tcpros_array);
Params.Set(0, ThisNode.Name);
Params.Set(1, name);
Params.Set(2, protos_array);
if (!Network.SplitUri(xmlRpcUri, out string peerHost, out int peerPort))
{
ROS.Error()($"[{ThisNode.Name}] Bad xml-rpc URI: [{xmlRpcUri}]");
return(false);
}
var client = new XmlRpcClient(peerHost, peerPort);
var requestTopicTask = client.ExecuteAsync("requestTopic", Params);
if (requestTopicTask.IsFaulted)
{
ROS.Error()($"[{ThisNode.Name}] Failed to contact publisher [{peerHost}:{peerPort}for topic [{name}]");
return(false);
}
ROS.Debug()($"[{ThisNode.Name}] Began asynchronous xmlrpc connection to http://{peerHost}:{peerPort}/ for topic [{name}]");
var conn = new PendingConnection(client, requestTopicTask, xmlRpcUri);
lock ( pendingConnections )
{
pendingConnections.Add(conn);
requestTopicTask.ContinueWith(t => PendingConnectionDone(conn, t));
}
return(true);
}
public static bool GetImpl(string key, out XmlRpcValue value, bool useCache)
{
string mappepKey = Names.Resolve(key);
value = new XmlRpcValue();
if (useCache)
{
lock (gate)
{
if (cachedValues.TryGetValue(mappepKey, out var cachedValue) && !cachedValue.IsEmpty)
{
value = cachedValue;
return(true);
}
}
}
XmlRpcValue parm2 = new XmlRpcValue(), result2 = new XmlRpcValue();
parm2.Set(0, ThisNode.Name);
parm2.Set(1, mappepKey);
value.SetArray(0);
bool ret = Master.Execute("getParam", parm2, result2, value, false);
if (ret && useCache)
{
lock (gate)
{
cachedValues[mappepKey] = value;
}
}
return(ret);
}
/// <summary>
/// </summary>
/// <param name="method"></param>
/// <param name="request">Full request to send to the master </param>
/// <param name="response">Full response including status code and status message. Initially empty.</param>
/// <param name="payload">Location to store the actual data requested, if any.</param>
/// <param name="wait_for_master">If you recieve an unseccessful status code, keep retrying.</param>
/// <returns></returns>
public static bool execute(string method, XmlRpcValue request, XmlRpcValue response, XmlRpcValue payload,
bool wait_for_master)
{
try
{
DateTime startTime = DateTime.Now;
string master_host = host;
int master_port = port;
CachedXmlRpcClient client = XmlRpcManager.Instance.getXMLRPCClient(master_host, master_port, "/");
bool printed = false;
bool success = false;
while (!success)
{
// Check if we are shutting down
if (XmlRpcManager.Instance.shutting_down)
return false;
// if the client is connected, execute the RPC call
success = client.IsConnected && client.Execute(method, request, response);
if (client.IsConnected && !success)
{
if (response != null && response.asArray != null && response.asArray.Length >= 2)
EDB.WriteLine("Execute failed: return={0}, desc={1}", response[0].asInt, response[1].asString);
else
EDB.WriteLine("response type == " + (response != null ? response.Type.ToString() : "null"));
}
// Set success to false when response validation fails
if (success && !XmlRpcManager.Instance.validateXmlrpcResponse(method, response, payload))
success = false;
if (success)
{
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return true;
}
if (!wait_for_master)
{
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return false;
}
if (!printed)
{
EDB.WriteLine("[{0}] FAILED TO CONTACT MASTER AT [{1}:{2}]. {3}", method, master_host,
master_port, (wait_for_master ? "Retrying for the next "+retryTimeout.TotalSeconds+" seconds..." : ""));
printed = true;
}
if (retryTimeout.TotalSeconds > 0 && DateTime.Now.Subtract(startTime) > retryTimeout)
{
EDB.WriteLine("[{0}] Timed out trying to connect to the master after [{1}] seconds", method,
retryTimeout.TotalSeconds);
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return false;
}
//recreate the client, thereby causing it to reinitiate its connection (gross, but effective -- should really be done in xmlrpcwin32)
XmlRpcManager.Instance.releaseXMLRPCClient(client);
client = null;
Thread.Sleep(250);
client = XmlRpcManager.Instance.getXMLRPCClient(master_host, master_port, "/");
}
}
catch (Exception e)
{
EDB.WriteLine(e);
}
EDB.WriteLine("Master API call: {0} failed!\n\tRequest:\n{1}", method, request);
return false;
}
public bool ExecuteNonBlock(string method, XmlRpcValue parameters)
{
return client.ExecuteNonBlock(method, parameters);
}
public bool ExecuteNonBlock(string method, XmlRpcValue parameters)
{
return executenonblock(instance, method, parameters.instance);
}
public bool ExecuteCheckDone(XmlRpcValue result)
{
return executecheckdone(instance, result.instance);
}
/// <summary>
/// </summary>
/// <param name="method"></param>
/// <param name="request">Full request to send to the master </param>
/// <param name="response">Full response including status code and status message. Initially empty.</param>
/// <param name="payload">Location to store the actual data requested, if any.</param>
/// <param name="wait_for_master">If you recieve an unseccessful status code, keep retrying.</param>
/// <returns></returns>
public static bool execute(string method, XmlRpcValue request, ref XmlRpcValue response, ref XmlRpcValue payload,
bool wait_for_master)
{
try
{
DateTime startTime = DateTime.Now;
string master_host = host;
int master_port = port;
//EDB.WriteLine("Trying to connect to master @ " + master_host + ":" + master_port);
XmlRpcClient client = XmlRpcManager.Instance.getXMLRPCClient(master_host, master_port, "/");
bool printed = false;
bool ok = true;
while (!client.IsConnected && !ROS._shutting_down && !XmlRpcManager.Instance.shutting_down ||
!(ok = client.Execute(method, request, response) && XmlRpcManager.Instance.validateXmlrpcResponse(method, response, ref payload)))
{
if (!wait_for_master)
{
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return false;
}
if (!printed)
{
EDB.WriteLine("[{0}] FAILED TO CONTACT MASTER AT [{1}:{2}]. {3}", method, master_host,
master_port, (wait_for_master ? "Retrying..." : ""));
printed = true;
}
if (retryTimeout.TotalSeconds > 0 && DateTime.Now.Subtract(startTime) > retryTimeout)
{
EDB.WriteLine("[{0}] Timed out trying to connect to the master after [{1}] seconds", method,
retryTimeout.TotalSeconds);
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return false;
}
Thread.Sleep(10);
}
if (ok && !firstsucces)
{
firstsucces = true;
//EDB.WriteLine(string.Format("CONNECTED TO MASTER AT [{0}:{1}]", master_host, master_port));
}
XmlRpcManager.Instance.releaseXMLRPCClient(client);
return true;
}
catch (Exception e)
{
Console.WriteLine(e);
}
return false;
}
public bool Execute(string method, XmlRpcValue parameters, XmlRpcValue result)
{
bool r = execute(instance, method, parameters.instance, result.instance);
return r;
}
public void setParam(String caller_id, String key, XmlRpcValue value)
{
key = Names.resolve_name(key,caller_id);
param_server.set_param(key, value, _notify_param_subscribers);
}
public void Execute(XmlRpcValue parms, XmlRpcValue reseseses)
{
_FUNC(parms, reseseses);
}
/// <summary>
/// Checks if master is running? I think.
/// </summary>
/// <returns></returns>
public static bool check()
{
XmlRpcValue args = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
args.Set(0, this_node.Name);
return execute("getPid", args, result, payload, false);
}
/// <summary>
/// Register a publisher
/// </summary>
/// <param name="caller_id"></param>
/// <param name="topic"></param>
/// <param name="topic_type"></param>
/// <param name="caller_api"></param>
/// <returns></returns>
public ReturnStruct registerPublisher(String caller_id, String topic, String topic_type, String caller_api)
{
reg_manager.register_publisher(topic, caller_id, caller_api);
if (!topic_types.ContainsValue(topic_type))
topic_types.Add(topic, topic_type);
List<String> puburis = publishers.get_apis(topic);
List<String> sub_uris = subscribers.get_apis(topic);
_notify_topic_subscribers(topic, puburis, sub_uris);
ReturnStruct rtn = new ReturnStruct();
rtn.statusMessage = String.Format("Registered [{0}] as publisher of [{1}]", caller_id, topic);
rtn.statusCode = 1;
rtn.value = new XmlRpcValue();
rtn.value.Set(0, new XmlRpcValue());
for (int i = 0; i < sub_uris.Count(); i++)
{
XmlRpcValue tmp = new XmlRpcValue(sub_uris[0]);
rtn.value.Set(i, tmp);
}
return rtn;
}
// Execute the named procedure on the remote server.
// Params should be an array of the arguments for the method.
// Returns true if the request was sent and a result received (although the result
// might be a fault).
public bool Execute(string method, XmlRpcValue parameters, XmlRpcValue result)
{
XmlRpcUtil.log(XmlRpcUtil.XMLRPC_LOG_LEVEL.SPEW, "XmlRpcClient::Execute: method {0} (_connectionState {0}).", method, _connectionState);
lock (this)
{
//result = null;
// This is not a thread-safe operation, if you want to do multithreading, use separate
// clients for each thread. If you want to protect yourself from multiple threads
// accessing the same client, replace this code with a real mutex.
if (_executing)
return false;
_executing = true;
//ClearFlagOnExit cf(_executing);
_sendAttempts = 0;
_isFault = false;
if (!setupConnection())
{
_executing = false;
return false;
}
if (!generateRequest(method, parameters))
{
_executing = false;
return false;
}
double msTime = -1.0;
_disp.Work(msTime);
if (_connectionState != ConnectionState.IDLE || !parseResponse(result, header.DataString))
{
_executing = false;
return false;
}
XmlRpcUtil.log(XmlRpcUtil.XMLRPC_LOG_LEVEL.DEBUG, "XmlRpcClient::execute: method {0} completed.", method);
_executing = false;
}
_executing = false;
return true;
}
/// <summary>
/// Gets all currently existing nodes and adds them to the nodes list
/// </summary>
/// <param name="nodes">List to store nodes</param>
/// <returns></returns>
public static bool getNodes(ref string[] nodes)
{
List<string> names = new List<string>();
XmlRpcValue args = new XmlRpcValue(), result = new XmlRpcValue(), payload = new XmlRpcValue();
args.Set(0, this_node.Name);
if (!execute("getSystemState", args, result, payload, true))
{
return false;
}
for (int i = 0; i < payload.Size; i++)
{
for (int j = 0; j < payload[i].Size; j++)
{
XmlRpcValue val = payload[i][j][1];
for (int k = 0; k < val.Size; k++)
{
string name = val[k].Get<string>();
names.Add(name);
}
}
}
nodes = names.ToArray();
return true;
}
public void Execute(XmlRpcValue parms, out XmlRpcValue reseseses)
{
SegFault();
reseseses = new XmlRpcValue();
execute(instance, parms.instance, reseseses.instance);
}
public void getInfo(XmlRpcValue info)
{
lock (subscriber_links_mutex)
{
foreach (SubscriberLink c in subscriber_links)
{
XmlRpcValue curr_info = new XmlRpcValue();
curr_info.Set(0, (int) c.connection_id);
curr_info.Set(1, c.destination_caller_id);
curr_info.Set(2, "o");
curr_info.Set(3, "TCPROS");
curr_info.Set(4, Name);
info.Set(info.Size, curr_info);
}
}
}
public static bool kill(string node)
{
CachedXmlRpcClient cl = clientForNode(node);
if (cl == null)
return false;
XmlRpcValue req = new XmlRpcValue(), resp = new XmlRpcValue(), payl = new XmlRpcValue();
req.Set(0, this_node.Name);
req.Set(1, "Out of respect for Mrs. " + this_node.Name);
if (!cl.Execute("shutdown", req, resp) || !XmlRpcManager.Instance.validateXmlrpcResponse("lookupNode", resp, payl))
return false;
payl.Dump();
XmlRpcManager.Instance.releaseXMLRPCClient(cl);
return true;
}
public XmlRpcValue GetStats()
{
XmlRpcValue stats = new XmlRpcValue();
stats.Set(0, Name);
XmlRpcValue conn_data = new XmlRpcValue();
conn_data.SetArray(0);
lock (subscriber_links_mutex)
{
int cidx = 0;
foreach (SubscriberLink sub_link in subscriber_links)
{
SubscriberLink.Stats s = sub_link.stats;
XmlRpcValue inside = new XmlRpcValue();
inside.Set(0, sub_link.connection_id);
inside.Set(1, s.bytes_sent);
inside.Set(2, s.message_data_sent);
inside.Set(3, s.messages_sent);
inside.Set(4, 0);
conn_data.Set(cidx++, inside);
}
}
stats.Set(1, conn_data);
return stats;
}
// Convert the response xml into a result value
private bool parseResponse(XmlRpcValue result, string _response)
{
bool success = true;
//XmlRpcValue result = null;
using (XmlReader reader = XmlReader.Create(new StringReader(_response)))
{
XmlDocument response = new XmlDocument();
response.Load(reader);
// Parse response xml into result
//int offset = 0;
XmlNodeList resp = response.GetElementsByTagName("methodResponse");
XmlNode responseNode = resp[0];
//if (!XmlRpcUtil.findTag(METHODRESPONSE_TAG, _response, out offset))
if (resp.Count == 0)
{
XmlRpcUtil.error("Error in XmlRpcClient::parseResponse: Invalid response - no methodResponse. Response:\n{0}", _response);
return false;
}
XmlElement pars = responseNode["params"];
XmlElement fault = responseNode["fault"];
//result = new XmlRpcValue();
if (pars != null)
{
bool isArray = false;
var selection = pars.SelectNodes("param");
if (selection.Count > 1)
{
result.SetArray(selection.Count);
int i = 0;
foreach (XmlNode par in selection)
{
var value = new XmlRpcValue();
value.fromXml(par["value"]);
result[i++] = value;
}
}
else if (selection.Count == 1)
{
result.fromXml(selection[0]["value"]);
}
else
success = false;
}
else if (fault != null && result.fromXml(fault))
{
success = false;
}
else
{
XmlRpcUtil.error("Error in XmlRpcClient::parseResponse: Invalid response - no param or fault tag. Response:\n{0}", _response);
}
_response = "";
}
return success;
}
// Execute the named procedure on the remote server, non-blocking.
// Params should be an array of the arguments for the method.
// Returns true if the request was sent and a result received (although the result
// might be a fault).
public bool ExecuteNonBlock(string method, XmlRpcValue parameters)
{
XmlRpcUtil.log(XmlRpcUtil.XMLRPC_LOG_LEVEL.SPEW, "XmlRpcClient::ExecuteNonBlock: method {0} (_connectionState {0}.", method, _connectionState);
// This is not a thread-safe operation, if you want to do multithreading, use separate
// clients for each thread. If you want to protect yourself from multiple threads
// accessing the same client, replace this code with a real mutex.
XmlRpcValue result = new XmlRpcValue();
if (_executing)
return false;
_executing = true;
_sendAttempts = 0;
_isFault = false;
if (!setupConnection())
{
_executing = false;
return false;
}
if (!generateRequest(method, parameters))
{
_executing = false;
return false;
}
_executing = false;
return true;
}
public bool Execute(string method, XmlRpcValue parameters, XmlRpcValue result)
{
return client.Execute(method, parameters, result);
}
public bool ExecuteCheckDone(XmlRpcValue result)
{
//result.clear();
// Are we done yet?
if (_connectionState != ConnectionState.IDLE)
return false;
if (!parseResponse(result, header.DataString))
{
// Hopefully the caller can determine that parsing failed.
}
XmlRpcUtil.log(XmlRpcUtil.XMLRPC_LOG_LEVEL.DEBUG, "XmlRpcClient::execute: method completed.");
return true;
}
private string generateRequestStr(string methodName, XmlRpcValue parameters)
{
string body = REQUEST_BEGIN;
body += methodName;
body += REQUEST_END_METHODNAME;
// If params is an array, each element is a separate parameter
if (parameters.Valid)
{
body += PARAMS_TAG;
if (parameters.Type == XmlRpcValue.ValueType.TypeArray)
{
for (int i = 0; i < parameters.Length; ++i)
{
body += PARAM_TAG;
body += parameters[i].toXml();
body += PARAM_ETAG;
}
}
else
{
body += PARAM_TAG;
body += parameters.toXml();
body += PARAM_ETAG;
}
body += PARAMS_ETAG;
}
body += REQUEST_END;
return body;
}
public ReturnStruct registerSubscriber(String caller_id, String topic, String topic_type, String caller_api)
{
reg_manager.register_subscriber(topic, caller_id, caller_api);
if (!topic_types.ContainsValue(topic_type))
topic_types.Add(topic, topic_type);
List<String> puburis = publishers.get_apis(topic);
ReturnStruct rtn = new ReturnStruct();
rtn.statusMessage = String.Format("Subscribed to [{0}] ", topic);
rtn.statusCode = 1;
rtn.value = new XmlRpcValue();
rtn.value.Set(0, new XmlRpcValue());
for (int i = 0; i < puburis.Count(); i++)
{
XmlRpcValue tmp = new XmlRpcValue(puburis[i]);
rtn.value.Set(i, tmp);
}
return rtn;
}
// Encode the request to call the specified method with the specified parameters into xml
private bool generateRequest(string methodName, XmlRpcValue parameters)
{
string body = generateRequestStr(methodName, parameters);
string header = generateHeader(body);
XmlRpcUtil.log(XmlRpcUtil.XMLRPC_LOG_LEVEL.DEBUG, "XmlRpcClient::generateRequest: header is {0} bytes, content-length is {1}.", header.Length, body.Length);
_request = header + body;
return true;
}
public bool ExecuteCheckDone(XmlRpcValue result)
{
return client.ExecuteCheckDone(result);
}
internal static CachedXmlRpcClient clientForNode(string nodename)
{
XmlRpcValue args = new XmlRpcValue();
args.Set(0, this_node.Name);
args.Set(1, nodename);
XmlRpcValue resp = new XmlRpcValue();
XmlRpcValue payl = new XmlRpcValue();
if (!execute("lookupNode", args, resp, payl, true))
return null;
if (!XmlRpcManager.Instance.validateXmlrpcResponse("lookupNode", resp, payl))
return null;
string nodeuri = payl.GetString();
string nodehost = null;
int nodeport = 0;
if (!network.splitURI(nodeuri, ref nodehost, ref nodeport) || nodehost == null || nodeport <= 0)
return null;
return XmlRpcManager.Instance.getXMLRPCClient(nodehost, nodeport, nodeuri);
}
