diff --git a/etc/db/upgrades/upgrade06-0983abac→81d9ea19.sql b/etc/db/upgrades/upgrade06-0983abac→81d9ea19.sql new file mode 100644 index 0000000..4c8d312 --- /dev/null +++ b/etc/db/upgrades/upgrade06-0983abac→81d9ea19.sql @@ -0,0 +1,207 @@ +-- Upgrade the database from commit 0983abac to 81d9ea19. +-- +-- NOTE: This upgrade must be applied to every schema in the database. +-- NOTE: Each application starts a transaction, which must be committed +-- or rolled back. +-- +-- This defines a new procedure adjust_planner() which resolves some +-- conflicts between shot sequences and the planner, such as removing +-- sequences that have been shot, renumbering, or adjusting the planned +-- times. +-- +-- It is meant to be called at regular intervals by an external process, +-- such as the runner (software/bin/runner.sh). +-- +-- A trigger for changes to the schema's `info` table is also added. +-- +-- To apply, run as the dougal user, for every schema in the database: +-- +-- psql <'planner' + INTO _planner_config + FROM file_data + WHERE data ? 'planner'; + + SELECT * + INTO _last_sequence + FROM sequences_summary + ORDER BY sequence DESC + LIMIT 1; + + SELECT * + INTO _planned_line + FROM planned_lines + WHERE sequence = _last_sequence.sequence AND line = _last_sequence.line; + + SELECT + COALESCE( + ((lead(ts0) OVER (ORDER BY sequence)) - ts1), + make_interval(mins => (_planner_config->>'defaultLineChangeDuration')::integer) + ) + INTO _lag + FROM planned_lines + WHERE sequence = _last_sequence.sequence AND line = _last_sequence.line; + + _incr = sign(_last_sequence.lsp - _last_sequence.fsp); + + RAISE NOTICE '_planner_config: %', _planner_config; + RAISE NOTICE '_last_sequence: %', _last_sequence; + RAISE NOTICE '_planned_line: %', _planned_line; + RAISE NOTICE '_incr: %', _incr; + + -- Does the latest sequence match a planned sequence? + IF _planned_line IS NULL THEN -- No it doesn't + RAISE NOTICE 'Latest sequence shot does not match a planned sequence'; + SELECT * INTO _planned_line FROM planned_lines ORDER BY sequence ASC LIMIT 1; + RAISE NOTICE '_planned_line: %', _planned_line; + + IF _planned_line.sequence <= _last_sequence.sequence THEN + RAISE NOTICE 'Renumbering the planned sequences starting from %', _planned_line.sequence + 1; + -- Renumber the planned sequences starting from last shot sequence number + 1 + UPDATE planned_lines + SET sequence = sequence + _last_sequence.sequence - _planned_line.sequence + 1; + END IF; + + -- The correction to make to the first planned line's ts0 will be based on either the last + -- sequence's EOL + default line change time or the current time, whichever is later. + _deltatime := GREATEST(COALESCE(_last_sequence.ts1_final, _last_sequence.ts1) + make_interval(mins => (_planner_config->>'defaultLineChangeDuration')::integer), current_timestamp) - _planned_line.ts0; + + -- Is the first of the planned lines start time in the past? (±5 mins) + IF _planned_line.ts0 < (current_timestamp - make_interval(mins => 5)) THEN + RAISE NOTICE 'First planned line is in the past. Adjusting times by %', _deltatime; + -- Adjust the start / end time of the planned lines by assuming that we are at + -- `defaultLineChangeDuration` minutes away from SOL of the first planned line. + UPDATE planned_lines + SET + ts0 = ts0 + _deltatime, + ts1 = ts1 + _deltatime; + END IF; + + ELSE -- Yes it does + RAISE NOTICE 'Latest sequence does match a planned sequence: %, %', _planned_line.sequence, _planned_line.line; + + -- Is it online? + IF EXISTS(SELECT 1 FROM raw_lines_files WHERE sequence = _last_sequence.sequence AND hash = '*online*') THEN + -- Yes it is + RAISE NOTICE 'Sequence % is online', _last_sequence.sequence; + + -- Let us get the SOL from the events log if we can + RAISE NOTICE 'Trying to set fsp, ts0 from events log FSP, FGSP'; + WITH e AS ( + SELECT * FROM events + WHERE + sequence = _last_sequence.sequence + AND ('FSP' = ANY(labels) OR 'FGSP' = ANY(labels)) + ORDER BY tstamp LIMIT 1 + ) + UPDATE planned_lines + SET + fsp = COALESCE(e.point, fsp), + ts0 = COALESCE(e.tstamp, ts0) + FROM e + WHERE planned_lines.sequence = _last_sequence.sequence; + + -- Shot interval + _shotinterval := (_last_sequence.ts1 - _last_sequence.ts0) / abs(_last_sequence.lsp - _last_sequence.fsp); + + RAISE NOTICE 'Estimating EOL from current shot interval: %', _shotinterval; + + SELECT (abs(lsp-fsp) * _shotinterval + ts0) - ts1 + INTO _deltatime + FROM planned_lines + WHERE sequence = _last_sequence.sequence; + + ---- Set ts1 for the current sequence + --UPDATE planned_lines + --SET + --ts1 = (abs(lsp-fsp) * _shotinterval) + ts0 + --WHERE sequence = _last_sequence.sequence; + + RAISE NOTICE 'Adjustment is %', _deltatime; + + IF abs(EXTRACT(EPOCH FROM _deltatime)) < 8 THEN + RAISE NOTICE 'Adjustment too small (< 8 s), so not applying it'; + RETURN; + END IF; + + -- Adjust ts1 for the current sequence + UPDATE planned_lines + SET ts1 = ts1 + _deltatime + WHERE sequence = _last_sequence.sequence; + + -- Now shift all sequences after + UPDATE planned_lines + SET ts0 = ts0 + _deltatime, ts1 = ts1 + _deltatime + WHERE sequence > _last_sequence.sequence; + + RAISE NOTICE 'Deleting planned sequences before %', _planned_line.sequence; + -- Remove all previous planner entries. + DELETE + FROM planned_lines + WHERE sequence < _last_sequence.sequence; + + ELSE + -- No it isn't + RAISE NOTICE 'Sequence % is offline', _last_sequence.sequence; + + -- We were supposed to finish at _planned_line.ts1 but we finished at: + _tstamp := GREATEST(COALESCE(_last_sequence.ts1_final, _last_sequence.ts1), current_timestamp); + -- WARNING Next line is for testing only + --_tstamp := COALESCE(_last_sequence.ts1_final, _last_sequence.ts1); + -- So we need to adjust timestamps by: + _deltatime := _tstamp - _planned_line.ts1; + + RAISE NOTICE 'Planned end: %, actual end: % (%, %)', _planned_line.ts1, _tstamp, _planned_line.sequence, _last_sequence.sequence; + RAISE NOTICE 'Shifting times by % for sequences > %', _deltatime, _planned_line.sequence; + -- NOTE: This won't work if sequences are not, err… sequential. + -- NOTE: This has been known to happen in 2020. + UPDATE planned_lines + SET + ts0 = ts0 + _deltatime, + ts1 = ts1 + _deltatime + WHERE sequence > _planned_line.sequence; + + RAISE NOTICE 'Deleting planned sequences up to %', _planned_line.sequence; + -- Remove all previous planner entries. + DELETE + FROM planned_lines + WHERE sequence <= _last_sequence.sequence; + + END IF; + + END IF; +END; +$$; + +DROP TRIGGER IF EXISTS info_tg ON info; +CREATE TRIGGER info_tg AFTER INSERT OR DELETE OR UPDATE ON info FOR EACH ROW EXECUTE FUNCTION public.notify('info'); + +-- +--NOTE Run `COMMIT;` now if all went well +--