37 case Markup.RUNNING => touched = true; runs += 1 |
38 case Markup.RUNNING => touched = true; runs += 1 |
38 case Markup.FINISHED => runs -= 1 |
39 case Markup.FINISHED => runs -= 1 |
39 case Markup.WARNING | Markup.LEGACY => warned = true |
40 case Markup.WARNING | Markup.LEGACY => warned = true |
40 case Markup.FAILED | Markup.ERROR => failed = true |
41 case Markup.FAILED | Markup.ERROR => failed = true |
41 case Markup.CANCELED => canceled = true |
42 case Markup.CANCELED => canceled = true |
|
43 case Markup.FINALIZED => finalized = true |
42 case _ => |
44 case _ => |
43 } |
45 } |
44 } |
46 } |
45 Command_Status(touched, accepted, warned, failed, canceled, forks, runs) |
47 Command_Status(touched, accepted, warned, failed, canceled, finalized, forks, runs) |
46 } |
48 } |
47 |
49 |
48 val empty = make(Iterator.empty) |
50 val empty = make(Iterator.empty) |
49 |
51 |
50 def merge(status_iterator: Iterator[Command_Status]): Command_Status = |
52 def merge(status_iterator: Iterator[Command_Status]): Command_Status = |
59 private val touched: Boolean, |
61 private val touched: Boolean, |
60 private val accepted: Boolean, |
62 private val accepted: Boolean, |
61 private val warned: Boolean, |
63 private val warned: Boolean, |
62 private val failed: Boolean, |
64 private val failed: Boolean, |
63 private val canceled: Boolean, |
65 private val canceled: Boolean, |
|
66 private val finalized: Boolean, |
64 forks: Int, |
67 forks: Int, |
65 runs: Int) |
68 runs: Int) |
66 { |
69 { |
67 def + (that: Command_Status): Command_Status = |
70 def + (that: Command_Status): Command_Status = |
68 Command_Status( |
71 Command_Status( |
69 touched || that.touched, |
72 touched || that.touched, |
70 accepted || that.accepted, |
73 accepted || that.accepted, |
71 warned || that.warned, |
74 warned || that.warned, |
72 failed || that.failed, |
75 failed || that.failed, |
73 canceled || that.canceled, |
76 canceled || that.canceled, |
|
77 finalized || that.finalized, |
74 forks + that.forks, |
78 forks + that.forks, |
75 runs + that.runs) |
79 runs + that.runs) |
76 |
80 |
77 def is_unprocessed: Boolean = accepted && !failed && (!touched || (forks != 0 && runs == 0)) |
81 def is_unprocessed: Boolean = accepted && !failed && (!touched || (forks != 0 && runs == 0)) |
78 def is_running: Boolean = runs != 0 |
82 def is_running: Boolean = runs != 0 |
79 def is_warned: Boolean = warned |
83 def is_warned: Boolean = warned |
80 def is_failed: Boolean = failed |
84 def is_failed: Boolean = failed |
81 def is_finished: Boolean = !failed && touched && forks == 0 && runs == 0 |
85 def is_finished: Boolean = !failed && touched && forks == 0 && runs == 0 |
82 def is_canceled: Boolean = canceled |
86 def is_canceled: Boolean = canceled |
|
87 def is_finalized: Boolean = finalized |
83 def is_terminated: Boolean = canceled || touched && forks == 0 && runs == 0 |
88 def is_terminated: Boolean = canceled || touched && forks == 0 && runs == 0 |
84 } |
89 } |
85 |
90 |
86 |
91 |
87 /* node status */ |
92 /* node status */ |
112 else if (status.is_finished) finished += 1 |
118 else if (status.is_finished) finished += 1 |
113 else unprocessed += 1 |
119 else unprocessed += 1 |
114 |
120 |
115 if (status.is_canceled) canceled = true |
121 if (status.is_canceled) canceled = true |
116 if (status.is_terminated) terminated = true |
122 if (status.is_terminated) terminated = true |
|
123 if (status.is_finalized) finalized = true |
117 } |
124 } |
118 val initialized = state.node_initialized(version, name) |
125 val initialized = state.node_initialized(version, name) |
119 val consolidated = state.node_consolidated(version, name) |
126 val consolidated = state.node_consolidated(version, name) |
120 |
127 |
121 Node_Status(unprocessed, running, warned, failed, finished, canceled, terminated, |
128 Node_Status(unprocessed, running, warned, failed, finished, canceled, terminated, |
122 initialized, consolidated) |
129 finalized, initialized, consolidated) |
123 } |
130 } |
124 } |
131 } |
125 |
132 |
126 sealed case class Node_Status( |
133 sealed case class Node_Status( |
127 unprocessed: Int, running: Int, warned: Int, failed: Int, finished: Int, |
134 unprocessed: Int, running: Int, warned: Int, failed: Int, finished: Int, |
128 canceled: Boolean, terminated: Boolean, initialized: Boolean, consolidated: Boolean) |
135 canceled: Boolean, terminated: Boolean, finalized: Boolean, initialized: Boolean, |
|
136 consolidated: Boolean) |
129 { |
137 { |
130 def ok: Boolean = failed == 0 |
138 def ok: Boolean = failed == 0 |
131 def total: Int = unprocessed + running + warned + failed + finished |
139 def total: Int = unprocessed + running + warned + failed + finished |
132 |
140 |
133 def json: JSON.Object.T = |
141 def json: JSON.Object.T = |
134 JSON.Object("ok" -> ok, "total" -> total, "unprocessed" -> unprocessed, |
142 JSON.Object("ok" -> ok, "total" -> total, "unprocessed" -> unprocessed, |
135 "running" -> running, "warned" -> warned, "failed" -> failed, "finished" -> finished, |
143 "running" -> running, "warned" -> warned, "failed" -> failed, "finished" -> finished, |
136 "canceled" -> canceled, "terminated" -> terminated, "initialized" -> initialized, |
144 "canceled" -> canceled, "terminated" -> terminated, "finalized" -> finalized, |
137 "consolidated" -> consolidated) |
145 "initialized" -> initialized, "consolidated" -> consolidated) |
138 } |
146 } |
139 |
147 |
140 |
148 |
141 /* node timing */ |
149 /* node timing */ |
142 |
150 |
190 { |
198 { |
191 def is_empty: Boolean = rep.isEmpty |
199 def is_empty: Boolean = rep.isEmpty |
192 def apply(name: Document.Node.Name): Node_Status = rep(name) |
200 def apply(name: Document.Node.Name): Node_Status = rep(name) |
193 def get(name: Document.Node.Name): Option[Node_Status] = rep.get(name) |
201 def get(name: Document.Node.Name): Option[Node_Status] = rep.get(name) |
194 |
202 |
195 def is_terminated(name: Document.Node.Name): Boolean = |
203 def quasi_consolidated(name: Document.Node.Name): Boolean = |
196 rep.get(name) match { |
204 rep.get(name) match { |
197 case Some(st) => st.terminated |
205 case Some(st) => !st.finalized && st.terminated |
198 case None => false |
206 case None => false |
199 } |
207 } |
200 |
208 |
201 def overall_node_status(name: Document.Node.Name): Overall_Node_Status.Value = |
209 def overall_node_status(name: Document.Node.Name): Overall_Node_Status.Value = |
202 rep.get(name) match { |
210 rep.get(name) match { |