Exemplo n.º 1
0
 /// <summary>Stop all jobs currently running in the scheduler.</summary>
 public override void Stop()
 {
     lock (this)
     {
         server.StopListening();
         server = null;
         KillRunners();
         base.Stop();
     }
 }
Exemplo n.º 2
0
        /// <summary>
        /// Start the jobs asynchronously. If 'waitUntilFinished'
        /// is true then control won't return until all jobs have finished.
        /// </summary>
        /// <param name="waitUntilFinished">if set to <c>true</c> [wait until finished].</param>
        public override void Start(bool waitUntilFinished)
        {
            CleanupOldRunners();

            AppDomain.CurrentDomain.AssemblyResolve += Manager.ResolveManagerAssembliesEventHandler;

            // Spin up a job manager server.
            server = new SocketServer();
            server.AddCommand("GetJob", OnGetJob);
            server.AddCommand("GetJobFailed", OnGetJobFailed);
            server.AddCommand("TransferOutputs", OnTransferOutputs);
            server.AddCommand("TransferData", OnTransferData);
            server.AddCommand("EndJob", OnEndJob);
            server.AddCommand("Error", OnError);

            // Tell server to start listening.
            Task.Run(() => server.StartListening(2222));

            // Call base to begin running jobs.
            base.Start(waitUntilFinished);
        }
Exemplo n.º 3
0
 /// <summary>Called by the client to send its output data.</summary>
 /// <param name="sender">The sender</param>
 /// <param name="args">The command arguments</param>
 private void OnTransferData(object sender, SocketServer.CommandArgs args)
 {
     TransferData arguments = args.obj as TransferData;
     System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     MemoryStream stream = new MemoryStream(arguments.data, 0, (int) arguments.dataLength);
     DataTable data = formatter.Deserialize(stream) as DataTable;
     DataStore store = new DataStore();
     store.Filename = Path.ChangeExtension(dbFileName, ".db");
     store.WriteTable(arguments.simulationName, arguments.tableName, data);
     server.Send(args.socket, "OK");
 }
Exemplo n.º 4
0
        /// <summary>Called by the client to send its output data.</summary>
        /// <param name="sender">The sender</param>
        /// <param name="args">The command arguments</param>
        private void OnTransferOutputs(object sender, SocketServer.CommandArgs args)
        {
            TransferArguments arguments = args.obj as TransferArguments;

            // Read from temp file.
            byte[] bytes = File.ReadAllBytes(arguments.fileName);
            MemoryStream s = new MemoryStream(bytes);
            DataTable table = ReflectionUtilities.BinaryDeserialise(s) as DataTable;
            File.Delete(arguments.fileName);

            DataStore store = new DataStore();
            store.Filename = Path.ChangeExtension(dbFileName, ".db");
            store.WriteTable(arguments.simulationName, arguments.tableName, table);
            server.Send(args.socket, "OK");
        }
Exemplo n.º 5
0
 /// <summary>An error has occurred in the socket server.</summary>
 /// <param name="sender">The sender of the event.</param>
 /// <param name="e">The event arguments</param>
 private void OnSocketServerError(object sender, SocketServer.ErrorArgs e)
 {
     internalExceptions.Add(new Exception(e.message + Environment.NewLine));
     Stop();
 }
Exemplo n.º 6
0
        /// <summary>Called by the client when a socket fails to get a job</summary>
        /// <param name="sender">The sender</param>
        /// <param name="args">The command arguments</param>
        private void OnGetJobFailed(object sender, SocketServer.CommandArgs args)
        {
            Job jobToRun = null;
            lock (jobs)
            {
                if (jobs.Count > 0)
                {
                    jobToRun = jobs[0];
                    jobs.RemoveAt(0);
                }
            }

            if (jobToRun == null)
                server.Send(args.socket, "NULL");
            else
            {
                GetJobReturnData returnData = new GetJobReturnData();
                returnData.key = jobToRun.Key;
                returnData.job = jobToRun.RunnableJob;
                server.Send(args.socket, returnData);
            }
        }
Exemplo n.º 7
0
        /// <summary>Called by the client to get the next job to run.</summary>
        /// <param name="sender">The sender</param>
        /// <param name="args">The command arguments</param>
        private void OnGetJob(object sender, SocketServer.CommandArgs args)
        {
            Job jobToRun = null;
            lock (jobs)
            {
                jobToRun = jobs.Find(job => !job.IsRunning && !job.isCompleted && typeof(Simulation).IsAssignableFrom(job.RunnableJob.GetType()));
                if (jobToRun != null)
                {
                    jobToRun.IsRunning = true;
                }
            }

            if (jobToRun == null)
                server.Send(args.socket, "NULL");
            else
            {
                GetJobReturnData returnData = new GetJobReturnData();
                returnData.key = jobToRun.Key;
                returnData.job = jobToRun.RunnableJob;
                server.Send(args.socket, returnData);
            }
        }
Exemplo n.º 8
0
 /// <summary>Called by the client to get the next job to run.</summary>
 /// <param name="sender">The sender</param>
 /// <param name="args">The command arguments</param>
 private void OnError(object sender, SocketServer.CommandArgs args)
 {
     string errorMessage = args.obj as string;
     internalExceptions.Add(new Exception(errorMessage));
     server.Send(args.socket, "OK");
 }
Exemplo n.º 9
0
 /// <summary>Called by the client to get the next job to run.</summary>
 /// <param name="sender">The sender</param>
 /// <param name="args">The command arguments</param>
 private void OnEndJob(object sender, SocketServer.CommandArgs args)
 {
     EndJobArguments arguments = args.obj as EndJobArguments;
     lock (jobs)
     {
         SetJobCompleted(arguments.key, arguments.errorMessage);
     }
     server.Send(args.socket, "OK");
 }