deploio-cli 0.2.0 → 0.4.0

data/lib/deploio/mysql_backup_service.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlBackupService
+    DEFAULT_EXTENSION = ".zst"
+
+    # @param name [String] the name the user typed, used for hints in messages
+    def initialize(data:, name: nil, dry_run: false)
+      @data = data || {}
+      @name = name
+      @dry_run = dry_run
+    end
+
+    def default_destination = "./#{@name}-latest-backup"
+
+    def backups
+      raise Deploio::UnsupportedBackupOperationError,
+        "Listing backups is not yet supported for dedicated MySQL instances; Feel free to implement it!\n" \
+          "Use 'deploio mysql backups download #{@name}' to fetch it."
+    end
+
+    def capture
+      cmd = ["ssh", "dbadmin@#{fqdn}", "sudo", "nine-mysql-backup"]
+      Output.command(cmd.join(" "))
+      system(*cmd) unless @dry_run
+    end
+
+    def download(destination:, db_name: nil)
+      name = resolve_db_name(db_name)
+
+      cmd = [
+        "rsync",
+        "-av",
+        "dbadmin@#{fqdn}:~/backup/mysql/latest/customer/#{name}/",
+        destination
+      ]
+
+      Output.command(cmd.join(" "))
+      unless @dry_run || system(*cmd)
+        raise Deploio::Error, "Failed to download MySQL backup for database '#{name}'."
+      end
+
+      nil
+    end
+
+    private
+
+    def resolve_db_name(db_name)
+      if databases.empty?
+        raise Deploio::Error,
+          "No databases found in MySQL instance; cannot download backup."
+      elsif databases.size > 1 && db_name.nil?
+        raise Deploio::Error,
+          "Multiple databases found in MySQL instance\n" \
+            "Databases: #{databases.join(", ")}\n" \
+            "Please specify the database name using the --db_name option."
+      end
+
+      db_name || databases.first
+    end
+
+    def databases
+      @databases ||= (
+        @data.dig("status", "atProvider", "databases")&.keys || []
+      ).reject { |db| db.strip.empty? }
+    end
+
+    def fqdn
+      value = @data.dig("status", "atProvider", "fqdn")
+
+      if value.nil? || value.empty?
+        raise Deploio::Error,
+          "Database FQDN not found; cannot reach the database server."
+      end
+
+      value
+    end
+  end
+end

data/lib/deploio/mysql_database_backup_service.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlDatabaseBackupService
+    DEFAULT_EXTENSION = ".sql.zst"
+    BACKUP_SCHEDULE_LABEL = "DatabaseBackupSchedule"
+
+    def initialize(
+      db_ref:,
+      data:,
+      nctl_client:,
+      name: nil,
+      rclone_client_factory: nil
+    )
+      @db_ref = db_ref
+      @data = data || {}
+      @nctl = nctl_client
+      @name = name || db_ref.full_name
+      @rclone_client_factory = rclone_client_factory || method(:build_rclone_client)
+    end
+
+    def default_destination
+      "./#{@name}-latest-backup#{DEFAULT_EXTENSION}"
+    end
+
+    # Nine takes these backups on a schedule and there is no way to trigger one.
+    def capture
+      raise Deploio::UnsupportedBackupOperationError,
+        "'#{@db_ref.full_name}' is an economy-tier database. Those are backed up automatically " \
+          "on their configured schedule and cannot be captured manually.\n" \
+          "Use 'deploio mysql backups list #{@name}' to see the available backups."
+    end
+
+    def backups
+      @backups ||= begin
+        entries = rclone.list(bucket_name)
+        entries = entries.select { |entry| own_backup?(entry["Name"].to_s) }
+        entries.sort_by { |entry| entry["ModTime"].to_s }.reverse
+      end
+    end
+
+    def download(destination:, db_name: nil)
+      backup = backups.first
+
+      unless backup
+        raise Deploio::Error,
+          "No backups found for '#{@db_ref.full_name}' in bucket '#{bucket_name}'."
+      end
+
+      rclone.download(bucket_name, backup["Name"], destination)
+      backup
+    end
+
+    private
+
+    def own_backup?(object_name)
+      return true if instance_name.empty?
+
+      object_name.start_with?("MySQLDatabase-#{instance_name}-")
+    end
+
+    def instance_name
+      @instance_name ||= @data.dig("status", "atProvider", "name").to_s
+    end
+
+    def bucket_name
+      bucket.dig("metadata", "name")
+    end
+
+    # The database resource holds no reference to its backup bucket.
+    # Therefore, match the bucket by name for now.
+    def bucket
+      @bucket ||= begin
+        candidates = @nctl
+          .get_services_by_type("bucket", project: @db_ref.project_name)
+          .select { |candidate| backup_bucket_for_database?(candidate) }
+
+        if candidates.empty?
+          raise Deploio::Error,
+            "No backup bucket found for '#{@db_ref.full_name}'. " \
+              "Check that backups are enabled for this database " \
+              "(spec.forProvider.backupSchedule)."
+        end
+
+        candidates.first
+      end
+    end
+
+    def backup_bucket_for_database?(bucket)
+      metadata = bucket["metadata"] || {}
+      labels = metadata["labels"] || {}
+
+      return false unless labels["nine.ch/controllerKind"] == BACKUP_SCHEDULE_LABEL
+
+      metadata["name"].to_s.match?(
+        /\Amysqldatabase-#{Regexp.escape(@db_ref.database_name)}-[0-9a-f]{7}\z/
+      )
+    end
+
+    def rclone
+      @rclone ||= @rclone_client_factory.call
+    end
+
+    def build_rclone_client
+      endpoint = bucket.dig("status", "atProvider", "endpoint")
+
+      if endpoint.nil? || endpoint.to_s.empty?
+        raise Deploio::Error,
+          "Backup bucket '#{bucket_name}' has no endpoint; cannot access backups."
+      end
+
+      client = RcloneClient.new(
+        endpoint: "https://#{endpoint}",
+        access_key: @nctl.get_bucket_user_access_key(
+          bucket_name,
+          project: @db_ref.project_name
+        ),
+        secret_key: @nctl.get_bucket_user_secret_key(
+          bucket_name,
+          project: @db_ref.project_name
+        ),
+        dry_run: @nctl.dry_run
+      )
+
+      client.check_requirements unless @nctl.dry_run
+      client
+    end
+  end
+end

data/lib/deploio/mysql_database_ref.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module Deploio
+  class MysqlDatabaseRef
+    attr_reader :project_name, :database_name
+
+    def initialize(input, available_databases: {})
+      @input = input.to_s
+      if available_databases.key?(@input)
+        match = available_databases[@input]
+        @project_name = match[:project_name]
+        @database_name = match[:database_name]
+      else
+        raise_not_found_error(@input, available_databases.keys)
+      end
+    end
+
+    def full_name = "#{project_name}-#{database_name}"
+    def to_s = full_name
+
+    def ==(other)
+      other.is_a?(self.class) && project_name == other.project_name && database_name == other.database_name
+    end
+
+    private
+
+    def raise_not_found_error(input, available_database_names)
+      message = "Database not found: '#{input}'"
+      suggestions = DidYouMean::SpellChecker.new(dictionary: available_database_names).correct(input) unless available_database_names.empty?
+      unless suggestions.nil? || suggestions.empty?
+        message += "\n\nDid you mean?"
+        suggestions.each { |suggestion| message += "\n  #{suggestion}" }
+      end
+      message += "\n\nRun 'deploio mysql' to see available MySQL databases."
+      raise Deploio::MysqlDatabaseNotFoundError, message
+    end
+  end
+end

data/lib/deploio/mysql_database_resolver.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Deploio
+  class MysqlDatabaseResolver
+    attr_reader :nctl, :current_org
+
+    def initialize(nctl_client:)
+      @nctl = nctl_client
+      @database_ref = MysqlDatabaseRef
+      @fetch_databases = -> { @nctl.get_all_mysql_databases }
+      @current_org = @nctl.current_org
+    end
+
+    def resolve(database_name: nil)
+      if database_name
+        return @database_ref.new(
+          database_name,
+          available_databases: available_databases_hash
+        )
+      end
+
+      raise Deploio::Error, "No database specified"
+    end
+
+    # Returns hash mapping database names -> { project_name:, database_name: }
+    def available_databases_hash
+      @available_databases_hash ||= begin
+        hash = {}
+        current_org = @nctl.current_org
+
+        @fetch_databases.call.each do |database|
+          metadata = database["metadata"] || {}
+          project_name = metadata["namespace"] || ""
+          database_name = metadata["name"]
+          full_name = "#{project_name}-#{database_name}"
+
+          hash[full_name] = {
+            project_name: project_name,
+            database_name: database_name
+          }
+
+          # Also index by short name (without org prefix) for convenience
+          if current_org && project_name.start_with?("#{current_org}-")
+            project = project_name.delete_prefix("#{current_org}-")
+            short_name = "#{project}-#{database_name}"
+
+            hash[short_name] ||= {
+              project_name: project_name,
+              database_name: database_name
+            }
+          end
+        end
+
+        hash
+      end
+    rescue
+      {}
+    end
+
+    def short_name_for(namespace, database_name)
+      org = current_org
+
+      if org && namespace.start_with?("#{org}-")
+        project = namespace.delete_prefix("#{org}-")
+        "#{project}-#{database_name}"
+      else
+        "#{namespace}-#{database_name}"
+      end
+    end
+  end
+end

data/lib/deploio/nctl_client.rb

@@ -100,6 +100,42 @@ module Deploio
       nil
     end
 
+    def get_all_mysql_databases
+      output_dedicated_dbs = capture("get", "mysql", "-A", "-o", "json")
+      output_shared_dbs = capture("get", "mysqldatabase", "-A", "-o", "json")
+      if (output_dedicated_dbs.nil? || output_dedicated_dbs.empty?) &&
+          (output_shared_dbs.nil? || output_shared_dbs.empty?)
+        return []
+      end
+
+      [
+        *JSON.parse(output_dedicated_dbs),
+        *JSON.parse(output_shared_dbs)
+      ]
+    rescue JSON::ParserError
+      []
+    end
+
+    def get_mysql_database(db_ref)
+      output = begin
+        capture("get", "mysql", db_ref.database_name,
+          "--project", db_ref.project_name, "-o", "json")
+      rescue Deploio::NctlError
+        nil
+      end
+
+      if output.nil? || output.empty?
+        output = capture("get", "mysqldatabase", db_ref.database_name,
+          "--project", db_ref.project_name, "-o", "json")
+      end
+
+      return nil if output.nil? || output.empty?
+
+      JSON.parse(output)
+    rescue JSON::ParserError
+      nil
+    end
+
     def get_apps_by_project(project)
       output = capture("get", "apps", "--project", project, "-o", "json")
       return [] if output.nil? || output.empty?
@@ -197,6 +233,14 @@ module Deploio
       nil
     end
 
+    def get_bucket_user_access_key(name, project:)
+      capture("get", "bucketuser", name, "--project", project, "--print-access-key").strip
+    end
+
+    def get_bucket_user_secret_key(name, project:)
+      capture("get", "bucketuser", name, "--project", project, "--print-secret-key").strip
+    end
+
     def get_projects
       output = capture("get", "projects", "-o", "json")
       return [] if output.nil? || output.empty?

data/lib/deploio/postgres_backup_service.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Deploio
+  # Backups for the dedicated tier (kind: Postgres), where we own the whole
+  # database server and reach it over SSH
+  # The naming is confusing, but this is how Nine names them and how the resources appear, so prefer to stay
+  # consistent with that
+  class PostgresBackupService
+    DEFAULT_EXTENSION = ".zst"
+
+    # @param name [String] the name the user typed, used for hints in messages
+    def initialize(data:, name: nil, dry_run: false)
+      @data = data || {}
+      @name = name
+      @dry_run = dry_run
+    end
+
+    def default_destination = "./#{@name}-latest-backup#{DEFAULT_EXTENSION}"
+
+    def backups
+      raise Deploio::UnsupportedBackupOperationError,
+        "Listing backups is not yet supported for dedicated PostgreSQL instances; Feel free to implement it!\n" \
+        "Use 'deploio pg backups download #{@name}' to fetch it."
+    end
+
+    def capture
+      cmd = ["ssh", "dbadmin@#{fqdn}", "sudo nine-postgresql-backup"]
+      Output.command(cmd.join(" "))
+      system(*cmd) unless @dry_run
+    end
+
+    def download(destination:, db_name: nil)
+      name = resolve_db_name(db_name)
+
+      cmd = ["rsync", "-av", "dbadmin@#{fqdn}:~/backup/postgresql/latest/customer/#{name}/#{name}.zst", destination]
+      Output.command(cmd.join(" "))
+      system(*cmd) unless @dry_run
+
+      nil
+    end
+
+    private
+
+    def resolve_db_name(db_name)
+      if databases.empty?
+        raise Deploio::Error, "No databases found in PostgreSQL instance; cannot download backup."
+      elsif databases.size > 1 && db_name.nil?
+        raise Deploio::Error,
+          "Multiple databases found in PostgreSQL instance\n" \
+          "Databases: #{databases.join(", ")}\n" \
+          "Please specify the database name using the --db_name option."
+      end
+
+      db_name || databases.first
+    end
+
+    def databases
+      @databases ||= (@data.dig("status", "atProvider", "databases")&.keys || []).reject { |db| db.strip.empty? }
+    end
+
+    def fqdn
+      value = @data.dig("status", "atProvider", "fqdn")
+      raise Deploio::Error, "Database FQDN not found; cannot reach the database server." if value.nil? || value.empty?
+
+      value
+    end
+  end
+end

data/lib/deploio/postgres_database_backup_service.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Deploio
+  # Backups for the economy tier (kind: PostgresDatabase), where the database
+  # lives on a shared server we have no access to.
+  # The naming is confusing, but this is how Nine names them and how the resources appear, so prefer to stay
+  # consistent with that
+  class PostgresDatabaseBackupService
+    DEFAULT_EXTENSION = ".sql.zst"
+
+    BACKUP_SCHEDULE_LABEL = "DatabaseBackupSchedule"
+
+    def initialize(db_ref:, data:, nctl_client:, name: nil, rclone_client_factory: nil)
+      @db_ref = db_ref
+      @data = data || {}
+      @nctl = nctl_client
+      @name = name || db_ref.full_name
+      @rclone_client_factory = rclone_client_factory || method(:build_rclone_client)
+    end
+
+    def default_destination
+      "./#{@name}-latest-backup#{DEFAULT_EXTENSION}"
+    end
+
+    # Nine takes these backups on a schedule
+    # (you can even see them using `kubectl get databasebackupschedules.storage.nine.ch -n renuo-chess-tracker -o json`)
+    # => there is no way to trigger one.
+    def capture
+      raise Deploio::UnsupportedBackupOperationError,
+        "'#{@db_ref.full_name}' is an economy-tier database. Those are backed up automatically " \
+        "on their configured schedule and cannot be captured manually.\n" \
+        "Use 'deploio pg backups list #{@name}' to see the available backups."
+    end
+
+    def backups
+      @backups ||= begin
+        entries = rclone.list(bucket_name)
+        entries = entries.select { |e| own_backup?(e["Name"].to_s) }
+        entries.sort_by { |e| e["ModTime"].to_s }.reverse
+      end
+    end
+
+    def download(destination:, db_name: nil)
+      backup = backups.first
+      unless backup
+        raise Deploio::Error, "No backups found for '#{@db_ref.full_name}' in bucket '#{bucket_name}'."
+      end
+
+      rclone.download(bucket_name, backup["Name"], destination)
+      backup
+    end
+
+    private
+
+    def own_backup?(object_name)
+      return true if instance_name.empty?
+
+      object_name.start_with?("PostgresDatabase-#{instance_name}-")
+    end
+
+    def instance_name
+      @instance_name ||= @data.dig("status", "atProvider", "name").to_s
+    end
+
+    def bucket_name
+      bucket.dig("metadata", "name")
+    end
+
+    # The PostgresDatabase resource holds no reference to its backup bucket
+    # Changes with service connections (I assume), but we're not there yet as we still have projects with the old setup.
+    # Therefore, we match by name
+    def bucket
+      @bucket ||= begin
+        candidates = @nctl.get_services_by_type("bucket", project: @db_ref.project_name).select do |bucket|
+          backup_bucket_for_database?(bucket)
+        end
+
+        if candidates.empty?
+          raise Deploio::Error,
+            "No backup bucket found for '#{@db_ref.full_name}'. " \
+            "Check that backups are enabled for this database (spec.forProvider.backupSchedule)."
+        end
+
+        candidates.first
+      end
+    end
+
+    def backup_bucket_for_database?(bucket)
+      metadata = bucket["metadata"] || {}
+      labels = metadata["labels"] || {}
+      return false unless labels["nine.ch/controllerKind"] == BACKUP_SCHEDULE_LABEL
+
+      metadata["name"].to_s.match?(/\Apostgresdatabase-#{Regexp.escape(@db_ref.database_name)}-[0-9a-f]{7}\z/)
+    end
+
+    def rclone
+      @rclone ||= @rclone_client_factory.call
+    end
+
+    def build_rclone_client
+      endpoint = bucket.dig("status", "atProvider", "endpoint")
+      if endpoint.nil? || endpoint.to_s.empty?
+        raise Deploio::Error, "Backup bucket '#{bucket_name}' has no endpoint; cannot access backups."
+      end
+
+      client = RcloneClient.new(
+        endpoint: "https://#{endpoint}",
+        access_key: @nctl.get_bucket_user_access_key(bucket_name, project: @db_ref.project_name),
+        secret_key: @nctl.get_bucket_user_secret_key(bucket_name, project: @db_ref.project_name),
+        dry_run: @nctl.dry_run
+      )
+      client.check_requirements unless @nctl.dry_run
+      client
+    end
+  end
+end

data/lib/deploio/rclone_client.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Deploio
+  class RcloneClient
+    REMOTE = "DEPLOIO"
+
+    attr_reader :dry_run
+
+    def initialize(endpoint:, access_key:, secret_key:, dry_run: false)
+      @endpoint = endpoint
+      @access_key = access_key
+      @secret_key = secret_key
+      @dry_run = dry_run
+    end
+
+    def check_requirements
+      check_rclone_installed
+    end
+
+    def list(bucket)
+      output = capture("lsjson", remote_path(bucket))
+      return [] if output.nil? || output.empty?
+
+      data = JSON.parse(output)
+      data.is_a?(Array) ? data : []
+    rescue JSON::ParserError
+      []
+    end
+
+    def download(bucket, object, destination)
+      run("copyto", remote_path(bucket, object), destination, "--progress", "--stats-one-line")
+    end
+
+    private
+
+    # --s3-no-check-bucket skips the HeadBucket call, which the read-only bucket
+    # user is not permitted to make.
+    # See also https://docs.nine.ch/docs/object-storage/object-storage-client-tools#rclone
+    def build_command(args)
+      ["rclone", *args.map(&:to_s), "--s3-no-check-bucket"]
+    end
+
+    def remote_path(bucket, object = nil)
+      object ? "#{REMOTE}:#{bucket}/#{object}" : "#{REMOTE}:#{bucket}"
+    end
+
+    def env
+      {
+        "RCLONE_CONFIG_#{REMOTE}_TYPE" => "s3",
+        "RCLONE_CONFIG_#{REMOTE}_PROVIDER" => "Other",
+        "RCLONE_CONFIG_#{REMOTE}_ENDPOINT" => @endpoint,
+        "RCLONE_CONFIG_#{REMOTE}_ACCESS_KEY_ID" => @access_key,
+        "RCLONE_CONFIG_#{REMOTE}_SECRET_ACCESS_KEY" => @secret_key
+      }
+    end
+
+    def capture(*args)
+      cmd = build_command(args)
+      if dry_run
+        Output.command(cmd.join(" "))
+        return ""
+      end
+
+      puts "> #{cmd.join(" ")}" if ENV["DEPLOIO_DEBUG"]
+      stdout, stderr, status = Open3.capture3(env, *cmd)
+      unless status.success?
+        raise Deploio::RcloneError, "rclone command failed: #{stderr}"
+      end
+
+      stdout
+    end
+
+    def run(*args)
+      cmd = build_command(args)
+      Output.command(cmd.join(" "))
+      return true if dry_run
+
+      unless system(env, *cmd)
+        raise Deploio::RcloneError, "rclone command failed: #{cmd.join(" ")}"
+      end
+
+      true
+    end
+
+    def check_rclone_installed
+      _stdout, _stderr, status = Open3.capture3("rclone", "version")
+      return if status.success?
+
+      raise Deploio::RcloneError,
+        "rclone not found. Please install it: brew install rclone"
+    rescue Errno::ENOENT
+      raise Deploio::RcloneError,
+        "rclone not found. Please install it: brew install rclone"
+    end
+  end
+end

data/lib/deploio/shared_options.rb

@@ -7,8 +7,8 @@ module Deploio
     def self.included(base)
       base.class_option :app, aliases: "-a", type: :string, desc: "App in <project>-<app> format"
       base.class_option :org, aliases: "-o", type: :string, desc: "Organization"
-      base.class_option :dry_run, type: :boolean, default: false, desc: "Print commands without executing"
-      base.class_option :no_color, type: :boolean, default: false, desc: "Disable colored output"
+      base.class_option :dry_run, type: :boolean, desc: "Print commands without executing"
+      base.class_option :no_color, type: :boolean, desc: "Disable colored output"
 
       base.define_singleton_method(:exit_on_failure?) { true }
     end