///|
fn plan_int(v : Json) -> Int32 raise StnError {
guard bounded_integer(v, -100000000.0, 100000000.0) is Some(n) else {
raise StnError("invalid_input", "expected bounded integer")
}
n
}
///|
pub fn analyze_plan(value : Json) -> Json raise StnError {
guard value is Object(obj) else {
raise StnError("invalid_input", "plan request must be object")
}
fields(obj, ["tasks", "dependencies", "max_nodes", "max_work"])
guard required(obj, "tasks") is Array(ts) else {
raise StnError("invalid_input", "tasks must be array")
}
if ts.length() > 24 {
raise StnError("limit_exceeded", "at most 24 tasks")
}
let tasks : Array[Task] = ts.map(v => {
guard v is Object(t) else {
raise StnError("invalid_input", "task must be object")
}
fields(t, [
"id", "min_duration", "max_duration", "release", "deadline", "resource",
])
let resource = match t.get("resource") {
None | Some(Null) => None
Some(v) => Some(text(v, "resource"))
}
{
id: text(required(t, "id"), "id"),
min_duration: plan_int(required(t, "min_duration")),
max_duration: plan_int(required(t, "max_duration")),
release: plan_int(required(t, "release")),
deadline: plan_int(required(t, "deadline")),
resource,
}
})
let dependencies : Array[Dependency] = match obj.get("dependencies") {
None => []
Some(Array(ds)) => {
if ds.length() > 64 {
raise StnError("limit_exceeded", "at most 64 dependencies")
}
ds.map(v => {
guard v is Object(d) else {
raise StnError("invalid_input", "dependency must be object")
}
fields(d, ["before", "after", "kind", "min_lag", "max_lag"])
let max_lag = match d.get("max_lag") {
None | Some(Null) => None
Some(v) => Some(plan_int(v))
}
{
before: text(required(d, "before"), "before"),
after: text(required(d, "after"), "after"),
kind: text(required(d, "kind"), "kind"),
min_lag: plan_int(required(d, "min_lag")),
max_lag,
}
})
}
_ => raise StnError("invalid_input", "dependencies must be array")
}
let nodes = match obj.get("max_nodes") {
None => 1000
Some(v) => plan_int(v)
}
let work = match obj.get("max_work") {
None => 20000000
Some(v) => plan_int(v)
}
let p = planning_problem(tasks, dependencies)
let result = plan(p, max_nodes=nodes, max_work=work)
let out : Map[String, Json] = Map([])
let stats = match result {
Planned(schedule, stats) => {
out["status"] = Json::string("planned")
out["schedule"] = Json::array(
schedule.map(s => {
let entry : Map[String, Json] = Map([], capacity=3)
entry["id"] = Json::string(s.id)
entry["start"] = Json::number(s.start.to_double())
entry["finish"] = Json::number(s.finish.to_double())
Json::object(entry)
}),
)
stats
}
Unschedulable(stats) => {
out["status"] = Json::string("unschedulable")
stats
}
}
out["stats"] = Json::object(
Map([
("nodes", Json::number(stats.nodes.to_double())),
("pruned", Json::number(stats.pruned.to_double())),
("decisions", Json::number(stats.decisions.to_double())),
("charged_work", Json::number(stats.charged_work.to_double())),
]),
)
Json::object(out)
}
///|
pub fn analyze_plan_batch(value : Json) -> Json raise StnError {
guard value is Array(xs) else {
raise StnError("invalid_input", "plan batch must be array")
}
if xs.length() > 64 {
raise StnError("limit_exceeded", "at most 64 plans")
}
Json::array(
xs.map(x => analyze_plan(x) catch { StnError(c, m) => error_json(c, m) }),
)
}