uffizzi-cli 0.1.4.3 → 0.2.2

data/lib/uffizzi/cli/project/compose.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'uffizzi'
+require 'uffizzi/auth_helper'
+require 'uffizzi/response_helper'
+require 'uffizzi/services/compose_file_service'
+require 'uffizzi/services/env_variables_service'
+require 'thor'
+
+module Uffizzi
+  class CLI::Project::Compose < Thor
+    include ApiClient
+
+    desc 'set', 'set'
+    def set
+      run(options, 'set')
+    end
+
+    desc 'unset', 'unset'
+    def unset
+      run(options, 'unset')
+    end
+
+    desc 'describe', 'describe'
+    def describe
+      run(options, 'describe')
+    end
+
+    private
+
+    def run(options, command)
+      return Uffizzi.ui.say('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
+      return Uffizzi.ui.say('This command needs project to be set in config file') unless Uffizzi::AuthHelper.project_set?
+
+      file_path = options[:file]
+      case command
+      when 'set'
+        handle_set_command(file_path)
+      when 'unset'
+        handle_unset_command
+      when 'describe'
+        handle_describe_command
+      when 'validate'
+        handle_validate_command(file_path)
+      end
+    end
+
+    def handle_set_command(file_path)
+      return Uffizzi.ui.say('No file provided') if file_path.nil?
+
+      hostname = ConfigFile.read_option(:hostname)
+      project_slug = ConfigFile.read_option(:project)
+      params = prepare_params(file_path)
+      response = set_compose_file(hostname, params, project_slug)
+
+      if ResponseHelper.created?(response)
+        Uffizzi.ui.say('compose file created')
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_unset_command
+      hostname = ConfigFile.read_option(:hostname)
+      project_slug = ConfigFile.read_option(:project)
+      response = unset_compose_file(hostname, project_slug)
+
+      if ResponseHelper.no_content?(response)
+        Uffizzi.ui.say('compose file deleted')
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_describe_command
+      hostname = ConfigFile.read_option(:hostname)
+      project_slug = ConfigFile.read_option(:project)
+      response = describe_compose_file(hostname, project_slug)
+      compose_file = response[:body][:compose_file]
+
+      if ResponseHelper.ok?(response)
+        if compose_file_valid?(compose_file)
+          Uffizzi.ui.say(Base64.decode64(compose_file[:content]))
+        else
+          ResponseHelper.handle_invalid_compose_response(response)
+        end
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def compose_file_valid?(compose_file)
+      compose_file[:state] == 'valid_file'
+    end
+
+    def prepare_params(file_path)
+      begin
+        compose_file_data = EnvVariablesService.substitute_env_variables(File.read(file_path))
+      rescue Errno::ENOENT => e
+        return Uffizzi.ui.say(e)
+      end
+
+      compose_file_dir = File.dirname(file_path)
+      dependencies = ComposeFileService.parse(compose_file_data, compose_file_dir)
+      absolute_path = File.absolute_path(file_path)
+      compose_file_params = {
+        path: absolute_path,
+        content: Base64.encode64(compose_file_data),
+        source: absolute_path,
+      }
+
+      {
+        compose_file: compose_file_params,
+        dependencies: dependencies,
+      }
+    end
+  end
+end

data/lib/uffizzi/cli/project.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'uffizzi'
+require 'uffizzi/auth_helper'
+require 'uffizzi/response_helper'
+require 'thor'
+
+module Uffizzi
+  class CLI::Project < Thor
+    include ApiClient
+
+    desc 'compose', 'compose'
+    method_option :file, required: false, aliases: '-f'
+    require_relative 'project/compose'
+    subcommand 'compose', Uffizzi::CLI::Project::Compose
+
+    desc 'list', 'list'
+    def list
+      run('list')
+    end
+
+    private
+
+    def run(command)
+      return Uffizzi.ui.say('You are not logged in.') unless Uffizzi::AuthHelper.signed_in?
+
+      case command
+      when 'list'
+        handle_list_command
+      end
+    end
+
+    def handle_list_command
+      hostname = ConfigFile.read_option(:hostname)
+      response = fetch_projects(hostname)
+
+      if ResponseHelper.ok?(response)
+        handle_succeed_response(response)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def handle_succeed_response(response)
+      projects = response[:body][:projects]
+      return Uffizzi.ui.say('No projects related to this email') if projects.empty?
+
+      set_default_project(projects.first) if projects.size == 1
+      print_projects(projects)
+    end
+
+    def print_projects(projects)
+      projects_list = projects.reduce('') do |acc, project|
+        "#{acc}#{project[:slug]}\n"
+      end
+      Uffizzi.ui.say(projects_list)
+    end
+
+    def set_default_project(project)
+      ConfigFile.write_option(:project, project[:slug])
+    end
+  end
+end

data/lib/uffizzi/cli.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'uffizzi'
 
 module Uffizzi
   class CLI < Thor
     require_relative 'cli/common'
+    class_option :help, type: :boolean, aliases: ['-h', 'help']
 
-    class_option :help, type: :boolean, aliases: HELP_MAPPINGS
-
-    desc 'version', 'Show Version'
+    desc 'version', 'show version'
     def version
       require_relative 'version'
-      puts Uffizzi::VERSION
+      Uffizzi.ui.say(Uffizzi::VERSION)
     end
 
     desc 'login', 'Login into Uffizzi'
     method_option :user, required: true, aliases: '-u'
-    method_option :hostname, required: true, aliases: '-h'
+    method_option :hostname, required: true
     def login
       require_relative 'cli/login'
       Login.new(options).run
@@ -30,16 +30,17 @@ module Uffizzi
       Logout.new.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
 
     desc 'config', 'config'
-    def config(command, property = nil, value = nil)
-      require_relative 'cli/config'
-      Config.new.run(command, property, value)
-    end
+    require_relative 'cli/config'
+    subcommand 'config', CLI::Config
+
+    desc 'preview', 'preview'
+    method_option :project, required: false
+    require_relative 'cli/preview'
+    subcommand 'preview', CLI::Preview
   end
 end

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

@@ -7,27 +7,93 @@ module ApiClient
   include ApiRoutes
   def create_session(hostname, params = {})
     uri = session_uri(hostname)
-    response = Uffizzi::HttpClient.make_request(uri, :post, false, params)
+    response = Uffizzi::HttpClient.make_post_request(uri, params, false)
 
     build_response(response)
   end
 
   def destroy_session(hostname)
     uri = session_uri(hostname)
-    response = Uffizzi::HttpClient.make_request(uri, :delete, true)
+    response = Uffizzi::HttpClient.make_delete_request(uri)
 
     build_response(response)
   end
 
   def fetch_projects(hostname)
     uri = projects_uri(hostname)
-    response = Uffizzi::HttpClient.make_request(uri, :get, true)
+    response = Uffizzi::HttpClient.make_get_request(uri)
 
     build_response(response)
   end
 
-  def print_errors(errors)
-    puts errors.keys.reduce([]) { |acc, key| acc.push(errors[key]) }
+  def set_compose_file(hostname, params, project_slug)
+    uri = compose_file_uri(hostname, project_slug)
+    response = Uffizzi::HttpClient.make_post_request(uri, params)
+
+    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, true)
+
+    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)
+
+    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)
+
+    build_response(response)
+  end
+
+  def fetch_deployments(hostname, project_slug)
+    uri = deployments_uri(hostname, project_slug)
+    response = Uffizzi::HttpClient.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)
+
+    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, true)
+
+    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)
+
+    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)
+
+    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)
+
+    build_response(response)
   end
 
   private

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

@@ -8,4 +8,28 @@ module ApiRoutes
   def projects_uri(hostname)
     "#{hostname}/api/cli/v1/projects"
   end
+
+  def compose_file_uri(hostname, project_slug)
+    "#{hostname}/api/cli/v1/projects/#{project_slug}/compose_file"
+  end
+
+  def validate_compose_file_uri(hostname, project_slug)
+    "#{compose_files_uri(hostname, project_slug)}/validate"
+  end
+
+  def deployments_uri(hostname, project_slug)
+    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments"
+  end
+
+  def deployment_uri(hostname, project_slug, deployment_id)
+    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}"
+  end
+
+  def activity_items_uri(hostname, project_slug, deployment_id)
+    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/activity_items"
+  end
+
+  def deploy_containers_uri(hostname, project_slug, deployment_id)
+    "#{hostname}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/deploy_containers"
+  end
 end

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

@@ -3,11 +3,30 @@
 require 'net/http'
 require 'json'
 require 'uffizzi/config_file'
+require 'uffizzi/response_helper'
 
 module Uffizzi
   class HttpClient
     class << self
-      def make_request(request_uri, method, require_cookies, params = {})
+      def make_get_request(request_uri, cookies_required = true)
+        make_request(:get, request_uri, cookies_required)
+      end
+
+      def make_post_request(request_uri, params = {}, cookies_required = true)
+        make_request(:post, request_uri, cookies_required, params)
+      end
+
+      def make_put_request(request_uri, cookies_required = true)
+        make_request(:put, request_uri, cookies_required)
+      end
+
+      def make_delete_request(request_uri, cookies_required = true)
+        make_request(:delete, request_uri, cookies_required)
+      end
+
+      private
+
+      def make_request(method, request_uri, require_cookies, params = {})
         uri = URI(request_uri)
         use_ssl = request_uri.start_with?('https')
 
@@ -24,8 +43,6 @@ module Uffizzi
         response
       end
 
-      private
-
       def build_request(uri, params, method, require_cookies)
         headers = { 'Content-Type' => 'application/json' }
         request = case method
@@ -45,6 +62,7 @@ module Uffizzi
         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
+
         request
       end
     end

data/lib/uffizzi/config_file.rb

@@ -23,22 +23,21 @@ module Uffizzi
 
       def read_option(option)
         data = read
-        return nil if data.nil?
+        return nil unless data.is_a?(Hash)
 
-        puts "The option #{option} doesn't exist in config file" if data[option].nil?
         data[option]
       end
 
       def option_exists?(option)
         data = read
-        return false if data.nil?
+        return false unless data.is_a?(Hash)
 
         data.key?(option)
       end
 
       def write_option(key, value)
         data = exists? ? read : {}
-        return nil if data.nil?
+        return nil unless data.is_a?(Hash)
 
         data[key] = value
         write(data.to_json)
@@ -46,7 +45,7 @@ module Uffizzi
 
       def delete_option(key)
         data = read
-        return nil if data.nil?
+        return nil unless data.is_a?(Hash)
 
         new_data = data.except(key)
         write(new_data.to_json)
@@ -58,11 +57,16 @@ module Uffizzi
 
       def list
         data = read
-        return nil if data.nil?
+        return nil unless data.is_a?(Hash)
 
-        data.each do |property, value|
-          puts "#{property} - #{value}"
+        content = data.reduce('') do |acc, pair|
+          property, value = pair
+          "#{acc}#{property} - #{value}\n"
         end
+
+        Uffizzi.ui.say(content)
+
+        data
       end
 
       private
@@ -70,9 +74,11 @@ module Uffizzi
       def read
         JSON.parse(File.read(CONFIG_PATH), symbolize_names: true)
       rescue Errno::ENOENT => e
-        puts e
+        Uffizzi.ui.say(e)
+        nil
       rescue JSON::ParserError
-        puts 'Config file is in incorrect format'
+        Uffizzi.ui.say('Config file is in incorrect format')
+        nil
       end
 
       def write(data)
@@ -92,9 +98,7 @@ module Uffizzi
       def create_file
         dir = File.dirname(CONFIG_PATH)
 
-        unless File.directory?(dir)
-          FileUtils.mkdir_p(dir)
-        end
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
 
         File.new(CONFIG_PATH, 'w')
       end

data/lib/uffizzi/response_helper.rb

@@ -22,6 +22,30 @@ module Uffizzi
       def no_content?(response)
         response[:code] == Net::HTTPNoContent
       end
+
+      def ok?(response)
+        response[:code] == Net::HTTPOK
+      end
+
+      def handle_failed_response(response)
+        print_errors(response[:body][:errors])
+      end
+
+      def handle_invalid_compose_response(response)
+        print_errors(response[:body][:compose_file][:payload][: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) }
+          else
+            Uffizzi.ui.say(errors[key])
+          end
+        end
+      end
     end
   end
 end

data/lib/uffizzi/services/compose_file_service.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'psych'
+require 'pathname'
+require 'base64'
+
+class ComposeFileService
+  class << self
+    def parse(compose_content, compose_file_path)
+      compose_data = parse_compose_content_to_object(compose_content)
+
+      env_files = prepare_services_env_files(compose_data['services']).flatten.uniq
+      config_files = fetch_configs(compose_data['configs'])
+      prepare_dependencies(env_files, config_files, compose_file_path)
+    end
+
+    private
+
+    def prepare_dependencies(env_files, config_files, compose_file_path)
+      prepare_dependency_files_data(env_files + config_files, compose_file_path)
+    end
+
+    def prepare_dependency_files_data(dependency_files, compose_file_path)
+      dependency_files.map do |dependency_file|
+        dependency_file_data = Psych.load(File.read("#{compose_file_path}/#{dependency_file}"))
+        {
+          path: dependency_file,
+          source: dependency_file,
+          content: Base64.encode64(dependency_file_data),
+        }
+      end
+    end
+
+    def fetch_configs(configs_data)
+      return [] if configs_data.nil?
+
+      Uffizzi.ui.say("Unsupported type of #{:configs} option") unless configs_data.is_a?(Hash)
+
+      configs = []
+      configs_data.each_pair do |config_name, config_data|
+        Uffizzi.ui.say("#{config_name} has an empty file") if config_data['file'].empty? || config_data['file'].nil?
+
+        configs << prepare_file_path(config_data['file'])
+      end
+
+      configs
+    end
+
+    def prepare_file_path(file_path)
+      pathname = Pathname.new(file_path)
+
+      pathname.cleanpath.to_s.strip.delete_prefix('/')
+    end
+
+    def parse_env_file(env_file)
+      case env_file
+      when String
+        Uffizzi.ui.say('env_file contains an empty value') if env_file.nil? || env_file.empty?
+        [prepare_file_path(env_file)]
+      when Array
+        Uffizzi.ui.say('env_file contains an empty value') if env_file.any? { |file| file.nil? || file.empty? }
+        env_file.map { |env_file_path| prepare_file_path(env_file_path) }
+      else
+        Uffizzi.ui.say("Unsupported type of #{:env_file} option")
+      end
+    end
+
+    def prepare_services_env_files(services)
+      return [] if services.nil?
+
+      services.keys.map do |service|
+        service_env_files = prepare_service_env_files(services.fetch(service))
+
+        service_env_files
+      end
+    end
+
+    def prepare_service_env_files(service_data)
+      env_files_data = []
+      service_data.each_pair do |key, value|
+        key_sym = key.to_sym
+        if key_sym == :env_file
+          env_files_data << parse_env_file(value)
+        end
+      end
+
+      env_files_data
+    end
+
+    def parse_compose_content_to_object(compose_content)
+      begin
+        compose_data = Psych.safe_load(compose_content)
+      rescue Psych::SyntaxError
+        Uffizzi.ui.say('Invalid compose file')
+      end
+
+      Uffizzi.ui.say('Unsupported compose file') if compose_data.nil?
+
+      compose_data
+    end
+  end
+end

data/lib/uffizzi/services/env_variables_service.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'psych'
+require 'pathname'
+require 'base64'
+
+class EnvVariablesService
+  class << self
+    def substitute_env_variables(compose_file_data)
+      compose_file_data.gsub(/\$\{?([?:\-_A-Za-z0-9]+)\}?/) do |variable|
+        variable_content = variable.match(/[?:\-_A-Za-z0-9]+/).to_s
+        fetch_variable_value(variable_content)
+      end
+    end
+
+    private
+
+    def fetch_variable_value(variable_content)
+      variable_name = variable_content.match(/^[_A-Za-z0-9]+/).to_s
+      variable_value = ENV[variable_name]
+      return variable_value unless variable_value.nil?
+      return fetch_variable_default_value(variable_content) if variable_has_default_value?(variable_content)
+
+      error_message = if variable_has_error_message?(variable_content)
+        fetch_env_error_message(variable_content)
+      else
+        "Environment variable #{variable_name} doesn't exist"
+      end
+      raise StandardError.new(error_message)
+    end
+
+    def variable_has_default_value?(variable_content)
+      variable_content.include?('-')
+    end
+
+    def fetch_variable_default_value(variable_content)
+      variable_content.split('-', 2).last
+    end
+
+    def variable_has_error_message?(variable_content)
+      variable_content.include?('?')
+    end
+
+    def fetch_env_error_message(variable_content)
+      variable_content.split('?', 2).last
+    end
+  end
+end

data/lib/uffizzi/version.rb

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