moonraker-bosun 0.1.0

data/lib/moonraker/bosun/client.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Moonraker
+  module Bosun
+    # Moonraker APIのクライアント
+    #
+    # APIの動作は docs/moonraker-api.md を参照。
+    class Client
+      FileInfo = Data.define(:path, :modified, :size, :permissions) do
+        def writable? = permissions == "rw"
+      end
+
+      RootInfo = Data.define(:name, :path, :permissions)
+
+      # MoonrakerがエラーのHTTPステータスを返した場合のエラー
+      class APIError < Error
+        attr_reader :code
+
+        def initialize(code, message)
+          @code = code
+          super(Messages.t(:"client.api_error", code: code, message: message))
+        end
+      end
+
+      attr_reader :base_url
+
+      def initialize(base_url, open_timeout: 5, read_timeout: 30)
+        @base_url = base_url
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+      end
+
+      def roots
+        get_json("/server/files/roots").map do |item|
+          RootInfo.new(name: item.fetch("name"), path: item.fetch("path"), permissions: item.fetch("permissions"))
+        end
+      end
+
+      def list_files(root)
+        get_json("/server/files/list", root: root).map do |item|
+          FileInfo.new(
+            path: item.fetch("path"),
+            modified: item.fetch("modified"),
+            size: item.fetch("size"),
+            permissions: item.fetch("permissions")
+          )
+        end
+      end
+
+      # Moonraker DBのnamespaceの一覧
+      def db_namespaces
+        get_json("/server/database/list").fetch("namespaces")
+      rescue KeyError => e
+        raise Error, Messages.t(:"client.invalid_response", context: "database/list", message: e.message)
+      end
+
+      # namespaceの内容(Hash)
+      def db_namespace(namespace)
+        get_json("/server/database/item", namespace: namespace).fetch("value")
+      rescue KeyError => e
+        raise Error, Messages.t(:"client.invalid_response", context: "database/item", message: e.message)
+      end
+
+      # print_stats.state を返す。Klipperがreadyでない場合(print_statsが空の場合)はnil
+      def print_state
+        get_json("/printer/objects/query", print_stats: nil).dig("status", "print_stats", "state")
+      end
+
+      # ファイルの内容をバイナリの文字列で返す
+      def download(root, path)
+        request(Net::HTTP::Get.new(uri(file_path(root, path)))).body.b
+      end
+
+      def delete_file(root, path)
+        request(Net::HTTP::Delete.new(uri(file_path(root, path))))
+        nil
+      end
+
+      # ファイルをアップロードする。同名のファイルがあれば上書きする(呼び出し側で確認すること)
+      #
+      # checksumにより、Moonraker側で内容が一致しなければ書き込まれない。
+      def upload(root, path, content)
+        dir = File.dirname(path)
+        fields = [["root", root]]
+        fields << ["path", dir] unless dir == "."
+        fields << ["checksum", Digest::SHA256.hexdigest(content)]
+        fields << ["file", content.b, { filename: File.basename(path), content_type: "application/octet-stream" }]
+        req = Net::HTTP::Post.new(uri("/server/files/upload"))
+        req.set_form(fields, "multipart/form-data")
+        JSON.parse(request(req).body)
+      rescue JSON::ParserError => e
+        raise Error, Messages.t(:"client.invalid_response", context: "upload", message: e.message)
+      end
+
+      private
+
+      def get_json(path, **query)
+        response = request(Net::HTTP::Get.new(uri(path, query)))
+        JSON.parse(response.body).fetch("result")
+      rescue JSON::ParserError, KeyError => e
+        raise Error, Messages.t(:"client.invalid_response", context: path, message: e.message)
+      end
+
+      def file_path(root, path)
+        segments = [root, *path.split("/")]
+        "/server/files/#{segments.map { |s| URI.encode_uri_component(s) }.join('/')}"
+      end
+
+      def uri(path, query = {})
+        uri = @base_url.dup
+        uri.path = @base_url.path.chomp("/") + path
+        uri.query = query.empty? ? nil : URI.encode_www_form(query)
+        uri
+      end
+
+      def request(req)
+        response = Net::HTTP.start(
+          req.uri.host, req.uri.port,
+          use_ssl: req.uri.scheme == "https",
+          open_timeout: @open_timeout, read_timeout: @read_timeout
+        ) { |http| http.request(req) }
+        raise api_error(response) unless response.is_a?(Net::HTTPSuccess)
+
+        response
+      rescue SystemCallError, SocketError, IOError, Timeout::Error,
+             Net::HTTPBadResponse, Net::ProtocolError, OpenSSL::SSL::SSLError => e
+        raise Error, Messages.t(:"client.connection_failed", url: @base_url, message: e.message)
+      end
+
+      # エラーの応答にはMoonraker内部のトレースバックが含まれるので、messageだけを使う
+      def api_error(response)
+        message = begin
+          JSON.parse(response.body).dig("error", "message")
+        rescue JSON::ParserError, TypeError
+          nil
+        end
+        APIError.new(response.code.to_i, message || response.message)
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/add.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Add < Base
+        include Fetching
+
+        def run(args)
+          args = parse_options(args)
+          return 0 unless args
+          raise Error, t(:"add.no_files") if args.empty?
+
+          args.each { |path| validate_path!(path) }
+          paths = args.uniq
+          tracking.check_workspace!(paths.map { |path| HostTracking.repo_path(path) })
+
+          infos = list_config_files
+          paths.each { |path| check_target!(path, infos[path]) }
+
+          commit_and_merge("add", fetch(paths, infos))
+          0
+        end
+
+        private
+
+        def check_target!(path, info)
+          raise Error, t(:"common.file_not_on_host", path: "#{FileRules::CONFIG_ROOT}/#{path}") unless info
+
+          reason = FileRules.exclusion(FileRules::CONFIG_ROOT, info)
+          return unless reason
+
+          raise Error, t(:"add.excluded", reason: FileRules.reason_text(reason), path: path)
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/audit.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Audit < Base
+        include StatusReport
+
+        def run(args)
+          args = parse_options(args)
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          git = @context.git
+          tracking = HostTracking.new(git)
+          problems = tracking.check_invariants
+          status = SyncStatus.new(git: git, client: client, tracking: tracking, strict: true)
+
+          report(git, status)
+          print_invariants(problems)
+
+          # トラッキングしていないファイルは、あえてトラッキングしないこともあるので問題としない
+          ok = problems.empty? && !status.unmerged? && status.renames.empty? &&
+               status.entries.all? { |entry| %i[synced untracked].include?(entry.state) }
+          out.puts
+          out.puts ok ? t(:"audit.ok") : t(:"audit.ng")
+          ok ? 0 : 1
+        end
+
+        private
+
+        def print_invariants(problems)
+          out.puts
+          if problems.empty?
+            out.puts t(:"audit.invariants_ok", branch: HostTracking::BRANCH)
+            return
+          end
+
+          out.puts t(:"audit.invariants_violated", branch: HostTracking::BRANCH)
+          problems.each { |problem| out.puts "  #{problem}" }
+          out.puts "  → #{t(:"audit.repair_guide", branch: HostTracking::BRANCH)}"
+          out.puts "  → #{t(:"audit.design_guide")}"
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/backup.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Backup < Base
+        include Fetching
+
+        # まだ何もバックアップしていないときに、ホストにあればバックアップするnamespace
+        # (Web UIなどの設定と、Moonrakerが管理するユーザの設定)
+        DEFAULT_NAMESPACES = %w[mainsail fluidd mobileraker maintenance webcams timelapse].freeze
+        NAMESPACE_PATTERN = /\A[A-Za-z0-9_.-]+\z/
+
+        def run(args)
+          status = false
+          args = parse_options(args) do |o|
+            o.on("-s", "--status", t(:"backup.status_option")) { status = true }
+          end
+          return 0 unless args
+
+          if status
+            check_no_arguments!(args, "--status")
+
+            print_status
+            return 0
+          end
+
+          args.each do |namespace|
+            raise Error, t(:"backup.invalid_namespace", namespace: namespace) unless NAMESPACE_PATTERN.match?(namespace)
+          end
+          backup(args.uniq)
+          0
+        end
+
+        def self.repo_path(namespace) = "#{HostTracking::DB_BACKUP_DIR}/#{namespace}.json"
+
+        private
+
+        # host-trackingでバックアップしているnamespace
+        def tracked_namespaces
+          tip = tracking.tip
+          return [] unless tip
+
+          @context.git.ls_tree_paths(tip, HostTracking::DB_BACKUP_DIR)
+                  .map { |path| File.basename(path, ".json") }
+        end
+
+        def backup(requested)
+          tracked = tracked_namespaces
+          host = client.db_namespaces
+          missing = []
+          targets =
+            if !requested.empty?
+              missing_requested = requested - host
+              unless missing_requested.empty?
+                raise Error, t(:"backup.missing_requested", namespaces: missing_requested.join(", "))
+              end
+
+              requested
+            elsif tracked.empty?
+              out.puts t(:"backup.first", namespaces: DEFAULT_NAMESPACES.join(", "))
+              DEFAULT_NAMESPACES & host
+            else
+              missing = tracked - host
+              tracked & host
+            end
+          raise Error, t(:"backup.no_targets") if targets.empty?
+
+          tracking.check_workspace!(targets.map { |namespace| self.class.repo_path(namespace) })
+
+          fetched = targets.map do |namespace|
+            f = HostTracking::Fetched.new(repo_path: self.class.repo_path(namespace),
+                                          content: serialize(client.db_namespace(namespace)), info: nil)
+            out.puts t(:"common.fetched", path: f.repo_path)
+            f
+          end
+          print_notices(missing, requested.empty? && !tracked.empty? ? (DEFAULT_NAMESPACES & host) - tracked : [])
+          commit_and_merge("backup", fetched)
+        end
+
+        # キーを辞書順に並べた、整形したJSON(Moonrakerが返すキーの順が変わっても差分が出ないようにする)
+        def serialize(value)
+          "#{JSON.pretty_generate(sort_keys(value))}\n"
+        end
+
+        def sort_keys(value)
+          case value
+          when Hash then value.keys.sort.to_h { |key| [key, sort_keys(value[key])] }
+          when Array then value.map { |item| sort_keys(item) }
+          else value
+          end
+        end
+
+        def print_notices(missing, new_defaults)
+          unless missing.empty?
+            out.puts
+            out.puts t(:"backup.missing")
+            missing.each { |namespace| out.puts "  #{namespace}" }
+            out.puts "  → #{t(:"backup.missing_guide")}"
+            out.puts
+          end
+          return if new_defaults.empty?
+
+          out.puts
+          out.puts t(:"backup.recommended")
+          new_defaults.each { |namespace| out.puts "  #{namespace}" }
+          out.puts "  → #{t(:"backup.recommended_guide")}"
+          out.puts
+        end
+
+        def print_status
+          tracked = tracked_namespaces
+          host = client.db_namespaces
+          names = (host | tracked).sort
+          width = names.map(&:size).max || 0
+          names.each do |namespace|
+            notes = status_notes(namespace, tracked, host)
+            out.puts notes.empty? ? namespace : format("%-*s  %s", width, namespace, notes)
+          end
+        end
+
+        # namespaceの状態(バックアップ中、ホストにない、推奨)
+        def status_notes(namespace, tracked, host)
+          notes = []
+          notes << :tracked if tracked.include?(namespace)
+          notes << :not_on_host unless host.include?(namespace)
+          notes << :recommended if DEFAULT_NAMESPACES.include?(namespace) && !tracked.include?(namespace)
+          notes.map { |note| t(:"backup.note.#{note}") }.join(t(:"backup.note_separator"))
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Base
+        include Messages
+
+        class << self
+          # 一覧に表示する説明(<コマンド名>.summary)
+          def summary = Messages.t(:"#{command_name}.summary")
+
+          def command_name = name.split("::").last.downcase
+        end
+
+        def initialize(context)
+          @context = context
+        end
+
+        private
+
+        def out = @context.out
+        def client = @context.client
+
+        # オプションを解析する。--help を表示した場合はnilを返す
+        def parse_options(args)
+          parser = OptionParser.new
+          parser.banner = t(:"#{self.class.command_name}.usage")
+          yield parser if block_given?
+          parser.on("-h", "--help", t(:"common.help_option")) do
+            out.print parser.help
+            return nil
+          end
+          parser.parse!(args)
+          args
+        rescue OptionParser::ParseError => e
+          raise Error, t(:"common.invalid_option", message: e.message)
+        end
+
+        # 引数を取らないコマンドで、引数が指定されていないことを確認する
+        def check_no_arguments!(args, command = self.class.command_name)
+          raise Error, t(:"common.no_arguments", command: command, args: args.join(" ")) unless args.empty?
+        end
+
+        # 手順の案内を、1行ずつ「→」を付けて表示する
+        def print_guide(guide)
+          guide.each_line(chomp: true) { |line| out.puts "  → #{line}" }
+        end
+
+        def validate_path!(path)
+          segments = path.split("/")
+          return unless path.empty? || path.start_with?("/") || segments.include?("..")
+
+          raise Error, t(:"common.invalid_path", path: path)
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/diff.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Diff < Base
+        def run(args)
+          stat = false
+          args = parse_options(args) do |o|
+            o.on("--stat", t(:"diff.stat_option")) { stat = true }
+          end
+          return 0 unless args
+
+          args.each { |path| validate_path!(path) }
+          git = @context.git
+          tip = HostTracking.new(git).tip
+          raise Error, t(:"common.no_tracked_files") unless tip
+
+          paths = args.empty? ? [HostTracking::CONFIG_DIR] : args.map { |path| HostTracking.repo_path(path) }
+          options = ["--no-ext-diff", "--no-renames"]
+          options << "--stat" if stat
+          options << "--color=always" if out.respond_to?(:tty?) && out.tty?
+          out.print git.run("diff", *options, HostTracking::BRANCH, "HEAD", "--", *paths)
+          0
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/export.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Export < Base
+        def run(args)
+          at = nil
+          rev = nil
+          output = nil
+          args = parse_options(args) do |o|
+            o.on("--at DATETIME", t(:"export.at_option")) { |v| at = v }
+            o.on("--rev REV", t(:"export.rev_option")) { |v| rev = v }
+            o.on("-o", "--output DIR", t(:"export.output_option")) { |v| output = v }
+          end
+          return 0 unless args
+          raise Error, t(:"export.at_and_rev") if at && rev
+
+          git = @context.git
+          tracking = HostTracking.new(git)
+          raise Error, t(:"export.no_branch", branch: HostTracking::BRANCH) unless tracking.tip
+
+          commit = if at
+                     commit_at(git, at)
+                   elsif rev
+                     commit_of_rev(git, rev)
+                   else
+                     tracking.tip
+                   end
+          tree = git.ls_tree(commit)
+          paths = args.empty? ? tree.keys.sort : args.map { |arg| resolve_path(tree, arg) }.uniq
+
+          dir = File.expand_path(output || default_dir(git, commit), @context.cwd)
+          raise Error, t(:"export.exists", dir: dir) if File.exist?(dir) || File.symlink?(dir)
+
+          write(git, tree, paths, dir)
+          print_result(git, commit, paths, dir)
+          0
+        end
+
+        private
+
+        def commit_at(git, at)
+          time = begin
+            Time.parse(at)
+          rescue ArgumentError
+            raise Error, t(:"export.invalid_time", at: at)
+          end
+          commit = git.run("rev-list", "-1", "--before=#{time.iso8601}", HostTracking::REF).strip
+          raise Error, t(:"export.none_before", time: time.strftime("%Y-%m-%d %H:%M:%S")) if commit.empty?
+
+          commit
+        end
+
+        # host-trackingは一直線の履歴なので、指定したコミットとの共通の祖先が、
+        # そのコミットの時点で取り込んでいた最新の取得の時点になる
+        def commit_of_rev(git, rev)
+          commit = git.rev_parse(rev)
+          raise Error, t(:"export.no_commit", rev: rev) unless commit
+
+          base = git.merge_base(commit, HostTracking::REF)
+          raise Error, t(:"export.not_merged", rev: rev, branch: HostTracking::BRANCH) unless base
+
+          base
+        end
+
+        # Root configからのパスと、リポジトリ上のパスのどちらでも指定できる
+        def resolve_path(tree, arg)
+          validate_path!(arg)
+          [HostTracking.repo_path(arg), arg].find { |path| tree.key?(path) } or
+            raise Error, t(:"export.not_in_snapshot", path: arg)
+        end
+
+        def default_dir(git, commit)
+          date = git.run("log", "-1", "--format=%cd", "--date=format-local:%Y%m%d-%H%M%S", commit).strip
+          "export-#{date}-#{commit[0, 7]}"
+        end
+
+        def write(git, tree, paths, dir)
+          FileUtils.mkdir_p(dir)
+          paths.each do |path|
+            dest = File.join(dir, path)
+            FileUtils.mkdir_p(File.dirname(dest))
+            File.open(dest, File::WRONLY | File::CREAT | File::EXCL | File::BINARY) do |f|
+              f.write(git.cat_blob(tree.fetch(path)))
+            end
+          end
+        end
+
+        def print_result(git, commit, paths, dir)
+          info = git.run("log", "-1", "--format=%cd%x00%s", "--date=format-local:%Y-%m-%d %H:%M:%S", commit).strip
+          date, subject = info.split("\0", 2)
+          out.puts "#{HostTracking::BRANCH}: #{commit[0, 7]} (#{date}) #{subject}"
+          out.puts t(:"export.written", dir: dir)
+          paths.each { |path| out.puts "  #{path}" }
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/fetching.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      # ホストから取得してhost-trackingにコミットし、現在のブランチにマージする処理
+      module Fetching
+        private
+
+        def tracking
+          @tracking ||= HostTracking.new(@context.git)
+        end
+
+        def list_config_files
+          client.list_files(FileRules::CONFIG_ROOT).to_h { |info| [info.path, info] }
+        end
+
+        # pathsはRoot configからのパス
+        def fetch(paths, infos)
+          paths.map do |path|
+            fetched = HostTracking::Fetched.new(
+              repo_path: HostTracking.repo_path(path),
+              content: client.download(FileRules::CONFIG_ROOT, path),
+              info: infos.fetch(path)
+            )
+            out.puts t(:"common.fetched", path: fetched.repo_path)
+            fetched
+          end
+        end
+
+        # removedはリポジトリ上のパス
+        def commit_and_merge(op, fetched, removed: [])
+          parent = tracking.tip
+          commit = fetched.empty? && removed.empty? ? nil : tracking.commit(op, fetched, removed: removed)
+          if commit
+            changed = parent ? @context.git.diff_paths(parent, commit) : fetched.map(&:repo_path).sort
+            out.puts t(:"tracking.committed", branch: HostTracking::BRANCH, commit: commit[0, 7])
+            changed.each do |path|
+              out.puts t(removed.include?(path) ? :"tracking.removed" : :"tracking.changed", path: path)
+            end
+          else
+            changed = []
+            out.puts t(:"tracking.no_change", branch: HostTracking::BRANCH)
+          end
+          merge(op, changed)
+        end
+
+        def check_not_printing!
+          state = client.print_state
+          return unless %w[printing paused].include?(state)
+
+          raise Error, t(:"common.printing", state: state)
+        end
+
+        # トラッキング中のファイル(Root configからのパス)
+        def tracked_paths
+          tip = tracking.tip
+          raise Error, t(:"common.no_tracked_files") unless tip
+
+          @context.git.ls_tree_paths(tip, HostTracking::CONFIG_DIR).map { |path| HostTracking.host_path(path) }
+        end
+
+        def merge(op, changed)
+          detail = changed.empty? ? op : "#{op}: #{changed.join(', ')}"
+          # gitに記録するメッセージなので、表示の言語によらず英語にする
+          return unless tracking.merge("Merge #{HostTracking::BRANCH} (#{detail})")
+
+          out.puts t(:"tracking.merged", branch: @context.git.current_branch)
+        rescue HostTracking::MergeError => e
+          @context.err.puts "bosun: #{e.message}"
+          raise Error, t(:"tracking.merge_incomplete")
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/commands/forget.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Forget < Base
+        include Fetching
+        include Removing
+
+        def run(args)
+          args = parse_options(args)
+          return 0 unless args
+          raise Error, t(:"forget.no_files") if args.empty?
+
+          paths = args.uniq
+          check_removable!(paths)
+
+          commit_and_merge("forget", [], removed: paths.map { |path| HostTracking.repo_path(path) })
+          out.puts
+          out.puts t(:"forget.kept")
+          0
+        end
+      end
+    end
+  end
+end