mtncloud-cli 1.0.0

data/lib/mtncloud/cli/mixins/backups_helper.rb

@@ -0,0 +1,200 @@
+require 'mtncloud/cli/mixins/print_helper'
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for backups management
+module MtnCloud::Cli::BackupsHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def backups_interface
+    raise "#{self.class} has not defined @backups_interface" if @backups_interface.nil?
+    @backups_interface
+  end
+
+  def backup_jobs_interface
+    raise "#{self.class} has not defined @backup_jobs_interface" if @backup_jobs_interface.nil?
+    @backup_jobs_interface
+  end
+
+  def backup_object_key
+    'backup'
+  end
+
+  def backup_list_key
+    'backups'
+  end
+
+  def find_backup_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_backup_by_id(val)
+    else
+      return find_backup_by_name(val)
+    end
+  end
+
+  def find_backup_by_id(id)
+    begin
+      json_response = backups_interface.get(id.to_i)
+      return json_response[backup_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Backup not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_backup_by_name(name)
+    json_response = backups_interface.list({name: name.to_s})
+    backups = json_response[backup_list_key]
+    if backups.empty?
+      print_red_alert "Backup not found by name '#{name}'"
+      return nil
+    elsif backups.size > 1
+      print_red_alert "#{backups.size} backups found by name '#{name}'"
+      puts_error as_pretty_table(backups, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return backups[0]
+    end
+  end
+
+  def backup_job_object_key
+    # 'backupJob'
+    'job'
+  end
+
+  def backup_job_list_key
+    # 'backupJobs'
+    'jobs'
+  end
+
+  def find_backup_job_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_backup_job_by_id(val)
+    else
+      return find_backup_job_by_name(val)
+    end
+  end
+
+  def find_backup_job_by_id(id)
+    begin
+      json_response = backup_jobs_interface.get(id.to_i)
+      return json_response[backup_job_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Backup job not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_backup_job_by_name(name)
+    json_response = backup_jobs_interface.list({name: name.to_s})
+    backup_jobs = json_response[backup_job_list_key]
+    if backup_jobs.empty?
+      print_red_alert "Backup job not found by name '#{name}'"
+      return nil
+    elsif backup_jobs.size > 1
+      print_red_alert "#{backup_jobs.size} backup jobs found by name '#{name}'"
+      puts_error as_pretty_table(backup_jobs, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return backup_jobs[0]
+    end
+  end
+
+  ## Backup Results
+
+  def backup_result_list_column_definitions()
+    {
+      "ID" => 'id',
+      "Backup" => lambda {|it| it['backup']['name'] rescue '' },
+      "Type" => lambda {|it| format_backup_result_type_tag(it) },
+      "Location" => lambda {|it| format_backup_result_location_tag(it) },
+      "Status" => lambda {|it| format_backup_result_status(it) },
+      #"Duration" => lambda {|it| format_duration(it['startDate'], it['endDate']) },
+      "Duration" => lambda {|it| format_duration_milliseconds(it['durationMillis']) if it['durationMillis'].to_i > 0 },
+      "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
+      "End Date" => lambda {|it| format_local_dt(it['endDate']) },
+      "Size" => lambda {|it| it['sizeInMb'].to_i != 0 ? format_bytes(it['sizeInMb'], 'MB') : '' },
+    }
+  end
+
+  def backup_result_column_definitions()
+    backup_result_list_column_definitions()
+  end
+
+  def format_backup_result_status(backup_result, return_color=cyan)
+    out = ""
+    status_string = backup_result['status'].to_s.upcase
+    if status_string == 'SUCCEEDED' || status_string == 'SUCCESS'
+      out <<  "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'FAILED'
+      out <<  "#{red}#{status_string.upcase}#{return_color}"
+    elsif status_string
+      out <<  "#{cyan}#{status_string.upcase}#{return_color}"
+    else
+      out <<  ""
+    end
+    out
+  end
+
+  ## Backup Restores
+
+  def backup_restore_list_column_definitions()
+    {
+      "ID" => 'id',
+      "Backup" => lambda {|it| it['backup']['name'] rescue '' },
+      "Backup Result ID" => lambda {|it| it['backupResultId'] rescue '' },
+      "Target" => lambda {|it| it['instance']['name'] rescue '' },
+      "Status" => lambda {|it| format_backup_result_status(it) },
+      #"Duration" => lambda {|it| format_duration(it['startDate'], it['endDate']) },
+      "Duration" => lambda {|it| format_duration_milliseconds(it['durationMillis']) if it['durationMillis'].to_i > 0 },
+      "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
+      "End Date" => lambda {|it| format_local_dt(it['endDate']) },
+    }
+  end
+
+  def backup_restore_column_definitions()
+    backup_restore_list_column_definitions()
+  end
+
+  def format_backup_restore_status(backup_restore, return_color=cyan)
+    format_backup_result_status(backup_restore, return_color)
+  end
+
+  # format backup result type tag based on associated backup data
+  def format_backup_result_type_tag(backup_result)
+    backup = backup_result['backup'] || {}
+    if backup['cronExpression'] || (backup['schedule'] && backup['schedule']['id']) || (backup['job'] && backup['job']['id'])
+      "#{cyan}POLICY#{reset}"
+    else
+      "#{yellow}MANUAL#{reset}"
+    end
+  end
+
+  # format backup result location tag based on storage provider
+  def format_backup_result_location_tag(backup_result)
+    backup = backup_result['backup'] || {}
+    if backup_result['storageProvider'] && backup_result['storageProvider']['id']
+      "#{green}REMOTE#{reset}"
+    elsif backup['storageProvider'] && backup['storageProvider']['id']
+      "#{green}REMOTE#{reset}"
+    elsif backup_result['backupProvider'] && backup_result['backupProvider']['id']
+      "#{green}REMOTE#{reset}"
+    elsif backup['backupProvider'] && backup['backupProvider']['id']
+      "#{green}REMOTE#{reset}"
+    else
+      "#{blue}LOCAL#{reset}"
+    end
+  end
+  
+end

data/lib/mtncloud/cli/mixins/deployments_helper.rb

@@ -0,0 +1,163 @@
+require 'mtncloud/cli/mixins/print_helper'
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for infrastructure management
+module MtnCloud::Cli::DeploymentsHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  ## Deployments
+
+  def deployments_interface
+    raise "#{self.class} has not defined @deployments_interface" if @deployments_interface.nil?
+    @deployments_interface
+  end
+
+  def deployment_object_key
+    'deployment'
+  end
+
+  def deployment_list_key
+    'deployments'
+  end
+
+  def find_deployment_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_deployment_by_id(val)
+    else
+      return find_deployment_by_name(val)
+    end
+  end
+
+  def find_deployment_by_id(id)
+    begin
+      json_response = deployments_interface.get(id.to_i)
+      return json_response[deployment_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Deployment not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_deployment_by_name(name)
+    json_response = deployments_interface.list({name: name.to_s})
+    deployments = json_response[deployment_list_key]
+    if deployments.empty?
+      print_red_alert "Deployment not found by name '#{name}'"
+      return nil
+    elsif deployments.size > 1
+      print_red_alert "#{deployments.size} deployments found by name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(deployments, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return deployments[0]
+    end
+  end
+
+
+  ## Deployment Types
+
+  # unused?
+  def find_deployment_type_by_name(val)
+    raise "find_deployment_type_by_name passed a bad name: #{val.inspect}" if val.to_s == ''
+    results = @deployments_interface.deployment_types(val)
+    result = nil
+    if !results['deploymentTypes'].nil? && !results['deploymentTypes'].empty?
+      result = results['deploymentTypes'][0]
+    elsif val.to_i.to_s == val
+      results = @deployments_interface.deployment_types(val.to_i)
+      result = results['deploymentType']
+    end
+    if result.nil?
+      print_red_alert "Deployment Type not found by '#{val}'"
+      return nil
+    end
+    return result
+  end
+
+  ## Deployment Versions
+
+  def deployment_version_object_key
+    # 'deploymentVersion'
+    'version'
+  end
+
+  def deployment_version_list_key
+    # 'deploymentVersions'
+    'versions'
+  end
+
+  def find_deployment_version_by_name_or_id(deployment_id, val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_deployment_version_by_id(deployment_id, val)
+    else
+      return find_deployment_version_by_name(deployment_id, val)
+    end
+  end
+
+  def find_deployment_version_by_id(deployment_id, id)
+    begin
+      json_response = deployments_interface.get_version(deployment_id, id.to_i)
+      return json_response[deployment_version_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Deployment version not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_deployment_version_by_name(deployment_id, name)
+    json_response = deployments_interface.list_versions(deployment_id, {userVersion: name.to_s})
+    deployment_versions = json_response[deployment_version_list_key]
+    if deployment_versions.empty?
+      print_red_alert "Deployment version not found by version '#{name}'"
+      return nil
+    elsif deployment_versions.size > 1
+      print_red_alert "#{deployment_versions.size} deployment versions found by version '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(deployment_versions, {"ID" => 'id', "VERSION" => 'userVersion'}, {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return deployment_versions[0]
+    end
+  end
+
+  def format_deployment_version_number(deployment_version)
+    if deployment_version
+      deployment_version['userVersion'] || deployment_version['version'] || ''
+    else
+      ''
+    end
+  end
+
+  def format_app_deploy_status(status, return_color=cyan)
+    out = ""
+    s = status.to_s.downcase
+    if s == 'deployed' || s == 'committed'
+      out << "#{green}#{s.upcase}#{return_color}"
+    elsif s == 'open' || s == 'archived'
+      out << "#{cyan}#{s.upcase}#{return_color}"
+    elsif s == 'failed'
+      out << "#{red}#{s.upcase}#{return_color}"
+    else
+      out << "#{yellow}#{s.upcase}#{return_color}"
+    end
+    out
+  end
+
+  def format_deploy_type(val)
+    return val
+  end
+
+end

data/lib/mtncloud/cli/mixins/execution_request_helper.rb

@@ -0,0 +1,50 @@
+require 'mtncloud/cli/mixins/print_helper'
+# Mixin for MtnCloud::Cli command classes
+# Provides refreshing execution-request records by unique id (uuid)
+module MtnCloud::Cli::ExecutionRequestHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def api_client
+    raise "#{self.class} has not defined @api_client" if @api_client.nil?
+    @api_client
+  end
+
+  def execution_request_interface
+    # get_interface('execution_request')
+    api_client.execution_request
+  end
+
+  # refresh execution request until it is finished
+  # returns json response data of the last execution request when status reached 'completed' or 'failed'
+  def wait_for_execution_request(execution_request_id, options={}, print_output = true)
+    refresh_interval = 10
+    if options[:refresh_interval].to_i > 0
+      refresh_interval = options[:refresh_interval]
+    end
+    execution_request = execution_request_interface.get(execution_request_id)['executionRequest']
+    refresh_display_seconds = refresh_interval % 1.0 == 0 ? refresh_interval.to_i : refresh_interval
+    # unless options[:quiet]
+    #   print cyan, "Execution request has not yet finished. Refreshing every #{refresh_display_seconds} seconds...", "\n", reset
+    # end
+    while (options[:waiting_status] || ['new', 'pending']).include?(execution_request['status']) do
+      sleep(refresh_interval)
+      execution_request = execution_request_interface.get(execution_request_id)['executionRequest']
+    end
+    if print_output && options[:quiet] != true
+      if execution_request['stdErr'].to_s.strip != '' && execution_request['stdErr'] != "stdin: is not a tty\n"
+        print_h2 "Error"
+        print execution_request['stdErr'].to_s.strip, reset, "\n"
+      end
+      if execution_request['stdOut'].to_s.strip != ''
+        print_h2 "Output"
+        print execution_request['stdOut'].to_s.strip, reset, "\n"
+      end
+      print reset, "\n"
+    end
+    return execution_request
+  end
+
+end