cronwatch 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0e24280879ad52eeeaf138342e4266225aa702893875d07c1ae9e3f7728b1b5
-  data.tar.gz: e828a6fb7fd737df7100480129d986232f59e2adef2f41eed50a42ef7e71913a
+  metadata.gz: ce9304826bfc7f8e79615453ee7b5c25503d3dbd7d8b803c229152b3e3c93844
+  data.tar.gz: ef0e084ae833b0e57f2dd997fa500ca43c6dfcddd65730265e166d7c227f00d5
 SHA512:
-  metadata.gz: af2ec018d78e9277c24a81392e071a26aa31554c7fb3d60967e96761dc615b6aa0e3a501c97415fdf73b8db57320e9d1ecc2e2840e6e843690705424c18e2d04
-  data.tar.gz: 2ccf44bdaedd6d130d4f77daabd6030ffdaf690ef484dded57e74cf68c8b2f01f8587acda1bfd54732d9ada59f5a2e7e90ad2f92bc0ec33be0c08f3437779dc6
+  metadata.gz: 23c832ba7e7ff1e34ca6930f3b9eb7785f6175db5bfec6ef731495f695a16454ea63e0fb474dd305771f33eed145d3ab41fa762ea40baafb8187254c8b1099d5
+  data.tar.gz: bdaac367aac5c069fd6c3c3c38117e40c1afa7f073d5cb95c2c56c0a97efa58a0fabe86b1640905d2d01ec44cef44ae78aaff45d03cc4fe9dd9e381295e44d57

data/lib/cronwatch/alerts/webhook.rb

@@ -38,7 +38,7 @@ module Cronwatch
       end
 
       def self.origin(url)
-        uri = URI(url)
+        uri = URI(HTTP.clean_url(url))
         raise URI::InvalidURIError unless uri.scheme && uri.host
 
         port = uri.port && uri.port != uri.default_port ? ":#{uri.port}" : ""

data/lib/cronwatch/http.rb

@@ -34,7 +34,7 @@ module Cronwatch
       # past it while the body is still arriving, returns the answer with an
       # empty body, as the SDK's channels treat a body they could not read.
       def post(url, body, headers)
-        uri = URI(url)
+        uri = HTTP.postable(url)
         deadline = HTTP.monotonic + @timeout
         request = Net::HTTP::Post.new(uri.request_uri)
         headers.each { |k, v| request[k] = HTTP.trim_header(v) }
@@ -96,6 +96,30 @@ module Cronwatch
       [deadline - monotonic, 0.001].max
     end
 
+    # A URL as fetch reads it: the spaces and control characters around it,
+    # and any tab or line break inside it, dropped (a pasted webhook URL often
+    # ends in a newline).
+    def clean_url(url)
+      url.to_s.gsub(/\A[\u0000-\u0020]+|[\u0000-\u0020]+\z/, "").delete("\t\n\r")
+    end
+
+    # The URL parsed, once it is one a channel can post to. Refused without
+    # quoting it: URI's own errors quote the whole URL, and a webhook URL's
+    # path is its credential.
+    def postable(url)
+      uri = begin
+        URI(clean_url(url))
+      rescue URI::Error, ArgumentError
+        nil
+      end
+      scheme = uri&.scheme&.downcase
+      unless %w[http https].include?(scheme) && uri.host && !uri.host.empty?
+        shown = uri&.scheme && uri.host ? "#{scheme}:" : "this URL"
+        raise ArgumentError, "only http and https URLs can be posted to, not #{shown}"
+      end
+      uri
+    end
+
     # A header value without the spaces, tabs and line breaks around it, as fetch sends it.
     def trim_header(value)
       value.to_s.gsub(/\A[ \t\r\n]+|[ \t\r\n]+\z/, "")

data/lib/cronwatch/schedule.rb

@@ -93,6 +93,34 @@ module Cronwatch
       nil
     end
 
+    # Every fire of a cron strictly after `from` and at or before `to`,
+    # ascending, or nil when there are more than `limit`. Walks the fires in
+    # batches, as firesBetween in schedule.ts asks croner for them, and drops
+    # any that do not move forward (see fire_after).
+    def fires_between(parsed, from, to, limit)
+      raise ArgumentError, "schedule \"#{parsed.source}\" was not made by Schedule.parse" unless parsed.pattern
+
+      out = []
+      probe = from
+      last = from
+      1000.times do
+        batch = next_runs(parsed, [limit + 1 - out.length, 24].min, probe)
+        return out if batch.empty?
+
+        batch.each do |t|
+          next if t <= last
+          return out if t > to
+
+          out << t
+          last = t
+          return nil if out.length > limit
+        end
+        finish = batch.last
+        probe = finish > probe ? finish : probe + 3_600_000
+      end
+      out
+    end
+
     # Up to `count` fires, each found from the one before, as croner's nextRuns.
     def next_runs(parsed, count, from)
       runs = []

data/lib/cronwatch/version.rb

@@ -2,5 +2,5 @@
 
 module Cronwatch
   # Kept in step with @cronwatch/sdk.
-  VERSION = "0.4.0"
+  VERSION = "0.5.1"
 end

data/lib/cronwatch/web/app.rb

@@ -47,10 +47,17 @@ module Cronwatch
     COOKIE = "cronwatch_token"
     DEFAULT_RUNS = 20
     MAX_RUNS = 500
+    # Runs per job the board reads in one go: the table's sparkline, and most jobs' lanes.
+    BOARD_PAGE_RUNS = 20
     COOKIE_MAX_AGE = 60 * 60 * 24 * 30
 
-    CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; form-action 'self'; " \
-          "frame-ancestors 'none'; base-uri 'none'"
+    # 'self' only for what the app shell needs: app.js (which registers the
+    # service worker and nothing else), the manifest, the worker and the icons.
+    # No inline script, and the pages work without any.
+    CSP = "default-src 'none'; script-src 'self'; style-src 'unsafe-inline'; img-src 'self' data:; " \
+          "manifest-src 'self'; worker-src 'self'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'"
+    # For the SVG icons, should one be opened on its own.
+    ASSET_CSP = "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'"
     # same-origin rather than no-referrer: under no-referrer browsers send
     # `Origin: null` on form posts, which the CSRF check would refuse, and the
     # forms redirect back to the page named by the same-origin Referer.
@@ -136,6 +143,18 @@ module Cronwatch
 
       announce(request, base) if @generated && !@announced
 
+      # The app shell: the manifest, icons, service worker, app.js and the
+      # offline page. Served to anyone, since a browser fetches some of it
+      # without cookies and none of it says anything about the jobs.
+      if %w[GET HEAD].include?(method)
+        if path == "/offline"
+          return html(HTML.message_page("You are offline", "CronWatch shows live data from your app, so it needs a connection.", base), 200, "no-cache")
+        end
+
+        asset = PWA.asset(path, base)
+        return shell(asset, base) if asset
+      end
+
       # No token outside development: fail closed.
       if !@token && !@opted_out
         return wants_html ? html(HTML.message_page("CronWatch routes are locked", "Set CRONWATCH_TOKEN (or pass token: to Cronwatch::Web.new), or pass token: nil to serve them open behind your own auth.", base), 503) : api({ ok: false, error: "CRONWATCH_TOKEN is not set" }, 503)
@@ -160,9 +179,9 @@ module Cronwatch
           end
         unless cron_secret_ok || token_ok
           if @generated
-            return wants_html ? html(HTML.message_page("Sign in", "CRONWATCH_TOKEN is not set, so this development server made a token. The sign-in link is in the server log: open it once and this browser stays signed in.", base), 401) : api({ ok: false, error: "Unauthorized: CRONWATCH_TOKEN is not set, so this development server made a token; it is in the server log" }, 401)
+            return wants_html ? html(HTML.message_page("Sign in", "CRONWATCH_TOKEN is not set, so this development server made a token. The sign-in link is in the server log: open it once and this browser stays signed in.", base, sign_in: true), 401) : api({ ok: false, error: "Unauthorized: CRONWATCH_TOKEN is not set, so this development server made a token; it is in the server log" }, 401)
           end
-          return wants_html ? html(HTML.message_page("Sign in", "Open this page with ?token=<your CRONWATCH_TOKEN> once and it will stay signed in.", base), 401) : api({ ok: false, error: "Unauthorized" }, 401)
+          return wants_html ? html(HTML.message_page("Sign in", "Open this page with ?token=<your CRONWATCH_TOKEN> once and it will stay signed in.", base, sign_in: true), 401) : api({ ok: false, error: "Unauthorized" }, 401)
         end
         unless query.nil?
           # Move the token from the URL into a cookie so it is not in history or logs.
@@ -179,15 +198,20 @@ module Cronwatch
 
       # HTML
       if method == "GET" && path == "/"
-        entries = cw.jobs_with_runs(20)
+        entries = cw.jobs_with_runs(BOARD_PAGE_RUNS)
+        now = cw.now
         runs_by_job = entries.to_h { |entry| [entry.job.name, entry.runs] }
-        return html(HTML.dashboard_page(entries.map(&:job), runs_by_job, cw.now, base, nil))
+        return html(HTML.dashboard_page(entries.map(&:job), runs_by_job, now, base, nil, board_lanes(cw, entries, now)))
       end
       if method == "GET" && parts[0] == "jobs" && parts.length == 2
         job = cw.job_summary(parts[1])
         return html(HTML.message_page("No such job", "#{parts[1]} is not in the store.", base), 404) unless job
 
-        return html(HTML.job_page(job, cw.runs(job.name, 50), cw.now, base))
+        now = cw.now
+        # Enough runs to draw the job's week; the page lists the newest fifty.
+        limit = Timeline.week_runs_limit(job, now)
+        runs = cw.runs(job.name, limit)
+        return html(HTML.job_page(job, runs, now, base, runs.length < limit))
       end
       if method == "POST" && path == "/check"
         cw.check
@@ -270,6 +294,22 @@ module Cronwatch
       api({ ok: false, error: "Not found" }, 404)
     end
 
+    # The board's timeline lanes, the first Timeline::BOARD_LANES jobs. The
+    # runs already read for the table usually cover the last day; only a job
+    # whose twenty newest runs all fall inside it (one that runs more often
+    # than every hour or so) is read again, deeper.
+    def board_lanes(cw, entries, now)
+      from = now - Timeline::BOARD_BEHIND_MS
+      entries.first(Timeline::BOARD_LANES).map do |entry|
+        runs = entry.runs
+        short = runs.length >= BOARD_PAGE_RUNS && runs.last.started_at > from
+        next Timeline::LaneInput.new(job: entry.job, runs: runs, complete: true) unless short
+
+        deeper = cw.runs(entry.job.name, Timeline::BOARD_RUNS)
+        Timeline::LaneInput.new(job: entry.job, runs: deeper, complete: deeper.length < Timeline::BOARD_RUNS)
+      end
+    end
+
     # Prints the development sign-in link, once per app.
     def announce(request, base)
       first = @announce_lock.synchronize do
@@ -422,9 +462,19 @@ module Cronwatch
       [303, { "location" => location, "cache-control" => "no-store", **SECURITY_HEADERS, **headers }, []]
     end
 
-    def html(body, status = 200)
+    # An app shell file. The worker may be scoped to the base (it is served
+    # from there anyway); the SVGs get a CSP of their own.
+    def shell(asset, base)
+      headers = { "content-type" => asset.type, "cache-control" => asset.cache, **SECURITY_HEADERS }
+      headers["content-security-policy"] = ASSET_CSP if asset.type == "image/svg+xml"
+      headers["service-worker-allowed"] = "#{base}/" if asset.worker
+      headers["content-length"] = asset.body.bytesize.to_s
+      [200, headers, [asset.body]]
+    end
+
+    def html(body, status = 200, cache = "no-store")
       [status, {
-        "content-type" => "text/html; charset=utf-8", "cache-control" => "no-store",
+        "content-type" => "text/html; charset=utf-8", "cache-control" => cache,
         "content-security-policy" => CSP, "x-frame-options" => "DENY", "content-length" => body.bytesize.to_s,
         **SECURITY_HEADERS,
       }, [body]]