uffizzi-cli 2.3.3 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27943054f960693c2d1b8539a823f15f28e0f12d5e4763440cba3ee2f03f3412
-  data.tar.gz: 352f258d3a5a3d40b21e4d2c10d01028c4e16ec12a8902a3995cb3a64b687d1f
+  metadata.gz: 1267ece15e161c558b60dd16dc1d6562417f1555eefb3fcf2f65cb2f32223295
+  data.tar.gz: 4d5a80140a3436822c56a5cb1f3930ccb18082d93359c5cda3cf2343348cc282
 SHA512:
-  metadata.gz: 025a64d8bc2e14ad93b21592d0b1ad5460e960019ef119fbf5afc78622317c0fb600f16fe4132f3bab6fb9c652176e4bae6a54ab49617db55e94f5c860238a1f
-  data.tar.gz: '09b7dfaab197c2aefe59cb187b570ce818d1fe2952f6545b3fccc432f05a4bdc75151f4f589d3d3abc65d8325f56dc3156a335ae41231e5d02815770b976e48d'
+  metadata.gz: f2092483072296f1fd039d8acf049b53f4ef2b799c09063eb7ce0251f747837865c09f5d222f5e011c65826991fc4eb35cc7cd85d08dfaa8b3418c7270a6bb06
+  data.tar.gz: 20a062cf54e7f5b9a04d618e0066cacbf837254bb5f5c6abc7e26a0ed959a814012cceb8af3bfbefb675ad2d431fee6fa0c250229e57a4480a838929b9ff2fa1

data/README.md

@@ -1,178 +1,10 @@
 # Uffizzi CLI
 
-A command-line interace (CLI) for [Uffizzi App](https://github.com/UffizziCloud/uffizzi_app)
-
-## Uffizzi Overview
-
-Uffizzi is an open-source engine for creating lightweight, ephemeral test environments for APIs and full-stack applications. Uffizzi enables teams to preview new features before merging and to mitigate the risk of introducing regressions into a codebase. Each preview gets a shareable URL that's updated when you push new commits or image tags, so teams can provide continual feedback during the development/QA process. Previews can be configured to expire or be destroyed when a pull request is closed, so environments exist only as long as they are needed. Uffizzi also helps deconflict shared development environments since previews are deployed as isolated namespaces—there is no risk of clobbering another developer's preview.
-
-While Uffizzi depends on Kubernetes, it does not require end-users to interface with Kubernetes directly. Instead, Uffizzi leverages Docker Compose as its configuration file format, so developers do not need modify Kubernetes manifests or even know about Kubernetes.
-
-Uffizzi is designed to integrate with any CI/CD system.
-
-## Uffizzi Architecture
-<img src="https://github.com/UffizziCloud/uffizzi_app/blob/main/docs/images/uffizzi-architecture.png" description="Uffizzi Architecture" width="320"/>
-
-Uffizzi consists of the following components:
-
-- [Uffizzi App](https://github.com/UffizziCloud/uffizzi_app) - The primary REST API for creating and managing Previews
-- [Uffizzi Controller](https://github.com/UffizziCloud/uffizzi_controller) - A smart proxy service that handles requests from Uffizzi App to the Kubernetes API
-- Uffizzi CLI (this repository) - A command-line interface for Uffizzi App
-
-To host Uffizzi yourself, you will also need the following external dependencies:
-
-- Kubernetes (k8s) cluster
-- Postgres database
-- Redis cache
+A command-line interace (CLI) for the [Uffizzi API](https://github.com/UffizziCloud/uffizzi)
 
 ## Installation
 
-The Uffizzi CLI can be used interactively or as part of an automated workflow (e.g. GitHub Actions). Both options use the `uffizzi/cli` container image available on Docker Hub.
-
-### Interactive mode
-
-Run the CLI as a Docker container in interactive mode:
-```
-docker run --interactive --rm --tty --entrypoint=sh uffizzi/cli
-```
-
-If you specify the following environment variables, the Docker image's
-entrypoint script can log you into Uffizzi before executing your command.
-
-- `UFFIZZI_USER`
-- `UFFIZZI_SERVER`
-- `UFFIZZI_PASSWORD`
-- `UFFIZZI_PROJECT` (optional)
-
-### Automated mode
-
-If you want to use Uffizzi as part of an automated workflow, you can pass the Uffizzi commands to the Docker run command. For example:
-
-```
-docker run -it --rm uffizzi/cli project list
-```
-
-## Sample commands and examples
-
-### help
-
-The `help` subcommand can be used to see more information about a particular command.
-
-Examples:
-
-```
-uffizzi help
-```
-
-```
-uffizzi preview help
-```
-
-```
-uffizzi project compose help
-```
-
-### login
-
-```
-uffizzi login --server=localhost:8080 --username=your@email.com
-```
-
-Log in to the app with the specified server.
-
-#### login options
-
-| Option       | Aliase | Description               |
-| ------------ | ------ | ------------------------- |
-| `--username`     | `-u`   | Your email for logging in |
-| `--server` |        | The URL of the Uffizzi installation  |
-
-If server uses basic authentication you can specify options for it by setting `basic_auth_user` and `basic_auth_password` via `config set` command.
-
-### config
-
-Use this command to configure your cli app.
-
-```
-$ uffizzi config
-```
-
-Launching interactive setup guide that sets the values for `server`, `username` and `project`
-
-### config subcommands
-
-This command has 4 subcommands `list`, `get`, `set`, and `delete`.
-
-```
-uffizzi config list
-```
-
-Shows all options and their values from the config file.
-
-```
-uffizzi config get-value OPTION
-```
-
-Shows the value of the specified option.
-
-```
-uffizzi config set OPTION VALUE
-```
-
-Sets specified value for specified option. If a specified option already exists and has value it will be overwritten.
-
-```
-uffizzi config unset OPTION
-```
-
-Unsets specified option.
-
-### project
-
-```
-uffizzi project
-```
-
-Use this command to configure your projects. This command has 2 subcommands `list` and `compose`.
-
-```
-uffizzi project list
-```
-
-Shows all your projects' slugs
-
-If you have only one project it will be added to your config file automatically, if there's more than one project you need to set up your project manually with the commands `uffizzi config set YOUR_PROJECT_SLUG` or `uffizzi project set-default YOUR_PROJECT_SLUG`
-
-```
-$ uffizzi project set-default PROJECT_SLUG
-```
-Create a preview from a compose file.
-
-Sets the default project given with the given project slug. When set, all commands use this project as the default context unless overridden by the --project flag.
-
-### preview
-
-Create and manage previews
-
-```
-uffizzi preview create docker-compose.uffizzi.yml
-```
-Create a preview from a compose file.
-
-```
-uffizzi preview delete deployment-21
-```
-Delete a preview with preview ID `deployment-21`.
-
-### disconnect
-
-```
-uffizzi disconnect CREDENTIAL_TYPE
-```
-
-Deletes credential of specified type
-
-Supported credential types - `docker-hub`, `acr`, `ecr`, `gcr`
+See the [Uffizzi Documentation](https://docs.uffizzi.com) for installation instructions.
 
 ## Contributing
 

data/lib/uffizzi/cli/cluster.rb

@@ -96,9 +96,9 @@ module Uffizzi
       when 'disconnect'
         ClusterDisconnectService.handle(options)
       when 'sleep'
-        handle_sleep_command(project_slug, command_args)
+        handle_sleep_command(command_args)
       when 'wake'
-        handle_wake_command(project_slug, command_args)
+        handle_wake_command(command_args)
       end
     end
 
@@ -141,7 +141,7 @@ module Uffizzi
 
       spinner = TTY::Spinner.new("[:spinner] Creating cluster #{cluster_name}...", format: :dots)
       spinner.auto_spin
-      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, oidc_token)
+      cluster_data = ClusterService.wait_cluster_deploy(cluster_name, cluster_api_connection_params)
 
       if ClusterService.failed?(cluster_data[:state])
         spinner.error
@@ -220,41 +220,27 @@ module Uffizzi
       return if options[:quiet]
 
       Uffizzi.ui.say("Kubeconfig was updated by the path: #{kubeconfig_path}")
+
+      synced_cluster_data = ClusterService.sync_cluster_data(command_args[:cluster_name], server: server, project_slug: project_slug)
+      cluster_state = synced_cluster_data[:state]
+      return if ClusterService.deployed?(cluster_state)
+
+      Uffizzi.ui.say(ClusterService.cluster_status_text_map[cluster_state])
+      handle_scale_up_cluster(cluster_name, cluster_api_connection_params) if ClusterService.scaled_down?(cluster_state)
     end
 
-    def handle_sleep_command(project_slug, command_args)
+    def handle_sleep_command(command_args)
       cluster_name = command_args[:cluster_name] || ConfigFile.read_option(:current_cluster)&.fetch(:name)
       return handle_missing_cluster_name_error if cluster_name.nil?
 
-      response = scale_down_cluster(ConfigFile.read_option(:server), project_slug, cluster_name)
-      return ResponseHelper.handle_failed_response(response) unless ResponseHelper.ok?(response)
-
-      spinner = TTY::Spinner.new("[:spinner] Scaling down cluster #{cluster_name}...", format: :dots)
-      spinner.auto_spin
-      ClusterService.wait_cluster_scale_down(project_slug, cluster_name)
-
-      spinner.success
-      Uffizzi.ui.say("Cluster #{cluster_name} was successfully scaled down")
+      handle_scale_down_cluster(cluster_name, cluster_api_connection_params)
     end
 
-    def handle_wake_command(project_slug, command_args)
+    def handle_wake_command(command_args)
       cluster_name = command_args[:cluster_name] || ConfigFile.read_option(:current_cluster)&.fetch(:name)
       return handle_missing_cluster_name_error if cluster_name.nil?
 
-      response = scale_up_cluster(ConfigFile.read_option(:server), project_slug, cluster_name)
-      return ResponseHelper.handle_failed_response(response) unless ResponseHelper.ok?(response)
-
-      spinner = TTY::Spinner.new("[:spinner] Waking up cluster #{cluster_name}...", format: :dots)
-      spinner.auto_spin
-      cluster_data = ClusterService.wait_cluster_scale_up(project_slug, cluster_name)
-
-      if ClusterService.failed_scaling_up?(cluster_data[:state])
-        spinner.error
-        Uffizzi.ui.say_error_and_exit("Failed to wake up cluster #{cluster_name}.")
-      end
-
-      spinner.success
-      Uffizzi.ui.say("Cluster #{cluster_name} was successfully scaled up")
+      handle_scale_up_cluster(cluster_name, cluster_api_connection_params)
     end
 
     def say_error_update_kubeconfig(cluster_data)
@@ -355,6 +341,35 @@ module Uffizzi
       Psych.safe_load(Base64.decode64(kubeconfig))
     end
 
+    def handle_scale_up_cluster(cluster_name, cluster_api_connection_params)
+      response = scale_up_cluster(cluster_api_connection_params[:server], project_slug, cluster_name)
+      return ResponseHelper.handle_failed_response(response) unless ResponseHelper.ok?(response)
+
+      spinner = TTY::Spinner.new("[:spinner] Waking up cluster #{cluster_name}...", format: :dots)
+      spinner.auto_spin
+      cluster_data = ClusterService.wait_cluster_scale_up(cluster_name, cluster_api_connection_params)
+
+      if ClusterService.failed_scaling_up?(cluster_data[:state])
+        spinner.error
+        Uffizzi.ui.say_error_and_exit("Failed to scale up cluster #{cluster_name}.")
+      end
+
+      spinner.success
+      Uffizzi.ui.say("Cluster #{cluster_name} was successfully scaled up")
+    end
+
+    def handle_scale_down_cluster(cluster_name, cluster_api_connection_params)
+      response = scale_down_cluster(cluster_api_connection_params[:server], project_slug, cluster_name)
+      return ResponseHelper.handle_failed_response(response) unless ResponseHelper.ok?(response)
+
+      spinner = TTY::Spinner.new("[:spinner] Scaling down cluster #{cluster_name}...", format: :dots)
+      spinner.auto_spin
+      ClusterService.wait_cluster_scale_down(cluster_name, cluster_api_connection_params)
+
+      spinner.success
+      Uffizzi.ui.say("Cluster #{cluster_name} was successfully scaled down")
+    end
+
     def handle_missing_cluster_name_error
       Uffizzi.ui.say("No kubeconfig found at #{KubeconfigService.default_path}")
       Uffizzi.ui.say('Please update the current context or provide a cluster name.')

data/lib/uffizzi/cli/dev.rb

@@ -116,7 +116,7 @@ module Uffizzi
 
     def wait_cluster_creation(cluster_name)
       Uffizzi.ui.say('Checking the cluster status...')
-      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, oidc_token)
+      cluster_data = ClusterService.wait_cluster_deploy(cluster_name, cluster_api_connection_params)
 
       if ClusterService.failed?(cluster_data[:state])
         Uffizzi.ui.say_error_and_exit("Cluster with name: #{cluster_name} failed to be created.")

data/lib/uffizzi/cli/install.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'uffizzi'
+require 'uffizzi/config_file'
+require 'uffizzi/services/kubeconfig_service'
+
+module Uffizzi
+  class Cli::Install < Thor
+    include ApiClient
+
+    default_task :controller
+
+    desc 'controller [HOSTNMAE]', 'Install uffizzi controller to cluster'
+    method_option :namespace, type: :string
+    method_option :email, type: :string, required: true
+    method_option :context, type: :string
+    method_option :issuer, type: :string, enum: ['letsencrypt', 'zerossl']
+    method_option :'repo-url', type: :string
+    def controller(hostname)
+      Uffizzi::AuthHelper.check_login
+
+      InstallService.kubectl_exists?
+      InstallService.helm_exists?
+
+      if options[:context].present? && options[:context] != InstallService.kubeconfig_current_context
+        InstallService.set_current_context(options[:context])
+      end
+
+      ask_confirmation
+
+      uri = parse_hostname(hostname)
+      installation_options = build_installation_options(uri)
+      check_existence_controller_settings(uri, installation_options)
+      helm_values = build_helm_values(installation_options)
+
+      InstallService.create_helm_values_file(helm_values)
+      helm_set_repo
+      InstallService.helm_install!(namespace)
+      InstallService.delete_helm_values_file
+      Uffizzi.ui.say('Helm release is deployed')
+
+      controller_setting_params = build_controller_setting_params(uri, installation_options)
+      create_controller_settings(controller_setting_params) if existing_controller_setting.blank?
+      Uffizzi.ui.say('Controller settings are saved')
+      say_success(uri)
+    end
+
+    private
+
+    def helm_set_repo
+      return if InstallService.helm_repo_search.present?
+
+      InstallService.helm_repo_add(options[:'repo-url'])
+    end
+
+    def build_installation_options(uri)
+      {
+        uri: uri,
+        controller_username: Faker::Lorem.characters(number: 10),
+        controller_password: generate_password,
+        cert_email: options[:email],
+        cluster_issuer: options[:issuer] || InstallService::DEFAULT_CLUSTER_ISSUER,
+      }
+    end
+
+    def wait_ip
+      spinner = TTY::Spinner.new('[:spinner] Waiting IP addess...', format: :dots)
+      spinner.auto_spin
+
+      ip = nil
+      try = 0
+
+      loop do
+        ip = InstallService.get_controller_ip(namespace)
+        break if ip.present?
+
+        if try == 30
+          spinner.error
+
+          return 'unknown'
+        end
+
+        try += 1
+        sleep(2)
+      end
+
+      spinner.success
+
+      ip
+    end
+
+    def wait_certificate_request_ready(uri)
+      spinner = TTY::Spinner.new('[:spinner] Waiting create certificate for controller host...', format: :dots)
+      spinner.auto_spin
+
+      try = 0
+
+      loop do
+        requests = InstallService.get_certificate_request(namespace, uri)
+        break if requests.all? { |r| r['status'].downcase == 'true' }
+
+        if try == 60
+          spinner.error
+
+          return Uffizzi.ui.say('Stop waiting creation certificate')
+        end
+
+        try += 1
+        sleep(2)
+      end
+
+      spinner.success
+    end
+
+    def build_helm_values(params)
+      {
+        global: {
+          uffizzi: {
+            controller: {
+              username: params[:controller_username],
+              password: params[:controller_password],
+            },
+          },
+        },
+        clusterIssuer: params.fetch(:cluster_issuer),
+        tlsPerDeploymentEnabled: true.to_s,
+        certEmail: params.fetch(:cert_email),
+        'ingress-nginx' => {
+          controller: {
+            ingressClassResource: {
+              default: true,
+            },
+          },
+        },
+        ingress: {
+          hostname: InstallService.build_controller_host(params[:uri].host),
+        },
+      }.deep_stringify_keys
+    end
+
+    def generate_password
+      hexatridecimal_base = 36
+      length = 8
+      rand(hexatridecimal_base**length).to_s(hexatridecimal_base)
+    end
+
+    def check_existence_controller_settings(uri, installation_options)
+      return if existing_controller_setting.blank?
+
+      Uffizzi.ui.say_error_and_exit('Installation canceled') unless update_and_continue?
+
+      controller_setting_params = build_controller_setting_params(uri, installation_options)
+      update_controller_settings(existing_controller_setting[:id], controller_setting_params)
+    end
+
+    def ask_confirmation
+      msg = "\r\n"\
+            'This command will install Uffizzi into the default namespace of'\
+            " the '#{InstallService.kubeconfig_current_context}' context."\
+            "\r\n"\
+            "To install in a different place, use options '--namespace' and/or '--context'."\
+            "\r\n\r\n"\
+            "After installation, new environments created for account '#{account_name}' will be deployed to this host cluster."\
+            "\r\n\r\n"
+
+      Uffizzi.ui.say(msg)
+
+      question = 'Okay to proceed?'
+      Uffizzi.ui.say_error_and_exit('Installation canceled') unless Uffizzi.prompt.yes?(question)
+    end
+
+    def update_and_continue?
+      msg = "\r\n"\
+            'You already have installation controller params. '\
+            "\r\n"\
+            'You can update previous params and continue installation or cancel installation.'\
+            "\r\n"
+
+      Uffizzi.ui.say(msg)
+
+      question = 'Do you want update the controller settings?'
+      Uffizzi.prompt.yes?(question)
+    end
+
+    def fetch_controller_settings
+      response = get_account_controller_settings(server, account_id)
+      return Uffizzi::ResponseHelper.handle_failed_response(response) unless Uffizzi::ResponseHelper.ok?(response)
+
+      response.dig(:body, :controller_settings)
+    end
+
+    def update_controller_settings(controller_setting_id, params)
+      response = update_account_controller_settings(server, account_id, controller_setting_id, params)
+      Uffizzi::ResponseHelper.handle_failed_response(response) unless Uffizzi::ResponseHelper.ok?(response)
+    end
+
+    def create_controller_settings(params)
+      response = create_account_controller_settings(server, account_id, params)
+      Uffizzi::ResponseHelper.handle_failed_response(response) unless Uffizzi::ResponseHelper.created?(response)
+    end
+
+    def build_controller_setting_params(uri, installation_options)
+      {
+        url: URI::HTTPS.build(host: InstallService.build_controller_host(uri.host)).to_s,
+        managed_dns_zone: uri.host,
+        login: installation_options[:controller_username],
+        password: installation_options[:controller_password],
+      }
+    end
+
+    def say_success(uri)
+      ip_address = wait_ip
+      wait_certificate_request_ready(uri)
+
+      msg = 'Your Uffizzi controller is ready. To configure DNS,'\
+            " create a record for the hostname '*.#{uri.host}' pointing to '#{ip_address}'"
+      Uffizzi.ui.say(msg)
+    end
+
+    def parse_hostname(hostname)
+      uri = URI.parse(hostname)
+      host = uri.host || hostname
+
+      case uri
+      when URI::HTTP, URI::HTTPS
+        uri
+      else
+        URI::HTTPS.build(host: host)
+      end
+    end
+
+    def namespace
+      options[:namespace] || InstallService::DEFAULT_NAMESPACE
+    end
+
+    def server
+      @server ||= ConfigFile.read_option(:server)
+    end
+
+    def account_id
+      @account_id ||= ConfigFile.read_option(:account, :id)
+    end
+
+    def account_name
+      @account_name ||= ConfigFile.read_option(:account, :name)
+    end
+
+    def existing_controller_setting
+      @existing_controller_setting ||= fetch_controller_settings[0]
+    end
+  end
+end

data/lib/uffizzi/cli/status.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'uffizzi'
+require 'uffizzi/config_file'
+
+module Uffizzi
+  class Cli::Status < Thor
+    include ApiClient
+
+    default_task :describe
+
+    desc 'describe', 'Show account status'
+    def describe
+      Uffizzi::AuthHelper.check_login
+
+      account_name = ConfigFile.read_option(:account)[:name]
+      response = fetch_account(ConfigFile.read_option(:server), account_name)
+
+      if ResponseHelper.ok?(response)
+        handle_describe_success_response(response)
+      elsif ResponseHelper.not_found?(response)
+        Uffizzi.ui.say("Account with name #{account_name} does not exist")
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    private
+
+    def handle_describe_success_response(response)
+      account = response[:body][:account]
+      account_rendered_params = {
+        account: account[:name],
+        plan: "Uffizzi #{account[:product_name]}",
+        api: account[:api_url],
+        controller: account[:vclusters_controller_url],
+      }
+
+      Uffizzi.ui.output_format = Uffizzi::UI::Shell::PRETTY_LIST
+      Uffizzi.ui.say(account_rendered_params)
+    end
+  end
+end