morpheus-cli 4.2.16 → 4.2.21

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

@@ -0,0 +1,115 @@
+require 'morpheus/cli/mixins/print_helper'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for infrastructure management
+module Morpheus::Cli::BackupsHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def backups_interface
+    # @api_client.groups
+    raise "#{self.class} has not defined @backups_interface" if @backups_interface.nil?
+    @backups_interface
+  end
+
+  def backup_jobs_interface
+    # @api_client.groups
+    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
+end

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

@@ -0,0 +1,135 @@
+require 'morpheus/cli/mixins/print_helper'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for infrastructure management
+module Morpheus::Cli::DeploymentsHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  ## Deployments
+
+  def deployments_interface
+    # @api_client.groups
+    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}'"
+      puts_error as_pretty_table(deployments, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print 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}'"
+      puts_error as_pretty_table(deployment_versions, {"ID" => 'id', "VERSION" => 'userVersion'}, {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return deployment_versions[0]
+    end
+  end
+
+end

data/lib/morpheus/cli/mixins/option_source_helper.rb

@@ -75,7 +75,7 @@ module Morpheus::Cli::OptionSourceHelper
 
   def get_cloud_options(refresh=false, api_params={})
     if !@available_cloud_options || refresh
-      option_results = options_interface.options_for_source('clouds', api_params)
+      option_results = options_interface.options_for_source('clouds', api_params.mege({'default' => 'false'}))
         @available_cloud_options = option_results['data'].collect {|it|
           {"name" => it["name"], "value" => it["value"], "id" => it["value"]}
         }

data/lib/morpheus/cli/mixins/print_helper.rb

@@ -186,72 +186,49 @@ module Morpheus::Cli::PrintHelper
     payload = api_request[:payload] || api_request[:body]
     #Morpheus::Logging::DarkPrinter.puts "API payload is: (#{payload.class}) #{payload.inspect}"
     content_type = (headers && headers['Content-Type']) ? headers['Content-Type'] : 'application/x-www-form-urlencoded'
-    
+    # build output, either CURL or REQUEST
+    output = ""
+    if api_request[:curl] || options[:curl]
+      output = format_curl_command(http_method, url, headers, payload, options)
+    else
+      output = format_api_request(http_method, url, headers, payload, options)
+    end
+    # this is an extra scrub, should remove
+    if options[:scrub]
+      output = Morpheus::Logging.scrub_message(output)
+    end
     # write to a file?
     if options[:outfile]
-      output = ""
-      if api_request[:curl] || options[:curl]
-        output = format_curl_command(http_method, url, headers, payload, options)
-      else
-        # body payload
-        output = payload
-        if content_type == 'application/json'
-          if payload.is_a?(String)
-            begin
-              payload = JSON.parse(payload)
-            rescue => e
-              #payload = "(unparsable) #{payload}"
-            end
-          end
-          output = JSON.pretty_generate(payload)
-        else
-          if payload.is_a?(File)
-            pretty_size = "#{payload.size} B"
-            output = "File: #{payload.path} (#{pretty_size})"
-          elsif payload.is_a?(String)
-            output = payload
-          else
-            if content_type == 'application/x-www-form-urlencoded'
-              body_str = payload.to_s
-              begin
-                body_str = URI.encode_www_form(payload)
-              rescue => ex
-                # raise ex
-              end
-              output = body_str
-            else
-              begin
-                output = JSON.pretty_generate(payload)
-              rescue
-                output = payload.to_s
-              end
-            end
-          end
-        end
-      end
-      if options[:scrub]
-        output = Morpheus::Logging.scrub_message(output)
-      end
       print_result = print_to_file(output, options[:outfile], options[:overwrite])
-      return print_result
+      # with_stdout_to_file(options[:outfile], options[:overwrite]) { print output }
+      print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes File.size(options[:outfile])})\n" unless options[:quiet]
+      #return print_result
+      return
     end
-
-    # curl output?
+    # print output
     if api_request[:curl] || options[:curl]
       print "\n"
-      puts "#{cyan}#{bold}#{dark}CURL COMMAND#{reset}"
-      print format_curl_command(http_method, url, headers, payload, options)
+      print "#{cyan}#{bold}#{dark}CURL COMMAND#{reset}\n"
+    else
       print "\n"
-      return
+      print "#{cyan}#{bold}#{dark}REQUEST#{reset}\n"
     end
+    print output
+    print reset, "\n"
+    print reset
+    return
+  end
 
-    print "\n"
-    puts "#{cyan}#{bold}#{dark}REQUEST#{reset}"
+  def format_api_request(http_method, url, headers, payload=nil, options={})
+    out = ""
+    # out << "\n"
+    # out << "#{cyan}#{bold}#{dark}REQUEST#{reset}\n"
     request_string = "#{http_method.to_s.upcase} #{url}".strip
-    print request_string, "\n"
-    print cyan
+    out << request_string + "\n"
+    out << cyan
     if payload
-      print "\n"
+      out << "\n"
+      content_type = (headers && headers['Content-Type']) ? headers['Content-Type'] : 'application/x-www-form-urlencoded'
       if content_type == 'application/json'
         if payload.is_a?(String)
           begin
@@ -260,23 +237,24 @@ module Morpheus::Cli::PrintHelper
             #payload = "(unparsable) #{payload}"
           end
         end
-        puts "#{cyan}#{bold}#{dark}JSON#{reset}"
+        out << "#{cyan}#{bold}#{dark}JSON#{reset}\n"
         if options[:scrub]
-          print Morpheus::Logging.scrub_message(JSON.pretty_generate(payload))
+          out << Morpheus::Logging.scrub_message(JSON.pretty_generate(payload))
         else
-          print JSON.pretty_generate(payload)
+          out << JSON.pretty_generate(payload)
         end
       else
-        print "Content-Type: #{content_type}", "\n"
-        print reset
+        out << "Content-Type: #{content_type}" + "\n"
+        out << reset
         if payload.is_a?(File)
-          pretty_size = "#{payload.size} B"
-          print "File: #{payload.path} (#{pretty_size})"
+          #pretty_size = "#{payload.size} B"
+          pretty_size = format_bytes(payload.size)
+          out << "File: #{payload.path} (#{pretty_size})"
         elsif payload.is_a?(String)
           if options[:scrub]
-            print Morpheus::Logging.scrub_message(payload)
+            out << Morpheus::Logging.scrub_message(payload)
           else
-            print payload
+            out << payload
           end
         else
           if content_type == 'application/x-www-form-urlencoded'
@@ -287,22 +265,24 @@ module Morpheus::Cli::PrintHelper
               # raise ex
             end
             if options[:scrub]
-              print Morpheus::Logging.scrub_message(body_str)
+              out << Morpheus::Logging.scrub_message(body_str)
             else
-              print body_str
+              out << body_str
             end
           else
             if options[:scrub]
-              print Morpheus::Logging.scrub_message(payload)
+              out << Morpheus::Logging.scrub_message(payload)
             else
-              print payload
+              out << payload
             end
           end
         end
       end
+      out << "\n"
     end
-    print "\n"
-    print reset
+    # out << "\n"
+    out << reset
+    return out
   end
 
   # format_curl_command generates a valid curl command for the given api request
@@ -1171,16 +1151,27 @@ module Morpheus::Cli::PrintHelper
     out
   end
 
-  def anded_list(items)
+  def format_list(items, conjunction="and", limit=nil)
     items = items ? items.clone : []
+    if limit
+      items = items.first(limit)
+    end
     last_item = items.pop
     if items.empty?
       return "#{last_item}"
     else
-      return items.join(", ") + " and #{last_item}"
+      return items.join(", ") + (conjunction.to_s.empty? ? ", " : " #{conjunction} ") + "#{last_item}" + ((limit && limit < (items.size+1)) ? " ..." : "")
     end
   end
 
+  def anded_list(items, limit=nil)
+    format_list(items, "and", limit)
+  end
+
+  def ored_list(items, limit=nil)
+    format_list(items, "or", limit)
+  end
+
   def sleep_with_dots(sleep_seconds, dots=3, dot_chr=".")
     dot_interval = (sleep_seconds.to_f / dots.to_i)
     dots.to_i.times do |dot_index|
@@ -1190,7 +1181,7 @@ module Morpheus::Cli::PrintHelper
   end
 
   def print_to_file(txt, filename, overwrite=false, access_mode = 'w+')
-    Morpheus::Logging::DarkPrinter.puts "Writing #{txt.to_s.bytesize} bytes to file #{filename} ..." if Morpheus::Logging.debug?
+    Morpheus::Logging::DarkPrinter.puts "Writing #{txt.to_s.bytesize} bytes to file #{filename}" if Morpheus::Logging.debug?
     outfile = nil
     begin
       full_filename = File.expand_path(filename)
@@ -1211,7 +1202,6 @@ module Morpheus::Cli::PrintHelper
       end
       outfile = File.open(full_filename, access_mode)
       outfile.print(txt)
-      print "#{cyan}Wrote #{txt.to_s.bytesize} bytes to file #{filename}\n"
       return 0
     rescue => ex
       # puts_error "Error writing to outfile '#{filename}'. Error: #{ex}"
@@ -1222,6 +1212,52 @@ module Morpheus::Cli::PrintHelper
     end
   end
 
+  def with_stdout_to_file(filename, overwrite=false, access_mode = 'w+', &block)
+    Morpheus::Logging::DarkPrinter.puts "Writing output to file #{filename}" if Morpheus::Logging.debug?
+    previous_stdout = my_terminal.stdout
+    outfile = nil
+    begin
+      full_filename = File.expand_path(filename)
+      if File.exists?(full_filename)
+        if !overwrite
+          print "#{red}Output file '#{filename}' already exists.#{reset}\n"
+          print "#{red}Use --overwrite to overwrite the existing file.#{reset}\n"
+          return 1
+        end
+      end
+      if Dir.exists?(full_filename)
+        print "#{red}Output file '#{filename}' is invalid. It is the name of an existing directory.#{reset}\n"
+        return 1
+      end
+      target_dir = File.dirname(full_filename)
+      if !Dir.exists?(target_dir)
+        FileUtils.mkdir_p(target_dir)
+      end
+      outfile = File.open(full_filename, access_mode)
+      # outfile.print(txt)
+      # ok just redirect stdout to the file
+      my_terminal.set_stdout(outfile)
+      result = yield
+      outfile.close if outfile
+      my_terminal.set_stdout(previous_stdout)
+      my_terminal.stdout.flush if my_terminal.stdout
+      # this does not work here.. i dunno why yet, it works in ensure though...
+      # print "#{cyan}Wrote #{File.size(full_filename)} bytes to file #{filename}\n"
+      if result
+        return result
+      else
+        return 0
+      end
+    rescue => ex
+      # puts_error "Error writing to outfile '#{filename}'. Error: #{ex}"
+      print_error "#{red}Error writing to file '#{filename}'.  Error: #{ex}#{reset}\n"
+      return 1
+    ensure
+      outfile.close if outfile
+      my_terminal.set_stdout(previous_stdout) if previous_stdout != my_terminal.stdout
+    end
+  end
+
   def format_percent(val, sig_dig=2)
     if val.nil?
       return ""