mtncloud-cli 1.0.0

data/lib/mtncloud/cli/commands/storage_server_types.rb

@@ -0,0 +1,45 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::StorageServerTypes
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::StorageServersHelper
+
+  set_command_description "View storage server types"
+  set_command_name :'storage-server-types'
+  register_subcommands :list, :get
+
+  # register_interfaces :storage_server_types
+
+  protected
+
+  def storage_server_type_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+    }
+  end
+
+  def storage_server_type_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+      "Creatable" => lambda {|it| format_boolean(it['creatable']) },
+      "Create Namespaces" => lambda {|it| format_boolean(it['createNamespaces']) },
+      "Create Groups" => lambda {|it| format_boolean(it['createGroups']) },
+      "Create Hosts" => lambda {|it| format_boolean(it['createHosts']) },
+      "Create Disks" => lambda {|it| format_boolean(it['createDisks']) },
+      "Has Namespaces" => lambda {|it| format_boolean(it['hasNamespaces']) },
+      "Has Groups" => lambda {|it| format_boolean(it['hasGroups']) },
+      "Has Hosts" => lambda {|it| format_boolean(it['hasHosts']) },
+      "Has Disks" => lambda {|it| format_boolean(it['hasDisks']) },
+      "Has File Browser" => lambda {|it| format_boolean(it['hasFileBrowser']) },
+    }
+  end
+
+end
+

data/lib/mtncloud/cli/commands/storage_servers.rb

@@ -0,0 +1,116 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::StorageServers
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::StorageServersHelper
+
+  set_command_name :'storage-servers'
+  set_command_description "View and manage storage servers."
+  register_subcommands :list, :get, :add, :update, :remove
+
+  # RestCommand settings
+  register_interfaces :storage_servers, :storage_server_types
+  set_rest_has_type true
+  # set_rest_type :storage_server_types
+
+  def render_response_for_get(json_response, options)
+    render_response(json_response, options, rest_object_key) do
+      record = json_response[rest_object_key]
+      print_h1 rest_label, [], options
+      print cyan
+      print_description_list(rest_column_definitions(options), record, options)
+      # show Storage Server Configuration
+      config = record['config']
+      if config && !config.empty?
+        print_h2 "Configuration"
+        print_description_list(config.keys, config)
+      end
+      print reset,"\n"
+    end
+  end
+
+  protected
+
+  def storage_server_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "Service URL" => lambda {|it| it['serviceUrl'] },
+      "Tenants" => lambda {|it| 
+        if it['tenants'] && !it['tenants'].empty?
+          it['tenants'].collect {|account| account['name'] }.join(', ')
+        else
+          it['owner'] ? it['owner']['name'] : (it['account'] ? it['account']['name'] : nil)
+        end
+      },
+      "Status" => lambda {|it| format_storage_server_status(it) },
+    }
+  end
+
+  def storage_server_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "Service URL" => lambda {|it| it['serviceUrl'] },
+      "Service Username" => lambda {|it| it['serviceUsername'] },
+      "Tenants" => lambda {|it| it['tenants'].collect {|account| account['name'] }.join(', ') },
+      "Owner" => lambda {|it| it['owner'] ? it['owner']['name'] : (it['account'] ? it['account']['name'] : nil) },
+      "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Status" => lambda {|it| format_storage_server_status(it) },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
+    }
+  end
+
+  def add_storage_server_option_types()
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'required' => false, 'defaultValue' => true},
+#      {'fieldName' => 'type', 'fieldLabel' => 'Storage Server Type', 'type' => 'select', 'optionSource' => 'storageServerTypes', 'required' => true},
+    ]
+  end
+
+  def add_storage_server_advanced_option_types()
+    [
+      {'fieldName' => 'visibility', 'fieldLabel' => 'Visibility', 'fieldGroup' => 'Advanced', 'type' => 'select', 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}], 'required' => false, 'description' => 'Visibility', 'category' => 'permissions'},
+      {'fieldName' => 'tenants', 'fieldLabel' => 'Tenants', 'fieldGroup' => 'Advanced', 'type' => 'multiSelect', 'optionSource' => lambda { |api_client, api_params| 
+        api_client.options.options_for_source("allTenants", {})['data']
+      }},
+    ]
+  end
+
+  def update_storage_server_option_types()
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text'},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
+      {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox'},
+    ]
+  end
+
+  def update_storage_server_advanced_option_types()
+    add_storage_server_advanced_option_types()
+  end
+
+  def format_storage_server_status(storage_server, return_color=cyan)
+    out = ""
+    status_string = storage_server['status']
+    if storage_server['enabled'] == false
+      out << "#{red}DISABLED#{return_color}"
+    elsif status_string.nil? || status_string.empty? || status_string == "unknown"
+      out << "#{white}UNKNOWN#{return_color}"
+    elsif status_string == 'ok'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'syncing'
+      out << "#{yellow}#{status_string.upcase}#{return_color}"
+    else
+      out << "#{red}#{status_string ? status_string.upcase : 'N/A'}#{storage_server['statusMessage'] ? "#{return_color} - #{storage_server['statusMessage']}" : ''}#{return_color}"
+    end
+    out
+  end
+
+end

data/lib/mtncloud/cli/commands/storage_volume_types.rb

@@ -0,0 +1,45 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::StorageVolumeTypes
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::StorageVolumesHelper
+
+  set_command_name :'storage-volume-types'
+  register_subcommands :list, :get
+
+  # register_interfaces :storage_volume_types
+
+  protected
+
+  def build_list_options(opts, options, params)
+    opts.on('--name VALUE', String, "Filter by name") do |val|
+      params['name'] = val
+    end
+    opts.on('--category VALUE', String, "Filter by category") do |val|
+      params['category'] = val
+    end
+    # build_standard_list_options(opts, options)
+    super
+  end
+
+  def storage_volume_type_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+    }
+  end
+
+  def storage_volume_type_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+    }
+  end
+
+end
+

data/lib/mtncloud/cli/commands/storage_volumes.rb

@@ -0,0 +1,236 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::StorageVolumes
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::RestCommand
+  include MtnCloud::Cli::StorageVolumesHelper
+  include MtnCloud::Cli::AccountsHelper
+
+  set_command_name :'storage-volumes'
+  set_command_description "View and manage storage volumes."
+  register_subcommands :list, :get, :add, :remove, :resize, :update_tenant
+
+  # RestCommand settings
+  register_interfaces :storage_volumes, :storage_volume_types, :accounts
+  set_rest_has_type true
+
+  protected
+
+  def build_list_options(opts, options, params)
+    opts.on('--storage-server VALUE', String, "Storage Server Name or ID") do |val|
+      options[:storage_server] = val
+    end
+    opts.on('-t', '--type TYPE', "Filter by type") do |val|
+      params['type'] = val
+    end
+    opts.on('--name VALUE', String, "Filter by name") do |val|
+      params['name'] = val
+    end
+    opts.on('--category VALUE', String, "Filter by category") do |val|
+      params['category'] = val
+    end
+    opts.on('--include-tenants', '--include-tenants', "Include sub-tenant storage volumes (master tenant only)") do
+      options[:include_tenants] = true
+      params['includeTenants'] = true
+    end
+    opts.on('--tenant TENANT', String, "Filter by Tenant Name or ID (master tenant only)") do |val|
+      options[:tenant] = val
+    end
+    # build_standard_list_options(opts, options)
+    super
+  end
+
+  def parse_list_options!(args, options, params)
+    parse_parameter_as_resource_id!(:storage_server, options, params)
+    if options[:tenant]
+      if options[:tenant].to_s =~ /\A\d+\Z/
+        params['tenantId'] = options[:tenant]
+      else
+        account = find_account_by_name_or_id(options[:tenant])
+        return 1 if account.nil?
+        params['tenantId'] = account['id']
+      end
+    end
+    super
+  end
+
+  def storage_volume_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "Source" => lambda {|it| format_storage_volume_source(it) },
+      "Storage" => lambda {|it| format_bytes(it['maxStorage']) },
+      "Status" => lambda {|it| format_storage_volume_status(it) },
+    }
+  end
+
+  def storage_volume_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
+      "Owner" => lambda {|it| it['owner'] ? it['owner']['name'] : (it['account'] ? it['account']['name'] : nil) },
+      "Cloud" => lambda {|it| it['zone']['name'] rescue '' },
+      "Datastore" => lambda {|it| it['datastore']['name'] rescue '' },
+      "Storage Group" => lambda {|it| it['storageGroup']['name'] rescue '' },
+      "Storage Server" => lambda {|it| it['storageServer']['name'] rescue '' },
+      "Source" => lambda {|it| format_storage_volume_source(it) },
+      "Storage" => lambda {|it| format_bytes(it['maxStorage']) },
+      "Status" => lambda {|it| format_storage_volume_status(it) },
+    }
+  end
+
+  def add_storage_volume_option_types()
+    [
+      {'fieldContext' => 'storageServer', 'fieldName' => 'id', 'fieldLabel' => 'Storage Server', 'type' => 'select', 'optionSource' => 'storageServers', 'optionParams' => {'createType' => 'block'}, 'required' => true},
+      {'fieldContext' => 'storageGroup', 'fieldName' => 'id', 'fieldLabel' => 'Storage Group', 'type' => 'select', 'optionSource' => 'storageGroups', 'required' => false},
+      {'shorthand' => '-t', 'fieldName' => 'type', 'fieldLabel' => 'Storage Volume Type', 'type' => 'select', 'optionSource' => 'storageVolumeTypes', 'required' => true},
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
+    ]
+  end
+
+  def update_storage_volume_option_types()
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text'},
+    ]
+  end
+
+  def resize_storage_volume_option_types()
+    [
+      {'fieldName' => 'maxStorage', 'fieldLabel' => 'New Size', 'type' => 'number', 'required' => true},
+    ]
+  end
+
+  def load_option_types_for_storage_volume(type_record, parent_record)
+    storage_volume_type = type_record
+    option_types = storage_volume_type['optionTypes']
+    # ughhh, all this to change a label for API which uses bytes and not MB
+    if option_types
+      size_option_type = option_types.find {|it| it['fieldName'] == 'maxStorage' }
+      if size_option_type
+        #size_option_type['fieldLabel'] = "Volume Size (bytes)"
+        size_option_type['fieldAddOn'] = "bytes"
+      end
+    end
+    return option_types
+  end
+
+  def resize(args)
+    options = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name]")
+      build_common_options(opts, options, [:options, :json, :dry_run, :quiet, :remote])
+    end
+    optparse.parse!(args)
+    if args.count < 1
+      puts optparse
+      exit 1
+    end
+    connect(options)
+    begin
+      volume = find_volume_by_name_or_id(args[0])
+      payload = {}
+      id = volume['id'].to_i
+      v_prompt = MtnCloud::Cli::OptionTypes.prompt([{'fieldName' => 'size', 'type' => 'number', 'fieldLabel' => "Volume Size (bytes)", 'required' => true, 'description' => 'Enter a volume size (bytes).', 'defaultValue' => volume['maxStorage']}], options[:options])
+      payload['maxStorage'] = v_prompt['size'].to_i
+      @storage_volumes_interface.resize(id, payload)
+    end
+  end
+
+  def update_tenant(args)
+    options = {}
+    params = {}
+    tenant_id = nil
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[volume] --tenant TENANT")
+      opts.on('--tenant TENANT', String, "Target Tenant (Account) Name or ID to transfer ownership to.") do |val|
+        tenant_id = val
+      end
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Transfer ownership of a storage volume to another tenant.
+[volume] is required. This is the name or id of a storage volume.
+--tenant is required unless provided via --payload. This is the name or id of the target tenant.
+Only an unattached volume may be transferred. All authorization and business-rule
+validation is performed by the server; its message is shown verbatim on failure.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    # CLI-side validation: require a target tenant unless a full payload is supplied.
+    # All other authorization and business rules are validated server-side.
+    if !options[:payload] && tenant_id.nil?
+      raise_command_error "--tenant is required to transfer ownership.\n#{optparse}"
+    end
+    connect(options)
+    volume = find_volume_by_name_or_id(args[0])
+    return 1 if volume.nil?
+    id = volume['id']
+    passed_options = parse_passed_options(options)
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({storage_volume_object_key => passed_options}) unless passed_options.empty?
+    else
+      account = find_account_by_name_or_id(tenant_id)
+      return 1 if account.nil?
+      payload[storage_volume_object_key] = {'tenant' => {'id' => account['id']}}
+      payload.deep_merge!({storage_volume_object_key => passed_options}) unless passed_options.empty?
+    end
+    @storage_volumes_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @storage_volumes_interface.dry.update_tenant(id, payload)
+      return 0, nil
+    end
+    json_response = @storage_volumes_interface.update_tenant(id, payload)
+    render_response(json_response, options, storage_volume_object_key) do
+      record = json_response[storage_volume_object_key]
+      owner_name = (record && record['owner'] ? record['owner']['name'] : (record && record['account'] ? record['account']['name'] : tenant_id))
+      print_green_success "Transferred storage volume #{record ? record['name'] : id} to tenant #{owner_name}"
+      print_h1 rest_label, [], options
+      print cyan
+      print_description_list(storage_volume_column_definitions(options), record, options)
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def find_volume_by_id(id)
+    begin
+      json_response = @storage_volumes_interface.get(id.to_i)
+      return json_response['storageVolume']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Volume not found by id #{id}"
+        exit 1
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_volume_by_name(name)
+    results = @storage_volumes_interface.list({name: name})
+    if results['storageVolumes'].empty?
+      print_red_alert "Volume not found by name #{name}"
+      exit 1
+    elsif results['storageVolumes'].size > 1
+      print_red_alert "Multiple Volumes exist with the name '#{name}'"
+      puts_error as_pretty_table(results['storageVolumes'], [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      exit 1
+    end
+    return results['storageVolumes'][0]
+  end
+
+  def find_volume_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_volume_by_id(val)
+    else
+      return find_volume_by_name(val)
+    end
+  end
+
+end