public bool CompareNamespace(string qualified_typename, out string typename)
{
var s = ServiceDefinitionUtil.SplitQualifiedName(qualified_typename);
typename = s.Item2;
return(s.Item1 == GetServiceName());
}
public object PackNamedArray(object s)
{
Type t;
var s1 = s as NamedMultiDimArray;
if (s1 != null)
{
t = s1.namedarray_array.GetType().GetElementType();
}
else
{
var s2 = s as Array;
if (s2 != null)
{
t = s2.GetType().GetElementType();
}
else
{
t = s.GetType();
}
}
string typename;
if (CompareNamespace(ServiceDefinitionUtil.FindStructRRType(t), out typename))
{
return(FindNamedArrayStub(typename).PackNamedArray(s));
}
else
{
return(node.PackNamedArray(s, context));
}
}
public override MessageElementStructure PackStructure(Object s)
{
if (s == null)
{
return(null);
}
string objtype = ServiceDefinitionUtil.FindStructRRType(s.GetType());
if (ServiceDefinitionUtil.SplitQualifiedName(objtype).Item1 == "RobotRaconteurServiceIndex")
{
string objshort = RemovePath(objtype);
switch (objshort)
{
case "NodeInfo":
return(NodeInfo_stubentry.PackStructure(s));
case "ServiceInfo":
return(ServiceInfo_stubentry.PackStructure(s));
}
}
else
{
return(base.PackStructure(s));
}
throw new Exception();
}
public override ServiceSkel CreateSkel(string path, object obj, ServerContext context)
{
string objtype = ServiceDefinitionUtil.FindObjectRRType(obj);
string objshort;
if (CompareNamespace(objtype, out objshort))
{
switch (objshort)
{
case "baseobj":
return(new baseobj_skel(path, (baseobj)obj, context));
case "subobj":
return(new subobj_skel(path, (subobj)obj, context));
default:
break;
}
}
else
{
return(base.CreateSkel(path, obj, context));
}
throw new ServiceException("Could not create skel");
}
protected bool VerifyObjectImplements2(string objecttype, string implementstype)
{
lock (this)
{
if (objecttype == implementstype)
{
return(true);
}
var s1 = ServiceDefinitionUtil.SplitQualifiedName(objecttype);
if (!pulled_service_defs.ContainsKey(s1.Item1))
{
//TODO: handle this better?
return(false);
}
if (!pulled_service_defs.ContainsKey(s1.Item1))
{
return(false);
}
var d = pulled_service_defs[s1.Item1];
var o = d.Objects.FirstOrDefault(x => x.Value.Name == s1.Item2).Value;
if (o == null)
{
return(false);
}
foreach (var e in o.Implements)
{
var deftype = d.Name;
var objtype = "";
if (e.Contains('.'))
{
objtype = e;
}
else
{
var s2 = ServiceDefinitionUtil.SplitQualifiedName(e);
deftype = s2.Item1;
objtype = s2.Item2;
}
if ((deftype + "." + objtype) == implementstype)
{
return(true);
}
if (VerifyObjectImplements2(deftype + "." + objtype, implementstype))
{
return(true);
}
}
return(false);
}
}
public virtual ServiceSkel CreateSkel(string path, object obj, ServerContext context)
{
string objecttype = ServiceDefinitionUtil.FindObjectRRType(obj);
string extdef = ServiceDefinitionUtil.SplitQualifiedName(objecttype).Item1;
if (extdef == this.GetServiceName())
{
throw new InvalidOperationException("Invalid service factory request");
}
return(node.GetServiceType(extdef).CreateSkel(path, obj, context));
}
public virtual MessageElementStructure PackStructure(object s)
{
string typename;
if (CompareNamespace(ServiceDefinitionUtil.FindStructRRType(s.GetType()), out typename))
{
return(FindStructureStub(typename).PackStructure(s));
}
else
{
return(node.PackStructure(s, context));
}
}
public MessageElementPodArray PackPodArray <T>(T[] s) where T : struct
{
string typename;
if (CompareNamespace(ServiceDefinitionUtil.FindStructRRType(s.GetType().GetElementType()), out typename))
{
return(((PodStub <T>)FindPodStub(typename)).PackPodArray(s));
}
else
{
return(node.PackPodArray(s, context));
}
}
//namedarray
public MessageElementNamedArray PackNamedArrayToArray <T>(ref T s) where T : struct
{
string typename;
if (CompareNamespace(ServiceDefinitionUtil.FindStructRRType(s.GetType()), out typename))
{
return(((INamedArrayStub <T>)FindNamedArrayStub(typename)).PackNamedArrayStructToArray(ref s));
}
else
{
return(node.PackNamedArrayToArray(ref s, context));
}
}
public MessageElementNamedMultiDimArray PackNamedMultiDimArray <T>(NamedMultiDimArray s) where T : struct
{
string typename;
if (CompareNamespace(ServiceDefinitionUtil.FindStructRRType(s.namedarray_array.GetType().GetElementType()), out typename))
{
return(((INamedArrayStub <T>)FindNamedArrayStub(typename)).PackNamedMultiDimArray(s));
}
else
{
return(node.PackNamedMultiDimArray <T>(s, context));
}
}
public override ServiceStub CreateStub(string objecttype, string path, ClientContext context)
{
if (ServiceDefinitionUtil.SplitQualifiedName(objecttype).Item1 == "RobotRaconteurServiceIndex")
{
string objshort = RemovePath(objecttype);
switch (objshort)
{
case "ServiceIndex":
return(new ServiceIndex_stub(path, context));
}
}
else
{
return(base.CreateStub(objecttype, path, context));
}
throw new ServiceException("Could not create stub");
}
public virtual ServiceStub CreateStub(string objecttype, string path, ClientContext context)
{
string extdef = ServiceDefinitionUtil.SplitQualifiedName(objecttype).Item1;
if (extdef == this.GetServiceName())
{
throw new InvalidOperationException("Invalid service factory request");
}
if (this.context == null)
{
return(node.GetServiceType(extdef).CreateStub(objecttype, path, context));
}
else
{
return(this.context.GetPulledServiceType(extdef).CreateStub(objecttype, path, context));
}
}
public override ServiceSkel CreateSkel(string path, object obj, ServerContext context)
{
string objtype = ServiceDefinitionUtil.FindObjectRRType(obj);
if (ServiceDefinitionUtil.SplitQualifiedName(objtype).Item1 == "RobotRaconteurServiceIndex")
{
string sobjtype = RemovePath(objtype);
switch (sobjtype)
{
case "ServiceIndex":
return(new ServiceIndex_skel(path, (ServiceIndex)obj, context));
}
}
else
{
return(base.CreateSkel(path, obj, context));
}
throw new ServiceException("Could not create skel");
}
public virtual RobotRaconteurException DownCastException(RobotRaconteurException exp)
{
try
{
if (!exp.Error.Contains("."))
{
return(exp);
}
ServiceFactory f = null;
var s = ServiceDefinitionUtil.SplitQualifiedName(exp.Error);
if (context != null)
{
if (!context.TryGetPulledServiceType(s.Item1, out f))
{
f = null;
}
}
if (f == null)
{
if (!node.TryGetServiceType(s.Item1, out f))
{
f = null;
}
}
if (f == null)
{
return(exp);
}
return(f.DownCastException(exp));
}
catch (Exception)
{
return(null);
}
}
public override T UnpackStructure <T>(MessageElementStructure l)
{
if (l == null)
{
return(default(T));
}
if (ServiceDefinitionUtil.SplitQualifiedName(l.Type).Item1 == "RobotRaconteurServiceIndex")
{
string objshort = RemovePath(l.Type);
switch (objshort)
{
case "NodeInfo":
return(NodeInfo_stubentry.UnpackStructure <T>(l));
case "ServiceInfo":
return(ServiceInfo_stubentry.UnpackStructure <T>(l));
}
}
else
{
return(base.UnpackStructure <T>(l));
}
throw new DataTypeException("Could not unpack structure");
}
public async Task <object> ConnectService(Transport c, string url, string username = null, object credentials = null, string objecttype = null, CancellationToken cancel = default(CancellationToken))
{
this.connecturl = url;
this.connecttransport = c;
var u = TransportUtil.ParseConnectionUrl(url);
m_RemoteNodeID = u.nodeid;
m_RemoteNodeName = u.nodename;
m_ServiceName = u.service;
//ProgramName = ProgramName1;
/* try
* {*/
//if (RobotRaconteurService.s.transports[c] == null) return null;
if (!c.CanConnectService(url))
{
throw new ServiceException("Invalid transport");
}
TransportConnection = await c.CreateTransportConnection(url, this, cancel);
m_Connected = true;
try
{
transport = c.TransportID;
m_RemoteEndpoint = 0;
ServiceDefinition[] d = await PullServiceDefinitionAndImports(null, cancel : cancel);
lock (pulled_service_defs)
{
foreach (var d2 in d)
{
if (!pulled_service_defs.ContainsKey(d2.Name))
{
pulled_service_defs.Add(d2.Name, d2);
}
}
}
if (!UsePulledServiceTypes)
{
m_ServiceDef = node.GetServiceType(d[0].Name);
}
else
{
var f = DynamicServiceFactory_.CreateServiceFactories(d.Select(x => x.ToString()).ToArray(), this);
lock (pulled_service_defs)
{
foreach (var f2 in f)
{
if (!pulled_service_types.ContainsKey(f2.GetServiceName()))
{
pulled_service_types.Add(f2.GetServiceName(), f2);
}
}
}
m_ServiceDef = GetPulledServiceType(d[0].Name);
}
MessageEntry e = new MessageEntry(MessageEntryType.ObjectTypeName, "");
//e.AddElement("servicepath", ServiceName);
e.ServicePath = ServiceName;
MessageEntry ret = await ProcessRequest(e, cancel);
if (ret.Error != MessageErrorType.None)
{
return(null);
}
string type = ret.FindElement("objecttype").CastData <string>();
if (type == "")
{
return(new ObjectNotFoundException("Could not find object type"));
}
;
if (objecttype != null)
{
VerifyObjectImplements(type, objecttype);
type = objecttype;
await PullServiceDefinitionAndImports(ServiceDefinitionUtil.SplitQualifiedName(type).Item2, cancel);
}
MessageEntry e2 = new MessageEntry();
e2.ServicePath = ServiceName;
e2.MemberName = "registerclient";
e2.EntryType = MessageEntryType.ConnectClient;
await ProcessRequest(e2, cancel);
if (username != null)
{
await AuthenticateUser(username, credentials, cancel);
}
ServiceStub stub = ServiceDef.CreateStub(type, ServiceName, this);
stubs.Add(ServiceName, stub);
Task noop = PeriodicTask.Run(PeriodicCleanupTask, TimeSpan.FromSeconds(5), cancel_source.Token).IgnoreResult();
return(stub);
}
catch (Exception e)
{
try
{
TransportConnection.Close();
}
catch { }
m_Connected = false;
throw e;
}
/*}
* catch {
* return null;
* }*/
}
public async Task <object> FindObjRef(string path, string objecttype, CancellationToken cancel)
{
lock (stubs)
{
if (stubs.Keys.Contains(path))
{
return(stubs[path]);
}
}
MessageEntry e = new MessageEntry(MessageEntryType.ObjectTypeName, "");
//MessageElement m = e.AddElement("ObjectPath", path);
e.ServicePath = path;
MessageEntry ret = await ProcessRequest(e, cancel);
string objecttype2 = ret.FindElement("objecttype").CastData <string>();
if (objecttype2 == "")
{
throw new ObjectNotFoundException("Object type was not returned.");
}
string objectdef = ServiceDefinitionUtil.SplitQualifiedName(objecttype2).Item1;
if (UsePulledServiceTypes)
{
bool pull = false;
lock (pulled_service_types)
{
if (!pulled_service_types.ContainsKey(objectdef))
{
pull = true;
}
}
if (pull)
{
ServiceDefinition[] d = await PullServiceDefinitionAndImports(null, cancel : cancel);
lock (pulled_service_defs)
{
foreach (var d2 in d)
{
if (!pulled_service_defs.ContainsKey(d2.Name))
{
pulled_service_defs.Add(d2.Name, d2);
}
}
}
var f = DynamicServiceFactory_.CreateServiceFactories(d.Select(x => x.ToString()).ToArray(), this);
lock (pulled_service_defs)
{
foreach (var f2 in f)
{
if (!pulled_service_types.ContainsKey(f2.GetServiceName()))
{
pulled_service_types.Add(f2.GetServiceName(), f2);
}
}
}
}
}
if (objecttype != null)
{
VerifyObjectImplements(objecttype2, objecttype);
objecttype2 = objecttype;
}
var stub = ServiceDef.CreateStub(objecttype2, path, this);
lock (stubs)
{
if (!stubs.Keys.Contains(path))
{
stubs[path] = stub;
return(stub);
}
else
{
return(stubs[path]);
}
}
}
static int Main(string[] args)
{
try
{
bool show_help = false;
bool show_version = false;
bool thunksource = false;
string lang = null;
var sources = new List <Source>();
string outfile = null;
var include_dirs = new List <string>();
string output_dir = ".";
var p = new OptionSet()
{
{ "thunksource", "generate thunk source code", v => thunksource = v != null },
{ "version", "print program version", v => show_version = v != null },
{ "output-dir=", "directory for output", v => output_dir = v },
{ "lang=", "language to generate sources for for (only csharp currently supported)", v => lang = v },
{ "import=", "input file for use in imports", v => sources.Add(new Source {
filename = v, is_import = true
}) },
{ "I|include-path=", "include path", v => include_dirs.Add(v) },
{ "outfile=", "unified output file (csharp only)", v => outfile = v },
{ "h|help", "show this message and exit", v => show_help = v != null },
};
try
{
foreach (var s in p.Parse(args))
{
sources.Add(new Source {
filename = s, is_import = false
});
}
}
catch (OptionException e)
{
Console.Write("RobotRaconteurWebGen: fatal error: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try 'RobotRaconteurWebGen --help' for more information.");
return(1);
}
if (show_help)
{
ShowHelp(p);
return(0);
}
if (show_version)
{
ShowVersion(p);
return(0);
}
if (!thunksource)
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: no command specified");
Console.WriteLine("Try 'RobotRaconteurWebGen --help' for more information.");
return(1);
}
if (sources.Count(x => x.is_import == false) == 0)
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: no files specified for thunksource");
return(1001);
}
if (lang != "csharp")
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: unknown or no language specified");
return(1012);
}
var robdef_path = Environment.GetEnvironmentVariable("ROBOTRACONTEUR_ROBDEF_PATH");
if (robdef_path != null)
{
robdef_path = robdef_path.Trim();
var env_dirs = robdef_path.Split(Path.PathSeparator);
include_dirs.AddRange(env_dirs);
}
foreach (var s in sources)
{
if (!File.Exists(s.filename) && !Path.IsPathFullyQualified(s.filename))
{
foreach (var inc in include_dirs)
{
string s3 = Path.Join(inc, s.filename);
if (File.Exists(s3))
{
s.filename = s3;
break;
}
}
}
}
foreach (var s in sources)
{
if (!File.Exists(s.filename))
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: input file not found {0}", s.filename);
return(1002);
}
}
if (!Directory.Exists(output_dir))
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: output director not found {0}", output_dir);
return(1003);
}
foreach (var s in sources)
{
ServiceDefinition d = null;
string def;
try
{
StreamReader sr = new StreamReader(s.filename);
def = sr.ReadToEnd();
sr.Close();
}
catch (Exception)
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: could not open file {0}", s.filename);
return(1004);
}
try
{
d = new ServiceDefinition();
ServiceDefinitionParseInfo parse_info = default(ServiceDefinitionParseInfo);
parse_info.RobDefFilePath = s.filename;
d.FromString(def, parse_info);
string a = d.ToString();
s.full_text = def;
s.service_def = d;
}
catch (ServiceDefinitionParseException ee)
{
Console.WriteLine("{0}({1}): error: {2}", s.filename, ee.ParseInfo.LineNumber, ee.ShortMessage);
return(1005);
}
}
try
{
ServiceDefinitionUtil.VerifyServiceDefinitions(sources.Select(x => x.service_def).ToDictionary(x => x.Name));
}
catch (ServiceDefinitionParseException ee)
{
Console.WriteLine("{0}({1}): error: {2}", ee.ParseInfo.RobDefFilePath, ee.ParseInfo.LineNumber, ee.ShortMessage);
return(1007);
}
catch (ServiceDefinitionVerifyException ee)
{
Console.WriteLine("{0}({1}): error: {2}", ee.ParseInfo.RobDefFilePath, ee.ParseInfo.LineNumber, ee.ShortMessage);
return(1008);
}
catch (Exception ee)
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: could not verify service definition set {0}", ee.Message);
return(1009);
}
if (outfile == null)
{
foreach (var s in sources)
{
if (s.is_import)
{
continue;
}
try
{
CSharpServiceLangGen.GenerateFiles(s.service_def, s.full_text, output_dir);
}
catch (Exception ee)
{
Console.WriteLine("{0}: error: could not generate thunksource files {1}", s.filename, ee.Message);
return(1010);
}
}
return(0);
}
else
{
StreamWriter f2;
try
{
f2 = new StreamWriter(outfile);
}
catch (Exception)
{
Console.WriteLine("RobotRaconteurWebGen: fatal error: could not open outfile for writing {0}", outfile);
return(1015);
}
using (f2)
{
CSharpServiceLangGen.GenerateOneFileHeader(f2);
foreach (var s in sources)
{
if (s.is_import)
{
continue;
}
try
{
CSharpServiceLangGen.GenerateOneFilePart(s.service_def, s.full_text, f2);
}
catch (Exception ee)
{
Console.WriteLine("{0}: error: could not generate thunksource files {1}", s.filename, ee.Message);
return(1010);
}
}
}
return(0);
}
}
catch (Exception e)
{
Console.Write("RobotRaconteurWebGen: error: ");
Console.WriteLine(e.Message);
return(1);
}
Console.WriteLine("RobotRaconteurGen: error: unknown internal error");
return(7);
}
static void Main(string[] args)
{
string command = args[0];
if (command == "loopback")
{
var t = new TcpTransport();
t.StartServer(22332);
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var s1 = new RobotRaconteurTestServiceSupport();
s1.RegisterServices(t);
ServiceTestClient s = new ServiceTestClient();
s.RunFullTest("rr+tcp://localhost:22332/?service=RobotRaconteurTestService",
"rr+tcp://localhost:22332/?service=RobotRaconteurTestService_auth")
.GetAwaiter().GetResult();
RobotRaconteurNode.s.Shutdown();
}
else
if (command == "client")
{
var url = args[1];
var auth_url = args[2];
int count = 1;
if (args.Length >= 4)
{
count = Int32.Parse(args[3]);
}
var t = new TcpTransport();
var t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterTransport(t2);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
for (int i = 0; i < count; i++)
{
ServiceTestClient s = new ServiceTestClient();
s.RunFullTest(url, auth_url).GetAwaiter().GetResult();
}
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test complete, no errors detected");
}
else if (command == "server")
{
int port = int.Parse(args[1]);
//NodeID id = new NodeID(args[2]);
string name = args[2];
var t2 = new LocalTransport();
t2.StartServerAsNodeName(name);
var t = new TcpTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
t.StartServer(port);
RobotRaconteurNode.s.RegisterTransport(t);
t.EnableNodeAnnounce();
try
{
t.LoadTlsNodeCertificate();
}
catch (Exception)
{
Console.WriteLine("Warning: Could not load TLS certificate");
}
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService3.com__robotraconteur__testing__TestService3Factory());
var s = new RobotRaconteurTestServiceSupport();
s.RegisterServices(t);
var s2 = new RobotRaconteurTestServiceSupport2();
s2.RegisterServices(t);
Console.WriteLine("Press enter to quit...");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
}
else if (command == "findservicebytype")
{
string servicetype = args[1];
string[] schemes = args[2].Split(new char[] { ',' });
var t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
System.Threading.Thread.Sleep(5000);
var r = RobotRaconteurNode.s.FindServiceByType(servicetype, schemes).Result;
foreach (var e in r)
{
Console.WriteLine("Name: " + e.Name);
Console.WriteLine("RootObjectType: " + e.RootObjectType);
Console.WriteLine("RootObjectImplements: " + e.ConnectionURL);
Console.WriteLine("ConnectionURL: " + String.Join(", ", e.ConnectionURL));
Console.WriteLine("NodeID: " + e.NodeID.ToString());
Console.WriteLine("NodeName: " + e.NodeName);
Console.WriteLine();
}
RobotRaconteurNode.s.Shutdown();
}
else if (command == "findnodebyid")
{
var nodeid = new NodeID(args[1]);
string[] schemes = args[2].Split(new char[] { ',' });
var t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
System.Threading.Thread.Sleep(6000);
var r = RobotRaconteurNode.s.FindNodeByID(nodeid, schemes).Result;
foreach (var e in r)
{
Console.WriteLine("NodeID: " + e.NodeID);
Console.WriteLine("NodeName: " + e.NodeName);
Console.WriteLine("ConnectionURL: " + String.Join(", ", e.ConnectionURL));
Console.WriteLine();
}
RobotRaconteurNode.s.Shutdown();
}
else if (command == "findnodebyname")
{
var name = args[1];
string[] schemes = args[2].Split(new char[] { ',' });
var t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
System.Threading.Thread.Sleep(6000);
var r = RobotRaconteurNode.s.FindNodeByName(name, schemes).Result;
foreach (var e in r)
{
Console.WriteLine("NodeID: " + e.NodeID);
Console.WriteLine("NodeName: " + e.NodeName);
Console.WriteLine("ConnectionURL: " + String.Join(", ", e.ConnectionURL));
Console.WriteLine();
}
RobotRaconteurNode.s.Shutdown();
}
else if (command == "robdeftest")
{
var robdef_filenames = args.Skip(1).ToArray();
var defs = new Dictionary <string, ServiceDefinition>();
var defs2 = new Dictionary <string, ServiceDefinition>();
foreach (var fname in robdef_filenames)
{
string robdef_text = new StreamReader(fname).ReadToEnd();
var def = new ServiceDefinition();
def.FromString(robdef_text);
defs.Add(def.Name, def);
string robdef_text2 = def.ToString();
var def3 = new ServiceDefinition();
def3.FromString(robdef_text2);
defs2.Add(def3.Name, def3);
}
ServiceDefinitionUtil.VerifyServiceDefinitions(defs);
foreach (var n in defs.Keys)
{
if (!ServiceDefinitionUtil.CompareServiceDefinitions(defs[n], defs2[n]))
{
throw new Exception("Service definition parse does not match");
}
}
foreach (var def in defs.Values)
{
Console.WriteLine(def.ToString());
}
foreach (var def in defs.Values)
{
foreach (var c in def.Constants.Values)
{
if (c.Name == "strconst")
{
var strconst = c.ValueToString();
Console.WriteLine("strconst " + strconst);
var strconst2 = ConstantDefinition.EscapeString(strconst);
var strconst3 = ConstantDefinition.UnescapeString(strconst2);
if (strconst3 != strconst)
{
throw new Exception("");
}
}
if (c.Name == "int32const")
{
Console.WriteLine("int32const: " + c.ValueToScalar <int>());
}
if (c.Name == "int32const_array")
{
var a = c.ValueToArray <int>();
Console.WriteLine("int32const_array: " + a.Length);
}
if (c.Name == "doubleconst_array")
{
var a = c.ValueToArray <double>();
Console.WriteLine("doubleconst_array: " + a.Length);
}
if (c.Name == "structconst")
{
var s = c.ValueToStructFields();
foreach (var f in s)
{
Console.Write(f.Name + ": " + f.ConstantRefName + " ");
}
Console.WriteLine();
}
}
}
ServiceDefinition def1;
if (defs.TryGetValue("com.robotraconteur.testing.TestService1", out def1))
{
var entry = def1.Objects["testroot"];
var p1 = (PropertyDefinition)entry.Members["d1"];
if (p1.Direction != MemberDefinition_Direction.both)
{
throw new Exception();
}
var p2 = (PipeDefinition)entry.Members["p1"];
if (p2.Direction != MemberDefinition_Direction.both)
{
throw new Exception();
}
if (p2.IsUnreliable)
{
throw new Exception();
}
var w1 = (WireDefinition)entry.Members["w1"];
if (w1.Direction != MemberDefinition_Direction.both)
{
throw new Exception();
}
var m1 = (MemoryDefinition)entry.Members["m1"];
if (m1.Direction != MemberDefinition_Direction.both)
{
throw new Exception();
}
}
ServiceDefinition def2;
if (defs.TryGetValue("com.robotraconteur.testing.TestService3", out def2))
{
var entry = def2.Objects["testroot3"];
var p1 = (PropertyDefinition)entry.Members["readme"];
if (p1.Direction != MemberDefinition_Direction.readonly_)
{
throw new Exception();
}
var p2 = (PropertyDefinition)entry.Members["writeme"];
if (p2.Direction != MemberDefinition_Direction.writeonly)
{
throw new Exception();
}
var p3 = (PipeDefinition)entry.Members["unreliable1"];
if (p3.Direction != MemberDefinition_Direction.readonly_)
{
throw new Exception();
}
if (!p3.IsUnreliable)
{
throw new Exception();
}
var p4 = (PipeDefinition)entry.Members["unreliable2"];
if (p4.Direction != MemberDefinition_Direction.both)
{
throw new Exception();
}
if (!p4.IsUnreliable)
{
throw new Exception();
}
var w1 = (WireDefinition)entry.Members["peekwire"];
if (w1.Direction != MemberDefinition_Direction.readonly_)
{
throw new Exception();
}
var w2 = (WireDefinition)entry.Members["pokewire"];
if (w2.Direction != MemberDefinition_Direction.writeonly)
{
throw new Exception();
}
var m1 = (MemoryDefinition)entry.Members["readmem"];
if (m1.Direction != MemberDefinition_Direction.readonly_)
{
throw new Exception();
}
Console.WriteLine("Found it");
}
return;
}
else
if (command == "loopback2")
{
var t = new TcpTransport();
t.StartServer(22332);
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService3.com__robotraconteur__testing__TestService3Factory());
var s1 = new RobotRaconteurTestServiceSupport2();
s1.RegisterServices(t);
ServiceTestClient2 s = new ServiceTestClient2();
s.RunFullTest("rr+tcp://localhost:22332/?service=RobotRaconteurTestService2")
.GetAwaiter().GetResult();
RobotRaconteurNode.s.Shutdown();
}
else
if (command == "client2")
{
var url = args[1];
int count = 1;
if (args.Length >= 3)
{
count = Int32.Parse(args[2]);
}
var t = new TcpTransport();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService3.com__robotraconteur__testing__TestService3Factory());
for (int i = 0; i < count; i++)
{
ServiceTestClient2 s = new ServiceTestClient2();
s.RunFullTest(url).GetAwaiter().GetResult();
}
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test complete, no errors detected");
}
else
{
throw new Exception("Unknown command");
}
}
public string RemovePath(string path)
{
return(ServiceDefinitionUtil.SplitQualifiedName(path).Item2);
}
