renuo-cli 4.20.0 → 4.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96e87891f76ac2c03e7d49276a00ec9f28b6d51530636c9fe18861b517202d56
-  data.tar.gz: 58a5b66274436e087f13ba451b252d2fc16a3e96c873e1abc43e6901e47dbc6c
+  metadata.gz: de8f99bc222386ca1ac0dd81b673d3a4382de875269d5df20aa06a3099ddef36
+  data.tar.gz: 7c6a5239dba6bef5d5e7ce46c3da8f8c6a9e6a3ba28cbfea237743bd4a65e136
 SHA512:
-  metadata.gz: 3f8ead33a76b828827e9ffeb699d9b4005d84bb3eb92bc984fae844c9d11acf3008d60cb980d75ee52707f98c68ad675a13d75d5d34c3bdc95b3ebab3a6fbef9
-  data.tar.gz: 682b8f5e3c1ce078db1bca379297a29c174f382d1a7ce882ee0a52db2056f6b54a6b3e330c6e790d0cb926130535b1e8982768886b1847fca5e7bd51b7f0a9ac
+  metadata.gz: 4fa9db9c017993228f783134a4bf03b11327436daadfcbb3dbc518519e017115b59011658e86d29147689fe0a1c5f1ecca975e45af36ed873d373379c8e4114a
+  data.tar.gz: f9626e0a2508da563348ab54f35a361556466fe17d0bc37866d2f7eb7d3b3a070c3769e4145b94bd48e0718062fa9f31f871c64de070bea89b902a7e3d41e3dc

data/README.md

@@ -24,6 +24,21 @@ Run `bundle exec ruby -Ilib ./bin/renuo` to run the executable. (e.g. `ruby -Ili
 
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+### Testing commands in the shell
+
+The easiest way to test the CLI during development is to temporarily add the local `bin` directory to your `PATH`:
+
+```shell
+export PATH="$PWD/bin:$PATH"
+```
+
+This binds the `renuo` command to your local version, so you can run commands directly:
+
+```shell
+renuo -h
+renuo generate_github_settings
+```
+
 To install this gem onto your local machine, run `bundle exec rake install`.
 
 To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`,

data/lib/renuo/cli/commands/ci/setup.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Renuo::Cli::Commands::Ci
+  class Setup
+    command "ci setup" do |c|
+      c.syntax = "renuo ci setup"
+      c.summary = "Installs and logs in to nctl."
+      c.description = c.summary
+      c.action { new.run }
+    end
+
+    def run
+      system! "echo 'deb [trusted=yes] https://repo.nine.ch/deb/ /' " \
+              "| sudo tee /etc/apt/sources.list.d/repo.nine.ch.list"
+      system! "sudo apt-get update -qqo Dir::Etc::sourcelist=/etc/apt/sources.list.d/repo.nine.ch.list"
+      system! "sudo apt-get install -qq nctl"
+      system! "nctl auth login"
+    end
+
+    private
+
+    def system!(cmd)
+      abort unless system cmd
+    end
+  end
+end

data/lib/renuo/cli/commands/ci/update_deploio_app.rb

@@ -7,6 +7,7 @@ module Renuo::Cli::Commands::Ci
       c.summary = "Updates a Deploio app."
       c.description = c.summary
       c.option "-d", "--docker", "If the app uses a Dockerfile"
+      c.option "-g", "--git-revision <hash>", String, "The Git revision"
       c.option "-p", "--project <name>", String, "The name of the project"
       c.example "renuo ci update-deploio-app main -dp renuo-dashboard",
                 "Updates the 'main' app of the 'renuo-dashboard' project using a Dockerfile"
@@ -14,27 +15,22 @@ module Renuo::Cli::Commands::Ci
     end
 
     def run
-      system! "checkout --use-cache" if @docker
-      system! "echo 'deb [trusted=yes] https://repo.nine.ch/deb/ /' " \
-              "| sudo tee /etc/apt/sources.list.d/repo.nine.ch.list"
-      system! "sudo apt-get update -qqo Dir::Etc::sourcelist=/etc/apt/sources.list.d/repo.nine.ch.list"
-      system! "sudo apt-get install -qq nctl"
-      system! "nctl auth login"
-      system! "nctl update app #{@app} -p #{@project} --env APP_REVISION=$SEMAPHORE_GIT_SHA " \
+      system! "nctl update app #{@app} -p #{@project} --env APP_REVISION=#{@git_revision} " \
               "#{"--build-env RUBY_VERSION=#{File.read(".ruby-version").strip} " if @docker}" \
-              "--git-revision $SEMAPHORE_GIT_SHA --skip-repo-access-check"
+              "--git-revision #{@git_revision} --skip-repo-access-check"
     end
 
     private
 
     def initialize(args, options)
       @app = args.first
-      @project = options.project
       @docker = options.docker
+      @git_revision = options.git_revision || ENV.fetch("SEMAPHORE_GIT_SHA", nil)
+      @project = options.project
 
       abort "missing app name" unless @app
       abort "missing project name" unless @project
-      abort "this command must be run in Semaphore" unless ENV.key?("SEMAPHORE_GIT_SHA")
+      abort "missing Git revision" unless @git_revision
     end
 
     def system!(cmd)

data/lib/renuo/cli/commands/create_deploio_app.rb

@@ -160,7 +160,7 @@ class Renuo::Cli::Commands::CreateDeploioApp # rubocop:disable Metrics/ClassLeng
         --project=#{@project_name_with_org_prefix} \\
         --postgres-database-version=#{@postgres_version} \\
         --location=nine-es34 \\
-        --backup-schedule=daily
+        --backup-schedule=daily \\
         --collation=C.UTF-8
     OUTPUT
   end

data/lib/renuo/cli/commands/debug.rb

@@ -3,22 +3,26 @@
 require_relative "../services/cache"
 require_relative "../services/deploio"
 require_relative "../services/heroku"
+require_relative "../services/hetzner"
+require "shellwords"
 
-class Renuo::Cli::Commands::Debug
+class Renuo::Cli::Commands::Debug # rubocop:disable Metrics/ClassLength
   Cache = Renuo::Cli::Services::Cache
   Deploio = Renuo::Cli::Services::Deploio
   Heroku = Renuo::Cli::Services::Heroku
+  Hetzner = Renuo::Cli::Services::Hetzner
 
   command "debug" do |c|
     c.syntax = "renuo debug <app-name or domain>"
     c.summary = "Shortcut to debug apps"
     c.description = <<~DESC
       Enter the container or show logs of the available apps on Heroku or Deploio.
-      The command will show a menu with all found targets.
+      The command will show a menu with all found targets across all organizations.
       It will only use a cache. You must manually update the cache with option 1).
     DESC
     c.option "-H", "--heroku", "Show only Heroku apps"
     c.option "-d", "--deploio", "Show only Deploio apps"
+    c.option "-z", "--hetzner", "Show only Hetzner vms"
     c.action do |args, options|
       new.run(args, options)
     rescue Interrupt
@@ -33,46 +37,56 @@ class Renuo::Cli::Commands::Debug
     query = args[0]
     abort(">> Please provide an app name or domain.") if query.blank?
 
-    cloud_unspecified = !options.heroku && !options.deploio
+    cloud_unspecified = !options.heroku && !options.deploio && !options.hetzner
     should_scan_heroku = options.heroku || cloud_unspecified
     should_scan_deploio = options.deploio || cloud_unspecified
+    should_scan_hetzner = options.hetzner || cloud_unspecified
 
     choose do |menu| # rubocop:todo Metrics/BlockLength
       deploio_cache_info = "Deploio: #{Cache.stored_at("deploio_apps") || "never"}"
       heroku_cache_info = "Heroku: #{Cache.stored_at("heroku_apps") || "never"}"
+      hetzner_cache_info = "Hetzner: #{Cache.stored_at("hetzner_vms") || "never"}"
 
-      menu.choice "Update caches (#{deploio_cache_info}, #{heroku_cache_info})" do
+      menu.choice "Update caches (#{deploio_cache_info}, #{heroku_cache_info}, #{hetzner_cache_info})" do
         if should_scan_deploio
           say "Updating Deploio cache"
           Cache.store("deploio_apps", Deploio.fetch_apps)
+          Cache.store("deploio_vms", Deploio.fetch_vms)
         end
         if should_scan_heroku
           say "Updating Heroku cache..."
           Cache.store("heroku_apps", Heroku.fetch_apps)
         end
+        if should_scan_hetzner
+          say "Updating Hetzner cache..."
+          Cache.store("hetzner_vms", Hetzner.fetch_vms)
+        end
         say "Caches updated"
       end
 
       open_cmds = []
 
-      # rubocop:disable Layout/LineLength
       if should_scan_deploio && Cache.stored_at("deploio_apps")
         select_deploio_targets(query).each do |app|
-          bash_cmd = "nctl #{bold("exec")} app #{bold(app[:name])} bash --project #{bold(app[:namespace])}"
-          menu.choice(bash_cmd) { exec bash_cmd.squish }
+          bash_display_cmd, bash_exec_cmd = nctl_command(app, "exec", "bash")
+          menu.choice(bash_display_cmd) { exec bash_exec_cmd.squish }
 
-          rails_console_cmd = "nctl #{bold("exec")} app #{bold(app[:name])} bundle #{bold("exec")} rails console --project #{bold(app[:namespace])}"
-          menu.choice(rails_console_cmd) { exec rails_console_cmd.squish }
+          bundle_display_cmd, bundle_exec_cmd = nctl_command(app, "exec", "bundle exec rails console")
+          menu.choice(bundle_display_cmd) { exec bundle_exec_cmd.squish }
 
-          log_cmd = "nctl #{bold("logs")} app #{bold(app[:name])} -f --project #{bold(app[:namespace])}"
-          menu.choice(log_cmd) { exec log_cmd.squish }
+          logs_display_cmd, logs_exec_cmd = nctl_command(app, "logs", "-f")
+          menu.choice(logs_display_cmd) { exec logs_exec_cmd.squish }
 
-          app[:hosts].each do |host|
-            open_cmds << "open https://#{host}"
-          end
+          app[:hosts].each { |host| open_cmds << "open https://#{host}" }
+        end
+      end
+
+      if should_scan_deploio && Cache.stored_at("deploio_vms")
+        select_deploio_vm_targets(query).each do |vm|
+          bash_cmd = "ssh root@#{vm[:fqdn]} docker ps"
+          menu.choice(bash_cmd) { exec bash_cmd.squish }
         end
       end
-      # rubocop:enable Layout/LineLength
 
       if should_scan_heroku && Cache.stored_at("heroku_apps")
         select_heroku_targets(query).each do |app|
@@ -91,6 +105,14 @@ class Renuo::Cli::Commands::Debug
         end
       end
 
+      if should_scan_hetzner && Cache.stored_at("hetzner_vms")
+        select_hetzner_vm_targets(query).each do |vm|
+          bash_cmd = "ssh root@#{vm[:fqdn] || vm[:public_ip]} docker ps"
+          menu.choice(bash_cmd) { exec bash_cmd.squish }
+          open_cmds << "open https://console.hetzner.com/projects/#{vm[:project_id]}/servers/#{vm[:id]}"
+        end
+      end
+
       open_cmds.uniq.each do |cmd|
         menu.choice(cmd) { exec cmd.squish }
       end
@@ -104,7 +126,38 @@ class Renuo::Cli::Commands::Debug
 
   def select_deploio_targets(query)
     Cache.restore("deploio_apps").select do |app|
-      app[:name].include?(query) || app[:namespace].include?(query) || app[:hosts].any? { |host| host.include?(query) }
+      app[:name].include?(query) ||
+        app[:namespace].include?(query) ||
+        app[:hosts].any? { |host| host.include?(query) }
+    end
+  end
+
+  def nctl_command(app, subcommand, trailing_args)
+    plain = "nctl #{subcommand} app #{app[:name]} #{trailing_args} --project #{app[:namespace]}"
+    display = "nctl #{bold(subcommand)} app #{bold(app[:name])} #{trailing_args} --project #{bold(app[:namespace])}"
+    with_deploio_org(app, display, plain)
+  end
+
+  def with_deploio_org(app, display_command, exec_command)
+    organization = app[:organization].to_s
+    return [display_command, exec_command] if organization.empty?
+
+    display_cmd = "nctl auth set-org #{bold(Shellwords.escape(organization))} && #{display_command}"
+    exec_cmd = "nctl auth set-org #{Shellwords.escape(organization)} && #{exec_command}"
+    [display_cmd, exec_cmd]
+  end
+
+  def select_deploio_vm_targets(query)
+    Cache.restore("deploio_vms").select do |vm|
+      vm[:name].include?(query) || vm[:namespace].include?(query) ||
+        vm[:hostname].include?(query) || vm[:ip].include?(query) ||
+        vm[:reverse_dns].include?(query) || vm[:fqdn].include?(query)
+    end
+  end
+
+  def select_hetzner_vm_targets(query)
+    Cache.restore("hetzner_vms").select do |vm|
+      vm[:name].include?(query) || vm[:public_ip].include?(query) || vm[:fqdn]&.include?(query)
     end
   end
 

data/lib/renuo/cli/services/deploio.rb

@@ -1,19 +1,75 @@
 # frozen_string_literal: true
 
+require "shellwords"
+
 class Renuo::Cli::Services::Deploio
   class << self
     def fetch_apps
-      fetch_apps_cmd = %(nctl get apps -A -o yaml)
-      stdout, stderr, status = Open3.capture3 fetch_apps_cmd
-      raise "Error fetching Deploio app list: #{stderr}" unless status.success?
+      active_org, available_orgs = fetch_whoami_orgs
 
-      YAML.load_stream(stdout).map do |app|
+      available_orgs.flat_map do |organization|
+        set_organization(organization)
+        parse_apps(fetch_apps_yaml, organization)
+      end
+    ensure
+      set_organization(active_org)
+    end
+
+    def fetch_whoami_orgs
+      stdout, = run_nctl_command('nctl auth whoami -o "yaml"')
+      whoami = YAML.safe_load(stdout)
+
+      [whoami["organization"], whoami["orgs"]]
+    end
+
+    def parse_apps(yaml, organization)
+      YAML.load_stream(yaml).filter_map do |app|
         name = app.dig("metadata", "name")
         namespace = app.dig("metadata", "namespace")
         spec_hosts = app.dig("spec", "forProvider", "hosts") || []
 
-        { name: name, namespace: namespace, hosts: spec_hosts }
+        { name: name, namespace: namespace, hosts: spec_hosts, organization: organization }
+      end
+    end
+
+    def fetch_vms
+      fetch_vms_cmd = %(nctl get cloudvm -A -o yaml)
+      stdout, stderr, status = Open3.capture3 fetch_vms_cmd
+      raise "Error fetching Deploio app list: #{stderr}" unless status.success?
+
+      YAML.load_stream(stdout).map do |app|
+        {
+          name: app.dig("metadata", "name"),
+          namespace: app.dig("metadata", "namespace"),
+          hostname: app.dig("spec", "forProvider", "hostname"),
+          ip: app.dig("status", "atProvider", "ipAddress"),
+          reverse_dns: app.dig("status", "atProvider", "reverseDNS"),
+          fqdn: app.dig("status", "atProvider", "fqdn")
+        }
       end
     end
+
+    private
+
+    def set_organization(organization) # rubocop:disable Naming/AccessorMethodName
+      return if organization.strip.empty?
+
+      _, stderr, status = run_nctl_command("nctl auth set-org #{Shellwords.escape(organization)}")
+      return if status.success?
+
+      raise "Error switching Deploio organization to #{organization}: #{stderr}"
+    end
+
+    def run_nctl_command(cmd)
+      stdout, stderr, status = Open3.capture3(cmd)
+      raise "Error fetching Deploio app list: #{stderr}" unless status.success?
+
+      [stdout, stderr, status]
+    end
+
+    def fetch_apps_yaml
+      stdout, = run_nctl_command("nctl get apps -A -o yaml")
+      stdout
+    end
   end
 end

data/lib/renuo/cli/services/hetzner.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Renuo::Cli::Services::Hetzner
+  class << self
+    LIST_TOKENS_CMD = "op item list --tags renuo-cli-debug-hetzner-token --format=json"
+    EXTRACT_CREDENTIALS_CMD = "op item get --reveal --field credential,project_id"
+    def fetch_vms
+      tokens = read_tokens
+      tokens.flat_map do |token_and_project|
+        token, project_id = token_and_project.split(",")
+        client = Client.new(token)
+        client.list_servers.map { |s| s.merge(project_id: project_id.to_i) }
+      end
+    end
+
+    private
+
+    def read_tokens
+      stdout, stderr, status = Open3.capture3("#{LIST_TOKENS_CMD} | #{EXTRACT_CREDENTIALS_CMD}")
+      raise "Failed to fetch Hetzner tokens: #{stderr}" unless status.success?
+
+      stdout.split("\n").map(&:strip).reject(&:empty?)
+    end
+  end
+
+  class Client
+    def initialize(token)
+      @token = token
+    end
+
+    BASE_URL = "https://api.hetzner.cloud/v1/"
+
+    def list_servers
+      response = get("servers")
+      raise "Error fetching Hetzner servers: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      data["servers"].map do |server|
+        {
+          id: server["id"],
+          name: server["name"],
+          status: server["status"],
+          public_ip: server.dig("public_net", "ipv4", "ip"),
+          private_ip: server.dig("private_net", 0, "ip"),
+          fqdn: server.dig("public_net", "ipv4", "dns_ptr")
+        }
+      end
+    end
+
+    def get(resource)
+      uri = URI("#{BASE_URL}#{resource}")
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{@token}"
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        http.request(req)
+      end
+    end
+  end
+end

data/lib/renuo/cli/templates/semaphore/semaphore-deploy.yml.erb

@@ -18,5 +18,6 @@ blocks:
         - name: deploying
           commands:
             - gem i -q renuo-cli
+            - renuo ci setup
             - renuo ci update-deploio-app <%= environment %> -p renuo-<%= project_name %>
             - renuo ci check-deploio-status <%= environment %> -p renuo-<%= project_name %>

data/lib/renuo/cli/version.rb

@@ -3,7 +3,7 @@
 # :nocov:
 module Renuo
   class Cli
-    VERSION = "4.20.0"
+    VERSION = "4.21.1"
     NAME = "renuo-cli"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: renuo-cli
 version: !ruby/object:Gem::Version
-  version: 4.20.0
+  version: 4.21.1
 platform: ruby
 authors:
 - Renuo AG
@@ -66,6 +66,7 @@ files:
 - lib/renuo/cli.rb
 - lib/renuo/cli/commands/check_deploio_status.rb
 - lib/renuo/cli/commands/ci/check_deploio_status.rb
+- lib/renuo/cli/commands/ci/setup.rb
 - lib/renuo/cli/commands/ci/update_deploio_app.rb
 - lib/renuo/cli/commands/commit_leaderboard_stage.rb
 - lib/renuo/cli/commands/commit_leaderboard_sync.rb
@@ -96,6 +97,7 @@ files:
 - lib/renuo/cli/services/cloudfront_config_service.rb
 - lib/renuo/cli/services/deploio.rb
 - lib/renuo/cli/services/heroku.rb
+- lib/renuo/cli/services/hetzner.rb
 - lib/renuo/cli/services/renuo_cli_config.rb
 - lib/renuo/cli/templates/semaphore/bin/cache_restore.erb
 - lib/renuo/cli/templates/semaphore/bin/cache_store.erb