Cache clear

Author: cb341

bin/purge_changed_cache

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "net/http"
+require "optparse"
+require "pathname"
+require "uri"
+
+options = {
+  batch_size: 100,
+  base_url: "https://cb341.dev"
+}
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: bin/purge_changed_cache OLD_BUILD_DIR NEW_BUILD_DIR [options]"
+
+  parser.on("-u", "--base-url URL", "Public site URL, default: https://cb341.dev") do |value|
+    options[:base_url] = value.delete_suffix("/")
+  end
+
+  parser.on("-n", "--dry-run", "Print URLs without calling Cloudflare") do
+    options[:dry_run] = true
+  end
+end.parse!
+
+old_dir, new_dir = ARGV.map { |path| Pathname(path).expand_path }
+
+abort "OLD_BUILD_DIR is required" unless old_dir
+abort "NEW_BUILD_DIR is required" unless new_dir
+abort "#{old_dir} does not exist" unless old_dir.directory?
+abort "#{new_dir} does not exist" unless new_dir.directory?
+
+def file_hashes(root)
+  root.find.each_with_object({}) do |path, hashes|
+    next unless path.file?
+
+    relative_path = path.relative_path_from(root).to_s
+    hashes[relative_path] = Digest::SHA256.file(path).hexdigest
+  end
+end
+
+def public_urls(base_url, path)
+  if path == "index.html"
+    ["#{base_url}/", "#{base_url}/index.html"]
+  elsif path.end_with?("/index.html")
+    directory_url = "#{base_url}/#{path.delete_suffix('/index.html')}/"
+    explicit_url = "#{base_url}/#{path}"
+    [directory_url, explicit_url]
+  else
+    ["#{base_url}/#{path}"]
+  end
+end
+
+old_hashes = file_hashes(old_dir)
+new_hashes = file_hashes(new_dir)
+
+changed_paths = (old_hashes.keys | new_hashes.keys).select do |path|
+  old_hashes[path] != new_hashes[path]
+end
+
+urls = changed_paths.flat_map { |path| public_urls(options[:base_url], path) }.uniq.sort
+
+if urls.empty?
+  puts "No changed cacheable URLs found."
+  exit
+end
+
+puts "Purging #{urls.length} changed URL(s):"
+urls.each { |url| puts "  #{url}" }
+
+exit if options[:dry_run]
+
+zone_id = ENV.fetch("CLOUDFLARE_ZONE_ID") do
+  abort "CLOUDFLARE_ZONE_ID is required"
+end
+
+api_token = ENV.fetch("CLOUDFLARE_API_TOKEN") do
+  abort "CLOUDFLARE_API_TOKEN is required"
+end
+
+endpoint = URI("https://api.cloudflare.com/client/v4/zones/#{zone_id}/purge_cache")
+
+urls.each_slice(options[:batch_size]) do |batch|
+  response = Net::HTTP.start(endpoint.host, endpoint.port, use_ssl: true) do |http|
+    request = Net::HTTP::Post.new(endpoint)
+    request["Authorization"] = "Bearer #{api_token}"
+    request["Content-Type"] = "application/json"
+    request.body = JSON.generate(files: batch)
+    http.request(request)
+  end
+
+  body = JSON.parse(response.body)
+  next if response.is_a?(Net::HTTPSuccess) && body["success"]
+
+  warn JSON.pretty_generate(body)
+  abort "Cloudflare purge request failed with HTTP #{response.code}"
+end

bin/warm_cache

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "net/http"
+require "optparse"
+require "rexml/document"
+require "thread"
+require "uri"
+
+options = {
+  concurrency: 4,
+  sitemap: "https://cb341.dev/sitemap.xml",
+  timeout: 15
+}
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: bin/warm_cache [options]"
+
+  parser.on("-s", "--sitemap URL", "Sitemap URL to read") do |value|
+    options[:sitemap] = value
+  end
+
+  parser.on("-j", "--concurrency COUNT", Integer, "Parallel requests, default: 4") do |value|
+    options[:concurrency] = [value, 1].max
+  end
+
+  parser.on("-t", "--timeout SECONDS", Integer, "Per-request timeout, default: 15") do |value|
+    options[:timeout] = [value, 1].max
+  end
+end.parse!
+
+def fetch(uri, timeout, limit = 5)
+  raise "too many redirects for #{uri}" if limit.zero?
+
+  response = Net::HTTP.start(
+    uri.host,
+    uri.port,
+    use_ssl: uri.scheme == "https",
+    open_timeout: timeout,
+    read_timeout: timeout
+  ) do |http|
+    request = Net::HTTP::Get.new(uri)
+    request["User-Agent"] = "cb341-cache-warmer/1.0"
+    http.request(request)
+  end
+
+  case response
+  when Net::HTTPRedirection
+    fetch(URI(response.fetch("location")), timeout, limit - 1)
+  else
+    response
+  end
+end
+
+sitemap_uri = URI(options[:sitemap])
+sitemap = fetch(sitemap_uri, options[:timeout])
+abort "Could not fetch sitemap: HTTP #{sitemap.code}" unless sitemap.is_a?(Net::HTTPSuccess)
+
+document = REXML::Document.new(sitemap.body)
+urls = REXML::XPath.each(document, "//*[local-name()='url']/*[local-name()='loc']").map do |element|
+  URI(element.text.strip)
+end
+
+abort "No URLs found in #{options[:sitemap]}" if urls.empty?
+
+queue = Queue.new
+urls.each { |url| queue << url }
+
+mutex = Mutex.new
+failures = []
+completed = 0
+
+workers = Array.new(options[:concurrency]) do
+  Thread.new do
+    loop do
+      url = queue.pop(true)
+      response = fetch(url, options[:timeout])
+      cache = response["cf-cache-status"] || "-"
+
+      mutex.synchronize do
+        completed += 1
+        puts format("[%<done>d/%<total>d] %<code>s %<cache>s %<url>s",
+                    done: completed,
+                    total: urls.length,
+                    code: response.code,
+                    cache: cache,
+                    url: url)
+        failures << [url, response.code] unless response.is_a?(Net::HTTPSuccess)
+      end
+    rescue ThreadError
+      break
+    rescue StandardError => error
+      mutex.synchronize do
+        completed += 1
+        puts "[#{completed}/#{urls.length}] ERROR #{url}: #{error.message}"
+        failures << [url, error.message]
+      end
+    end
+  end
+end
+
+workers.each(&:join)
+
+if failures.any?
+  warn "\n#{failures.length} request(s) failed."
+  exit 1
+end