uffizzi-cli 0.6.0 → 0.8.0

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

@@ -8,153 +8,197 @@ module ApiClient
 
   def create_session(server, params = {})
     uri = session_uri(server)
-    response = Uffizzi::HttpClient.make_post_request(uri, params, false)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
   def destroy_session(server)
     uri = session_uri(server)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
   def fetch_projects(server)
     uri = projects_uri(server)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  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 describe_project(server, project_slug)
+    uri = project_uri(server, project_slug)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def create_credential(server, params)
     uri = credentials_uri(server)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
   def fetch_deployment_services(server, project_slug, deployment_id)
     uri = preview_services_uri(server, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def delete_credential(server, credential_type)
     uri = delete_credential_uri(server, credential_type)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
   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 = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def set_compose_file(server, params, project_slug)
     uri = compose_file_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
   def unset_compose_file(server, project_slug)
     uri = compose_file_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
   def fetch_secrets(server, project_slug)
     uri = secrets_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def bulk_create_secrets(server, project_slug, params)
     uri = "#{secrets_uri(server, project_slug)}/bulk_create"
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+    response = http_client.make_post_request(uri, params)
 
     build_response(response)
   end
 
   def delete_secret(server, project_slug, id)
     uri = secret_uri(server, project_slug, id)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
   def describe_compose_file(server, project_slug)
     uri = compose_file_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def validate_compose_file(server, project_slug)
     uri = validate_compose_file_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def fetch_deployments(server, project_slug)
     uri = deployments_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
   def create_deployment(server, project_slug, params)
     uri = deployments_uri(server, project_slug)
-    response = Uffizzi::HttpClient.make_post_request(uri, params)
+    response = http_client.make_post_request(uri, params)
+
+    build_response(response)
+  end
+
+  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 delete_deployment(server, project_slug, deployment_id)
     uri = deployment_uri(server, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_delete_request(uri)
+    response = http_client.make_delete_request(uri)
 
     build_response(response)
   end
 
   def describe_deployment(server, project_slug, deployment_id)
     uri = deployment_uri(server, project_slug, deployment_id)
-    response = Uffizzi::HttpClient.make_get_request(uri)
+    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 = Uffizzi::HttpClient.make_get_request(uri)
+    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 = Uffizzi::HttpClient.make_get_request(uri)
+    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 = Uffizzi::HttpClient.make_post_request(uri, params)
+    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

@@ -7,6 +7,10 @@ module ApiRoutes
     "#{server}/api/cli/v1/projects/#{project_slug}/compose_file"
   end
 
+  def project_uri(server, project_slug)
+    "#{server}/api/cli/v1/projects/#{project_slug}"
+  end
+
   def projects_uri(server)
     "#{server}/api/cli/v1/projects"
   end
@@ -48,6 +52,10 @@ module ApiRoutes
     "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/events"
   end
 
+  def check_credential_uri(server, type)
+    "#{server}/api/cli/v1/account/credentials/#{type}/check_credential"
+  end
+
   def credentials_uri(server)
     "#{server}/api/cli/v1/account/credentials"
   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_has_value?(:basic_auth_user) && ConfigFile.option_has_value?(: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

data/lib/uffizzi/config_file.rb

@@ -8,17 +8,21 @@ module Uffizzi
     CONFIG_PATH = "#{Dir.home}/.config/uffizzi/config_default.json"
 
     class << self
+      def config_path
+        CONFIG_PATH
+      end
+
       def create(account_id, cookie, server)
         data = prepare_config_data(account_id, cookie, server)
         data.each_pair { |key, value| write_option(key, value) }
       end
 
       def delete
-        File.delete(CONFIG_PATH) if exists?
+        File.delete(config_path) if exists?
       end
 
       def exists?
-        File.exist?(CONFIG_PATH)
+        File.exist?(config_path)
       end
 
       def read_option(option)
@@ -79,7 +83,7 @@ module Uffizzi
       end
 
       def read
-        data = File.read(CONFIG_PATH)
+        data = File.read(config_path)
         options = data.split("\n")
         options.reduce({}) do |acc, option|
           key, value = option.split('=', 2)
@@ -112,11 +116,11 @@ module Uffizzi
       end
 
       def create_file
-        dir = File.dirname(CONFIG_PATH)
+        dir = File.dirname(config_path)
 
         FileUtils.mkdir_p(dir) unless File.directory?(dir)
 
-        File.new(CONFIG_PATH, 'w')
+        File.new(config_path, 'w')
       end
     end
   end

data/lib/uffizzi/date_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Uffizzi
+  module DateHelper
+    TWO_MINUTES = 120
+    TWO_HOURS = 120
+    TWO_DAYS = 48
+    TWO_WEEKS = 14
+    TWO_MONTHS = (365 / 12 * 2)
+    TWO_YEARS = 730
+
+    class << self
+      def count_distanse(now, previous_date)
+        seconds = (now - previous_date).round
+        return convert_to_words(seconds, 'seconds') if seconds < TWO_MINUTES
+
+        minutes = seconds / 60
+        return convert_to_words(minutes, 'minutes') if minutes < TWO_HOURS
+
+        hours = minutes / 60
+        return convert_to_words(hours, 'hours') if hours < TWO_DAYS
+
+        days = hours / 24
+        return convert_to_words(days, 'days') if days < TWO_WEEKS
+
+        weeks = days / 7
+        return convert_to_words(weeks, 'weeks') if days < TWO_MONTHS
+
+        months = (days / (365 / 12)).round
+        return convert_to_words(months, 'months') if days < TWO_YEARS
+
+        years = days / 365
+        convert_to_words(years, 'years')
+      end
+
+      private
+
+      def convert_to_words(value, unit)
+        "#{value} #{unit} ago"
+      end
+    end
+  end
+end

data/lib/uffizzi/response_helper.rb

@@ -28,22 +28,26 @@ module Uffizzi
       end
 
       def handle_failed_response(response)
-        print_errors(response[:body][:errors])
+        prepared_errors = prepare_errors(response[:body][:errors])
+        raise Uffizzi::Error.new(prepared_errors)
       end
 
       def handle_invalid_compose_response(response)
-        print_errors(response[:body][:compose_file][:payload][:errors])
+        prepared_errors = prepare_errors(response[:body][:compose_file][:payload][:errors])
+        raise Uffizzi::Error.new(prepared_errors)
       end
 
       private
 
-      def print_errors(errors)
-        errors.each_key do |key|
-          if errors[key].is_a?(Array)
-            errors[key].each { |error_message| Uffizzi.ui.say(error_message) }
+      def prepare_errors(errors)
+        errors.values.reduce('') do |acc, error_messages|
+          if error_messages.is_a?(Array)
+            error_messages.each { |error_message| acc = "#{acc}#{error_message}\n" }
           else
-            Uffizzi.ui.say(errors[key])
+            acc = "#{acc}#{error_messages}\n"
           end
+
+          acc
         end
       end
     end

data/lib/uffizzi/services/command_service.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class CommandService
+  class << self
+    def project_set?(options)
+      !options[:project].nil? || (Uffizzi::ConfigFile.exists? && Uffizzi::ConfigFile.option_has_value?(:project))
+    end
+  end
+end

data/lib/uffizzi/services/compose_file_service.rb

@@ -29,6 +29,9 @@ class ComposeFileService
           content: Base64.encode64(dependency_file_data),
         }
       end
+    rescue Errno::ENOENT => e
+      dependency_path = e.message.split('- ').last
+      raise Uffizzi::Error.new("The config file #{dependency_path} does not exist")
     end
 
     def fetch_configs(configs_data)

data/lib/uffizzi/services/preview_service.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'uffizzi/clients/api/api_client'
+
 class PreviewService
   class << self
+    include ApiClient
+
     def read_deployment_id(deployment_name)
       return nil unless deployment_name.start_with?('deployment-')
       return nil unless deployment_name.split('-').size == 2
@@ -11,5 +15,98 @@ class PreviewService
 
       deployment_id
     end
+
+    def run_containers_deploy(project_slug, deployment)
+      deployment_id = deployment[:id]
+      params = { id: deployment_id }
+
+      response = deploy_containers(Uffizzi::ConfigFile.read_option(:server), project_slug, deployment_id, params)
+
+      if !Uffizzi::ResponseHelper.no_content?(response)
+        Uffizzi::ResponseHelper.handle_failed_response(response)
+      end
+
+      activity_items = wait_containers_creation(deployment, project_slug)
+      wait_containers_deploy(deployment, project_slug, activity_items)
+    end
+
+    private
+
+    def wait_containers_creation(deployment, project_slug)
+      spinner = TTY::Spinner.new('[:spinner] Creating containers...', format: :dots)
+      spinner.auto_spin
+
+      activity_items = []
+      loop do
+        response = get_activity_items(Uffizzi::ConfigFile.read_option(:server), project_slug, deployment[:id])
+        handle_activity_items_response(response, spinner)
+        activity_items = response[:body][:activity_items]
+        break if activity_items.count == deployment[:containers].count
+
+        sleep(5)
+      end
+
+      spinner.success
+
+      Uffizzi.ui.say('Done')
+
+      activity_items
+    end
+
+    def wait_containers_deploy(deployment, project_slug, activity_items)
+      spinner = TTY::Spinner::Multi.new('[:spinner] Deploying preview...', format: :dots, style: {
+                                          middle: '  ',
+                                          bottom: '  ',
+                                        })
+
+      containers_spinners = create_containers_spinners(activity_items, spinner)
+
+      loop do
+        response = get_activity_items(Uffizzi::ConfigFile.read_option(:server), project_slug, deployment[:id])
+        handle_activity_items_response(response, spinner)
+        activity_items = response[:body][:activity_items]
+        update_containers_spinners!(activity_items, containers_spinners)
+        break if activity_items.all? { |activity_item| activity_item[:state] == 'deployed' || activity_item[:state] == 'failed' }
+
+        sleep(5)
+      end
+
+      spinner.success?
+    end
+
+    def create_containers_spinners(activity_items, spinner)
+      activity_items.map do |activity_item|
+        container_spinner = spinner.register("[:spinner] #{activity_item[:name]}")
+        container_spinner.auto_spin
+        {
+          name: activity_item[:name],
+          spinner: container_spinner,
+        }
+      end
+    end
+
+    def update_containers_spinners!(activity_items, containers_spinners)
+      finished_activity_items = activity_items.filter do |activity_item|
+        activity_item[:state] == 'deployed' || activity_item[:state] == 'failed'
+      end
+
+      finished_activity_items.each do |activity_item|
+        container_spinner = containers_spinners.detect { |spinner| spinner[:name] == activity_item[:name] }
+        spinner = container_spinner[:spinner]
+        case activity_item[:state]
+        when 'deployed'
+          spinner.success
+        when 'failed'
+          spinner.error
+        end
+      end
+    end
+
+    def handle_activity_items_response(response, spinner)
+      unless Uffizzi::ResponseHelper.ok?(response)
+        spinner.error
+        Uffizzi::ResponseHelper.handle_failed_response(response)
+      end
+    end
   end
 end

data/lib/uffizzi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uffizzi
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

data/man/uffizzi-connect

@@ -0,0 +1,37 @@
+.\" generated with Ronn-NG/v0.9.1
+.\" http://github.com/apjanke/ronn-ng/tree/0.9.1
+.TH "UFFIZZI\-CONNECT" "" "April 2022" ""
+.SH "NAME"
+\fBuffizzi\-connect\fR \- grant a Uffizzi user account access to external services
+.SH "SYNOPSIS"
+.nf
+uffizzi connect COMMAND
+.fi
+.SH "DESCRIPTION"
+.nf
+Grants a Uffizzi user account access to external services
+
+For more information on connecting to external services, see:
+https://docs\.uffizzi\.com/cli
+.fi
+.SH "COMMANDS"
+.nf
+COMMAND is one of the following:
+
+acr
+    Connect to Azure Container Registry (azurecr\.io)\.
+
+docker\-hub
+    Connect to Docker Hub (hub\.docker\.com)\.
+
+ecr
+    Connect to Amazon Elastic Container Registry (amazonaws\.com)\.
+
+gcr
+    Connect to Google Container Registry (gcr\.io)\.
+
+gchr
+    Connect to GitHub Container Registry (ghcr\.io)\.
+.fi
+.P
+Run \'uffizzi connect COMMAND \-\-help\' for more information on a command\.