moonraker-bosun 0.1.0

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Get < Base
+        def run(args)
+          root = FileRules::CONFIG_ROOT
+          args = parse_options(args) do |o|
+            o.on("-r", "--root ROOT", t(:"common.root_option")) { |v| root = v }
+          end
+          return 0 unless args
+          raise Error, t(:"get.no_files") if args.empty?
+
+          targets = args.map do |path|
+            validate_path!(path)
+            [path, File.basename(path)]
+          end
+          check_destinations!(targets.map(&:last))
+
+          # 途中で失敗したときに一部のファイルだけが残らないよう、すべて取得してから書き込む
+          contents = targets.map { |path, name| [name, download(root, path)] }
+          contents.each do |name, body|
+            File.open(File.join(@context.cwd, name), File::WRONLY | File::CREAT | File::EXCL | File::BINARY) do |f|
+              f.write(body)
+            end
+            out.puts t(:"common.fetched", path: name)
+          end
+          0
+        end
+
+        private
+
+        def check_destinations!(names)
+          duplicated = names.tally.select { |_, count| count > 1 }.keys
+          raise Error, t(:"get.duplicated", names: duplicated.join(", ")) unless duplicated.empty?
+
+          existing = names.select do |name|
+            path = File.join(@context.cwd, name)
+            File.exist?(path) || File.symlink?(path)
+          end
+          return if existing.empty?
+
+          raise Error, t(:"get.exists", names: existing.join(", "))
+        end
+
+        def download(root, path)
+          client.download(root, path)
+        rescue Client::APIError => e
+          raise unless e.code == 404
+
+          raise Error, t(:"common.file_not_on_host", path: "#{root}/#{path}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Ls < Base
+        def run(args)
+          root = FileRules::CONFIG_ROOT
+          all = false
+          long = false
+          args = parse_options(args) do |o|
+            o.on("-r", "--root ROOT", t(:"common.root_option")) { |v| root = v }
+            o.on("-a", "--all", t(:"ls.all_option")) { all = true }
+            o.on("-l", "--long", t(:"ls.long_option")) { long = true }
+          end
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          entries = client.list_files(root).sort_by(&:path).filter_map do |info|
+            reason = FileRules.exclusion(root, info)
+            [info, reason] if all || reason.nil?
+          end
+          long ? print_long(entries) : entries.map(&:first).each { |info| out.puts info.path }
+          0
+        end
+
+        private
+
+        def print_long(entries)
+          size_width = entries.map { |info, _| info.size.to_s.size }.max
+          entries.each do |info, reason|
+            line = format("%-2s  %*d  %s  %s",
+                          info.permissions, size_width, info.size,
+                          Time.at(info.modified).strftime("%Y-%m-%d %H:%M:%S"), info.path)
+            line += "  #{t(:"ls.excluded", reason: FileRules.reason_text(reason))}" if reason
+            out.puts line
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Pull < Base
+        include Fetching
+
+        def run(args)
+          args = parse_options(args)
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          tip = tracking.tip
+          raise Error, t(:"common.no_tracked_files") unless tip
+
+          tracked = @context.git.ls_tree_paths(tip, HostTracking::CONFIG_DIR).map { |path| HostTracking.host_path(path) }
+          tracking.check_workspace!(tracked.map { |path| HostTracking.repo_path(path) })
+
+          infos = list_config_files
+          deleted = tracked.reject { |path| infos.key?(path) }
+          read_only = tracked.select { |path| infos.key?(path) && !infos[path].writable? }
+          targets = tracked - deleted - read_only
+          untracked = infos.keys.sort.select do |path|
+            !tracked.include?(path) && FileRules.exclusion(FileRules::CONFIG_ROOT, infos[path]).nil?
+          end
+
+          fetched = fetch(targets, infos)
+          # マージで衝突した場合でも確認できるよう、マージの前に表示する
+          warn_skipped(:host_deleted, deleted)
+          warn_skipped(:host_read_only, read_only)
+          warn_skipped(:untracked, untracked)
+          commit_and_merge("pull", fetched)
+          0
+        end
+
+        private
+
+        def warn_skipped(state, paths)
+          return if paths.empty?
+
+          out.puts
+          out.puts t(:"common.not_fetched", label: SyncStatus.label(state))
+          paths.each { |path| out.puts "  #{path}" }
+          print_guide(SyncStatus.guide(state))
+          out.puts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Push < Base
+        include Fetching
+
+        def run(args)
+          dry_run = false
+          args = parse_options(args) do |o|
+            o.on("-n", "--dry-run", t(:"push.dry_run_option")) { dry_run = true }
+          end
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          git = @context.git
+          raise Error, t(:"common.no_tracked_files") unless tracking.tip
+
+          # 反映の後にhost-trackingをマージするので、addやpullと同じ状態であることを確認する
+          tracking.check_workspace!([HostTracking::CONFIG_DIR])
+          check_not_printing!
+
+          plan = PushPlan.new(SyncStatus.new(git: git, client: client, tracking: tracking))
+          print_plan(plan)
+          unless plan.ok?
+            out.puts
+            out.puts t(:"push.aborted")
+            return 1
+          end
+          return 0 if plan.actions.empty?
+
+          if dry_run
+            out.puts
+            out.puts t(:"push.dry_run")
+            return 0
+          end
+
+          out.puts
+          execute(plan.actions)
+          out.puts
+          out.puts t(:"push.restart")
+          0
+        end
+
+        private
+
+        def execute(actions)
+          check_unchanged_since_plan!(actions)
+
+          uploaded = []
+          begin
+            actions.each do |action|
+              client.upload(FileRules::CONFIG_ROOT, action.path, @context.git.cat_blob(action.blob))
+              uploaded << action
+              out.puts t(:"push.uploaded", path: action.path)
+            end
+          rescue StandardError, SignalException
+            # Ctrl-Cなどで中断した場合も、反映できたファイルを記録する
+            rest = actions - uploaded
+            @context.err.puts "bosun: #{t(:"push.upload_failed", paths: rest.map(&:path).join(', '))}"
+            # 反映できたファイルだけでも記録し、host-trackingが実際のホストとずれないようにする
+            begin
+              record(uploaded) unless uploaded.empty?
+            rescue StandardError, SignalException => e
+              @context.err.puts "bosun: #{t(:"push.record_failed", message: e.message)}"
+            end
+            raise
+          end
+          record(uploaded)
+        end
+
+        # 計画を立てた後にホストで変更されていないかを、書き込む直前の一覧で確認する
+        def check_unchanged_since_plan!(actions)
+          infos = list_config_files
+          changed = actions.reject do |action|
+            info = infos[action.path]
+            if action.kind == :create
+              info.nil?
+            else
+              info&.writable? && info.modified == action.host.modified && info.size == action.host.size
+            end
+          end
+          return if changed.empty?
+
+          raise Error, t(:"push.changed_since_plan", paths: changed.map(&:path).join(", "))
+        end
+
+        # アップロードしたファイルを取得し直して、host-trackingにコミットする
+        def record(actions)
+          infos = list_config_files
+          paths = actions.map(&:path)
+          missing = paths.reject { |path| infos.key?(path) }
+          raise Error, t(:"push.uploaded_missing", paths: missing.join(", ")) unless missing.empty?
+
+          fetched = fetch(paths, infos)
+          actions.zip(fetched).each do |action, f|
+            next if @context.git.hash_object(f.content, write: false) == action.blob
+
+            @context.err.puts "bosun: #{t(:"push.content_mismatch", path: action.path)}"
+          end
+          commit_and_merge("push", fetched)
+        end
+
+        def print_plan(plan)
+          if plan.actions.empty? && plan.ok?
+            out.puts t(:"push.nothing")
+          else
+            plan.actions.each { |action| out.puts t(:"push.#{action.kind}", path: action.path) }
+          end
+
+          unless plan.problems.empty?
+            out.puts
+            out.puts t(:"push.problems")
+            plan.problems.each do |problem|
+              out.puts "  #{problem.path}: #{problem.reason}"
+              out.puts "    → #{problem.guide}"
+            end
+          end
+
+          print_skipped(plan.skipped)
+        end
+
+        def print_skipped(skipped)
+          skipped.group_by(&:state).each do |state, entries|
+            out.puts
+            out.puts t(:"push.skipped", label: SyncStatus.label(state))
+            entries.each { |entry| out.puts "  #{entry.path}" }
+            print_guide(SyncStatus.guide(state))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      # forgetとrmで共通の処理
+      module Removing
+        private
+
+        # 指定したファイルがトラッキング中で、ローカルで変更されていないことを確認する
+        def check_removable!(paths)
+          paths.each { |path| validate_path!(path) }
+          tracked = tracked_paths
+          untracked = paths.reject { |path| tracked.include?(path) }
+          raise Error, t(:"remove.not_tracked", paths: untracked.join(", ")) unless untracked.empty?
+
+          tracking.check_workspace!(paths.map { |path| HostTracking.repo_path(path) })
+          check_not_modified_locally!(paths)
+        end
+
+        # マージで変更と削除が衝突するので、ローカル(HEAD)で変更されているファイルは先に中止する
+        # (ローカルで削除したファイルは指定できる)
+        def check_not_modified_locally!(paths)
+          tracked_tree = @context.git.ls_tree(tracking.tip, HostTracking::CONFIG_DIR)
+          local_tree = @context.git.ls_tree("HEAD", HostTracking::CONFIG_DIR)
+          modified = paths.select do |path|
+            repo_path = HostTracking.repo_path(path)
+            local_tree.key?(repo_path) && local_tree[repo_path] != tracked_tree[repo_path]
+          end
+          return if modified.empty?
+
+          raise Error, t(:"remove.locally_modified", paths: modified.join(", "),
+                                                     branch: HostTracking::BRANCH, dir: HostTracking::CONFIG_DIR)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Rm < Base
+        include Fetching
+        include Removing
+
+        def run(args)
+          dry_run = false
+          args = parse_options(args) do |o|
+            o.on("-n", "--dry-run", t(:"rm.dry_run_option")) { dry_run = true }
+          end
+          return 0 unless args
+          raise Error, t(:"rm.no_files") if args.empty?
+
+          paths = args.uniq
+          check_removable!(paths)
+          check_not_printing!
+          infos = check_host!(paths)
+
+          paths.each { |path| out.puts t(:"rm.plan", path: path) }
+          if dry_run
+            out.puts
+            out.puts t(:"rm.dry_run")
+            return 0
+          end
+
+          out.puts
+          execute(paths, infos)
+          0
+        end
+
+        private
+
+        # ホストのファイルが、最後に取得した内容と一致することを厳密に確認する
+        def check_host!(paths)
+          infos = list_config_files
+          tracked_tree = @context.git.ls_tree(tracking.tip, HostTracking::CONFIG_DIR)
+          problems = paths.filter_map do |path|
+            info = infos[path]
+            if info.nil?
+              t(:"rm.host_deleted", path: path)
+            elsif !info.writable?
+              t(:"rm.not_writable", path: path)
+            elsif host_blob(path) != tracked_tree[HostTracking.repo_path(path)]
+              # 最後に取得した後のホストでの変更を、確認せずに失わないようにする
+              t(:"rm.host_modified", path: path)
+            end
+          end
+          return infos if problems.empty?
+
+          details = problems.map { |problem| "  #{problem}" }.join("\n")
+          raise Error, t(:"rm.aborted", details: details)
+        end
+
+        def host_blob(path)
+          @context.git.hash_object(client.download(FileRules::CONFIG_ROOT, path), write: false)
+        end
+
+        def execute(paths, infos)
+          check_unchanged_since_check!(paths, infos)
+
+          deleted = []
+          begin
+            paths.each do |path|
+              client.delete_file(FileRules::CONFIG_ROOT, path)
+              deleted << path
+              out.puts t(:"rm.deleted", path: path)
+            end
+          rescue StandardError, SignalException
+            # Ctrl-Cなどで中断した場合も、削除できたファイルを記録する
+            rest = paths - deleted
+            @context.err.puts "bosun: #{t(:"rm.delete_failed", paths: rest.join(', '))}"
+            # 削除できたファイルだけでも記録し、host-trackingが実際のホストとずれないようにする
+            begin
+              record(deleted) unless deleted.empty?
+            rescue StandardError, SignalException => e
+              @context.err.puts "bosun: #{t(:"rm.record_failed", message: e.message)}"
+            end
+            raise
+          end
+          record(deleted)
+        end
+
+        # 確認の後にホストで変更されていないかを、削除する直前の一覧で確認する
+        def check_unchanged_since_check!(paths, infos)
+          current = list_config_files
+          changed = paths.reject do |path|
+            now = current[path]
+            now&.writable? && now.modified == infos[path].modified && now.size == infos[path].size
+          end
+          return if changed.empty?
+
+          raise Error, t(:"rm.changed_since_check", paths: changed.join(", "))
+        end
+
+        def record(paths)
+          commit_and_merge("rm", [], removed: paths.map { |path| HostTracking.repo_path(path) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Roots < Base
+        def run(args)
+          long = false
+          args = parse_options(args) do |o|
+            o.on("-l", "--long", t(:"roots.long_option")) { long = true }
+          end
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          # Moonrakerが返す順(configが先頭)のまま表示する
+          roots = client.roots
+          if long
+            name_width = roots.map { |root| root.name.size }.max
+            roots.each do |root|
+              out.puts format("%-2s  %-*s  %s", root.permissions, name_width, root.name, root.path)
+            end
+          else
+            roots.each { |root| out.puts root.name }
+          end
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      class Status < Base
+        include StatusReport
+
+        def run(args)
+          args = parse_options(args)
+          return 0 unless args
+
+          check_no_arguments!(args)
+
+          git = @context.git
+          report(git, SyncStatus.new(git: git, client: client, tracking: HostTracking.new(git)))
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    module Commands
+      # SyncStatusの表示(statusとauditで共通)
+      module StatusReport
+        private
+
+        def report(git, status)
+          print_summary(git, status)
+          print_entries(status)
+          print_renames(status)
+          print_dirty(git)
+        end
+
+        def print_summary(git, status)
+          if status.tip
+            date = git.run("log", "-1", "--format=%cd", "--date=format-local:%Y-%m-%d %H:%M:%S", status.tip).strip
+            out.puts "#{HostTracking::BRANCH}: #{status.tip[0, 7]} (#{date})"
+          else
+            out.puts t(:"status.no_tip", branch: HostTracking::BRANCH)
+          end
+          return unless status.unmerged?
+
+          out.puts
+          out.puts t(:"status.unmerged", branch: HostTracking::BRANCH)
+          out.puts "  → #{t(:"status.unmerged_guide", branch: HostTracking::BRANCH)}"
+        end
+
+        def print_entries(status)
+          SyncStatus::STATES.each do |state|
+            next if state == :synced
+
+            entries = status.by_state(state)
+            next if entries.empty?
+
+            out.puts
+            out.puts "#{SyncStatus.label(state)}:"
+            entries.each { |entry| out.puts "  #{entry.path}" }
+            print_guide(SyncStatus.guide(state))
+          end
+
+          synced = status.by_state(:synced).size
+          out.puts
+          if synced == status.entries.size && synced.positive?
+            out.puts t(:"status.all_synced", count: synced)
+          else
+            out.puts t(:"status.synced_count", count: synced)
+          end
+        end
+
+        def print_renames(status)
+          return if status.renames.empty?
+
+          out.puts
+          out.puts t(:"status.renames")
+          status.renames.each do |rename|
+            out.puts "  #{rename.from} → #{rename.to}"
+            out.puts "  → #{t(:"status.rename_guide", to: rename.to, from: rename.from)}"
+          end
+        end
+
+        def print_dirty(git)
+          dirty = git.dirty_paths([HostTracking::CONFIG_DIR])
+          return if dirty.empty?
+
+          out.puts
+          out.puts t(:"status.dirty")
+          dirty.each { |path| out.puts "  #{path}" }
+        end
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/config.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Moonraker
+  module Bosun
+    class Config
+      ENV_BASE_URL = "MOONRAKER_BASE_URL"
+
+      attr_reader :base_url
+
+      def self.from_env(env = ENV)
+        url = env[ENV_BASE_URL]
+        raise Error, Messages.t(:"config.not_set", name: ENV_BASE_URL) if url.nil? || url.empty?
+
+        new(base_url: url)
+      end
+
+      def initialize(base_url:)
+        uri = URI.parse(base_url)
+        unless uri.is_a?(URI::HTTP) && uri.host
+          raise Error, Messages.t(:"config.not_http", name: ENV_BASE_URL, url: base_url)
+        end
+
+        @base_url = uri
+      rescue URI::InvalidURIError
+        raise Error, Messages.t(:"config.invalid_url", name: ENV_BASE_URL, url: base_url)
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    # コマンドの実行に必要な入出力や接続先
+    class Context
+      attr_reader :out, :err, :env, :cwd
+
+      def initialize(out:, err:, env:, cwd: nil, client: nil)
+        @out = out
+        @err = err
+        @env = env
+        @cwd = cwd || Dir.pwd
+        @client = client
+      end
+
+      def client
+        @client ||= Client.new(Config.from_env(env).base_url)
+      end
+
+      def git
+        @git ||= Git.open(cwd)
+      end
+    end
+  end
+end

data/lib/moonraker/bosun/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    # ユーザに表示して終了するエラー
+    class Error < StandardError; end
+  end
+end

data/lib/moonraker/bosun/file_rules.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Moonraker
+  module Bosun
+    # ホストのファイルを一覧やトラッキングの対象にするかどうかの判定
+    #
+    # docs/design.md の「対象のファイル」を参照。
+    module FileRules
+      CONFIG_ROOT = "config"
+
+      # Klipperの SAVE_CONFIG によるもの: <名前>-YYYYMMDD_HHMMSS.cfg
+      KLIPPER_BACKUP = /-\d{8}_\d{6}(?:\.cfg)?\z/
+      # Moonrakerによるもの: .<名前>.bkp
+      MOONRAKER_BACKUP = /\A\..+\.bkp\z/
+
+      REASONS = %i[read_only backup].freeze
+
+      module_function
+
+      def reason_text(reason) = Messages.t(:"exclusion.#{reason}")
+
+      def host_backup?(path)
+        name = File.basename(path)
+        KLIPPER_BACKUP.match?(name) || MOONRAKER_BACKUP.match?(name)
+      end
+
+      # 除外する理由(REASONSのキー)を返す。除外しない場合はnil
+      def exclusion(root, info)
+        return nil unless root == CONFIG_ROOT
+        return :read_only unless info.writable?
+        return :backup if host_backup?(info.path)
+
+        nil
+      end
+    end
+  end
+end