mtncloud-cli 1.0.0

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

@@ -0,0 +1,93 @@
+require 'mtncloud/cli/mixins/print_helper'
+require 'mtncloud/cli/option_types'
+require 'mtncloud/rest_client'
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for storage server management
+# including storage servers and storage server types
+module MtnCloud::Cli::StorageServersHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def storage_servers_interface
+    # @api_client.storage_servers
+    raise "#{self.class} has not defined @storage_servers_interface" if @storage_servers_interface.nil?
+    @storage_servers_interface
+  end
+
+  def storage_server_types_interface
+    # @api_client.storage_server_types
+    raise "#{self.class} has not defined @storage_server_types_interface" if @storage_server_types_interface.nil?
+    @storage_server_types_interface
+  end
+
+  def storage_server_object_key
+    'storageServer'
+  end
+
+  def storage_server_list_key
+    'storageServers'
+  end
+
+  def storage_server_label
+    'Storage Server'
+  end
+
+  def storage_server_label_plural
+    'Storage Server'
+  end
+
+  def storage_server_type_object_key
+    'storageServerType'
+  end
+
+  def storage_server_type_list_key
+    'storageServerTypes'
+  end
+
+  def storage_server_type_label
+    'Storage Server Type'
+  end
+
+  def storage_server_type_label_plural
+    'Storage Server Types'
+  end
+
+  def find_storage_server_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_storage_server_by_id(val)
+    else
+      return find_storage_server_by_name(val)
+    end
+  end
+
+  def find_storage_server_by_id(id)
+    begin
+      json_response = storage_servers_interface.get(id.to_i)
+      return json_response[storage_server_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Storage Server not found by id #{id}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_storage_server_by_name(name)
+    lbs = storage_servers_interface.list({name: name.to_s})[storage_server_list_key]
+    if lbs.empty?
+      print_red_alert "Storage Server not found by name #{name}"
+      return nil
+    elsif lbs.size > 1
+      print_red_alert "#{lbs.size} storage servers found by name #{name}"
+      #print_lbs_table(lbs, {color: red})
+      print reset,"\n\n"
+      return nil
+    else
+      return lbs[0]
+    end
+  end
+
+end

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

@@ -0,0 +1,76 @@
+require 'mtncloud/cli/mixins/print_helper'
+require 'mtncloud/cli/option_types'
+require 'mtncloud/rest_client'
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for storage volume management
+# including storage volumes and storage volume types
+module MtnCloud::Cli::StorageVolumesHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def storage_volumes_interface
+    # @api_client.storage_volumes
+    raise "#{self.class} has not defined @storage_volumes_interface" if @storage_volumes_interface.nil?
+    @storage_volumes_interface
+  end
+
+  def storage_volume_types_interface
+    # @api_client.storage_volume_types
+    raise "#{self.class} has not defined @storage_volume_types_interface" if @storage_volume_types_interface.nil?
+    @storage_volume_types_interface
+  end
+
+  def storage_volume_object_key
+    'storageVolume'
+  end
+
+  def storage_volume_list_key
+    'storageVolumes'
+  end
+
+  def storage_volume_label
+    'Storage Volume'
+  end
+
+  def storage_volume_label_plural
+    'Storage Volume'
+  end
+
+  def storage_volume_type_object_key
+    'storageVolumeType'
+  end
+
+  def storage_volume_type_list_key
+    'storageVolumeTypes'
+  end
+
+  def storage_volume_type_label
+    'Storage Volume Type'
+  end
+
+  def storage_volume_type_label_plural
+    'Storage Volume Types'
+  end
+
+  def format_storage_volume_status(record, return_color=cyan)
+    out = ""
+    status_string = record['status']
+    if status_string.nil? || status_string.empty? || status_string == "unknown"
+      out << "#{white}UNKNOWN#{return_color}"
+    elsif status_string == 'provisioned' || status_string == 'unattached'
+      out << "#{cyan}#{status_string.capitalize}#{return_color}"
+    elsif status_string == 'syncing'
+      out << "#{yellow}#{status_string.capitalize}#{return_color}"
+    else
+      out << "#{red}#{status_string ? status_string.capitalize : 'N/A'}#{record['statusMessage'] ? "#{return_color} - #{record['statusMessage']}" : ''}#{return_color}"
+    end
+    out
+  end
+
+  def format_storage_volume_source(storage_volume)
+    storage_volume['source']
+  end
+
+end

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

@@ -0,0 +1,246 @@
+require 'mtncloud/cli/mixins/print_helper'
+# Provides common finder methods for VDI Pool management commands
+module MtnCloud::Cli::VdiHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  ## VDI Pools
+
+  def vdi_pools_interface
+    raise "#{self.class} has not defined @vdi_pools_interface" if @vdi_pools_interface.nil?
+    @vdi_pools_interface
+  end
+
+  def vdi_pool_object_key
+    'vdiPool'
+  end
+
+  def vdi_pool_list_key
+    'vdiPools'
+  end
+
+  def find_vdi_pool_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_vdi_pool_by_id(val)
+    else
+      return find_vdi_pool_by_name(val)
+    end
+  end
+
+  def find_vdi_pool_by_id(id)
+    begin
+      json_response = vdi_pools_interface.get(id.to_i)
+      return json_response[vdi_pool_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "VDI Pool not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_vdi_pool_by_name(name)
+    json_response = vdi_pools_interface.list({name: name.to_s})
+    vdi_pools = json_response[vdi_pool_list_key]
+    if vdi_pools.empty?
+      print_red_alert "VDI Pool not found by name '#{name}'"
+      return nil
+    elsif vdi_pools.size > 1
+      print_red_alert "#{vdi_pools.size} VDI Pools found by name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(vdi_pools, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return vdi_pools[0]
+    end
+  end
+
+  def format_vdi_pool_status(vdi_pool, return_color=cyan)
+    out = ""
+    status_string = vdi_pool['status'].to_s.downcase
+    if status_string
+      if ['available'].include?(status_string)
+        out << "#{green}#{status_string.upcase}"
+      elsif ['unavailable'].include?(status_string)
+        out << "#{red}#{status_string.upcase}"
+      else
+        out << "#{return_color}#{status_string.upcase}"
+      end
+    end
+    out + return_color
+  end
+
+  ## VDI Allocations
+
+  def vdi_allocations_interface
+    raise "#{self.class} has not defined @vdi_allocations_interface" if @vdi_allocations_interface.nil?
+    @vdi_allocations_interface
+  end
+
+  def vdi_allocation_object_key
+    'vdiAllocation'
+  end
+
+  def vdi_allocation_list_key
+    'vdiAllocations'
+  end
+
+  def find_vdi_allocation_by_id(id)
+    begin
+      json_response = vdi_allocations_interface.get(id.to_i)
+      return json_response[vdi_allocation_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "VDI Allocation not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def format_vdi_allocation_status(vdi_allocation, return_color=cyan)
+    out = ""
+    status_string = vdi_allocation['status'].to_s.downcase
+    if status_string
+      if ['available'].include?(status_string)
+        out << "#{green}#{status_string.upcase}"
+      # elsif ['preparing'].include?(status_string)
+      #   out << "#{yellow}#{status_string.upcase}"
+      # elsif ['reserved', 'shutdown'].include?(status_string)
+      #   out << "#{yellow}#{status_string.upcase}"
+      elsif ['failed'].include?(status_string)
+        out << "#{red}#{status_string.upcase}"
+      else
+        out << "#{return_color}#{status_string.upcase}"
+      end
+    end
+    out + return_color
+  end
+
+  def get_available_vdi_apps(refresh=false)
+    if !@available_vdi_apps || refresh
+      @available_vdi_apps = @vdi_apps_interface.list({max:-1})['vdiApps'] #  || []
+    end
+    return @available_vdi_apps
+  end
+  
+  def get_vdi_app_by_name_or_code(name)
+    return get_available_vdi_apps().find { |z| z['name'].downcase == name.downcase || z['code'].downcase == name.downcase}
+  end
+
+  ## VDI Apps
+
+  def vdi_apps_interface
+    raise "#{self.class} has not defined @vdi_apps_interface" if @vdi_apps_interface.nil?
+    @vdi_apps_interface
+  end
+
+  def vdi_app_object_key
+    'vdiApp'
+  end
+
+  def vdi_app_list_key
+    'vdiApps'
+  end
+
+  def find_vdi_app_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_vdi_app_by_id(val)
+    else
+      return find_vdi_app_by_name(val)
+    end
+  end
+
+  def find_vdi_app_by_id(id)
+    begin
+      json_response = vdi_apps_interface.get(id.to_i)
+      return json_response[vdi_app_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "VDI App not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_vdi_app_by_name(name)
+    json_response = vdi_apps_interface.list({name: name.to_s})
+    vdi_apps = json_response[vdi_app_list_key]
+    if vdi_apps.empty?
+      print_red_alert "VDI App not found by name '#{name}'"
+      return nil
+    elsif vdi_apps.size > 1
+      print_red_alert "#{vdi_apps.size} VDI App found by name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(vdi_apps, {"ID" => 'id', "NAME" => 'name'}, {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return vdi_apps[0]
+    end
+  end
+
+
+  ## VDI Gateways
+
+  def vdi_gateways_interface
+    raise "#{self.class} has not defined @vdi_gateways_interface" if @vdi_gateways_interface.nil?
+    @vdi_gateways_interface
+  end
+
+  def vdi_gateway_object_key
+    'vdiGateway'
+  end
+
+  def vdi_gateway_list_key
+    'vdiGateways'
+  end
+
+  def find_vdi_gateway_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_vdi_gateway_by_id(val)
+    else
+      return find_vdi_gateway_by_name(val)
+    end
+  end
+
+  def find_vdi_gateway_by_id(id)
+    begin
+      json_response = vdi_gateways_interface.get(id.to_i)
+      return json_response[vdi_gateway_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "VDI Gateway not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_vdi_gateway_by_name(name)
+    json_response = vdi_gateways_interface.list({name: name.to_s})
+    vdi_gateways = json_response[vdi_gateway_list_key]
+    if vdi_gateways.empty?
+      print_red_alert "VDI Gateway not found by name '#{name}'"
+      return nil
+    elsif vdi_gateways.size > 1
+      print_red_alert "#{vdi_gateways.size} VDI Gateway found by name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(vdi_gateways, {"ID" => 'id', "NAME" => 'name'}, {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return vdi_gateways[0]
+    end
+  end
+
+
+end

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

@@ -0,0 +1,73 @@
+require 'mtncloud/cli/mixins/print_helper'
+
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for fetching and printing whoami information
+module MtnCloud::Cli::WhoamiHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def load_whoami(refresh=false)
+    appliance = @remote_appliance # from establish_connection()
+    if appliance.nil?
+      print_red_alert "No current appliance. See `remote use`."
+      exit 1
+    end
+    # fetch from cache first
+    whoami_response = nil
+    cached_response = ::MtnCloud::Cli::Whoami.load_whoami(appliance[:name], appliance[:username], refresh)
+    if cached_response
+      whoami_response = cached_response
+    else
+      whoami_interface = @whoami_interface || @api_client.whoami
+      whoami_response = whoami_interface.get()
+      # save the result to the cache
+      ::MtnCloud::Cli::Whoami.save_whoami(appliance[:name], appliance[:username], whoami_response)
+    end
+
+    @current_user = whoami_response["user"]
+    if @current_user.empty?
+      print_red_alert "Unauthenticated. Please login."
+      exit 1
+    end
+    @is_master_account = whoami_response["isMasterAccount"]
+    @user_permissions = whoami_response["permissions"]
+    if whoami_response["appliance"]
+      @appliance_build_verison = whoami_response["appliance"]["buildVersion"]
+    else
+      @appliance_build_verison = nil
+    end
+
+    return whoami_response
+  end
+
+  def current_account
+    if @current_user.nil?
+      load_whoami
+    end
+    @current_user ? @current_user['account'] : nil
+  end
+
+  def is_master_account
+    if @current_user.nil?
+      load_whoami
+    end
+    @is_master_account
+  end
+
+  def current_user
+    if @current_user.nil?
+      load_whoami
+    end
+    @current_user
+  end
+
+  def current_user_permissions
+    if @user_permissions.nil?
+      load_whoami
+    end
+    @user_permissions
+  end
+
+end

data/lib/mtncloud/cli/option_parser.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+
+module MtnCloud
+  module Cli
+
+    # an enhanced OptionParser
+    # Modifications include
+    # * footer property to compliment banner with footer="Get details about a thing by ID."
+    # * hidden options with add_hidden_option "--not-in-help"
+    # * errors raised from parse! will have a reference to the parser itself.
+    #    this is useful so you can you print the banner (usage) message in your error handling
+    class MtnCloud::Cli::OptionParser < OptionParser
+
+      attr_accessor :footer
+
+      # Array of option names to keep out of help message
+      attr_accessor :hidden_options
+
+      alias :original_to_s :to_s
+
+      def to_s
+        full_help_message
+      end
+
+      def full_help_message(opts={})
+        out = ""
+        #out << original_to_s
+        if banner
+          out << "#{banner}".sub(/\n?\z/, "\n")
+        end
+        if !self.to_a.empty?
+          #out << "Options:\n"
+          # the default way..
+          # out << summarize().join("")
+          # super hacky, should be examining the option, not the fully formatted description
+          my_summaries = summarize()
+          if opts[:show_hidden_options]
+            my_summaries.each do |full_line|
+              out << full_line
+            end
+          else
+            on_hidden_option = false
+            my_summaries.each do |full_line|
+              opt_description = full_line.to_s.strip
+              if opt_description.start_with?("-")
+                is_hidden = (hidden_options || []).find { |hidden_switch|
+                  if hidden_switch.start_with?("-")
+                    opt_description.start_with?("#{hidden_switch} ")
+                  else
+                    opt_description.start_with?("--#{hidden_switch} ")
+                  end
+                }
+                if is_hidden
+                  on_hidden_option = true
+                else
+                  on_hidden_option = false
+                  out << full_line
+                end
+              else
+                if on_hidden_option == false
+                  out << full_line
+                end
+              end
+            end
+          end
+        end
+        if footer
+          # nice_footer = footer.split("\n").collect {|line| "#{summary_indent}#{line}" }.join("\n")
+          nice_footer = footer
+          out << "\n"
+          out << "#{nice_footer}".sub(/\n?\z/, "\n")
+          # out << "\n"
+        end
+        out
+      end
+
+      def hidden_options
+        @hidden_options ||= []
+      end
+
+      def add_hidden_option(opt_name)
+        opt_array = [opt_name].flatten.compact
+        @hidden_options ||= []
+        opt_array.each do |val|
+          if !@hidden_options.include?(val)
+            @hidden_options << val
+          end
+        end
+        @hidden_options
+      end
+
+      # this needs mods too, but we dont use it...
+      # def parse
+      # end
+
+      def parse!(*args)
+        # it is actually # def parse(argv = default_argv, into: nil)
+        argv = [args].flatten() # args[0].flatten
+        #help_wanted = argv.find {|arg| arg == "--help" || arg ==  "-h" }
+        help_wanted = (argv.last == "--help" || argv.last ==  "-h") ? argv.last : nil
+        begin
+          return super(*args)
+        rescue OptionParser::ParseError => e
+          # last arg is --help
+          # maybe they just got the Try --help message and its on the end
+          # so strip all option arguments to avoid OptionParser::InvalidOption, etc.
+          # this is not ideal, it means you cannot pass these strings as the last argument to your command.
+          if help_wanted
+            argv = argv.reject {|arg| arg =~ /^\-+/ }
+            argv << help_wanted
+            return super(argv)
+          else
+            e.optparse = self
+            raise e
+          end
+          
+        end
+      end
+    end
+  end
+end
+
+# ParseError is overridden to set parser reference.
+# todo: dont monkey patch like this
+class OptionParser::ParseError
+  attr_accessor :optparse
+end