public void CreateWorker(string id, string puppetMasterUrl, string serviceUrl, string entryUrl)
{
Logger.LogInfo("[WORKER] " + id + " " + puppetMaster + " " + serviceUrl + " " + entryUrl);
if (puppetMasterUrl != "")
{
Logger.LogInfo("CONTACTING PUPPET MASTER");
try
{
IPuppetMaster pm = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), puppetMasterUrl);
pm.CreateWorker(id, puppetMasterUrl, serviceUrl, entryUrl);
}
catch (Exception ex)
{
if (ex is RemotingException || ex is SocketException)
{
Logger.LogErr("Puppet Master @ " + puppetMasterUrl + " is down. --> " + ex.Message);
}
}
}
else
{
IPuppetMaster p = new PM();
p.CreateWorker(id, puppetMasterUrl, serviceUrl, entryUrl);
}
Logger.LogInfo("Waiting 1 second for node start");
Thread.Sleep(1000);
}
public bool CreateWorker(string id, string puppetMasterUrl, string serviceUrl, string entryUrl)
{
// Convert the localhost's to local IP address
Uri puppetMasterUri = ConvertLocalhostInUri(puppetMasterUrl);
Uri serviceUri = ConvertLocalhostInUri(serviceUrl);
Uri entryUri = ConvertLocalhostInUri(entryUrl);
// If the PuppetMaster is my own
if (puppetMasterUri.Equals(url))
{
// Add worker to the HashMap
workers.Add(new KeyValuePair <int, String>(int.Parse(id), serviceUri.ToString()));
// Start the worker process
string workerExecutablePath = Path.Combine(Directory.GetParent(System.IO.Directory.GetCurrentDirectory()).Parent.Parent.FullName, "Worker\\bin\\Debug\\Worker.exe");
Process.Start(workerExecutablePath, id + " " + serviceUri.ToString() + " " + entryUri.ToString());
Console.WriteLine("Created worker " + id + " at " + serviceUri.ToString() + ". Entry Level:" + entryUri.ToString() + ".");
Thread.Sleep(500);
return(true);
}
else
{
// Retrieve the remote Puppet Master object
IPuppetMaster puppetMasterObj = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), puppetMasterUri.ToString());
// Create the worker in the remote Puppet Master
puppetMasterObj.CreateWorker(id, puppetMasterUri.ToString(), serviceUri.ToString(), entryUri.ToString());
}
return(false);
}
public Client(Node info,TcpChannel channel, IPuppetMaster puppet, ICentralDirectory cd)
{
Registers = new string[10];
Info = info;
Channel = channel;
Puppet = puppet;
CD = cd;
}
public PuppetMaster(int id)
{
TcpChannel channel = new TcpChannel(20000 + id);
ChannelServices.RegisterChannel(channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(PuppetMasterRemote), "PM", WellKnownObjectMode.Singleton);
this.me = ((IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), "tcp://localhost:" + (20000 + id).ToString() + "/PM"));
}
internal void callRemoteWaitWorker(int workerId, int seconds)
{
String puppetToConnect = workerPuppetMap[workerId];
IPuppetMaster puppet = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppetToConnect);
puppet.slowWorker(seconds, workerId);
}
internal void callRemoteFreezeWorker(int workerId)
{
String puppetToConnect = workerPuppetMap[workerId];
IPuppetMaster puppet = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppetToConnect);
puppet.freezeWorker(workerId);
}
internal void callRemoteUnfreezeTracker(int trackerId)
{
String puppetToConnect = workerPuppetMap[trackerId];
IPuppetMaster puppet = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppetToConnect);
puppet.unfreezeTracker(trackerId);
}
private void PuppetMaster_Go(IPuppetMaster master)
{
try
{
master.BuyPlayers();
}
catch (Exception ex)
{
Logger.Log(LogType.Error, $"Error in program: {ex.Message} \n{ex.StackTrace}");
System.Windows.Forms.MessageBox.Show("Error in program. Please close program and browser and try again");
}
}
internal void callPuppetsDisplayStatus()
{
// displayStatus();//display status on local node
for (int i = 0; i < puppetUrlList.Count; i++)//including myself
{
IPuppetMaster puppet = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppetUrlList[i]);
puppet.displayStatus();//display status on remote nodes
}
}
public void sendToPM(string msg)
{
if (!(msg.StartsWith("BroEvent") && lightLog))
{
string cfgpath = @"..\..\..\cfg.txt";
StreamReader script = new StreamReader(cfgpath);
String Line = script.ReadLine();
IPuppetMaster pm = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
Line);
pm.toLog(msg);
}
}
private static void addPuppetListener(Node node, string puppet)
{
Console.WriteLine("addPuppetListener " + puppet);
IPuppetMaster pMaster = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), puppet);
string sender = node.URL;
node.JoinEvent += (url) => { pMaster.reportJoinEvent(sender, url); };
node.DisconectedEvent += (url) => { pMaster.reportDisconectionEvent(sender, url); };
node.TrackerChangeEvent += (url) => { pMaster.reportTrackerChangeEvent(sender, url); };
node.WorkStartEvent += (peer, split, clientUrl) => { pMaster.reportWorkStartEvent(sender, peer, split, clientUrl); };
node.WorkEndEvent += (peer) => { pMaster.reportWorkEndEvent(sender, peer); };
node.JobDoneEvent += (url) => { pMaster.reportJobDoneEvent(sender, url); };
node.NewJobEvent += (splits, mapper, classname, clientUrl) => { pMaster.reportNewJobEvent(sender, splits, mapper, classname, clientUrl); };
}
internal void createWorker(WorkerMetadata workerMetadata)
{
String puppetToConnect = workerMetadata.PuppetRUL;
if (puppetToConnect.ToLower().Equals(puppetUrl.ToLower()))//worker can be started through local puppet
{
createLocalWorker(workerMetadata);
}
else //worker started through remote puppet
{
IPuppetMaster puppet = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppetToConnect);
puppet.createLocalWorker(workerMetadata);
}
}
private void workerCmd(int id, string puppetUrl, string serviceUrl, string entryUrl)
{
String command = "WORKER " + id + " " + puppetUrl + " " + serviceUrl + " " + entryUrl;
workers.Add(id, serviceUrl);
//TODO add code here
IPuppetMaster pm = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), puppetUrl);
if (pm.createWorker(id, serviceUrl, entryUrl))
{
AddToLog(command);
}
else
{
AddToLog("Invalid Command: " + command);
}
}
public void unsubscribe(string processName, string topicName)
{
if (this.single || this.site == (this.subsWithSite[processName]))
{
Console.WriteLine(subsWithUrl[processName]);
ISubscriber subscriber = (ISubscriber)Activator.GetObject(
typeof(ISubscriber),
this.subsWithUrl[processName]);
subscriber.UnsubEvent(topicName);
}
else
{
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[this.subsWithSite[processName]]);
puppetM.unsubscribe(processName, topicName);
}
}
public void publish(string processName, string numberEvents, string topicName, string interval)
{
if (this.single || this.site == (this.pubWithSite[processName]))
{
Console.WriteLine(pubWithUrl[processName]);
IPublisher publisher = (IPublisher)Activator.GetObject(
typeof(IPublisher),
this.pubWithUrl[processName]);
publisher.pubEvent(numberEvents, topicName, interval);
}
else
{
//IPuppetMaster puppetM = PuppetMaster
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[this.pubWithSite[processName]]);
puppetM.publish(processName, numberEvents, topicName, interval);
}
}
public void addBroker(string name, string site, string URL, string URLParent)
{
int siteB = convertStoI(site);
if (this.single || this.site == siteB)
{
String arguments = name + " " + site + " " + URL + " " + URLParent + " " + policy + " " + order + " " + logLvl;
String filename = @"..\..\..\Broker\bin\Debug\Broker.exe";
Process.Start(filename, arguments);
}
else
{
//Remote PuppetSlave starts the process.
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[siteB]);
puppetM.addBroker(name, site, URL, URLParent);
}
this.brokers.Add(name, URL);
this.brokersSite.Add(siteB, URL);
this.brokerNameSite.Add(name, siteB);
}
public void addPublisher(string name, string site, string url)
{
int siteB = convertStoI(site);
string urlbroker = this.brokersSite[siteB];
if (this.single || this.site == siteB)
{
String arguments = name + " " + site + " " + url + " " + urlbroker;
String filename = @"..\..\..\Publisher\bin\Debug\Publisher.exe";
Process.Start(filename, arguments);
}
else
{
//Remote Puppet Code.
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[siteB]);
puppetM.addPublisherRemote(name, site, url, urlbroker);
}
this.pubWithUrl.Add(name, url);
this.pubWithSite.Add(name, siteB);
}
public PuppetMasterService(IPuppetMaster puppetMaster)
{
this.puppetMaster = puppetMaster;
this.logger = puppetMaster.GetLogger();
workers = new List<IWorker>();
}
static void Main(string[] args)
{
System.IO.File.WriteAllText(@"log.txt", string.Empty);
TcpChannel channel = new TcpChannel(30000);
ChannelServices.RegisterChannel(channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(RemotePuppetMaster),
"puppet",
WellKnownObjectMode.Singleton);
FileParsing.ConfigurationData config = null;
try {
config = FileParsing.ConfigurationFile.ReadConfigurationFile(@"../../config.txt");
}
catch (Exception e) {
Console.WriteLine("Error reading configuration file.");
Console.ReadLine();
return;
}
if (config == null)
{
Console.WriteLine("Error.");
Console.ReadLine();
return;
}
pmAddress = "tcp://" + config.PuppetMasterIP + ":30000/puppet";
// Check what type of puppet master this process should be
Console.WriteLine("Should I be the Main or a Slave Puppet Master?");
Console.WriteLine(" 1 - Main PM");
Console.WriteLine(" 2 - Slave PM");
ConsoleKeyInfo keyInfo;
int type = 0;
while (true)
{
keyInfo = Console.ReadKey();
Console.WriteLine();
if (keyInfo.KeyChar == '1')
{
type = 0;
break;
}
else if (keyInfo.KeyChar == '2')
{
type = 1;
break;
}
else
{
Console.Write("Enter 1 or 2: ");
}
}
if (type == 1)
{
Console.WriteLine(" .. Waiting for commands ..");
Console.WriteLine("====== PRESS ANY KEY TO QUIT ======");
Console.ReadLine();
return;
}
// Main process master
Console.WriteLine("Creating processes..");
foreach (FileParsing.Process processData in config.processes)
{
//Process newProcess = new Process();
if (processData.type == FileParsing.ProcessType.Broker)
{
// Configure the process using the StartInfo properties.
//newProcess.StartInfo.FileName = @"..\..\..\Broker\bin\Debug\Broker.exe";
// Como vamos ter que criar o canal de TCP com o porto, passamos aqui o endereco
//newProcess.StartInfo.Arguments = processData.port + " " + processData.serviceName + " " + processData.name;
//newProcess.Start();
string arguments = processData.port + " " + processData.serviceName + " " + processData.name + " " + config.GetOrdering() + " " + config.GetRoutingPolicy() + " " + config.GetLoggingLevel();
//Puppetmaster com o ip do processo
IPuppetMaster pup = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
"tcp://" + processData.ip + ":30000/puppet");
pup.CreateBroker(arguments);
IPuppetBroker obj = (IPuppetBroker)Activator.GetObject(
typeof(IPuppetBroker),
processData.url);
PuppetMaster.brokers.Add(processData.name, obj);
}
else if (processData.type == FileParsing.ProcessType.Publisher)
{
// Configure the process using the StartInfo properties.
//newProcess.StartInfo.FileName = @"..\..\..\Publisher\bin\Debug\Publisher.exe";
// Como vamos ter que criar o canal de TCP com o porto, passamos aqui o endereco
//newProcess.StartInfo.Arguments = processData.port + " " + processData.serviceName + " " + processData.name;
//newProcess.Start();
string arguments = processData.port + " " + processData.serviceName + " " + processData.name;
//Puppetmaster com o ip do processo
IPuppetMaster pup = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
"tcp://" + processData.ip + ":30000/puppet");
pup.CreatePublisher(arguments);
IPuppetPublisher obj = (IPuppetPublisher)Activator.GetObject(
typeof(IPuppetPublisher),
processData.url);
PuppetMaster.publishers.Add(processData.name, obj);
}
else if (processData.type == FileParsing.ProcessType.Subscriber)
{
// Configure the process using the StartInfo properties.
//newProcess.StartInfo.FileName = @"..\..\..\Subscriber\bin\Debug\Subscriber.exe";
// Como vamos ter que criar o canal de TCP com o porto, passamos aqui o endereco
//newProcess.StartInfo.Arguments = processData.port + " " + processData.serviceName + " " + processData.name;
//newProcess.Start();
string arguments = processData.port + " " + processData.serviceName + " " + processData.name;
//Puppetmaster com o ip do processo
IPuppetMaster pup = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
"tcp://" + processData.ip + ":30000/puppet");
pup.CreateSubscriber(arguments);
IPuppetSubscriber obj = (IPuppetSubscriber)Activator.GetObject(
typeof(IPuppetSubscriber),
processData.url);
PuppetMaster.subscribers.Add(processData.name, obj);
}
IPuppetProcess obj2 = (IPuppetProcess)Activator.GetObject(
typeof(IPuppetProcess),
processData.url);
PuppetMaster.processes.Add(processData.name, obj2);
}
// Obter port mais alto para criar os brokers extra
int maxPort = 0;
foreach (FileParsing.Process processData in config.processes)
{
int port;
if (Int32.TryParse(processData.port, out port))
{
maxPort = System.Math.Max(maxPort, port);
}
}
// Criar Brokers de backup
foreach (FileParsing.Process processData in config.processes)
{
if (processData.type == FileParsing.ProcessType.Broker)
{
//Puppetmaster com o ip do processo
IPuppetMaster pup = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
"tcp://" + processData.ip + ":30000/puppet");
// Criar o segundo e terceiro brokers a partir da informacao do primeiro broker
int port1 = maxPort + 1;
int port2 = maxPort + 2;
string arguments = port1.ToString() + " " + processData.serviceName + " " + processData.name + "_1" + " " + config.GetOrdering() + " " + config.GetRoutingPolicy() + " " + config.GetLoggingLevel();
pup.CreateBroker(arguments);
arguments = port2.ToString() + " " + processData.serviceName + " " + processData.name + "_2" + " " + config.GetOrdering() + " " + config.GetRoutingPolicy() + " " + config.GetLoggingLevel();
pup.CreateBroker(arguments);
// Prepare port for next iteration
maxPort += 2;
string broker1Url = "tcp://" + processData.ip + ":" + port1.ToString() + "/" + processData.serviceName;
string broker2Url = "tcp://" + processData.ip + ":" + port2.ToString() + "/" + processData.serviceName;
// Obter interfaces dos processos para adicionar aos dicionarios
IPuppetBroker broker_1 = (IPuppetBroker)Activator.GetObject(
typeof(IPuppetBroker),
broker1Url);
IPuppetBroker broker_2 = (IPuppetBroker)Activator.GetObject(
typeof(IPuppetBroker),
broker2Url);
PuppetMaster.brokers.Add(processData.name + "_1", broker_1);
PuppetMaster.brokers.Add(processData.name + "_2", broker_2);
IPuppetProcess brokerP_1 = (IPuppetProcess)Activator.GetObject(
typeof(IPuppetBroker),
broker1Url);
IPuppetProcess brokerP_2 = (IPuppetProcess)Activator.GetObject(
typeof(IPuppetBroker),
broker2Url);
PuppetMaster.processes.Add(processData.name + "_1", brokerP_1);
PuppetMaster.processes.Add(processData.name + "_2", brokerP_2);
// Relacionar brokers de backup com o site e os brokers principais
FileParsing.Process newbrokerProcess1 = new FileParsing.Process(processData.name + "_1", broker1Url, processData.GetSite(), processData.type);
FileParsing.Process newbrokerProcess2 = new FileParsing.Process(processData.name + "_2", broker2Url, processData.GetSite(), processData.type);
// Join these processes in a BrokerNode
BrokerNode node = new BrokerNode();
IPuppetBroker originalBroker = brokers[processData.name];
node.AddBroker(originalBroker, processData);
node.AddBroker(broker_1, newbrokerProcess1);
node.AddBroker(broker_2, newbrokerProcess2);
node.site = processData.GetSite();
// Add this node under the name of the original node
brokerNodes.Add(processData.name, node);
}
}
// Make each process known to its neighbours
foreach (FileParsing.Process processData in config.processes)
{
IPuppetProcess objProcess;
processes.TryGetValue(processData.name, out objProcess);
if (objProcess != null)
{
objProcess.RegisterPuppetMaster(pmAddress);
}
if (processData.type == FileParsing.ProcessType.Broker)
{
FileParsing.Site site;
site = processData.GetSite();
IPuppetBroker obj;
brokers.TryGetValue(processData.name, out obj);
if (obj != null)
{
if (site.parent != null)
{
FileParsing.Process parentData = site.parent.broker;
String parentUrl = parentData.url;
String parentName = parentData.name;
// No replication
//Regista pai no filho
/*obj.RegisterChild( parentUrl, parentName );
*
* //Regista filho no pai
* IPuppetBroker objParent;
* brokers.TryGetValue( parentName, out objParent );
* if ( objParent != null ) {
* objParent.RegisterChild( processData.url, processData.name );
* }*/
// Replication
BrokerNode parentNode = brokerNodes[parentName];
if (parentNode != null)
{
// Regista pai no filho
obj.RegisterChildReplication(parentNode.GetListOfAddresses(), parentName);
obj.RegisterParentReplication(parentName);
}
BrokerNode childNode = null;
brokerNodes.TryGetValue(processData.name, out childNode);
if (childNode != null)
{
//Regista filho no pai
parentNode.brokers[0].RegisterChildReplication(childNode.GetListOfAddresses(), processData.name);
}
}
foreach (FileParsing.Process subProcess in site.subscribers)
{
obj.RegisterSubscriber(subProcess.url, subProcess.name);
}
foreach (FileParsing.Process pubProcess in site.publishers)
{
obj.RegisterPublisher(pubProcess.url);
}
}
}
if (processData.type == FileParsing.ProcessType.Subscriber)
{
FileParsing.Site site;
site = processData.GetSite();
IPuppetSubscriber obj;
subscribers.TryGetValue(processData.name, out obj);
// No replication
/*if ( obj != null)
* {
* obj.RegisterBroker(site.broker.url);
* }*/
// Replication - send the url of all Brokers in the node along with the original's name
BrokerNode node = brokerNodes[site.broker.name];
obj.RegisterBrokers(node.GetListOfAddresses());
}
if (processData.type == FileParsing.ProcessType.Publisher)
{
FileParsing.Site site;
site = processData.GetSite();
IPuppetPublisher obj;
publishers.TryGetValue(processData.name, out obj);
// No replication
/*if ( obj != null ) {
* obj.RegisterBroker( site.broker.url );
* }*/
// Replication - send the url of all Brokers in the node along with the original's name
BrokerNode node = brokerNodes[site.broker.name];
obj.RegisterBrokers(node.GetListOfAddresses());
}
}
// Ligar os brokers replica aos subscribers do site e brokers de outros sites
foreach (var node in PuppetMaster.brokerNodes)
{
FileParsing.Site site = node.Value.site;
Console.WriteLine("Processing site " + site.name);
if (site.parent != null)
{
FileParsing.Process parentData = site.parent.broker;
String parentNodeName = parentData.name;
// No replication
//Regista pai no filho
/*obj.RegisterChild( parentUrl, parentName );
*
* //Regista filho no pai
* IPuppetBroker objParent;
* brokers.TryGetValue( parentName, out objParent );
* if ( objParent != null ) {
* objParent.RegisterChild( processData.url, processData.name );
* }*/
BrokerNode parentNode = brokerNodes[parentNodeName];
for (int i = 1; i < 3; ++i)
{
// Replication
// Regista pai no filho
node.Value.brokers[i].RegisterChildReplication(parentNode.GetListOfAddresses(), parentNodeName);
node.Value.brokers[i].RegisterParentReplication(parentNodeName);
}
//Regista filhos no pai
for (int j = 1; j < 3; ++j)
{
parentNode.brokers[j].RegisterChildReplication(node.Value.GetListOfAddresses(), node.Value.site.broker.name);
}
}
for (int i = 1; i < 3; ++i)
{
((IPuppetProcess)node.Value.brokers[i]).RegisterPuppetMaster(pmAddress);
foreach (FileParsing.Process subProcess in site.subscribers)
{
node.Value.brokers[i].RegisterSubscriber(subProcess.url, subProcess.name);
}
foreach (FileParsing.Process pubProcess in site.publishers)
{
node.Value.brokers[i].RegisterPublisher(pubProcess.url);
}
}
}
// Make each replicated broker known to its neighbours
foreach (FileParsing.Process processData in config.processes)
{
if (processData.type == FileParsing.ProcessType.Broker)
{
FileParsing.Site site;
site = processData.GetSite();
BrokerNode broker = brokerNodes[processData.name];
for (int i = 0; i < 3; i++)
{
string url = broker.brokersData[i].url;
IPuppetBroker obj = broker.brokers[i];
obj.RegisterReplicas(broker.GetListOfAddressesExcept(url), processData.name, i);
}
}
}
// Criar sequencer se for ordem Total
if (config.GetOrdering() == FileParsing.Ordering.Total)
{
// Create Sequencer process
Process seqProcess = new Process();
// Configure the process using the StartInfo properties.
seqProcess.StartInfo.FileName = @"..\..\..\Sequencer\bin\Debug\Sequencer.exe";
seqProcess.Start();
string seqUrl = "tcp://" + config.PuppetMasterIP + ":8999/seq";
// Send sequencer url to all processes
foreach (var broker in brokers)
{
IPuppetBroker bro = broker.Value;
bro.RegisterSequencer(seqUrl);
}
}
// Puppet Master main loop
System.Console.WriteLine("Hi, I'm a puppet master...");
Console.WriteLine("Enter commands: ");
string command = "";
while (command != "exit")
{
Console.Write("> ");
command = System.Console.ReadLine();
ProcessCommand(command);
}
}
public void crash(string processName)
{
if (processName.Contains("publisher"))
{
if (this.site.Equals(this.pubWithSite[processName]) || this.single)
{
Console.WriteLine(pubWithUrl[processName]);
formP.BeginInvoke(formP.myDelegate, pubWithUrl[processName]);
IPublisher publisher = (IPublisher)Activator.GetObject(
typeof(IPublisher),
this.pubWithUrl[processName]);
SendCrashAsync RemoteDel = new SendCrashAsync(publisher.crash);
IAsyncResult RemAra = RemoteDel.BeginInvoke(null, null);
}
else
{
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[this.pubWithSite[processName]]);
puppetM.crash(processName);
}
}
if (processName.Contains("subscriber"))
{
if (this.site.Equals(this.subsWithSite[processName]) || this.single)
{
Console.WriteLine(subsWithUrl[processName]);
formP.BeginInvoke(formP.myDelegate, subsWithUrl[processName]);
ISubscriber subscriber = (ISubscriber)Activator.GetObject(
typeof(ISubscriber),
this.subsWithUrl[processName]);
SendCrashAsync RemoteDel = new SendCrashAsync(subscriber.crash);
IAsyncResult RemAra = RemoteDel.BeginInvoke(null, null);
}
else
{
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[this.subsWithSite[processName]]);
puppetM.crash(processName);
}
}
if (processName.Contains("broker"))
{
if (this.brokers.Equals(this.brokers[processName]) || this.single)
{
Console.WriteLine(brokers[processName]);
formP.BeginInvoke(formP.myDelegate, brokers[processName]);
IBroker broker = (IBroker)Activator.GetObject(
typeof(IBroker),
this.brokers[processName]);
SendCrashAsync RemoteDel = new SendCrashAsync(broker.crash);
IAsyncResult RemAra = RemoteDel.BeginInvoke(null, null);
}
else
{
IPuppetMaster puppetM = (IPuppetMaster)Activator.GetObject(
typeof(IPuppetMaster),
puppets[this.brokerNameSite[processName]]);
puppetM.crash(processName);
}
}
}
public void startWorker(int id, string pmUrl, string serviceUrl, string entryUrl)
{
IPuppetMaster goodLife = ((IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), pmUrl));
goodLife.startWorker(id, serviceUrl, entryUrl);
}
private static void HandleCommand(String input, String url)
{
IPuppetMaster puppetMaster = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), url);
string[] split = input.Split(' ');
if (split[split.Count() - 1] == "")
{
split = split.Take(split.Count() - 1).ToArray();
}
string command = split[0];
switch (command)
{
case WORKER:
/*
* WORKER <ID> <PUPPETMASTER-URL> <SERVICE-URL> <ENTRY-URL>
*/
if (split.Length <= 5)
{
//Create Client
string id = split[1];
string puppetMasterUrl = split[2];
string serviceUrl = split[3];
if (split.Length == 5)
{
string entryUrl = split[4];
puppetMaster.CreateWorker(id, puppetMasterUrl, serviceUrl, entryUrl);
}
else
{
puppetMaster.CreateWorker(id, puppetMasterUrl, serviceUrl);
}
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: WORKER <ID> <PUPPETMASTER-URL> <SERVICE-URL> <ENTRY-URL>");
}
break;
case SUBMIT:
/*
* SUBMIT <ENTRY-URL> <FILE> <OUTPUT> <S> <MAP>
*/
if (split.Length == 7)
{
// Get the arguments
string entryUrl = split[1];
string file = split[2];
string output = split[3];
int numberOfSplits = int.Parse(split[4]);
string className = split[5];
string classImplementationPath = split[6];
// Probably not the best approach...
// Our test files and output directory are in the Puppet Master .exe's directory inside folder "files"
string path = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
file = Path.Combine(path, file);
output = Path.Combine(path, output);
// Create the directory if it doesn't exist
if (!Directory.Exists(output))
{
Directory.CreateDirectory(output);
Console.WriteLine("[SUBMIT] Created output directory at {0}", output);
}
classImplementationPath = Path.Combine(path, classImplementationPath);
// Submit job to the puppetMaster Impl
try {
puppetMaster.SubmitJob(entryUrl, file, output, className, classImplementationPath, numberOfSplits);
} catch (Exception exception) {
System.Console.WriteLine(exception.StackTrace);
System.Console.ReadLine();
}
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: SUBMIT <ENTRY-URL> <FILE> <OUTPUT> <S> <MAP> <DLL>");
}
break;
case WAIT:
/*
* WAIT <SECS>
*/
if (split.Length == 2)
{
int secs = Int32.Parse(split[1]);
puppetMaster.Wait(secs);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: WAIT <SECS>");
}
break;
case STATUS:
/*
* STATUS
*/
puppetMaster.Status();
break;
case SLOWW:
/*
* SLOWW <ID> <delay-in-seconds>
*/
if (split.Length == 3)
{
string id = split[1];
int delayInSeconds = Int32.Parse(split[2]);
puppetMaster.SlowW(id, delayInSeconds);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: SLOWW <ID> <delay-in-seconds>");
}
break;
case FREEZEW:
/*
* FREEZEW <ID>
*/
if (split.Length == 2)
{
string id = split[1];
puppetMaster.FrezeeW(id);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: FREEZEW <ID>");
}
break;
case UNFREEZEW:
/*
* UNFREEZEW <ID>
*/
if (split.Length == 2)
{
string id = split[1];
puppetMaster.UnfreezeW(id);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: UNFREEZEW <ID>");
}
break;
case FREEZEC:
/*
* FREEZEC <ID>
*/
if (split.Length == 2)
{
string id = split[1];
puppetMaster.FreezeC(id);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: FREEZEC <ID>");
}
break;
case UNFREEZEC:
/*
* UNFREEZEC <ID>
*/
if (split.Length == 2)
{
string id = split[1];
puppetMaster.UnfreezeC(id);
}
else
{
// Input error, it has more than 4 arguments
Console.WriteLine("Wrong usage. Usage: UNFREEZEC <ID>");
}
break;
}
}
public void writeToLog(string message)
{
IPuppetMaster pm = (IPuppetMaster)Activator.GetObject(typeof(IPuppetMaster), _puppetMasterURL);
pm.reportToLog(message);
}
public PuppetMasterService(IPuppetMaster puppetMaster)
{
this.puppetMaster = puppetMaster;
this.logger = puppetMaster.GetLogger();
workers = new List <IWorker>();
}
