Mercurial > hg > orthanc
annotate UnitTestsSources/MultiThreadingTests.cpp @ 2565:0f06b4d5b3d0 jobs
JobsEngine
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 07 May 2018 13:20:29 +0200 |
parents | f8681f251caa |
children | c09ce3c038fc |
rev | line source |
---|---|
827
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
1 /** |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
2 * Orthanc - A Lightweight, RESTful DICOM Store |
1900 | 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
1288
6e7e5ed91c2d
upgrade to year 2015
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1009
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
2447
878b59270859
upgrade to year 2018
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2382
diff
changeset
|
5 * Copyright (C) 2017-2018 Osimis S.A., Belgium |
827
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
6 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
7 * This program is free software: you can redistribute it and/or |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
8 * modify it under the terms of the GNU General Public License as |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
9 * published by the Free Software Foundation, either version 3 of the |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
10 * License, or (at your option) any later version. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
11 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
12 * In addition, as a special exception, the copyright holders of this |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
13 * program give permission to link the code of its release with the |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
15 * that use the same license as the "OpenSSL" library), and distribute |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
16 * the linked executables. You must obey the GNU General Public License |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
17 * in all respects for all of the code used other than "OpenSSL". If you |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
18 * modify file(s) with this exception, you may extend this exception to |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
19 * your version of the file(s), but you are not obligated to do so. If |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
20 * you do not wish to do so, delete this exception statement from your |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
21 * version. If you delete this exception statement from all source files |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
22 * in the program, then also delete it here. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
23 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
24 * This program is distributed in the hope that it will be useful, but |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
25 * WITHOUT ANY WARRANTY; without even the implied warranty of |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
27 * General Public License for more details. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
28 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
29 * You should have received a copy of the GNU General Public License |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
31 **/ |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
32 |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
776
diff
changeset
|
33 |
831
84513f2ee1f3
pch for unit tests and server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
827
diff
changeset
|
34 #include "PrecompiledHeadersUnitTests.h" |
723 | 35 #include "gtest/gtest.h" |
36 | |
781 | 37 #include "../OrthancServer/Scheduler/ServerScheduler.h" |
723 | 38 #include "../Core/OrthancException.h" |
2143
fd5875662670
creation of namespace SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2140
diff
changeset
|
39 #include "../Core/SystemToolbox.h" |
723 | 40 #include "../Core/Toolbox.h" |
760 | 41 #include "../Core/MultiThreading/Locker.h" |
42 #include "../Core/MultiThreading/Mutex.h" | |
43 #include "../Core/MultiThreading/ReaderWriterLock.h" | |
723 | 44 |
45 using namespace Orthanc; | |
46 | |
47 namespace | |
48 { | |
1396
ac4efabeb80c
Migration of the orthanc-client as a separate project
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1304
diff
changeset
|
49 class DynamicInteger : public IDynamicObject |
723 | 50 { |
51 private: | |
52 int value_; | |
53 std::set<int>& target_; | |
54 | |
55 public: | |
56 DynamicInteger(int value, std::set<int>& target) : | |
57 value_(value), target_(target) | |
58 { | |
59 } | |
60 | |
61 int GetValue() const | |
62 { | |
63 return value_; | |
64 } | |
65 }; | |
66 } | |
67 | |
68 | |
69 TEST(MultiThreading, SharedMessageQueueBasic) | |
70 { | |
71 std::set<int> s; | |
72 | |
73 SharedMessageQueue q; | |
74 ASSERT_TRUE(q.WaitEmpty(0)); | |
75 q.Enqueue(new DynamicInteger(10, s)); | |
76 ASSERT_FALSE(q.WaitEmpty(1)); | |
77 q.Enqueue(new DynamicInteger(20, s)); | |
78 q.Enqueue(new DynamicInteger(30, s)); | |
79 q.Enqueue(new DynamicInteger(40, s)); | |
80 | |
81 std::auto_ptr<DynamicInteger> i; | |
82 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(10, i->GetValue()); | |
83 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(20, i->GetValue()); | |
84 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(30, i->GetValue()); | |
85 ASSERT_FALSE(q.WaitEmpty(1)); | |
86 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(40, i->GetValue()); | |
87 ASSERT_TRUE(q.WaitEmpty(0)); | |
88 ASSERT_EQ(NULL, q.Dequeue(1)); | |
89 } | |
90 | |
91 | |
92 TEST(MultiThreading, SharedMessageQueueClean) | |
93 { | |
94 std::set<int> s; | |
95 | |
96 try | |
97 { | |
98 SharedMessageQueue q; | |
99 q.Enqueue(new DynamicInteger(10, s)); | |
100 q.Enqueue(new DynamicInteger(20, s)); | |
1583
9ea3d082b064
got rid of custom exceptions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1582
diff
changeset
|
101 throw OrthancException(ErrorCode_InternalError); |
723 | 102 } |
103 catch (OrthancException&) | |
104 { | |
105 } | |
106 } | |
107 | |
108 | |
760 | 109 TEST(MultiThreading, Mutex) |
110 { | |
111 Mutex mutex; | |
112 Locker locker(mutex); | |
113 } | |
114 | |
115 | |
116 TEST(MultiThreading, ReaderWriterLock) | |
117 { | |
118 ReaderWriterLock lock; | |
119 | |
120 { | |
121 Locker locker1(lock.ForReader()); | |
122 Locker locker2(lock.ForReader()); | |
123 } | |
124 | |
125 { | |
126 Locker locker3(lock.ForWriter()); | |
127 } | |
128 } | |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
129 |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
130 |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
131 |
2382
7284093111b0
big reorganization to cleanly separate framework vs. server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
132 #include "../Core/DicomNetworking/ReusableDicomUserConnection.h" |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
133 |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
134 TEST(ReusableDicomUserConnection, DISABLED_Basic) |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
135 { |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
136 ReusableDicomUserConnection c; |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
137 c.SetMillisecondsBeforeClose(200); |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
138 printf("START\n"); fflush(stdout); |
775
d3ba35466225
integration mainline -> lua-scripting
Sebastien Jodogne <s.jodogne@gmail.com>
diff
changeset
|
139 |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
140 { |
1427
d710ea64f0fd
Custom setting of the local AET during C-Store SCU (both in Lua and in the REST API)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1396
diff
changeset
|
141 RemoteModalityParameters remote("STORESCP", "localhost", 2000, ModalityManufacturer_Generic); |
d710ea64f0fd
Custom setting of the local AET during C-Store SCU (both in Lua and in the REST API)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1396
diff
changeset
|
142 ReusableDicomUserConnection::Locker lock(c, "ORTHANC", remote); |
2222
21713ce8717b
Fix handling of Move Originator AET and ID in C-MOVE SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2143
diff
changeset
|
143 lock.GetConnection().StoreFile("/home/jodogne/DICOM/Cardiac/MR.X.1.2.276.0.7230010.3.1.4.2831157719.2256.1336386844.676281"); |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
144 } |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
145 |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
146 printf("**\n"); fflush(stdout); |
2242
4e8e0ad2001c
move USleep() in SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2222
diff
changeset
|
147 SystemToolbox::USleep(1000000); |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
148 printf("**\n"); fflush(stdout); |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
149 |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
150 { |
1427
d710ea64f0fd
Custom setting of the local AET during C-Store SCU (both in Lua and in the REST API)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1396
diff
changeset
|
151 RemoteModalityParameters remote("STORESCP", "localhost", 2000, ModalityManufacturer_Generic); |
d710ea64f0fd
Custom setting of the local AET during C-Store SCU (both in Lua and in the REST API)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1396
diff
changeset
|
152 ReusableDicomUserConnection::Locker lock(c, "ORTHANC", remote); |
2222
21713ce8717b
Fix handling of Move Originator AET and ID in C-MOVE SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2143
diff
changeset
|
153 lock.GetConnection().StoreFile("/home/jodogne/DICOM/Cardiac/MR.X.1.2.276.0.7230010.3.1.4.2831157719.2256.1336386844.676277"); |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
154 } |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
155 |
2140 | 156 SystemToolbox::ServerBarrier(); |
769
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
157 printf("DONE\n"); fflush(stdout); |
3f946e5c3802
ReusableDicomUserConnection
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
760
diff
changeset
|
158 } |
765 | 159 |
160 | |
161 | |
1000
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
162 class Tutu : public IServerCommand |
765 | 163 { |
164 private: | |
165 int factor_; | |
166 | |
167 public: | |
168 Tutu(int f) : factor_(f) | |
169 { | |
170 } | |
171 | |
172 virtual bool Apply(ListOfStrings& outputs, | |
173 const ListOfStrings& inputs) | |
174 { | |
175 for (ListOfStrings::const_iterator | |
1304 | 176 it = inputs.begin(); it != inputs.end(); ++it) |
765 | 177 { |
178 int a = boost::lexical_cast<int>(*it); | |
179 int b = factor_ * a; | |
180 | |
181 printf("%d * %d = %d\n", a, factor_, b); | |
182 | |
183 //if (a == 84) { printf("BREAK\n"); return false; } | |
184 | |
185 outputs.push_back(boost::lexical_cast<std::string>(b)); | |
186 } | |
187 | |
2242
4e8e0ad2001c
move USleep() in SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2222
diff
changeset
|
188 SystemToolbox::USleep(30000); |
765 | 189 |
190 return true; | |
191 } | |
192 }; | |
193 | |
768 | 194 |
770 | 195 static void Tata(ServerScheduler* s, ServerJob* j, bool* done) |
768 | 196 { |
1000
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
197 typedef IServerCommand::ListOfStrings ListOfStrings; |
779 | 198 |
770 | 199 while (!(*done)) |
768 | 200 { |
201 ListOfStrings l; | |
202 s->GetListOfJobs(l); | |
1304 | 203 for (ListOfStrings::iterator it = l.begin(); it != l.end(); ++it) |
204 { | |
205 printf(">> %s: %0.1f\n", it->c_str(), 100.0f * s->GetProgress(*it)); | |
206 } | |
2242
4e8e0ad2001c
move USleep() in SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2222
diff
changeset
|
207 SystemToolbox::USleep(3000); |
768 | 208 } |
209 } | |
210 | |
211 | |
1009
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
212 TEST(MultiThreading, ServerScheduler) |
765 | 213 { |
995
8c67382f44a7
limit number of jobs in the scheduler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
994
diff
changeset
|
214 ServerScheduler scheduler(10); |
765 | 215 |
216 ServerJob job; | |
1000
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
217 ServerCommandInstance& f2 = job.AddCommand(new Tutu(2)); |
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
218 ServerCommandInstance& f3 = job.AddCommand(new Tutu(3)); |
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
219 ServerCommandInstance& f4 = job.AddCommand(new Tutu(4)); |
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
220 ServerCommandInstance& f5 = job.AddCommand(new Tutu(5)); |
765 | 221 f2.AddInput(boost::lexical_cast<std::string>(42)); |
222 //f3.AddInput(boost::lexical_cast<std::string>(42)); | |
223 //f4.AddInput(boost::lexical_cast<std::string>(42)); | |
1009
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
224 f2.ConnectOutput(f3); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
225 f3.ConnectOutput(f4); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
226 f4.ConnectOutput(f5); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
227 |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
228 f3.SetConnectedToSink(true); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
229 f5.SetConnectedToSink(true); |
765 | 230 |
231 job.SetDescription("tutu"); | |
232 | |
770 | 233 bool done = false; |
234 boost::thread t(Tata, &scheduler, &job, &done); | |
768 | 235 |
236 | |
765 | 237 //scheduler.Submit(job); |
238 | |
1000
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
239 IServerCommand::ListOfStrings l; |
765 | 240 scheduler.SubmitAndWait(l, job); |
241 | |
1492 | 242 ASSERT_EQ(2u, l.size()); |
1009
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
243 ASSERT_EQ(42 * 2 * 3, boost::lexical_cast<int>(l.front())); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
244 ASSERT_EQ(42 * 2 * 3 * 4 * 5, boost::lexical_cast<int>(l.back())); |
26642cecd36d
clearer job interface
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1005
diff
changeset
|
245 |
1000
13e230bbd882
rename filter to command
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
995
diff
changeset
|
246 for (IServerCommand::ListOfStrings::iterator i = l.begin(); i != l.end(); i++) |
765 | 247 { |
248 printf("** %s\n", i->c_str()); | |
249 } | |
250 | |
2140 | 251 //SystemToolbox::ServerBarrier(); |
2242
4e8e0ad2001c
move USleep() in SystemToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2222
diff
changeset
|
252 //SystemToolbox::USleep(3000000); |
768 | 253 |
1453
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
254 scheduler.Stop(); |
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
255 |
770 | 256 done = true; |
1453
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
257 if (t.joinable()) |
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
258 { |
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
259 t.join(); |
c0bdc47165ef
code to warn about possible threading problems
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1427
diff
changeset
|
260 } |
765 | 261 } |
2556 | 262 |
263 | |
264 | |
265 | |
266 | |
267 #if !defined(ORTHANC_SANDBOXED) | |
268 # error The macro ORTHANC_SANDBOXED must be defined | |
269 #endif | |
270 | |
271 #if ORTHANC_SANDBOXED == 1 | |
272 # error The job engine cannot be used in sandboxed environments | |
273 #endif | |
274 | |
2557 | 275 #include "../Core/Logging.h" |
276 | |
2559 | 277 #include <boost/math/special_functions/round.hpp> |
2556 | 278 #include <boost/date_time/posix_time/posix_time.hpp> |
2557 | 279 #include <queue> |
2556 | 280 |
281 namespace Orthanc | |
282 { | |
283 enum JobState | |
284 { | |
285 JobState_Pending, | |
286 JobState_Running, | |
287 JobState_Success, | |
288 JobState_Failure, | |
289 JobState_Paused, | |
290 JobState_Retry | |
291 }; | |
2565 | 292 |
293 static const char* EnumerationToString(JobState state) | |
294 { | |
295 switch (state) | |
296 { | |
297 case JobState_Pending: | |
298 return "Pending"; | |
299 | |
300 case JobState_Running: | |
301 return "Running"; | |
302 | |
303 case JobState_Success: | |
304 return "Success"; | |
305 | |
306 case JobState_Failure: | |
307 return "Failure"; | |
308 | |
309 case JobState_Paused: | |
310 return "Paused"; | |
311 | |
312 case JobState_Retry: | |
313 return "Retry"; | |
314 | |
315 default: | |
316 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
317 } | |
318 } | |
2556 | 319 |
2562 | 320 enum JobStepCode |
2556 | 321 { |
2562 | 322 JobStepCode_Success, |
323 JobStepCode_Failure, | |
324 JobStepCode_Continue, | |
325 JobStepCode_Retry | |
2556 | 326 }; |
327 | |
328 | |
2557 | 329 class JobStepResult |
2556 | 330 { |
331 private: | |
2562 | 332 JobStepCode status_; |
2556 | 333 |
334 public: | |
2562 | 335 explicit JobStepResult(JobStepCode status) : |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
336 status_(status) |
2556 | 337 { |
338 } | |
339 | |
2557 | 340 virtual ~JobStepResult() |
2556 | 341 { |
342 } | |
343 | |
2562 | 344 JobStepCode GetCode() const |
2556 | 345 { |
346 return status_; | |
347 } | |
348 }; | |
349 | |
350 | |
2557 | 351 class RetryResult : public JobStepResult |
2556 | 352 { |
353 private: | |
354 unsigned int timeout_; // Retry after "timeout_" milliseconds | |
355 | |
356 public: | |
357 RetryResult(unsigned int timeout) : | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
358 JobStepResult(JobStepCode_Retry), |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
359 timeout_(timeout) |
2556 | 360 { |
361 } | |
362 | |
363 unsigned int GetTimeout() const | |
364 { | |
365 return timeout_; | |
366 } | |
367 }; | |
368 | |
369 | |
370 class IJob : public boost::noncopyable | |
371 { | |
372 public: | |
373 virtual ~IJob() | |
374 { | |
375 } | |
376 | |
2557 | 377 virtual JobStepResult* ExecuteStep() = 0; |
2556 | 378 |
379 virtual void ReleaseResources() = 0; // For pausing jobs | |
380 | |
381 virtual float GetProgress() = 0; | |
382 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
383 virtual void GetDescription(Json::Value& value) = 0; |
2556 | 384 }; |
385 | |
386 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
387 class JobStatus |
2562 | 388 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
389 private: |
2562 | 390 ErrorCode errorCode_; |
391 float progress_; | |
392 Json::Value description_; | |
393 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
394 public: |
2562 | 395 JobStatus() : |
396 errorCode_(ErrorCode_Success), | |
397 progress_(0), | |
398 description_(Json::objectValue) | |
399 { | |
400 } | |
401 | |
402 JobStatus(ErrorCode code, | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
403 IJob& job) : |
2562 | 404 errorCode_(code), |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
405 progress_(job.GetProgress()) |
2562 | 406 { |
2565 | 407 if (progress_ < 0) |
2562 | 408 { |
2565 | 409 progress_ = 0; |
410 } | |
411 | |
412 if (progress_ > 1) | |
413 { | |
414 progress_ = 1; | |
2562 | 415 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
416 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
417 job.GetDescription(description_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
418 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
419 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
420 ErrorCode GetErrorCode() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
421 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
422 return errorCode_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
423 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
424 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
425 float GetProgress() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
426 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
427 return progress_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
428 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
429 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
430 const Json::Value& GetDescription() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
431 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
432 return description_; |
2562 | 433 } |
434 }; | |
435 | |
436 | |
2559 | 437 class JobInfo |
438 { | |
439 private: | |
440 std::string id_; | |
441 int priority_; | |
442 JobState state_; | |
2565 | 443 boost::posix_time::ptime timestamp_; |
2559 | 444 boost::posix_time::ptime creationTime_; |
445 boost::posix_time::time_duration runtime_; | |
446 boost::posix_time::ptime eta_; | |
2562 | 447 JobStatus status_; |
2559 | 448 |
449 public: | |
450 JobInfo(const std::string& id, | |
451 int priority, | |
452 JobState state, | |
2562 | 453 const JobStatus& status, |
2559 | 454 const boost::posix_time::ptime& creationTime, |
455 const boost::posix_time::time_duration& runtime) : | |
456 id_(id), | |
457 priority_(priority), | |
458 state_(state), | |
2565 | 459 timestamp_(boost::posix_time::microsec_clock::universal_time()), |
2559 | 460 creationTime_(creationTime), |
2562 | 461 runtime_(runtime), |
462 status_(status) | |
2559 | 463 { |
2562 | 464 float ms = static_cast<float>(runtime_.total_milliseconds()); |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
465 float remaining = boost::math::llround(1.0f - status_.GetProgress()) * ms; |
2565 | 466 eta_ = timestamp_ + boost::posix_time::milliseconds(remaining); |
467 } | |
468 | |
469 JobInfo() : | |
470 priority_(0), | |
471 state_(JobState_Failure), | |
472 timestamp_(boost::posix_time::microsec_clock::universal_time()), | |
473 creationTime_(timestamp_), | |
474 runtime_(boost::posix_time::milliseconds(0)), | |
475 eta_(timestamp_) | |
476 { | |
2559 | 477 } |
478 | |
479 const std::string& GetIdentifier() const | |
480 { | |
481 return id_; | |
482 } | |
483 | |
484 int GetPriority() const | |
485 { | |
486 return priority_; | |
487 } | |
488 | |
489 JobState GetState() const | |
490 { | |
491 return state_; | |
492 } | |
493 | |
494 const boost::posix_time::ptime& GetInfoTime() const | |
495 { | |
2565 | 496 return timestamp_; |
2559 | 497 } |
498 | |
499 const boost::posix_time::ptime& GetCreationTime() const | |
500 { | |
501 return creationTime_; | |
502 } | |
503 | |
504 const boost::posix_time::time_duration& GetRuntime() const | |
505 { | |
506 return runtime_; | |
507 } | |
508 | |
509 const boost::posix_time::ptime& GetEstimatedTimeOfArrival() const | |
510 { | |
511 return eta_; | |
512 } | |
513 | |
2562 | 514 const JobStatus& GetStatus() const |
2559 | 515 { |
516 return status_; | |
517 } | |
518 | |
2562 | 519 JobStatus& GetStatus() |
2559 | 520 { |
521 return status_; | |
522 } | |
2565 | 523 |
524 void Format(Json::Value& target) const | |
525 { | |
526 target = Json::objectValue; | |
527 target["ID"] = id_; | |
528 target["Priority"] = priority_; | |
529 target["ErrorCode"] = EnumerationToString(status_.GetErrorCode()); | |
530 target["State"] = EnumerationToString(state_); | |
531 target["Timestamp"] = boost::posix_time::to_iso_string(timestamp_); | |
532 target["CreationTime"] = boost::posix_time::to_iso_string(creationTime_); | |
533 target["Runtime"] = static_cast<uint32_t>(runtime_.total_milliseconds()); | |
534 target["EstimatedTimeOfArrival"] = boost::posix_time::to_iso_string(eta_); | |
535 target["Progress"] = boost::math::iround(status_.GetProgress() * 100.0f); | |
536 target["Description"] = status_.GetDescription(); | |
537 } | |
2559 | 538 }; |
539 | |
540 | |
2557 | 541 class JobHandler : public boost::noncopyable |
2562 | 542 { |
2557 | 543 private: |
2559 | 544 std::string id_; |
545 JobState state_; | |
546 std::auto_ptr<IJob> job_; | |
547 int priority_; // "+inf()" means highest priority | |
548 boost::posix_time::ptime creationTime_; | |
2562 | 549 boost::posix_time::ptime lastStateChangeTime_; |
550 boost::posix_time::time_duration runtime_; | |
2559 | 551 boost::posix_time::ptime retryTime_; |
552 bool pauseScheduled_; | |
2562 | 553 JobStatus lastStatus_; |
2557 | 554 |
555 void SetStateInternal(JobState state) | |
556 { | |
557 const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time(); | |
558 | |
559 if (state_ == JobState_Running) | |
560 { | |
2562 | 561 runtime_ += (now - lastStateChangeTime_); |
2557 | 562 } |
563 | |
564 state_ = state; | |
2562 | 565 lastStateChangeTime_ = now; |
2557 | 566 pauseScheduled_ = false; |
567 } | |
568 | |
569 public: | |
570 JobHandler(IJob* job, | |
571 int priority) : | |
572 id_(Toolbox::GenerateUuid()), | |
573 state_(JobState_Pending), | |
574 job_(job), | |
575 priority_(priority), | |
576 creationTime_(boost::posix_time::microsec_clock::universal_time()), | |
2562 | 577 lastStateChangeTime_(creationTime_), |
2559 | 578 runtime_(boost::posix_time::milliseconds(0)), |
2562 | 579 retryTime_(creationTime_), |
580 pauseScheduled_(false) | |
2557 | 581 { |
582 if (job == NULL) | |
583 { | |
584 throw OrthancException(ErrorCode_NullPointer); | |
585 } | |
586 } | |
587 | |
588 const std::string& GetId() const | |
589 { | |
590 return id_; | |
591 } | |
592 | |
2562 | 593 IJob& GetJob() const |
594 { | |
595 assert(job_.get() != NULL); | |
596 return *job_; | |
597 } | |
598 | |
2557 | 599 void SetPriority(int priority) |
600 { | |
601 priority_ = priority; | |
602 } | |
603 | |
604 int GetPriority() const | |
605 { | |
606 return priority_; | |
607 } | |
608 | |
609 JobState GetState() const | |
610 { | |
611 return state_; | |
612 } | |
613 | |
614 void SetState(JobState state) | |
615 { | |
616 if (state == JobState_Retry) | |
617 { | |
618 // Use "SetRetryState()" | |
619 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
620 } | |
621 else | |
622 { | |
623 SetStateInternal(state); | |
624 } | |
625 } | |
626 | |
627 void SetRetryState(unsigned int timeout) | |
628 { | |
629 if (state_ == JobState_Running) | |
630 { | |
631 SetStateInternal(JobState_Retry); | |
632 retryTime_ = (boost::posix_time::microsec_clock::universal_time() + | |
633 boost::posix_time::milliseconds(timeout)); | |
634 } | |
635 else | |
636 { | |
637 // Only valid for running jobs | |
638 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
639 } | |
640 } | |
641 | |
642 void SchedulePause() | |
643 { | |
644 if (state_ == JobState_Running) | |
645 { | |
646 pauseScheduled_ = true; | |
647 } | |
648 else | |
649 { | |
650 // Only valid for running jobs | |
651 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
652 } | |
653 } | |
654 | |
655 bool IsPauseScheduled() | |
656 { | |
657 return pauseScheduled_; | |
658 } | |
659 | |
660 bool IsRetryReady(const boost::posix_time::ptime& now) const | |
661 { | |
662 if (state_ != JobState_Retry) | |
663 { | |
664 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
665 } | |
666 else | |
667 { | |
2558 | 668 return retryTime_ <= now; |
2557 | 669 } |
670 } | |
2559 | 671 |
2565 | 672 const boost::posix_time::ptime& GetCreationTime() const |
673 { | |
674 return creationTime_; | |
675 } | |
676 | |
677 const boost::posix_time::time_duration& GetRuntime() const | |
678 { | |
679 return runtime_; | |
680 } | |
681 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
682 const JobStatus& GetLastStatus() const |
2559 | 683 { |
2562 | 684 return lastStatus_; |
685 } | |
2559 | 686 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
687 void SetLastStatus(const JobStatus& status) |
2562 | 688 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
689 lastStatus_ = status; |
2562 | 690 } |
2557 | 691 }; |
692 | |
693 | |
2558 | 694 class JobsRegistry : public boost::noncopyable |
2556 | 695 { |
696 private: | |
2557 | 697 struct PriorityComparator |
2556 | 698 { |
2557 | 699 bool operator() (JobHandler*& a, |
700 JobHandler*& b) const | |
701 { | |
702 return a->GetPriority() < b->GetPriority(); | |
703 } | |
704 }; | |
705 | |
706 typedef std::map<std::string, JobHandler*> JobsIndex; | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
707 typedef std::list<JobHandler*> CompletedJobs; |
2557 | 708 typedef std::set<JobHandler*> RetryJobs; |
709 typedef std::priority_queue<JobHandler*, | |
710 std::vector<JobHandler*>, // Could be a "std::deque" | |
711 PriorityComparator> PendingJobs; | |
712 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
713 boost::mutex mutex_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
714 JobsIndex jobsIndex_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
715 PendingJobs pendingJobs_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
716 CompletedJobs completedJobs_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
717 RetryJobs retryJobs_; |
2557 | 718 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
719 boost::condition_variable pendingJobAvailable_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
720 size_t maxCompletedJobs_; |
2557 | 721 |
722 | |
723 #ifndef NDEBUG | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
724 bool IsPendingJob(const JobHandler& job) const |
2557 | 725 { |
726 PendingJobs copy = pendingJobs_; | |
727 while (!copy.empty()) | |
728 { | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
729 if (copy.top() == &job) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
730 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
731 return true; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
732 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
733 |
2557 | 734 copy.pop(); |
735 } | |
736 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
737 return false; |
2557 | 738 } |
739 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
740 bool IsCompletedJob(JobHandler& job) const |
2557 | 741 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
742 for (CompletedJobs::const_iterator it = completedJobs_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
743 it != completedJobs_.end(); ++it) |
2556 | 744 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
745 if (*it == &job) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
746 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
747 return true; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
748 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
749 } |
2557 | 750 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
751 return false; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
752 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
753 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
754 bool IsRetryJob(JobHandler& job) const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
755 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
756 return retryJobs_.find(&job) != retryJobs_.end(); |
2557 | 757 } |
758 #endif | |
2558 | 759 |
760 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
761 void CheckInvariants() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
762 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
763 #ifndef NDEBUG |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
764 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
765 PendingJobs copy = pendingJobs_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
766 while (!copy.empty()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
767 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
768 assert(copy.top()->GetState() == JobState_Pending); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
769 copy.pop(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
770 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
771 } |
2557 | 772 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
773 assert(completedJobs_.size() <= maxCompletedJobs_); |
2558 | 774 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
775 for (CompletedJobs::const_iterator it = completedJobs_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
776 it != completedJobs_.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
777 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
778 assert((*it)->GetState() == JobState_Success || |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
779 (*it)->GetState() == JobState_Failure); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
780 } |
2557 | 781 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
782 for (RetryJobs::const_iterator it = retryJobs_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
783 it != retryJobs_.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
784 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
785 assert((*it)->GetState() == JobState_Retry); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
786 } |
2558 | 787 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
788 for (JobsIndex::const_iterator it = jobsIndex_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
789 it != jobsIndex_.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
790 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
791 JobHandler& job = *it->second; |
2557 | 792 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
793 assert(job.GetId() == it->first); |
2557 | 794 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
795 switch (job.GetState()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
796 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
797 case JobState_Pending: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
798 assert(!IsRetryJob(job) && IsPendingJob(job) && !IsCompletedJob(job)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
799 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
800 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
801 case JobState_Success: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
802 case JobState_Failure: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
803 assert(!IsRetryJob(job) && !IsPendingJob(job) && IsCompletedJob(job)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
804 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
805 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
806 case JobState_Retry: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
807 assert(IsRetryJob(job) && !IsPendingJob(job) && !IsCompletedJob(job)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
808 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
809 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
810 case JobState_Running: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
811 case JobState_Paused: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
812 assert(!IsRetryJob(job) && !IsPendingJob(job) && !IsCompletedJob(job)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
813 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
814 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
815 default: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
816 throw OrthancException(ErrorCode_InternalError); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
817 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
818 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
819 #endif |
2558 | 820 } |
2557 | 821 |
822 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
823 void ForgetOldCompletedJobs() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
824 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
825 if (maxCompletedJobs_ != 0) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
826 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
827 while (completedJobs_.size() > maxCompletedJobs_) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
828 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
829 assert(completedJobs_.front() != NULL); |
2557 | 830 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
831 std::string id = completedJobs_.front()->GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
832 assert(jobsIndex_.find(id) != jobsIndex_.end()); |
2557 | 833 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
834 jobsIndex_.erase(id); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
835 delete(completedJobs_.front()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
836 completedJobs_.pop_front(); |
2558 | 837 } |
2557 | 838 } |
839 } | |
840 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
841 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
842 void MarkRunningAsCompleted(JobHandler& job, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
843 bool success) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
844 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
845 LOG(INFO) << "Job has completed with " << (success ? "success" : "failure") |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
846 << ": " << job.GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
847 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
848 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
849 assert(job.GetState() == JobState_Running); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
850 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
851 job.SetState(success ? JobState_Success : JobState_Failure); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
852 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
853 completedJobs_.push_back(&job); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
854 ForgetOldCompletedJobs(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
855 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
856 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
857 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
858 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
859 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
860 void MarkRunningAsRetry(JobHandler& job, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
861 unsigned int timeout) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
862 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
863 LOG(INFO) << "Job scheduled for retry in " << timeout << "ms: " << job.GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
864 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
865 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
866 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
867 assert(job.GetState() == JobState_Running && |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
868 retryJobs_.find(&job) == retryJobs_.end()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
869 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
870 retryJobs_.insert(&job); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
871 job.SetRetryState(timeout); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
872 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
873 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
874 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
875 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
876 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
877 void MarkRunningAsPaused(JobHandler& job) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
878 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
879 LOG(INFO) << "Job paused: " << job.GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
880 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
881 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
882 assert(job.GetState() == JobState_Running); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
883 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
884 job.SetState(JobState_Paused); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
885 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
886 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
887 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
888 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
889 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
890 public: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
891 JobsRegistry() : |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
892 maxCompletedJobs_(10) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
893 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
894 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
895 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
896 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
897 ~JobsRegistry() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
898 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
899 for (JobsIndex::iterator it = jobsIndex_.begin(); it != jobsIndex_.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
900 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
901 assert(it->second != NULL); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
902 delete it->second; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
903 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
904 } |
2557 | 905 |
906 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
907 void SetMaxCompletedJobs(size_t i) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
908 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
909 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
910 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
911 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
912 maxCompletedJobs_ = i; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
913 ForgetOldCompletedJobs(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
914 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
915 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
916 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
917 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
918 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
919 void ListJobs(std::set<std::string>& target) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
920 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
921 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
922 CheckInvariants(); |
2557 | 923 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
924 for (JobsIndex::const_iterator it = jobsIndex_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
925 it != jobsIndex_.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
926 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
927 target.insert(it->first); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
928 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
929 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
930 |
2557 | 931 |
2565 | 932 void GetJobsInfo(std::map<std::string, JobInfo>& target) |
933 { | |
934 boost::mutex::scoped_lock lock(mutex_); | |
935 CheckInvariants(); | |
936 | |
937 for (JobsIndex::const_iterator it = jobsIndex_.begin(); | |
938 it != jobsIndex_.end(); ++it) | |
939 { | |
940 const JobHandler& handler = *it->second; | |
941 target[it->first] = JobInfo(handler.GetId(), | |
942 handler.GetPriority(), | |
943 handler.GetState(), | |
944 handler.GetLastStatus(), | |
945 handler.GetCreationTime(), | |
946 handler.GetRuntime()); | |
947 } | |
948 } | |
949 | |
950 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
951 void Submit(std::string& id, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
952 IJob* job, // Takes ownership |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
953 int priority) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
954 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
955 std::auto_ptr<JobHandler> handler(new JobHandler(job, priority)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
956 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
957 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
958 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
959 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
960 id = handler->GetId(); |
2557 | 961 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
962 pendingJobs_.push(handler.get()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
963 pendingJobAvailable_.notify_one(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
964 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
965 jobsIndex_.insert(std::make_pair(id, handler.release())); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
966 |
2565 | 967 LOG(INFO) << "New job submitted with priority " << priority << ": " << id; |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
968 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
969 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
970 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
971 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
972 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
973 void Submit(IJob* job, // Takes ownership |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
974 int priority) |
2557 | 975 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
976 std::string id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
977 Submit(id, job, priority); |
2557 | 978 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
979 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
980 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
981 void SetPriority(const std::string& id, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
982 int priority) |
2556 | 983 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
984 LOG(INFO) << "Changing priority to " << priority << " for job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
985 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
986 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
987 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
988 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
989 JobsIndex::iterator found = jobsIndex_.find(id); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
990 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
991 if (found == jobsIndex_.end()) |
2557 | 992 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
993 LOG(WARNING) << "Unknown job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
994 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
995 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
996 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
997 found->second->SetPriority(priority); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
998 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
999 if (found->second->GetState() == JobState_Pending) |
2557 | 1000 { |
1001 // If the job is pending, we need to reconstruct the | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1002 // priority queue, as the heap condition has changed |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1003 |
2557 | 1004 PendingJobs copy; |
1005 std::swap(copy, pendingJobs_); | |
1006 | |
1007 assert(pendingJobs_.empty()); | |
1008 while (!copy.empty()) | |
1009 { | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1010 pendingJobs_.push(copy.top()); |
2557 | 1011 copy.pop(); |
1012 } | |
1013 } | |
1014 } | |
1015 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1016 CheckInvariants(); |
2557 | 1017 } |
1018 | |
1019 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1020 void Pause(const std::string& id) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1021 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1022 LOG(INFO) << "Pausing job: " << id; |
2558 | 1023 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1024 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1025 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1026 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1027 JobsIndex::iterator found = jobsIndex_.find(id); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1028 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1029 if (found == jobsIndex_.end()) |
2557 | 1030 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1031 LOG(WARNING) << "Unknown job: " << id; |
2557 | 1032 } |
1033 else | |
1034 { | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1035 switch (found->second->GetState()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1036 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1037 case JobState_Pending: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1038 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1039 // If the job is pending, we need to reconstruct the |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1040 // priority queue to remove it |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1041 PendingJobs copy; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1042 std::swap(copy, pendingJobs_); |
2557 | 1043 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1044 assert(pendingJobs_.empty()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1045 while (!copy.empty()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1046 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1047 if (copy.top()->GetId() != id) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1048 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1049 pendingJobs_.push(copy.top()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1050 } |
2557 | 1051 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1052 copy.pop(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1053 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1054 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1055 found->second->SetState(JobState_Paused); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1056 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1057 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1058 } |
2558 | 1059 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1060 case JobState_Retry: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1061 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1062 RetryJobs::iterator item = retryJobs_.find(found->second); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1063 assert(item != retryJobs_.end()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1064 retryJobs_.erase(item); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1065 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1066 found->second->SetState(JobState_Paused); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1067 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1068 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1069 } |
2558 | 1070 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1071 case JobState_Paused: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1072 case JobState_Success: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1073 case JobState_Failure: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1074 // Nothing to be done |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1075 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1076 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1077 case JobState_Running: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1078 found->second->SchedulePause(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1079 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1080 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1081 default: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1082 throw OrthancException(ErrorCode_InternalError); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1083 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1084 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1085 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1086 CheckInvariants(); |
2558 | 1087 } |
1088 | |
1089 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1090 void Resume(const std::string& id) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1091 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1092 LOG(INFO) << "Resuming job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1093 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1094 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1095 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1096 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1097 JobsIndex::iterator found = jobsIndex_.find(id); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1098 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1099 if (found == jobsIndex_.end()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1100 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1101 LOG(WARNING) << "Unknown job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1102 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1103 else if (found->second->GetState() != JobState_Paused) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1104 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1105 LOG(WARNING) << "Cannot resume a job that is not paused: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1106 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1107 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1108 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1109 found->second->SetState(JobState_Pending); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1110 pendingJobs_.push(found->second); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1111 pendingJobAvailable_.notify_one(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1112 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1113 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1114 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1115 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1116 |
2562 | 1117 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1118 void Resubmit(const std::string& id) |
2558 | 1119 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1120 LOG(INFO) << "Resubmitting failed job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1121 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1122 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1123 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1124 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1125 JobsIndex::iterator found = jobsIndex_.find(id); |
2562 | 1126 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1127 if (found == jobsIndex_.end()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1128 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1129 LOG(WARNING) << "Unknown job: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1130 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1131 else if (found->second->GetState() != JobState_Failure) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1132 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1133 LOG(WARNING) << "Cannot resubmit a job that has not failed: " << id; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1134 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1135 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1136 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1137 bool ok = false; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1138 for (CompletedJobs::iterator it = completedJobs_.begin(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1139 it != completedJobs_.end(); ++it) |
2562 | 1140 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1141 if (*it == found->second) |
2562 | 1142 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1143 ok = true; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1144 completedJobs_.erase(it); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1145 break; |
2562 | 1146 } |
1147 } | |
1148 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1149 assert(ok); |
2562 | 1150 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1151 found->second->SetState(JobState_Pending); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1152 pendingJobs_.push(found->second); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1153 pendingJobAvailable_.notify_one(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1154 } |
2562 | 1155 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1156 CheckInvariants(); |
2558 | 1157 } |
2557 | 1158 |
2562 | 1159 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1160 void ScheduleRetries() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1161 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1162 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1163 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1164 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1165 RetryJobs copy; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1166 std::swap(copy, retryJobs_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1167 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1168 const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time(); |
2557 | 1169 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1170 assert(retryJobs_.empty()); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1171 for (RetryJobs::iterator it = copy.begin(); it != copy.end(); ++it) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1172 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1173 if ((*it)->IsRetryReady(now)) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1174 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1175 LOG(INFO) << "Retrying job: " << (*it)->GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1176 (*it)->SetState(JobState_Pending); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1177 pendingJobs_.push(*it); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1178 pendingJobAvailable_.notify_one(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1179 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1180 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1181 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1182 retryJobs_.insert(*it); |
2557 | 1183 } |
2556 | 1184 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1185 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1186 CheckInvariants(); |
2558 | 1187 } |
2556 | 1188 |
2558 | 1189 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1190 bool GetState(JobState& state, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1191 const std::string& id) |
2558 | 1192 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1193 boost::mutex::scoped_lock lock(mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1194 CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1195 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1196 JobsIndex::const_iterator it = jobsIndex_.find(id); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1197 if (it == jobsIndex_.end()) |
2556 | 1198 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1199 return false; |
2556 | 1200 } |
2558 | 1201 else |
2557 | 1202 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1203 state = it->second->GetState(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1204 return true; |
2562 | 1205 } |
2558 | 1206 } |
2557 | 1207 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1208 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1209 class RunningJob : public boost::noncopyable |
2558 | 1210 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1211 private: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1212 JobsRegistry& registry_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1213 JobHandler* handler_; // Can only be accessed if the registry |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1214 // mutex is locked! |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1215 IJob* job_; // Will by design be in mutual exclusion, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1216 // because only one RunningJob can be |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1217 // executed at a time on a JobHandler |
2558 | 1218 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1219 std::string id_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1220 int priority_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1221 JobState targetState_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1222 unsigned int targetRetryTimeout_; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1223 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1224 public: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1225 RunningJob(JobsRegistry& registry, |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1226 unsigned int timeout) : |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1227 registry_(registry), |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1228 handler_(NULL), |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1229 targetState_(JobState_Failure), |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1230 targetRetryTimeout_(0) |
2562 | 1231 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1232 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1233 boost::mutex::scoped_lock lock(registry_.mutex_); |
2558 | 1234 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1235 while (registry_.pendingJobs_.empty()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1236 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1237 if (timeout == 0) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1238 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1239 registry_.pendingJobAvailable_.wait(lock); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1240 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1241 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1242 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1243 bool success = registry_.pendingJobAvailable_.timed_wait |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1244 (lock, boost::posix_time::milliseconds(timeout)); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1245 if (!success) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1246 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1247 // No pending job |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1248 return; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1249 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1250 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1251 } |
2559 | 1252 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1253 handler_ = registry_.pendingJobs_.top(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1254 registry_.pendingJobs_.pop(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1255 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1256 assert(handler_->GetState() == JobState_Pending); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1257 handler_->SetState(JobState_Running); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1258 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1259 job_ = &handler_->GetJob(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1260 id_ = handler_->GetId(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1261 priority_ = handler_->GetPriority(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1262 } |
2559 | 1263 } |
1264 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1265 ~RunningJob() |
2559 | 1266 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1267 if (IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1268 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1269 boost::mutex::scoped_lock lock(registry_.mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1270 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1271 switch (targetState_) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1272 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1273 case JobState_Failure: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1274 registry_.MarkRunningAsCompleted(*handler_, false); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1275 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1276 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1277 case JobState_Success: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1278 registry_.MarkRunningAsCompleted(*handler_, true); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1279 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1280 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1281 case JobState_Paused: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1282 registry_.MarkRunningAsPaused(*handler_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1283 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1284 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1285 case JobState_Retry: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1286 registry_.MarkRunningAsRetry(*handler_, targetRetryTimeout_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1287 break; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1288 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1289 default: |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1290 assert(0); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1291 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1292 } |
2559 | 1293 } |
1294 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1295 bool IsValid() const |
2559 | 1296 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1297 return (handler_ != NULL && |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1298 job_ != NULL); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1299 } |
2559 | 1300 |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1301 const std::string& GetId() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1302 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1303 if (!IsValid()) |
2559 | 1304 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1305 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1306 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1307 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1308 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1309 return id_; |
2559 | 1310 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1311 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1312 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1313 int GetPriority() const |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1314 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1315 if (!IsValid()) |
2559 | 1316 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1317 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
2559 | 1318 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1319 else |
2559 | 1320 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1321 return priority_; |
2559 | 1322 } |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1323 } |
2559 | 1324 |
2565 | 1325 IJob& GetJob() |
1326 { | |
1327 if (!IsValid()) | |
1328 { | |
1329 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
1330 } | |
1331 else | |
1332 { | |
1333 return *job_; | |
1334 } | |
1335 } | |
1336 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1337 bool IsPauseScheduled() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1338 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1339 if (!IsValid()) |
2559 | 1340 { |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1341 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
2559 | 1342 } |
1343 else | |
1344 { | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1345 boost::mutex::scoped_lock lock(registry_.mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1346 registry_.CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1347 assert(handler_->GetState() == JobState_Running); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1348 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1349 return handler_->IsPauseScheduled(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1350 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1351 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1352 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1353 void MarkSuccess() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1354 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1355 if (!IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1356 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1357 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1358 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1359 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1360 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1361 targetState_ = JobState_Success; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1362 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1363 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1364 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1365 void MarkFailure() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1366 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1367 if (!IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1368 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1369 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1370 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1371 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1372 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1373 targetState_ = JobState_Failure; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1374 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1375 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1376 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1377 void MarkPause() |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1378 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1379 if (!IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1380 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1381 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1382 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1383 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1384 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1385 targetState_ = JobState_Paused; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1386 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1387 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1388 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1389 void MarkRetry(unsigned int timeout) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1390 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1391 if (!IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1392 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1393 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1394 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1395 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1396 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1397 targetState_ = JobState_Retry; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1398 targetRetryTimeout_ = timeout; |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1399 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1400 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1401 |
2565 | 1402 void UpdateStatus(ErrorCode code) |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1403 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1404 if (!IsValid()) |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1405 { |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1406 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1407 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1408 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1409 { |
2565 | 1410 JobStatus status(code, *job_); |
1411 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1412 boost::mutex::scoped_lock lock(registry_.mutex_); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1413 registry_.CheckInvariants(); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1414 assert(handler_->GetState() == JobState_Running); |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1415 |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1416 handler_->SetLastStatus(status); |
2559 | 1417 } |
1418 } | |
2565 | 1419 }; |
1420 }; | |
2559 | 1421 |
2565 | 1422 |
1423 | |
1424 class JobsEngine | |
1425 { | |
1426 private: | |
1427 enum State | |
1428 { | |
1429 State_Setup, | |
1430 State_Running, | |
1431 State_Stopping, | |
1432 State_Done | |
1433 }; | |
1434 | |
1435 boost::mutex stateMutex_; | |
1436 State state_; | |
1437 JobsRegistry registry_; | |
1438 boost::thread retryHandler_; | |
1439 std::vector<boost::thread> workers_; | |
1440 | |
1441 bool ExecuteStep(JobsRegistry::RunningJob& running, | |
1442 size_t workerIndex) | |
1443 { | |
1444 assert(running.IsValid()); | |
1445 | |
1446 LOG(INFO) << "Executing job with priority " << running.GetPriority() | |
1447 << " in worker thread " << workerIndex << ": " << running.GetId(); | |
1448 | |
1449 if (running.IsPauseScheduled()) | |
2559 | 1450 { |
2565 | 1451 running.GetJob().ReleaseResources(); |
1452 running.MarkPause(); | |
1453 return false; | |
1454 } | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1455 |
2565 | 1456 std::auto_ptr<JobStepResult> result; |
1457 | |
1458 { | |
1459 try | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1460 { |
2565 | 1461 result.reset(running.GetJob().ExecuteStep()); |
2559 | 1462 |
2565 | 1463 if (result->GetCode() == JobStepCode_Failure) |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1464 { |
2565 | 1465 running.UpdateStatus(ErrorCode_InternalError); |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1466 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1467 else |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1468 { |
2565 | 1469 running.UpdateStatus(ErrorCode_Success); |
1470 } | |
1471 } | |
1472 catch (OrthancException& e) | |
1473 { | |
1474 running.UpdateStatus(e.GetErrorCode()); | |
1475 } | |
1476 catch (boost::bad_lexical_cast&) | |
1477 { | |
1478 running.UpdateStatus(ErrorCode_BadFileFormat); | |
1479 } | |
1480 catch (...) | |
1481 { | |
1482 running.UpdateStatus(ErrorCode_InternalError); | |
1483 } | |
1484 | |
1485 if (result.get() == NULL) | |
1486 { | |
1487 result.reset(new JobStepResult(JobStepCode_Failure)); | |
1488 } | |
1489 } | |
1490 | |
1491 switch (result->GetCode()) | |
1492 { | |
1493 case JobStepCode_Success: | |
1494 running.MarkSuccess(); | |
1495 return false; | |
1496 | |
1497 case JobStepCode_Failure: | |
1498 running.MarkFailure(); | |
1499 return false; | |
1500 | |
1501 case JobStepCode_Retry: | |
1502 running.MarkRetry(dynamic_cast<RetryResult&>(*result).GetTimeout()); | |
1503 return false; | |
1504 | |
1505 case JobStepCode_Continue: | |
1506 return true; | |
1507 | |
1508 default: | |
1509 throw OrthancException(ErrorCode_InternalError); | |
1510 } | |
1511 } | |
1512 | |
1513 static void RetryHandler(JobsEngine* engine) | |
1514 { | |
1515 assert(engine != NULL); | |
1516 | |
1517 for (;;) | |
1518 { | |
1519 boost::this_thread::sleep(boost::posix_time::milliseconds(200)); | |
1520 | |
1521 { | |
1522 boost::mutex::scoped_lock lock(engine->stateMutex_); | |
1523 | |
1524 if (engine->state_ != State_Running) | |
1525 { | |
1526 return; | |
1527 } | |
1528 } | |
1529 | |
1530 engine->GetRegistry().ScheduleRetries(); | |
1531 } | |
1532 } | |
1533 | |
1534 static void Worker(JobsEngine* engine, | |
1535 size_t workerIndex) | |
1536 { | |
1537 assert(engine != NULL); | |
1538 | |
1539 LOG(INFO) << "Worker thread " << workerIndex << " has started"; | |
1540 | |
1541 for (;;) | |
1542 { | |
1543 { | |
1544 boost::mutex::scoped_lock lock(engine->stateMutex_); | |
1545 | |
1546 if (engine->state_ != State_Running) | |
1547 { | |
1548 return; | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1549 } |
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1550 } |
2559 | 1551 |
2565 | 1552 JobsRegistry::RunningJob running(engine->GetRegistry(), 100); |
1553 | |
1554 if (running.IsValid()) | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1555 { |
2565 | 1556 for (;;) |
1557 { | |
1558 if (!engine->ExecuteStep(running, workerIndex)) | |
1559 { | |
1560 break; | |
1561 } | |
1562 } | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1563 } |
2565 | 1564 } |
1565 } | |
1566 | |
1567 public: | |
1568 JobsEngine() : | |
1569 state_(State_Setup), | |
1570 workers_(1) | |
1571 { | |
1572 } | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1573 |
2565 | 1574 ~JobsEngine() |
1575 { | |
1576 if (state_ != State_Setup && | |
1577 state_ != State_Done) | |
1578 { | |
1579 LOG(ERROR) << "INTERNAL ERROR: JobsEngine::Stop() should be invoked manually to avoid mess in the destruction order!"; | |
1580 Stop(); | |
1581 } | |
1582 } | |
1583 | |
1584 void SetWorkersCount(size_t count) | |
1585 { | |
1586 if (count == 0) | |
1587 { | |
1588 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
1589 } | |
1590 | |
1591 boost::mutex::scoped_lock lock(stateMutex_); | |
1592 | |
1593 if (state_ != State_Setup) | |
1594 { | |
1595 // Can only be invoked before calling "Start()" | |
1596 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
1597 } | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1598 |
2565 | 1599 workers_.resize(count); |
1600 } | |
1601 | |
1602 JobsRegistry& GetRegistry() | |
1603 { | |
1604 return registry_; | |
1605 } | |
1606 | |
1607 void Start() | |
1608 { | |
1609 boost::mutex::scoped_lock lock(stateMutex_); | |
1610 | |
1611 if (state_ != State_Setup) | |
1612 { | |
1613 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
1614 } | |
1615 | |
1616 retryHandler_ = boost::thread(RetryHandler, this); | |
1617 | |
1618 for (size_t i = 0; i < workers_.size(); i++) | |
1619 { | |
1620 workers_[i] = boost::thread(Worker, this, i); | |
1621 } | |
1622 | |
1623 state_ = State_Running; | |
2559 | 1624 |
2565 | 1625 LOG(WARNING) << "The jobs engine has started"; |
1626 } | |
1627 | |
1628 | |
1629 void Stop() | |
1630 { | |
1631 { | |
1632 boost::mutex::scoped_lock lock(stateMutex_); | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1633 |
2565 | 1634 if (state_ != State_Running) |
1635 { | |
1636 return; | |
1637 } | |
1638 | |
1639 state_ = State_Stopping; | |
1640 } | |
1641 | |
1642 LOG(INFO) << "Stopping the jobs engine"; | |
1643 | |
1644 if (retryHandler_.joinable()) | |
1645 { | |
1646 retryHandler_.join(); | |
1647 } | |
1648 | |
1649 for (size_t i = 0; i < workers_.size(); i++) | |
1650 { | |
1651 if (workers_[i].joinable()) | |
1652 { | |
1653 workers_[i].join(); | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1654 } |
2559 | 1655 } |
2565 | 1656 |
1657 { | |
1658 boost::mutex::scoped_lock lock(stateMutex_); | |
1659 state_ = State_Done; | |
1660 } | |
1661 | |
1662 LOG(WARNING) << "The jobs engine has stopped"; | |
1663 } | |
2556 | 1664 }; |
1665 } | |
2557 | 1666 |
1667 | |
1668 | |
1669 class DummyJob : public Orthanc::IJob | |
1670 { | |
1671 private: | |
1672 JobStepResult result_; | |
2565 | 1673 unsigned int count_; |
1674 unsigned int steps_; | |
2557 | 1675 |
1676 public: | |
1677 DummyJob() : | |
2565 | 1678 result_(Orthanc::JobStepCode_Success), |
1679 count_(0), | |
1680 steps_(4) | |
2557 | 1681 { |
1682 } | |
1683 | |
1684 explicit DummyJob(JobStepResult result) : | |
2565 | 1685 result_(result), |
1686 count_(0), | |
1687 steps_(4) | |
2557 | 1688 { |
1689 } | |
1690 | |
1691 virtual JobStepResult* ExecuteStep() | |
1692 { | |
2565 | 1693 boost::this_thread::sleep(boost::posix_time::milliseconds(50)); |
1694 | |
1695 if (count_ == steps_ - 1) | |
1696 { | |
1697 return new JobStepResult(result_); | |
1698 } | |
1699 else | |
1700 { | |
1701 count_++; | |
1702 return new JobStepResult(JobStepCode_Continue); | |
1703 } | |
2557 | 1704 } |
1705 | |
1706 virtual void ReleaseResources() | |
1707 { | |
1708 } | |
1709 | |
1710 virtual float GetProgress() | |
1711 { | |
2565 | 1712 return static_cast<float>(count_) / static_cast<float>(steps_ - 1); |
2557 | 1713 } |
1714 | |
2563
98dfc1948d00
RunningJob::ExecuteStep()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2562
diff
changeset
|
1715 virtual void GetDescription(Json::Value& value) |
2557 | 1716 { |
2565 | 1717 value["hello"] = "world"; |
2557 | 1718 } |
1719 }; | |
1720 | |
1721 | |
2558 | 1722 static bool CheckState(Orthanc::JobsRegistry& registry, |
2557 | 1723 const std::string& id, |
1724 Orthanc::JobState state) | |
1725 { | |
1726 Orthanc::JobState s; | |
2558 | 1727 if (registry.GetState(s, id)) |
2557 | 1728 { |
1729 return state == s; | |
1730 } | |
1731 else | |
1732 { | |
1733 return false; | |
1734 } | |
1735 } | |
1736 | |
1737 | |
2558 | 1738 TEST(JobsRegistry, Priority) |
2557 | 1739 { |
2558 | 1740 JobsRegistry registry; |
2557 | 1741 |
1742 std::string i1, i2, i3, i4; | |
2558 | 1743 registry.Submit(i1, new DummyJob(), 10); |
1744 registry.Submit(i2, new DummyJob(), 30); | |
1745 registry.Submit(i3, new DummyJob(), 20); | |
1746 registry.Submit(i4, new DummyJob(), 5); | |
2557 | 1747 |
2558 | 1748 registry.SetMaxCompletedJobs(2); |
2557 | 1749 |
1750 std::set<std::string> id; | |
2558 | 1751 registry.ListJobs(id); |
2557 | 1752 |
1753 ASSERT_EQ(4u, id.size()); | |
1754 ASSERT_TRUE(id.find(i1) != id.end()); | |
1755 ASSERT_TRUE(id.find(i2) != id.end()); | |
1756 ASSERT_TRUE(id.find(i3) != id.end()); | |
1757 ASSERT_TRUE(id.find(i4) != id.end()); | |
1758 | |
2558 | 1759 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Pending)); |
2557 | 1760 |
1761 { | |
2558 | 1762 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1763 ASSERT_TRUE(job.IsValid()); |
1764 ASSERT_EQ(30, job.GetPriority()); | |
1765 ASSERT_EQ(i2, job.GetId()); | |
1766 | |
2558 | 1767 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Running)); |
2557 | 1768 } |
1769 | |
2558 | 1770 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Failure)); |
1771 ASSERT_TRUE(CheckState(registry, i3, Orthanc::JobState_Pending)); | |
2557 | 1772 |
1773 { | |
2558 | 1774 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1775 ASSERT_TRUE(job.IsValid()); |
1776 ASSERT_EQ(20, job.GetPriority()); | |
1777 ASSERT_EQ(i3, job.GetId()); | |
1778 | |
1779 job.MarkSuccess(); | |
1780 | |
2558 | 1781 ASSERT_TRUE(CheckState(registry, i3, Orthanc::JobState_Running)); |
2557 | 1782 } |
1783 | |
2558 | 1784 ASSERT_TRUE(CheckState(registry, i3, Orthanc::JobState_Success)); |
2557 | 1785 |
1786 { | |
2558 | 1787 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1788 ASSERT_TRUE(job.IsValid()); |
1789 ASSERT_EQ(10, job.GetPriority()); | |
1790 ASSERT_EQ(i1, job.GetId()); | |
1791 } | |
1792 | |
1793 { | |
2558 | 1794 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1795 ASSERT_TRUE(job.IsValid()); |
1796 ASSERT_EQ(5, job.GetPriority()); | |
1797 ASSERT_EQ(i4, job.GetId()); | |
1798 } | |
1799 | |
1800 { | |
2558 | 1801 JobsRegistry::RunningJob job(registry, 1); |
2557 | 1802 ASSERT_FALSE(job.IsValid()); |
1803 } | |
1804 | |
1805 Orthanc::JobState s; | |
2558 | 1806 ASSERT_TRUE(registry.GetState(s, i1)); |
1807 ASSERT_FALSE(registry.GetState(s, i2)); // Removed because oldest | |
1808 ASSERT_FALSE(registry.GetState(s, i3)); // Removed because second oldest | |
1809 ASSERT_TRUE(registry.GetState(s, i4)); | |
2557 | 1810 |
2558 | 1811 registry.SetMaxCompletedJobs(1); // (*) |
1812 ASSERT_FALSE(registry.GetState(s, i1)); // Just discarded by (*) | |
1813 ASSERT_TRUE(registry.GetState(s, i4)); | |
2557 | 1814 } |
1815 | |
1816 | |
2558 | 1817 TEST(JobsRegistry, Simultaneous) |
2557 | 1818 { |
2558 | 1819 JobsRegistry registry; |
1820 | |
1821 std::string i1, i2; | |
1822 registry.Submit(i1, new DummyJob(), 20); | |
1823 registry.Submit(i2, new DummyJob(), 10); | |
1824 | |
1825 ASSERT_TRUE(CheckState(registry, i1, Orthanc::JobState_Pending)); | |
1826 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Pending)); | |
1827 | |
1828 { | |
1829 JobsRegistry::RunningJob job1(registry, 0); | |
1830 JobsRegistry::RunningJob job2(registry, 0); | |
1831 | |
1832 ASSERT_TRUE(job1.IsValid()); | |
1833 ASSERT_TRUE(job2.IsValid()); | |
1834 | |
1835 job1.MarkFailure(); | |
1836 job2.MarkSuccess(); | |
1837 | |
1838 ASSERT_TRUE(CheckState(registry, i1, Orthanc::JobState_Running)); | |
1839 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Running)); | |
1840 } | |
1841 | |
1842 ASSERT_TRUE(CheckState(registry, i1, Orthanc::JobState_Failure)); | |
1843 ASSERT_TRUE(CheckState(registry, i2, Orthanc::JobState_Success)); | |
1844 } | |
1845 | |
1846 | |
1847 TEST(JobsRegistry, Resubmit) | |
1848 { | |
1849 JobsRegistry registry; | |
2557 | 1850 |
1851 std::string id; | |
2558 | 1852 registry.Submit(id, new DummyJob(), 10); |
2557 | 1853 |
2558 | 1854 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); |
2557 | 1855 |
2558 | 1856 registry.Resubmit(id); |
1857 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
2557 | 1858 |
1859 { | |
2558 | 1860 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1861 ASSERT_TRUE(job.IsValid()); |
1862 job.MarkFailure(); | |
1863 | |
2558 | 1864 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); |
2557 | 1865 |
2558 | 1866 registry.Resubmit(id); |
1867 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
2557 | 1868 } |
1869 | |
2558 | 1870 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Failure)); |
2557 | 1871 |
2558 | 1872 registry.Resubmit(id); |
1873 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
2557 | 1874 |
1875 { | |
2558 | 1876 JobsRegistry::RunningJob job(registry, 0); |
2557 | 1877 ASSERT_TRUE(job.IsValid()); |
1878 ASSERT_EQ(id, job.GetId()); | |
1879 | |
1880 job.MarkSuccess(); | |
2558 | 1881 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); |
1882 } | |
1883 | |
1884 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Success)); | |
1885 | |
1886 registry.Resubmit(id); | |
1887 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Success)); | |
1888 } | |
1889 | |
1890 | |
1891 TEST(JobsRegistry, Retry) | |
1892 { | |
1893 JobsRegistry registry; | |
1894 | |
1895 std::string id; | |
1896 registry.Submit(id, new DummyJob(), 10); | |
1897 | |
1898 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1899 | |
1900 { | |
1901 JobsRegistry::RunningJob job(registry, 0); | |
1902 ASSERT_TRUE(job.IsValid()); | |
1903 job.MarkRetry(0); | |
1904 | |
1905 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
1906 } | |
1907 | |
1908 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Retry)); | |
1909 | |
1910 registry.Resubmit(id); | |
1911 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Retry)); | |
1912 | |
1913 registry.ScheduleRetries(); | |
1914 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1915 | |
1916 { | |
1917 JobsRegistry::RunningJob job(registry, 0); | |
1918 ASSERT_TRUE(job.IsValid()); | |
1919 job.MarkSuccess(); | |
1920 | |
1921 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
2557 | 1922 } |
1923 | |
2558 | 1924 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Success)); |
1925 } | |
1926 | |
1927 | |
1928 TEST(JobsRegistry, PausePending) | |
1929 { | |
1930 JobsRegistry registry; | |
1931 | |
1932 std::string id; | |
1933 registry.Submit(id, new DummyJob(), 10); | |
1934 | |
1935 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1936 | |
1937 registry.Pause(id); | |
1938 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
1939 | |
1940 registry.Pause(id); | |
1941 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
1942 | |
1943 registry.Resubmit(id); | |
1944 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
1945 | |
1946 registry.Resume(id); | |
1947 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
2557 | 1948 } |
2558 | 1949 |
1950 | |
1951 TEST(JobsRegistry, PauseRunning) | |
1952 { | |
1953 JobsRegistry registry; | |
1954 | |
1955 std::string id; | |
1956 registry.Submit(id, new DummyJob(), 10); | |
1957 | |
1958 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1959 | |
1960 { | |
1961 JobsRegistry::RunningJob job(registry, 0); | |
1962 ASSERT_TRUE(job.IsValid()); | |
1963 | |
1964 registry.Resubmit(id); | |
2562 | 1965 job.MarkPause(); |
2558 | 1966 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); |
1967 } | |
1968 | |
1969 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
1970 | |
1971 registry.Resubmit(id); | |
1972 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
1973 | |
1974 registry.Resume(id); | |
1975 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1976 | |
1977 { | |
1978 JobsRegistry::RunningJob job(registry, 0); | |
1979 ASSERT_TRUE(job.IsValid()); | |
1980 | |
1981 job.MarkSuccess(); | |
1982 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
1983 } | |
1984 | |
1985 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Success)); | |
1986 } | |
1987 | |
1988 | |
1989 TEST(JobsRegistry, PauseRetry) | |
1990 { | |
1991 JobsRegistry registry; | |
1992 | |
1993 std::string id; | |
1994 registry.Submit(id, new DummyJob(), 10); | |
1995 | |
1996 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
1997 | |
1998 { | |
1999 JobsRegistry::RunningJob job(registry, 0); | |
2000 ASSERT_TRUE(job.IsValid()); | |
2001 | |
2002 job.MarkRetry(0); | |
2003 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
2004 } | |
2005 | |
2006 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Retry)); | |
2007 | |
2008 registry.Pause(id); | |
2009 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Paused)); | |
2010 | |
2011 registry.Resume(id); | |
2012 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Pending)); | |
2013 | |
2014 { | |
2015 JobsRegistry::RunningJob job(registry, 0); | |
2016 ASSERT_TRUE(job.IsValid()); | |
2017 | |
2018 job.MarkSuccess(); | |
2019 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Running)); | |
2020 } | |
2021 | |
2022 ASSERT_TRUE(CheckState(registry, id, Orthanc::JobState_Success)); | |
2023 } | |
2565 | 2024 |
2025 | |
2026 TEST(JobsEngine, Basic) | |
2027 { | |
2028 JobsEngine engine; | |
2029 | |
2030 std::string s; | |
2031 | |
2032 for (size_t i = 0; i < 20; i++) | |
2033 engine.GetRegistry().Submit(s, new DummyJob(), rand() % 10); | |
2034 | |
2035 engine.SetWorkersCount(3); | |
2036 engine.Start(); | |
2037 | |
2038 boost::this_thread::sleep(boost::posix_time::milliseconds(200)); | |
2039 | |
2040 engine.Stop(); | |
2041 | |
2042 typedef std::map<std::string, JobInfo> Jobs; | |
2043 | |
2044 Jobs jobs; | |
2045 engine.GetRegistry().GetJobsInfo(jobs); | |
2046 | |
2047 Json::Value v; | |
2048 for (Jobs::const_iterator it = jobs.begin(); it != jobs.end(); ++it) | |
2049 { | |
2050 Json::Value vv; | |
2051 it->second.Format(vv); | |
2052 v[it->first] = vv; | |
2053 } | |
2054 | |
2055 std::cout << v << std::endl; | |
2056 } |