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(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 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 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;
}
}
}
}
