uffizzi-cli 0.5.2 → 0.7.3

data/lib/uffizzi/cli/project.rb

@@ -5,37 +5,46 @@ require 'uffizzi/auth_helper'
 require 'uffizzi/response_helper'
 
 module Uffizzi
-  class CLI::Project < Thor
+  class Cli::Project < Thor
     include ApiClient
 
-    desc 'compose', 'compose'
+    desc 'compose', 'Manage the compose file for a project'
     method_option :file, required: false, aliases: '-f'
     require_relative 'project/compose'
-    subcommand 'compose', Uffizzi::CLI::Project::Compose
+    subcommand 'compose', Uffizzi::Cli::Project::Compose
 
-    desc 'secret', 'Secrets Actions'
+    desc 'secret', 'Manage secrets for a project'
     require_relative 'project/secret'
-    subcommand 'secret', Uffizzi::CLI::Project::Secret
+    subcommand 'secret', Uffizzi::Cli::Project::Secret
 
-    desc 'list', 'list'
+    desc 'list', 'List all projects in the account'
     def list
       run('list')
     end
 
+    desc 'set-default PROJECT_SLUG', 'set-default'
+    def set_default(project_slug)
+      run('set-default', project_slug: project_slug)
+    end
+
+    map('set-default' => :set_default)
+
     private
 
-    def run(command)
+    def run(command, project_slug: nil)
       return Uffizzi.ui.say('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
 
       case command
       when 'list'
         handle_list_command
+      when 'set-default'
+        handle_set_default_command(project_slug)
       end
     end
 
     def handle_list_command
-      hostname = ConfigFile.read_option(:hostname)
-      response = fetch_projects(hostname)
+      server = ConfigFile.read_option(:server)
+      response = fetch_projects(server)
 
       if ResponseHelper.ok?(response)
         handle_succeed_response(response)
@@ -52,6 +61,21 @@ module Uffizzi
       print_projects(projects)
     end
 
+    def handle_set_default_command(project_slug)
+      response = describe_project(ConfigFile.read_option(:server), project_slug)
+
+      if ResponseHelper.ok?(response)
+        handle_succeed_set_default_response(response)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_succeed_set_default_response(response)
+      set_default_project(response[:body][:project])
+      Uffizzi.ui.say('Default project has been updated.')
+    end
+
     def print_projects(projects)
       projects_list = projects.reduce('') do |acc, project|
         "#{acc}#{project[:slug]}\n"

data/lib/uffizzi/cli.rb

@@ -3,57 +3,51 @@
 require 'uffizzi'
 
 module Uffizzi
-  class CLI < Thor
+  class Cli < Thor
+    class_option :project, type: :string
+
     def self.exit_on_failure?
       true
     end
 
-    desc 'version', 'show version'
+    desc 'version', 'Print version information for uffizzi CLI'
     def version
       require_relative 'version'
       Uffizzi.ui.say(Uffizzi::VERSION)
     end
 
-    desc 'login [OPTIONS]', 'Login into Uffizzi'
-    method_option :user, required: true, aliases: '-u'
-    method_option :hostname, required: true
+    desc 'login [OPTIONS]', 'Login to Uffizzi to view and manage your previews'
+    method_option :server, required: false, aliases: '-s'
+    method_option :username, required: false, aliases: '-u'
     def login
       require_relative 'cli/login'
       Login.new(options).run
     end
 
-    desc 'logout', 'Logout from Uffizzi'
+    desc 'logout', 'Log out of a Uffizzi user account'
     def logout
       require_relative 'cli/logout'
       Logout.new(options).run
     end
 
-    desc 'projects', 'projects'
-    def projects
-      require_relative 'cli/projects'
-      Projects.new.run
-    end
-
     desc 'project', 'project'
     require_relative 'cli/project'
-    subcommand 'project', CLI::Project
+    subcommand 'project', Cli::Project
 
     desc 'config', 'config'
     require_relative 'cli/config'
-    subcommand 'config', CLI::Config
+    subcommand 'config', Cli::Config
 
     desc 'preview', 'preview'
     method_option :project, required: false
     require_relative 'cli/preview'
-    subcommand 'preview', CLI::Preview
+    subcommand 'preview', Cli::Preview
 
-    desc 'connect CREDENTIAL_TYPE', 'Connect credentials into Uffizzi'
-    def connect(credential_type, credential_file_path = nil)
-      require_relative 'cli/connect'
-      Connect.new.run(credential_type, credential_file_path)
-    end
+    desc 'connect', 'connect'
+    require_relative 'cli/connect'
+    subcommand 'connect', Cli::Connect
 
-    desc 'disconect CREDENTIAL_TYPE', 'Disonnect credentials from Uffizzi'
+    desc 'disconect CREDENTIAL_TYPE', 'Revoke a Uffizzi user account access to external services'
     def disconnect(credential_type)
       require_relative 'cli/disconnect'
       Disconnect.new.run(credential_type)
@@ -62,11 +56,14 @@ module Uffizzi
     class << self
       protected
 
+      require_relative 'cli/common'
       def dispatch(meth, given_args, given_opts, config)
         args, opts = Thor::Options.split(given_args)
-        return Cli::Common.show_manual(filename(args)) if show_help?(args, opts)
+        return Common.show_manual(filename(args)) if show_help?(args, opts)
 
         super
+      rescue SystemExit, Interrupt, SocketError
+        raise Uffizzi::Error.new('The command was interrupted')
       end
 
       private

data/lib/uffizzi/clients/api/api_client.rb

@@ -6,155 +6,199 @@ require_relative 'http_client'
 module ApiClient
   include ApiRoutes
 
-  def create_session(hostname, params = {})
-    uri = session_uri(hostname)
-    response = Uffizzi::HttpClient.make_post_request(uri, params, false)
+  def create_session(server, params = {})
+    uri = session_uri(server)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def destroy_session(hostname)
-    uri = session_uri(hostname)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+  def destroy_session(server)
+    uri = session_uri(server)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def fetch_projects(hostname)
-    uri = projects_uri(hostname)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def fetch_projects(server)
+    uri = projects_uri(server)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def create_credential(hostname, params)
-    uri = credentials_uri(hostname)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+  def fetch_credentials(server)
+    uri = credentials_uri(server)
+
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def check_credential(server, type)
+    uri = check_credential_uri(server, type)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def fetch_deployment_services(hostname, project_slug, deployment_id)
-    uri = preview_services_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def describe_project(server, project_slug)
+    uri = project_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def delete_credential(hostname, credential_type)
-    uri = delete_credential_uri(hostname, credential_type)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+  def create_credential(server, params)
+    uri = credentials_uri(server)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def fetch_deployment_service_logs(hostname, project_slug, deployment_id, container_name)
-    uri = preview_service_logs_uri(hostname, project_slug, deployment_id, container_name)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def fetch_deployment_services(server, project_slug, deployment_id)
+    uri = preview_services_uri(server, project_slug, deployment_id)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def set_compose_file(hostname, params, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+  def delete_credential(server, credential_type)
+    uri = delete_credential_uri(server, credential_type)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def unset_compose_file(hostname, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+  def fetch_deployment_service_logs(server, project_slug, deployment_id, container_name)
+    uri = preview_service_logs_uri(server, project_slug, deployment_id, container_name)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def fetch_secrets(hostname, project_slug)
-    uri = secrets_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def set_compose_file(server, params, project_slug)
+    uri = compose_file_uri(server, project_slug)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def bulk_create_secrets(hostname, project_slug, params)
-    uri = "#{secrets_uri(hostname, project_slug)}/bulk_create"
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+  def unset_compose_file(server, project_slug)
+    uri = compose_file_uri(server, project_slug)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def delete_secret(hostname, project_slug, id)
-    uri = secret_uri(hostname, project_slug, id)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+  def fetch_secrets(server, project_slug)
+    uri = secrets_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def describe_compose_file(hostname, project_slug)
-    uri = compose_file_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def bulk_create_secrets(server, project_slug, params)
+    uri = "#{secrets_uri(server, project_slug)}/bulk_create"
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def validate_compose_file(hostname, project_slug)
-    uri = validate_compose_file_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def delete_secret(server, project_slug, id)
+    uri = secret_uri(server, project_slug, id)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def fetch_deployments(hostname, project_slug)
-    uri = deployments_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def describe_compose_file(server, project_slug)
+    uri = compose_file_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def create_deployment(hostname, project_slug, params)
-    uri = deployments_uri(hostname, project_slug)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+  def validate_compose_file(server, project_slug)
+    uri = validate_compose_file_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def delete_deployment(hostname, project_slug, deployment_id)
-    uri = deployment_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+  def fetch_deployments(server, project_slug)
+    uri = deployments_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
-  def describe_deployment(hostname, project_slug, deployment_id)
-    uri = deployment_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def create_deployment(server, project_slug, params)
+    uri = deployments_uri(server, project_slug)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
-  def fetch_events(hostname, project_slug, deployment_id)
-    uri = events_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def update_deployment(server, project_slug, deployment_id, params)
+    uri = deployment_uri(server, project_slug, deployment_id)
+    response = http_client.make_put_request(uri, params)
 
     build_response(response)
   end
 
-  def get_activity_items(hostname, project_slug, deployment_id)
-    uri = activity_items_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+  def delete_deployment(server, project_slug, deployment_id)
+    uri = deployment_uri(server, project_slug, deployment_id)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
-  def deploy_containers(hostname, project_slug, deployment_id, params)
-    uri = deploy_containers_uri(hostname, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+  def describe_deployment(server, project_slug, deployment_id)
+    uri = deployment_uri(server, project_slug, deployment_id)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def fetch_events(server, project_slug, deployment_id)
+    uri = events_uri(server, project_slug, deployment_id)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def get_activity_items(server, project_slug, deployment_id)
+    uri = activity_items_uri(server, project_slug, deployment_id)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def deploy_containers(server, project_slug, deployment_id, params)
+    uri = deploy_containers_uri(server, project_slug, deployment_id)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
   private
 
+  def http_client
+    if @http_client.nil?
+      params = {}
+      if Uffizzi::ConfigFile.exists?
+        params[:cookie] = Uffizzi::ConfigFile.read_option(:cookie)
+        params[:basic_auth_user] = Uffizzi::ConfigFile.read_option(:basic_auth_user)
+        params[:basic_auth_password] = Uffizzi::ConfigFile.read_option(:basic_auth_password)
+      end
+
+      @http_client = Uffizzi::HttpClient.new(params[:cookie], params[:basic_auth_user], params[:basic_auth_password])
+    end
+
+    @http_client
+  end
+
   def build_response(response)
     {
       body: response_body(response),
@@ -164,7 +208,7 @@ module ApiClient
   end
 
   def response_body(response)
-    return nil if response.body.nil?
+    return nil if response.body.nil? || response.body.empty?
 
     JSON.parse(response.body, symbolize_names: true)
   rescue JSON::ParserError
@@ -178,6 +222,7 @@ module ApiClient
     cookie_content = cookies.first
     cookie = cookie_content.split(';').first
     Uffizzi::ConfigFile.rewrite_cookie(cookie) if Uffizzi::ConfigFile.exists?
+    http_client.auth_cookie = cookie
 
     cookie
   end

data/lib/uffizzi/clients/api/api_routes.rb

@@ -3,64 +3,72 @@
 require 'cgi'
 
 module ApiRoutes
-  def compose_file_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/compose_file"
+  def compose_file_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/compose_file"
   end
 
-  def projects_uri(hostname)
-    "#{hostname}/api/cli/v1/projects"
+  def project_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}"
   end
 
-  def secret_uri(hostname, project_slug, id)
+  def projects_uri(server)
+    "#{server}/api/cli/v1/projects"
+  end
+
+  def secret_uri(server, project_slug, id)
     path_id = CGI.escape(id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/secrets/#{path_id}"
+    "#{server}/api/cli/v1/projects/#{project_slug}/secrets/#{path_id}"
+  end
+
+  def secrets_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/secrets"
   end
 
-  def secrets_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/secrets"
+  def session_uri(server)
+    "#{server}/api/cli/v1/session"
   end
 
-  def session_uri(hostname)
-    "#{hostname}/api/cli/v1/session"
+  def validate_compose_file_uri(server, project_slug)
+    "#{compose_files_uri(server, project_slug)}/validate"
   end
 
-  def validate_compose_file_uri(hostname, project_slug)
-    "#{compose_files_uri(hostname, project_slug)}/validate"
+  def deployments_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments"
   end
 
-  def deployments_uri(hostname, project_slug)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments"
+  def deployment_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}"
   end
 
-  def deployment_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}"
+  def activity_items_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/activity_items"
   end
 
-  def activity_items_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/activity_items"
+  def deploy_containers_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/deploy_containers"
   end
 
-  def deploy_containers_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/deploy_containers"
+  def events_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/events"
   end
 
-  def events_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/events"
+  def check_credential_uri(server, type)
+    "#{server}/api/cli/v1/account/credentials/#{type}/check_credential"
   end
 
-  def credentials_uri(hostname)
-    "#{hostname}/api/cli/v1/account/credentials"
+  def credentials_uri(server)
+    "#{server}/api/cli/v1/account/credentials"
   end
 
-  def preview_services_uri(hostname, project_slug, deployment_id)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers"
+  def preview_services_uri(server, project_slug, deployment_id)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers"
   end
 
-  def delete_credential_uri(hostname, credential_type)
-    "#{hostname}/api/cli/v1/account/credentials/#{credential_type}"
+  def delete_credential_uri(server, credential_type)
+    "#{server}/api/cli/v1/account/credentials/#{credential_type}"
   end
 
-  def preview_service_logs_uri(hostname, project_slug, deployment_id, container_name)
-    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/logs"
+  def preview_service_logs_uri(server, project_slug, deployment_id, container_name)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/logs"
   end
 end

data/lib/uffizzi/clients/api/http_client.rb

@@ -2,67 +2,69 @@
 
 require 'net/http'
 require 'json'
-require 'uffizzi/config_file'
-require 'uffizzi/response_helper'
 
 module Uffizzi
   class HttpClient
-    class << self
-      def make_get_request(request_uri, cookies_required = true)
-        make_request(:get, request_uri, cookies_required)
-      end
+    attr_accessor :auth_cookie, :basic_auth_user, :basic_auth_password
 
-      def make_post_request(request_uri, params = {}, cookies_required = true)
-        make_request(:post, request_uri, cookies_required, params)
-      end
+    def initialize(auth_cookie, basic_auth_user, basic_auth_password)
+      @auth_cookie = auth_cookie
+      @basic_auth_user = basic_auth_user
+      @basic_auth_password = basic_auth_password
+    end
 
-      def make_put_request(request_uri, cookies_required = true)
-        make_request(:put, request_uri, cookies_required)
-      end
+    def make_get_request(request_uri)
+      make_request(:get, request_uri)
+    end
 
-      def make_delete_request(request_uri, cookies_required = true)
-        make_request(:delete, request_uri, cookies_required)
-      end
+    def make_post_request(request_uri, params = {})
+      make_request(:post, request_uri, params)
+    end
 
-      private
+    def make_put_request(request_uri, params = {})
+      make_request(:put, request_uri, params)
+    end
 
-      def make_request(method, request_uri, require_cookies, params = {})
-        uri = URI(request_uri)
-        use_ssl = request_uri.start_with?('https')
+    def make_delete_request(request_uri)
+      make_request(:delete, request_uri)
+    end
 
-        response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
-          request = build_request(uri, params, method, require_cookies)
+    private
 
-          http.request(request)
-        end
+    def make_request(method, request_uri, params = {})
+      uri = URI(request_uri)
+      use_ssl = request_uri.start_with?('https')
 
-        raise Uffizzi::Error.new('Not authorized') if response.is_a?(Net::HTTPUnauthorized)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
+        request = build_request(uri, params, method)
 
-        response
+        http.request(request)
       end
 
-      def build_request(uri, params, method, require_cookies)
-        headers = { 'Content-Type' => 'application/json' }
-        request = case method
-                  when :get
-                    Net::HTTP::Get.new(uri.path, headers)
-                  when :post
-                    Net::HTTP::Post.new(uri.path, headers)
-                  when :delete
-                    Net::HTTP::Delete.new(uri.path, headers)
-                  when :put
-                    Net::HTTP::Put.new(uri.path, headers)
-        end
-        if request.instance_of?(Net::HTTP::Post)
-          request.body = params.to_json
-        end
-        request['Cookie'] = ConfigFile.read_option(:cookie) if require_cookies
-        if ConfigFile.exists? && ConfigFile.option_exists?(:basic_auth_user) && ConfigFile.option_exists?(:basic_auth_password)
-          request.basic_auth(ConfigFile.read_option(:basic_auth_user), ConfigFile.read_option(:basic_auth_password))
-        end
+      raise Uffizzi::Error.new('Not authorized') if response.is_a?(Net::HTTPUnauthorized)
+
+      response
+    end
 
-        request
+    def build_request(uri, params, method)
+      headers = { 'Content-Type' => 'application/json' }
+      request = case method
+                when :get
+                  Net::HTTP::Get.new(uri.path, headers)
+                when :post
+                  Net::HTTP::Post.new(uri.path, headers)
+                when :delete
+                  Net::HTTP::Delete.new(uri.path, headers)
+                when :put
+                  Net::HTTP::Put.new(uri.path, headers)
+      end
+      if request.instance_of?(Net::HTTP::Post) || request.instance_of?(Net::HTTP::Put)
+        request.body = params.to_json
       end
+      request['Cookie'] = @auth_cookie
+      request.basic_auth(@basic_auth_user, @basic_auth_password)
+
+      request
     end
   end
 end