public MyException(System.Runtime.Serialization.SerializationInfo info,
System.Runtime.Serialization.StreamingContext context)
: base(info, context)
{
campo = info.GetInt32("campo");
mo = (MyRemoteInterface)info.GetValue("mo", typeof(MyRemoteInterface));
}
static void Main(string[] args)
{
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, false);
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface),
"tcp://localhost:8086/MyRemoteObjectName");
if (obj == null)
{
System.Console.WriteLine("Could not locate server");
}
if (args.Length == 0)
{
executeMain(0, "");
}
else if (args.Length == 0)
{
executeMain(1, args[0]);
}
else
{
return;
}
}
static void Main()
{
// allocate and register channel
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, true);
// get reference to remote service
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface),
"tcp://localhost:8086/MyRemoteObjectName");
try {
// first a simple synchronous call
Console.WriteLine(obj.MetodoOla());
// change this to true to use the callback (alt.2)
bool useCallback = false;
if (!useCallback)
{
// Alternative 1: asynchronous call without callback
// Create delegate to remote method
RemoteAsyncDelegate RemoteDel = new RemoteAsyncDelegate(obj.MetodoOla);
// Call delegate to remote method
IAsyncResult RemAr = RemoteDel.BeginInvoke(null, null);
// Wait for the end of the call and then explictly call EndInvoke
RemAr.AsyncWaitHandle.WaitOne();
Console.WriteLine(RemoteDel.EndInvoke(RemAr));
}
else
{
// Alternative 2: asynchronous call with callback
// Create delegate to remote method
RemoteAsyncDelegate RemoteDel = new RemoteAsyncDelegate(obj.MetodoOla);
// Create delegate to local callback
AsyncCallback RemoteCallback = new AsyncCallback(Client.OurRemoteAsyncCallBack);
// Call remote method
IAsyncResult RemAr = RemoteDel.BeginInvoke(RemoteCallback, null);
}
}
catch (SocketException) {
System.Console.WriteLine("Could not locate server");
}
catch (MyException e) {
Console.WriteLine("I caught an exception: " + e.campo);
Console.WriteLine("I caught an exception: " + e.mo.OlaSemExcepcao());
}
Console.ReadLine();
}
public void executeByPuppet()
{
int urlRead = 0;
BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
provider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
string name = "s";
int port = 8086;
if (uri != null)
{
props["port"] = uri.Port;
port = uri.Port;
}
else
{
props["port"] = 8086;
}
if (id != null)
{
props["name"] = id;
name = id;
}
TcpChannel channel = new TcpChannel(props, null, provider);
ChannelServices.RegisterChannel(channel, false);
MyRemoteInterface obj = null;
while (obj == null)
{
try
{
String reference = "tcp://localhost:" + urls[urlRead].Port + "/MyRemoteObjectName/" + names[urlRead];
obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
if (obj == null)
{
urlRead++;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.ReadLine();
}
}
executeMain(obj, 1, fileName, urlRead);
}
public void clean()
{
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, false);
String reference = "tcp://localhost:50001/MyRemoteObjectName";
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
// The GetManuallyMarshaledObject() method uses RemotingServices.Marshal()
// to create an ObjRef object for a SampleTwo object.
ObjRef objRefSampleTwo = obj.GetManuallyMarshaledObject();
SampleTwo objectSampleTwo = (SampleTwo)RemotingServices.Unmarshal(objRefSampleTwo);
}
public void updateReplicas(IDictionary <string, List <List <Field> > > tupleSpace2)
{
List <string> serversDown = new List <string>();
Console.WriteLine("IM OBJECT " + uri.Port + "and im updating:------------");
foreach (string s in urls.Keys)
{
Console.WriteLine("Server " + s);
}
Console.WriteLine("--------------------------------------------------------");
List <Task> TaskList = new List <Task>();
Task t = null;
foreach (string s in urls.Keys)
{
if (urls[s].Equals(uri))
{
continue;
}
String reference = "tcp://localhost:" + urls[s].Port + "/MyRemoteObjectName/" + s;
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
t = new Task(() =>
{
try
{
obj.update(tupleSpace2);
}
catch (Exception e)
{
if (e is RemotingException || e is SocketException)
{
serversDown.Add(s);
}
}
});
t.Start();
TaskList.Add(t);
}
Task.WaitAll(TaskList.ToArray());
foreach (string down in serversDown)
{
urls.Remove(down);
}
}
static void Main(string[] args)
{
try
{
BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
provider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = 0;
props["name"] = "c";
TcpChannel channel = new TcpChannel(props, null, provider);
ChannelServices.RegisterChannel(channel, false);
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface),
"tcp://localhost:8086/MyRemoteObjectName/s");
if (obj == null)
{
System.Console.WriteLine("Could not locate server");
}
if (args.Length == 0)
{
executeMain(obj, 0, "", 0);
}
else if (args.Length == 0)
{
executeMain(obj, 1, args[0], 0);
}
else
{
return;
}
}
catch (Exception e)
{
Console.WriteLine(e.GetType());
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.Message);
Console.ReadLine();
}
}
static void Main()
{
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel, false);
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface),
"tcp://localhost:8086/MyRemoteObjectName");
if (obj == null)
{
System.Console.WriteLine("Could not locate server");
}
else
{
try {
Console.WriteLine(obj.MetodoOla());
} catch (MyException e) {
Console.WriteLine("I caught an exception: " + e.campo);
Console.WriteLine("I caught an exception: " + e.mo.OlaSemExcepcao());
}
}
Console.ReadLine();
}
public MyException(int c, MyRemoteInterface mo)
{
campo = c;
this.mo = mo;
}
public static void executeMain(MyRemoteInterface obj, int args, string arg, int urlRead)
{
string str_fields = "";
List <string> cmds = new List <string>();
List <string> field_list = new List <string>();
List <List <string> > field_list2 = new List <List <string> >();
List <List <Field> > lField;
string[] cmd_params;
string cmd = "";
int delay = 0;
int repeat = 0;
if (args == 1)
{
string[] lines = File.ReadAllLines(arg);
foreach (string l in lines)
{
if (l.Length == 0)
{
continue;
}
if (l.Contains("end"))
{
cmd = l;
}
else
{
cmd_params = l.Split(' ');
cmd = cmd_params[0];
str_fields = cmd_params[1];
if (cmd.Contains("repeat") || cmd.Equals("wait"))
{
Console.WriteLine("status command " + cmd + " " + cmd_params[1]);
}
else
{
if (cmd_params.Length > 2)
{
return;
}
field_list = argumentParser(str_fields);
}
}
int sent = 0;
while (sent == 0)
{
try
{
switch (cmd)
{
case "add":
obj.add(field_list);
if (repeat > 0)
{
field_list2.Add(field_list);
cmds.Add(cmd);
}
sent = 1;
break;
case "read":
lField = obj.readTuple(field_list);
if (repeat > 0)
{
field_list2.Add(field_list);
cmds.Add(cmd);
}
while (lField == null)
{
lField = obj.readTuple(field_list);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
sent = 1;
break;
case "take":
if (repeat > 0)
{
field_list2.Add(field_list);
cmds.Add(cmd);
}
lField = obj.take(field_list);
while (lField == null)
{
lField = obj.take(field_list);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
sent = 1;
break;
case "wait":
Int32.TryParse(str_fields, out delay);
System.Threading.Thread.Sleep(delay);
if (repeat > 0)
{
List <string> x = new List <string>();
x.Add(str_fields);
field_list2.Add(x);
cmds.Add(cmd);
}
sent = 1;
break;
case "begin-repeat":
Int32.TryParse(str_fields, out repeat);
sent = 1;
break;
case "end-repeat":
for (int i = 0; i < (repeat - 1); i++)
{
repeatCmd(obj, field_list2, cmds);
}
repeat = 0;
sent = 1;
break;
}
}
catch (Exception e)
{
if (e is RemotingException || e is SocketException)
{
Thread.Sleep(7000);
urlRead++;
Console.WriteLine("SERVER CRASHED, REPLACING REMOTE OBJECT");
String reference = "";
bool set = false;
while (!set)
{
reference = "tcp://localhost:" + urls[urlRead].Port + "/MyRemoteObjectName/" + names[urlRead];
obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
Console.WriteLine("Trying: " + reference);
if (obj == null)
{
urlRead++;
continue;
}
else
{
set = true;
break;
}
}
}
}
}
sent = 0;
}
}
else
{
try
{
while (true)
{
Console.WriteLine("Write a command add|take|read <field1,field2,...,fieldn> (exit:to leave) :");
string l = Console.ReadLine();
if (l.Length == 0)
{
continue;
}
cmd_params = l.Split(' ');
cmd = cmd_params[0];
str_fields = cmd_params[1].Replace("\n", "");
field_list = argumentParser(str_fields);
if (cmd.Equals("exit"))
{
Console.WriteLine("Exiting");
break;
}
switch (cmd)
{
case "add":
obj.add(field_list);
break;
case "read":
lField = obj.readTuple(field_list);
while (lField == null)
{
lField = obj.readTuple(field_list);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
break;
case "take":
lField = obj.take(field_list);
while (lField == null)
{
lField = obj.readTuple(field_list);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
break;
default: Console.WriteLine("Invalid Command : {0}. Please,use the correct command syntax.", cmd); break;
}
}
}
catch (SocketException)
{
System.Console.WriteLine("Could not locate server");
}
catch (ArgumentOutOfRangeException)
{
System.Console.WriteLine("bad input format1\nadd|take|read <field1,field2,...,fieldn>\nEx: add <\"ola\">");
executeMain(obj, args, arg, urlRead);
}
catch (IndexOutOfRangeException)
{
System.Console.WriteLine("bad input format2\nadd|take|read <field1,field2,...,fieldn>\nEx: add <\"ola\">");
executeMain(obj, args, arg, urlRead);
}
catch (RemotingException e)
{
System.Console.WriteLine("OBJJJJ");
Console.WriteLine(e.GetType());
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.Message);
obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface),
"tcp://localhost:8086/MyRemoteObjectName/s");
executeMain(obj, args, arg, urlRead);
}
}
}
public static void repeatCmd(MyRemoteInterface obj, List <List <string> > field_list2, List <string> cmds)
{
int delay = 0;
List <List <Field> > lField;
for (int i = 0; i < cmds.Count; i++)
{
switch (cmds[i])
{
case "add":
obj.add(field_list2[i]);
break;
case "read":
lField = obj.readTuple(field_list2[i]);
while (lField == null)
{
lField = obj.readTuple(field_list2[i]);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
break;
case "take":
lField = obj.take(field_list2[i]);
while (lField == null)
{
lField = obj.take(field_list2[i]);
}
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
break;
case "wait":
Int32.TryParse(field_list2[i][0], out delay);
System.Threading.Thread.Sleep(delay);
Console.WriteLine(delay);
break;
}
}
}
public static void repeatCmd(List <List <string> > field_list2, List <string> cmds)
{
int delay = 0;
List <List <Field> > lField = null;
List <List <List <Field> > > lField2 = null;
for (int i = 0; i < cmds.Count; i++)
{
int y = 0;
List <Task> TaskList = new List <Task>();
lField2 = new List <List <List <Field> > >();
Task t = null;
int read = 0;
int add = 0;
foreach (string server in names)
{
Console.WriteLine("Sending to server in" + urls[y] + "named " + server + " command: " + cmds[i]);
String reference = "tcp://localhost:" + urls[y].Port + "/MyRemoteObjectName/" + server;
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
if (obj != null)
{
switch (cmds[i])
{
case "add":
add += 1;
t = new Task(() =>
{
obj.add(field_list2[i]);
});
break;
case "read":
read += 1;
t = new Task(() =>
{
lField = obj.readTuple(field_list2[i]);
while (lField == null)
{
lField = obj.readTuple(field_list2[i]);
}
lField2.Add(lField);
});
break;
case "take":
t = new Task(() =>
{
lField = obj.take(field_list2[i]);
while (lField == null)
{
lField = obj.take(field_list2[i]);
}
lField2.Add(lField);
});
break;
case "wait":
Int32.TryParse(field_list2[i][0], out delay);
System.Threading.Thread.Sleep(delay);
Console.WriteLine("delaying :" + delay);
break;
}
}
if (t != null)
{
t.Start();
TaskList.Add(t);
}
y++;
}
y = 0;
Thread.Sleep(2000);
if (read > 0)
{
Task.WaitAny(TaskList.ToArray());
read = 0;
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
continue;
}
else if (add > 0)
{
Task.WaitAll(TaskList.ToArray());
add = 0;
continue;
}
else
{
List <List <Field> > tuplesToTake = new List <List <Field> >();
Random getrandom = new Random();
Task.WaitAll(TaskList.ToArray());
Console.WriteLine("--------------------------------------------------------------------------------");
foreach (List <List <Field> > lls in lField2)
{
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine(" TUPLES SELECTED FROM ");
foreach (List <Field> ls in lls)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
}
Console.WriteLine("--------------------------------------------------------------------------------");
/* int rand = getrandom.Next(0, lField2.Count);
* tuplesToTake = lField2[rand];
* TaskList = new List<Task>();
* lField2 = new List<List<List<Field>>>();
* foreach (string server in names)
* {
*
* Console.WriteLine("Sending to server in" + urls[y] + "named " + server + " command: ");
* String reference = "tcp://localhost:" + urls[y].Port + "/MyRemoteObjectName/" + server;
* MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
* typeof(MyRemoteInterface), reference);
* t = new Task(() =>
* {
* lField = obj.take(field_list2[i]);
* while (lField == null)
* lField = obj.take(field_list2[i]);
* lField2.Add(lField);
* });
* t.Start();
* TaskList.Add(t);
* }
* Task.WaitAll(TaskList.ToArray());*/
}
}
}
public static void executeMain(int args, string arg)
{
string str_fields = "";
List <string> cmds = new List <string>();
List <string> field_list = new List <string>();
List <List <string> > field_list2 = new List <List <string> >();
List <List <Field> > lField = new List <List <Field> >();
List <List <List <Field> > > lField2 = new List <List <List <Field> > >();
string[] cmd_params;
string cmd = "";
int delay = 0;
int repeat = 0;
int read = 0;
int add = 0;
if (args == 1)
{
string[] lines = File.ReadAllLines(arg);
foreach (string l in lines)
{
lField2 = new List <List <List <Field> > >();
if (l.Length == 0)
{
continue;
}
if (l.Contains("end"))
{
cmd = l;
}
else
{
cmd_params = l.Split(' ');
cmd = cmd_params[0];
str_fields = cmd_params[1];
if (cmd.Contains("repeat") || cmd.Equals("wait"))
{
Console.WriteLine("status command " + cmd + " " + cmd_params[1]);
}
else
{
if (cmd_params.Length > 2)
{
return;
}
field_list = argumentParser(str_fields);
}
}
Console.WriteLine(l);
int y = 0;
List <Task> TaskList = new List <Task>();
Task t = null;
switch (cmd)
{
case "wait":
Int32.TryParse(str_fields, out delay);
System.Threading.Thread.Sleep(delay);
Console.WriteLine("delaying :" + delay);
break;
case "begin-repeat":
Int32.TryParse(str_fields, out repeat);
break;
case "end-repeat":
for (int i = 0; i < (repeat - 1); i++)
{
repeatCmd(field_list2, cmds);
}
repeat = 0;
break;
default:
foreach (string server in names)
{
Console.WriteLine("Sending to server in" + urls[y] + "named " + server + " command: " + l);
String reference = "tcp://localhost:" + urls[y].Port + "/MyRemoteObjectName/" + server;
MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
typeof(MyRemoteInterface), reference);
if (obj != null)
{
switch (cmd)
{
case "add":
add += 1;
t = new Task(() =>
{
obj.add(field_list);
});
break;
case "read":
read += 1;
t = new Task(() =>
{
lField = obj.readTuple(field_list);
while (lField == null)
{
lField = obj.readTuple(field_list);
}
lField2.Add(lField);
});
break;
case "take":
t = new Task(() =>
{
lField = obj.take(field_list);
while (lField == null)
{
lField = obj.take(field_list);
}
lField2.Add(lField);
});
break;
}
}
if (t != null)
{
t.Start();
TaskList.Add(t);
}
y++;
}
if (repeat > 0)
{
if (!cmd.Contains("repeat"))
{
if (cmd.Equals("wait"))
{
List <string> sl = new List <string>();
sl.Add(str_fields);
field_list2.Add(sl);
}
else
{
field_list2.Add(field_list);
}
cmds.Add(cmd);
}
}
y = 0;
Thread.Sleep(2000);
if (read > 0)
{
Task.WaitAny(TaskList.ToArray());
read = 0;
foreach (List <Field> ls in lField)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
continue;
}
else if (add > 0)
{
Task.WaitAll(TaskList.ToArray());
add = 0;
continue;
}
else
{
List <List <Field> > tuplesToTake = new List <List <Field> >();
Random getrandom = new Random();
Task.WaitAll(TaskList.ToArray());
Console.WriteLine("--------------------------------------------------------------------------------");
foreach (List <List <Field> > lls in lField2)
{
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine(" TUPLES SELECTED FROM ");
foreach (List <Field> ls in lls)
{
foreach (Field f in ls)
{
if (f.getType() == 0 || f.getType() == 2)
{
Console.WriteLine(f.getClassName());
}
else
{
Console.WriteLine(f.getString());
}
}
}
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
}
Console.WriteLine("--------------------------------------------------------------------------------");
/*int rand = getrandom.Next(0, lField2.Count);
* TaskList = new List<Task>();
* lField2 = new List<List<List<Field>>>();
* foreach (string server in names)
* {
*
* Console.WriteLine("Sending to server in" + urls[y] + "named " + server + " command: " + l);
* String reference = "tcp://localhost:" + urls[y].Port + "/MyRemoteObjectName/" + server;
* MyRemoteInterface obj = (MyRemoteInterface)Activator.GetObject(
* typeof(MyRemoteInterface), reference);
* t = new Task(() =>
* {
* lField = obj.take(field_list);
* while (lField == null)
* lField = obj.take(field_list);
* lField2.Add(lField);
* });
* t.Start();
* TaskList.Add(t);
* }
* Task.WaitAll(TaskList.ToArray());*/
}
break;
}
}
}
}
