Exemplo n.º 1
0
        static void Main(string[] args)
        {
            var config = new DataTypes.ConfigurationFileObject(PuppetSettings.Default.ConfigFile); //Use this to read configuration files.
            //var v = DataTypes.ConfigurationFileObject.ReadConfig("Test.config"); //or this
            var pcsaddresses = config.ConfigurationNodes.SelectMany(i => i.PCSAddress).Distinct().ToList();


            INodeManager pcs     = null;
            TcpChannel   channel = new TcpChannel(9999);

            ChannelServices.RegisterChannel(channel, true);
            int port      = 10000;
            int portNodes = 11000;

            foreach (var address in config.ConfigurationNodes.SelectMany(i => i.Addresses))          //Config node = details of one operation
            {
                nodeAddressMapping.Add(address, "tcp://localhost:" + portNodes + "/op" + portNodes); //Creates the same mapping but for the nodes instead of the pcs
                portNodes += 1;
            }
            portNodes = 11000;
            foreach (var uniqAddress in pcsaddresses)                      //Iteration over all the PCSs
            {
                pcsAddressMapping.Add(uniqAddress, "localhost:" + port++); //Create a mapping for the real (localhost) address

                pcs = (INodeManager)Activator.GetObject(typeof(INodeManager), "tcp://" + pcsAddressMapping[uniqAddress] + "/NodeManagerService");

                List <DADStorm.DataTypes.NodeOperatorData> ListOfNodeInformations = new List <DADStorm.DataTypes.NodeOperatorData>();
                var ConfigNodesWherePCSIsIncluded = config.getNodesFromPCS(uniqAddress);
                foreach (var ConfigNode in ConfigNodesWherePCSIsIncluded)                                  //Iteration over all the configuration nodes for that PCS
                {
                    var NodeAddresses = ConfigNode.Addresses.Where(i => i.Contains(uniqAddress)).ToList(); //Fake (remote) Addresses of the node
                    foreach (var NodeAddress in NodeAddresses)
                    {
                        List <DADStorm.DataTypes.Downstream> downstream = new List <DADStorm.DataTypes.Downstream>();
                        List <string> siblings = new List <string>();
                        foreach (var node in ConfigNode.Addresses) //Creation of a list of siblings
                        {
                            if (!node.Equals(NodeAddress))
                            {
                                siblings.Add(nodeAddressMapping[node]);
                            }
                        }
                        foreach (var OperatorConfig in config.getNodesRequiringOPName(ConfigNode.NodeName))    //Configuration nodes that require our operation (downstreams)
                        {
                            var listOfDownstreamNodes = new List <string>();
                            foreach (var downstreamnode in OperatorConfig.Addresses)
                            {
                                listOfDownstreamNodes.Add(nodeAddressMapping[downstreamnode]);
                            }
                            downstream.Add(new DADStorm.DataTypes.Downstream()
                            {
                                Routing   = OperatorConfig.Routing,
                                TargetIPs = listOfDownstreamNodes
                            });
                        }
                        List <DADTuple> initialTuples;
                        if (ConfigNode.TargetData.Contains("."))
                        {
                            initialTuples = DADTuple.InputFileReader(ConfigNode.TargetData);
                        }
                        else
                        {
                            initialTuples = new List <DADTuple>();
                        }

                        List <string> Opargs;
                        if (ConfigNode.Operation == DADStorm.DataTypes.OperatorType.custom)
                        {
                            byte[] code = File.ReadAllBytes(ConfigNode.OperationArgs[0]);
                            Opargs = new List <string>()
                            {
                                code.ToString(),
                                    ConfigNode.OperationArgs[1]
                            };
                        }
                        else
                        {
                            Opargs = ConfigNode.OperationArgs;
                        }
                        DADStorm.DataTypes.NodeOperatorData data = new DADStorm.DataTypes.NodeOperatorData()
                        {
                            OperatorID      = ConfigNode.NodeName,
                            ConnectionPort  = portNodes++,
                            OperatorName    = "op", //TODO:Change this to come from config
                            TypeofRouting   = ConfigNode.Routing,
                            Siblings        = siblings,
                            Downstream      = downstream,
                            TypeofOperation = ConfigNode.Operation,
                            OperationArgs   = Opargs,
                            Initialtuples   = initialTuples,
                            NodeAddress     = NodeAddress,
                            LogTuples       = (config.Logging == DataTypes.LoggingLevel.full)
                        };

                        ListOfNodeInformations.Add(data);   //New node that will be created by the PCS with the data stated right up here.
                    }
                }
                //DADStorm.DataTypes.NodeOperatorData nop = new DADStorm.DataTypes.NodeOperatorData()
                //{
                //}

                var bo = pcs.init(ListOfNodeInformations);
                GC.KeepAlive(pcs);
                pcsServers.Add(uniqAddress, pcs);
            }

            //TcpChannel channelLog = new TcpChannel(9999);
            //ChannelServices.RegisterChannel(channelLog, true);
            System.Runtime.Remoting.RemotingConfiguration.RegisterWellKnownServiceType(
                typeof(Logger),
                "logger",
                System.Runtime.Remoting.WellKnownObjectMode.Singleton);
            System.Console.WriteLine("Logging Service open on port: 9999");

            ILogger Logger = (ILogger)Activator.GetObject(typeof(ILogger), "tcp://localhost:9999/logger");

            //var test = config.ConfigurationNodes.Where(i => i.NodeName == "OP1").ToList().First().PCSAddress.First();
            GC.KeepAlive(Logger);


            /*    if (pcsLocalhost == null) {
             *      System.Console.WriteLine("Could not locate server.");
             *      return;
             *  }*/

            foreach (var line in config.Script)
            {
                Logger.log(line.ToString());
                string[] command = line.ToString().Split(null);

                try
                {
                    handleInput(config, command);
                }
                catch (IndexOutOfRangeException)
                {
                    Console.WriteLine("Invalid Arguments");
                }
            }

            Console.WriteLine();
            Console.WriteLine("Available commands are:");
            Console.WriteLine("     start OP_ID");
            Console.WriteLine("     status");
            Console.WriteLine("     interval time");
            Console.WriteLine("     crash OP_ID Rep_ID");
            Console.WriteLine("     freeze OP_ID Rep_ID");
            Console.WriteLine("     unfreeze OP_ID Rep_ID");
            Console.WriteLine();

            while (true)
            {
                string commandLine = Console.ReadLine();
                Logger.log(commandLine);
                string[] command = commandLine.Split(null);

                try
                {
                    handleInput(config, command);
                }
                catch (IndexOutOfRangeException)
                {
                    Console.WriteLine("Invalid Arguments");
                }
            }
        }
Exemplo n.º 2
0
        private static void handleInput(DataTypes.ConfigurationFileObject config, string[] command)
        {
            List <string> psCandidate   = null;
            List <string> nodeCandidate = null;

            switch (command[0].ToLower())
            {
            case "start":
                if (config.ConfigurationNodes.Where(i => i.NodeName.Equals(command[1])).Select(i => i.TargetData).First().Contains("."))
                {       //HACK: So that start other nodes does not do anything
                    psCandidate = config.getAddressesFromOPName(command[1]);
                    var res = psCandidate.First();
                    pcsServers[res].start(command[1]);
                }
                //foreach (var p in ps)
                //{
                //    pcsServers[p].start(command[1]);
                //}

                break;

            case "status":
                foreach (var pcss in pcsServers.Select(i => i.Value))
                {
                    pcss.status();
                }
                break;

            case "interval":
                Interval = Convert.ToInt32(command[2]);
                break;

            case "crash":
                psCandidate   = config.getAddressesFromOPName(command[1]);
                nodeCandidate = config.ConfigurationNodes.Where(i => i.NodeName == command[1]).SelectMany(n => n.Addresses).ToList();
                var toCrash = psCandidate[Convert.ToInt32(command[2])];
                pcsServers[toCrash].crash(nodeAddressMapping[nodeCandidate[Convert.ToInt32(command[2])]]);
                break;

            case "freeze":
                psCandidate   = config.getAddressesFromOPName(command[1]);
                nodeCandidate = config.ConfigurationNodes.Where(i => i.NodeName == command[1]).SelectMany(n => n.Addresses).ToList();
                var toFreeze = psCandidate[Convert.ToInt32(command[2])];
                pcsServers[toFreeze].freeze(nodeAddressMapping[nodeCandidate[Convert.ToInt32(command[2])]]);
                break;

            case "unfreeze":
                psCandidate   = config.getAddressesFromOPName(command[1]);
                nodeCandidate = config.ConfigurationNodes.Where(i => i.NodeName == command[1]).SelectMany(n => n.Addresses).ToList();
                var toThaw = psCandidate[Convert.ToInt32(command[2])];
                pcsServers[toThaw].unfreeze(nodeAddressMapping[nodeCandidate[Convert.ToInt32(command[2])]]);
                break;

            case "wait":
                Thread.Sleep(Convert.ToInt32(command[1]));
                break;

            default:
                Console.WriteLine("Invalid command");
                break;
            }
            Thread.Sleep(Interval);
        }