Ejemplo n.º 1
0
 void IBatchProcessing.pushJob(Job job)
 {
     try
     {
         lock (JobQueue)
         {
             lock (JobStorage)
             {
                 JobStorage.Add(job.JobId, job);
                 JobQueue.Enqueue(job);
                 job.SetWaiting();
                 Trace.WriteLineIf(ts.TraceInfo, string.Format("Job id= {0:D} in Warteschlange gestellt", job.JobId));
             }
             // Wenn der Server ohne Arbeite ist, wird sofort die Bearbeitung eines neuen
             // Jobs gestartet
             if (!busy)
             {
                 ProcessNextJob();
             }
         }
     }
     catch (Exception ex)
     {
         log.Log(RC.CreateError("PushJob: " + ex.Message));
         Trace.Fail("PushJob: " + ex.Message);
     }
 }
Ejemplo n.º 2
0
 // Wurde ein Job asynchron durchgeführt vom Worker, dann wird diese Methode zurückgerufen
 void JobFinished(IAsyncResult ar)
 {
     if (ar.IsCompleted)
     {
         JobFinished();
     }
     else
     {
         log.Log(RC.CreateError("BatchProcessor.JobFinished: Ein Thread, der einen Job macht, wurde vorzeitig abgebrochen. JobId: " + currentJob.JobId));
     }
 }
Ejemplo n.º 3
0
        // 2011.05.09, mko : Parameterlose Version, um nach einem Abort eines Jobs zu reagieren
        void JobFinished(int taskId)
        {
            try
            {
                lock (JobStorage)
                {
                    // Worker zur Wiederverwendung freigeben
                    workerIdle.Enqueue(ActiveWorker[taskId].Item2);

                    // 2011.05.09, mko: Abgebrochene Jobs werden hier nicht mehr gelöscht !
                    var finishedJob = ActiveWorker[taskId].Item1;
                    if (finishedJob.JobState != Job.JobStates.aborted)
                    {
                        finishedJob.SetFinished();
                        Trace.WriteLineIf(ts.TraceInfo, string.Format("Job id= {0:N0} fertiggestellt", finishedJob.JobId));
                    }

                    // OneWay Jobs automatisch löschen. Nicht OneWay Jobs verbleiben
                    // bis zur Auslieferung im JobStorage
                    // 2011.05.09, mko: Unabhängig vom Zustand werden (z.B. Finished od. aborted)
                    // werden One- Way Jobs gelöscht (vorher nur Finished Jobs. Aborted wurden immer
                    // gelöscht)
                    if (finishedJob.OneWay)
                    {
                        JobStorage.Remove(finishedJob.JobId);
                    }

                    // Verzeichnis der aktuelle bearbeiteten Jobs bereinigen
                    ActiveWorker.Remove(taskId);

                    // Signalisieren an WaitUntilJobFinished, das ein Job fertiggestellt wurde
                    JobFertigEvent.Set();
                } // End Lock

                lock (JobQueue)
                {
                    // Nächste arbeitsbereite Jobs zur Ausführung bringen
                    ProcessNextJob();
                }
            }
            catch (Exception ex)
            {
                log.Log(RC.CreateError("BatchProcessing.JobFinished: " + ex.Message));
                Trace.Fail("BatchProcessing.JobFinished: " + ex.Message);
            }
        }
Ejemplo n.º 4
0
        bool IBatchProcessing.Resume()
        {
            try
            {
                lock (JobQueue)
                {
                    _pause = false;
                    // Sind weitere Jobs in der Job-Queue, dann wird die Arbeit mit dem nächsten Job
                    // aus der Queue unmittelbar fortgesetzt
                    ProcessNextJob();
                } // End Lock
                return(true);
            }

            catch (Exception ex)
            {
                log.Log(RC.CreateError("BatchProcessing.JobFinished: " + ex.Message));
                Trace.Fail("BatchProcessing.JobFinished: " + ex.Message);
                return(false);
            }
        }
Ejemplo n.º 5
0
        // 2011.05.09, mko : Parameterlose Version, um nach einem Abort eines Jobs zu reagieren
        void JobFinished()
        {
            try
            {
                lock (JobQueue)
                {
                    // 2011.05.09, mko: Abgebrochene Jobs werden hier nicht mehr gelöscht !
                    if (currentJob.JobState != Job.JobStates.aborted)
                    {
                        currentJob.SetFinished();
                        Trace.WriteLineIf(ts.TraceInfo, string.Format("Job id= {0:N0} fertiggestellt", currentJob.JobId));
                    }

                    // OneWay Jobs automatisch löschen. Nicht OneWay Jobs verbleiben
                    // bis zur Auslieferung im JobStorage
                    // 2011.05.09, mko: Unabhängig vom Zustand werden (z.B. Finished od. aborted)
                    // werden One- Way Jobs gelöscht (vorher nur Finished Jobs. Aborted wurden immer
                    // gelöscht)
                    if (currentJob.OneWay)
                    {
                        JobStorage.Remove(currentJob.JobId);
                    }

                    busy = false;

                    // Signalisieren an WaitUntilJobFinished, das ein Job fertiggestellt wurde
                    JobFertigEvent.Set();

                    // Nächten arbeitsbereiten Job zur Ausführung bringen
                    ProcessNextJob();
                } // End Lock
            }
            catch (Exception ex)
            {
                log.Log(RC.CreateError("BatchProcessing.JobFinished: " + ex.Message));
                Trace.Fail("BatchProcessing.JobFinished: " + ex.Message);
            }
        }