morpheus-cli 3.4.1.10 → 3.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 546db01c07f0ed59b7d0c6a78f5864e6dc123b00
-  data.tar.gz: e4965c3651a6396c17a45481e03988cdf0edbb4b
+SHA256:
+  metadata.gz: dd3b5e29881772dd9ef4e80eb5226176fa814c4661464f68ffe9249e0ccda99c
+  data.tar.gz: cdbca169540925cfa847c48c12aad367bd4626a733e2844323d6078f5d351a44
 SHA512:
-  metadata.gz: 83cce232452557026284d972f1f123d7fd0e72e188ae9518913ab746e04964d144bd903b58dc28c4ee175e3d309e491cbedb1efb9c48089785ca90bcf2d1aa86
-  data.tar.gz: c784eb91e5e4ff851d173c7682de04a7326329e1fc59d6fa8a9caf81abde6758af5915020368a54e3612176300192b94dcf48af653e0f8f4d74691ecb6d45201
+  metadata.gz: 1f094793c1f8e11ffc84c9dea26e2e094881efb22d5b0d71b65ed5d206df40b16e6fc80ddbdf6e028c12184749f485113aba555c2d6fd595c2643e1d6f8547cb
+  data.tar.gz: 4715322bcc111e6e82fa8fcd98e60b0123ebc50afd6b22a7719cc108cf36e2c02c095456e0fa3dad2800e0fb4b65724c9bbad668eed46e966d2db2389a5dec1d

data/lib/morpheus/api/api_client.rb

@@ -295,4 +295,8 @@ class Morpheus::APIClient
     Morpheus::PackagesInterface.new(@access_token, @refresh_token, @expires_at, @base_url)
   end
 
+  def cypher
+    Morpheus::CypherInterface.new(@access_token, @refresh_token, @expires_at, @base_url)
+  end
+  
 end

data/lib/morpheus/api/cypher_interface.rb

@@ -0,0 +1,55 @@
+require 'morpheus/api/api_client'
+require 'uri'
+
+class Morpheus::CypherInterface < Morpheus::APIClient
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
+
+  def get(id, params={})
+    raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
+    url = "#{@base_url}/api/cypher/#{id}"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def list(params={})
+    url = "#{@base_url}/api/cypher"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def create(payload)
+    url = "#{@base_url}/api/cypher"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def update(id, payload)
+    url = "#{@base_url}/api/cypher/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def destroy(id, params={})
+    url = "#{@base_url}/api/cypher/#{id}"
+    headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :delete, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
+
+  def decrypt(id, params={})
+    url = "#{@base_url}/api/cypher/#{id}/decrypt"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+end

data/lib/morpheus/api/storage_providers_interface.rb

@@ -1,4 +1,5 @@
 require 'morpheus/api/api_client'
+require 'uri'
 
 class Morpheus::StorageProvidersInterface < Morpheus::APIClient
   def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
@@ -44,4 +45,116 @@ class Morpheus::StorageProvidersInterface < Morpheus::APIClient
     execute(opts)
   end
 
+  def list_files(id, file_path, params={})
+    if file_path.to_s.strip == "/"
+      file_path = ""
+    end
+    url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}" + "/files/#{URI.escape(file_path)}".squeeze('/')
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  # upload a file without multipart
+  def upload_file(id, local_file, destination, params={})
+    # puts "upload_file #{local_file} to destination #{destination}"
+    # destination should be the full filePath, but the api looks like directory?filename=
+    path = destination.to_s.squeeze("/")
+    if !path || path == "" || path == "/" || path == "."
+      raise "#{self.class}.upload_file() passed a bad destination: '#{destination}'"
+    end
+    if path[0].chr == "/"
+      path = path[1..-1]
+    end
+    path_chunks = path.split("/")
+    filename = path_chunks.pop
+    safe_dirname = path_chunks.collect {|it| URI.escape(it) }.join("/")
+    # filename = File.basename(destination)
+    # dirname = File.dirname(destination)
+    # if filename == "" || filename == "/"
+    #   filename = File.basename(local_file)
+    # end
+    url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}" + "/files/#{safe_dirname}".squeeze('/')
+    headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/octet-stream'}
+    headers[:params][:filename] = filename # File.basename(destination)
+    if !local_file.kind_of?(File)
+      local_file = File.new(local_file, 'rb')
+    end
+    payload = local_file
+    headers['Content-Length'] = local_file.size # File.size(local_file)
+    execute(method: :post, url: url, headers: headers, payload: payload)
+  end
+
+  def download_file(id, file_path, params={})
+    raise "#{self.class}.download_file() passed a blank id!" if id.to_s == ''
+    raise "#{self.class}.download_file() passed a blank file path!" if file_path.to_s == ''
+    escaped_file_path = file_path.split("/").collect {|it| URI.escape(it) }.join("/")
+    url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}" + "/download-file/#{escaped_file_path}".squeeze('/')
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts, false)
+  end
+
+  def download_file_chunked(id, file_path, outfile, params={})
+    raise "#{self.class}.download_file() passed a blank id!" if id.to_s == ''
+    raise "#{self.class}.download_file() passed a blank file path!" if file_path.to_s == ''
+    escaped_file_path = file_path.split("/").collect {|it| URI.escape(it) }.join("/")
+    url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}" + "/download-file/#{escaped_file_path}".squeeze('/')
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    # execute(opts, false)
+    if Dir.exists?(outfile)
+      raise "outfile is invalid. It is the name of an existing directory: #{outfile}"
+    end
+    # if @verify_ssl == false
+    #   opts[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+    # end
+    if @dry_run
+      return opts
+    end
+    http_response = nil
+    File.open(outfile, 'w') {|f|
+      block = proc { |response|
+        response.read_body do |chunk|
+          # writing to #{outfile} ..."
+          f.write chunk
+        end
+      }
+      opts[:block_response] = block
+      http_response = RestClient::Request.new(opts).execute
+      # RestClient::Request.execute(opts)
+    }
+    return http_response
+  end
+
+  def download_zip_chunked(id, outfile, params={})
+    #url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}" + ".zip"
+    url = "#{@base_url}/api/storage/providers/#{URI.escape(id.to_s)}/download-zip"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    # execute(opts, false)
+    if Dir.exists?(outfile)
+      raise "outfile is invalid. It is the name of an existing directory: #{outfile}"
+    end
+    # if @verify_ssl == false
+    #   opts[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+    # end
+    if @dry_run
+      return opts
+    end
+    http_response = nil
+    File.open(outfile, 'w') {|f|
+      block = proc { |response|
+        response.read_body do |chunk|
+          # writing to #{outfile} ..."
+          f.write chunk
+        end
+      }
+      opts[:block_response] = block
+      http_response = RestClient::Request.new(opts).execute
+      # RestClient::Request.execute(opts)
+    }
+    return http_response
+  end
+
 end

data/lib/morpheus/cli.rb

@@ -138,6 +138,7 @@ module Morpheus
       load 'morpheus/cli/network_pool_servers_command.rb'
       load 'morpheus/cli/network_domains_command.rb'
       load 'morpheus/cli/network_proxies_command.rb'
+      load 'morpheus/cli/cypher_command.rb'
       load 'morpheus/cli/image_builder_command.rb'
       load 'morpheus/cli/preseed_scripts_command.rb'
       load 'morpheus/cli/boot_scripts_command.rb'

data/lib/morpheus/cli/archives_command.rb

@@ -820,7 +820,6 @@ class Morpheus::Cli::ArchivesCommand
                 groups_str = owner_str
               end
             end
-            groups_str = 
             file_info << truncate_string(groups_str, 15).ljust(15, " ")
             # File Type
             content_type = archive_file['contentType'].to_s
@@ -848,7 +847,7 @@ class Morpheus::Cli::ArchivesCommand
                 mtime = format_local_dt(last_updated, {format: "%b %e %Y"})
               end
             end
-            file_info << mtime # .ljust(21, " ")
+            file_info << mtime.ljust(12, " ")
             if params[:fullTree]
               file_info << file_color + archive_file["filePath"].to_s + cyan
             else
@@ -871,7 +870,7 @@ class Morpheus::Cli::ArchivesCommand
           if do_one_file_per_line
             print file_names.join("\n")
           else
-            print file_names.join(" ")
+            print file_names.join("\t")
           end
           print "\n"
         end
@@ -1287,11 +1286,11 @@ class Morpheus::Cli::ArchivesCommand
         if options[:dry_run]
           # print_dry_run @archive_files_interface.dry.download_file_by_path(full_file_path), full_command_string
           if use_public_url
-            print_dry_run @archive_files_interface.dry.download_file_by_path_chunked(full_file_path, outfile), full_command_string
-          else
             print_dry_run @archive_files_interface.dry.download_public_file_by_path_chunked(full_file_path, outfile), full_command_string
+          else
+            print_dry_run @archive_files_interface.dry.download_file_by_path_chunked(full_file_path, outfile), full_command_string
           end
-          return 1
+          return 0
         end
         if !options[:quiet]
           print cyan + "Downloading archive file #{bucket_id}:#{file_path} to #{outfile} ... "

data/lib/morpheus/cli/cli_command.rb

@@ -318,7 +318,16 @@ module Morpheus
                   k, v = k.split(":")
                 end
                 if (!k.to_s.empty?)
-                  options[:query_filters][k.to_s.strip] = v.to_s.strip
+                  if options[:query_filters].key?(k.to_s.strip)
+                    cur_val = options[:query_filters][k.to_s.strip]
+                    if cur_val.instance_of?(Array)
+                      options[:query_filters][k.to_s.strip] << v.to_s.strip
+                    else
+                      options[:query_filters][k.to_s.strip] = [cur_val, v.to_s.strip]
+                    end
+                  else
+                    options[:query_filters][k.to_s.strip] = v.to_s.strip
+                  end
                 end
               end
             end

data/lib/morpheus/cli/clouds.rb

@@ -198,6 +198,7 @@ class Morpheus::Cli::Clouds
         "Location" => 'location',
         "Visibility" => lambda {|it| it['visibility'].to_s.capitalize },
         "Groups" => lambda {|it| it['groups'].collect {|g| g.instance_of?(Hash) ? g['name'] : g.to_s }.join(', ') },
+        "Enabled" => lambda {|it| format_boolean(it['enabled']) },
         "Status" => lambda {|it| format_cloud_status(it) }
       }
       print_description_list(description_cols, cloud)

data/lib/morpheus/cli/cypher_command.rb

@@ -0,0 +1,412 @@
+require 'json'
+require 'yaml'
+require 'table_print'
+require 'morpheus/cli/cli_command'
+
+class Morpheus::Cli::CypherCommand
+  include Morpheus::Cli::CliCommand
+
+  set_command_name :cypher
+
+  register_subcommands :list, :get, :add, :remove, :decrypt
+  
+  def initialize()
+    # @appliance_name, @appliance_url = Morpheus::Cli::Remote.active_appliance
+  end
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @cypher_interface = @api_client.cypher
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def list(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :json, :dry_run, :remote])
+      opts.footer = "List cypher items."
+    end
+    optparse.parse!(args)
+    connect(options)
+    begin
+      params.merge!(parse_list_options(options))
+      if options[:dry_run]
+        print_dry_run @cypher_interface.dry.list(params)
+        return 0
+      end
+      json_response = @cypher_interface.list(params)      
+      cypher_items = json_response["cyphers"]
+      if options[:json]
+        puts as_json(json_response, options, "cyphers")
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, "cyphers")
+        return 0
+      elsif options[:csv]
+        puts records_as_csv(cypher_items, options)
+        return 0
+      end
+      title = "Morpheus Cypher List"
+      subtitles = []
+      subtitles += parse_list_subtitles(options)
+      print_h1 title, subtitles
+      if cypher_items.empty?
+        print cyan,"No cypher items found.",reset,"\n"
+      else
+        cypher_columns = {
+          "ID" => 'id',
+          "KEY" => lambda {|it| it["itemKey"] || it["key"] },
+          "LEASE REMAINING" => lambda {|it| it['expireDate'] ? format_local_dt(it['expireDate']) : "" },
+          "DATED CREATED" => lambda {|it| format_local_dt(it["dateCreated"]) },
+          "LAST ACCESSED" => lambda {|it| format_local_dt(it["lastAccessed"]) }
+        }
+        if options[:include_fields]
+          cypher_columns = options[:include_fields]
+        end
+        print cyan
+        print as_pretty_table(cypher_items, cypher_columns, options)
+        print reset
+        print_results_pagination(json_response)
+      end
+      print reset,"\n"
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def get(args)
+    options = {}
+    do_decrypt = false
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      opts.on(nil, '--decrypt', 'Display the decrypted value') do
+        do_decrypt = true
+      end
+      build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.footer = "Get details about a cypher." + "\n" +
+                    "[id] is required. This is the id or key of a cypher."
+    end
+    optparse.parse!(args)
+    if args.count != 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "wrong number of arguments, expected 1 and got #{args.count}\n#{optparse}"
+      return 1
+    end
+    connect(options)
+    begin
+      if options[:dry_run]
+        if args[0].to_s =~ /\A\d{1,}\Z/
+          print_dry_run @cypher_interface.dry.get(args[0].to_i)
+        else
+          print_dry_run @cypher_interface.dry.list({name:args[0]})
+        end
+        return
+      end
+      cypher_item = find_cypher_by_name_or_id(args[0])
+      return 1 if cypher_item.nil?
+      json_response = {'cypher' => cypher_item}  # skip redundant request
+      decrypt_json_response = nil
+      if do_decrypt
+        decrypt_json_response = @cypher_interface.decrypt(cypher_item["id"])
+      end
+      # json_response = @cypher_interface.get(cypher_item['id'])
+      cypher_item = json_response['cypher']
+      if options[:json]
+        puts as_json(json_response, options, "cypher")
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, "cypher")
+        return 0
+      elsif options[:csv]
+        puts records_as_csv([cypher_item], options)
+        return 0
+      end
+      print_h1 "Cypher Details"
+      print cyan
+      description_cols = {
+        "ID" => 'id',
+        # what here
+        "Key" => lambda {|it| it["itemKey"] },
+        #"Value" => lambda {|it| it["value"] || "************" },
+        "Lease Remaining" => lambda {|it| format_local_dt(it["expireDate"]) },
+        "Date Created" => lambda {|it| format_local_dt(it["dateCreated"]) },
+        "Last Accessed" => lambda {|it| format_local_dt(it["lastAccessed"]) }
+      }
+      print_description_list(description_cols, cypher_item)
+      if decrypt_json_response
+        print_h2 "Decrypted Value"
+        print cyan
+        puts decrypt_json_response["cypher"] ? decrypt_json_response["cypher"]["itemValue"] : ""
+      end
+      print reset, "\n"
+
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def decrypt(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.footer = "Decrypt the value of a cypher." + "\n" +
+                    "[id] is required. This is the id or key of a cypher."
+    end
+    optparse.parse!(args)
+    if args.count != 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "wrong number of arguments, expected 1 and got #{args.count}\n#{optparse}"
+      return 1
+    end
+    connect(options)
+    begin
+      cypher_item = find_cypher_by_name_or_id(args[0])
+      return 1 if cypher_item.nil?
+      if options[:dry_run]
+        print_dry_run @cypher_interface.dry.decrypt(cypher_item["id"], params)
+        return
+      end
+      
+      cypher_item = find_cypher_by_name_or_id(args[0])
+      return 1 if cypher_item.nil?
+
+      json_response = @cypher_interface.decrypt(cypher_item["id"], params)
+      if options[:json]
+        puts as_json(json_response, options, "cypher")
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, "cypher")
+        return 0
+      elsif options[:csv]
+        puts records_as_csv([json_response["crypt"]], options)
+        return 0
+      end
+      print_h1 "Cypher Decrypt"
+      print cyan
+      print_description_list({
+        "ID" => 'id',
+        "Key" => lambda {|it| it["itemKey"] },
+        "Value" => lambda {|it| it["itemValue"] }
+        }, json_response["cypher"])
+      print reset, "\n"
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  def add(args)
+    options = {}
+    params = {}
+    
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      opts.on('--key VALUE', String, "Key for this cypher") do |val|
+        params['itemKey'] = val
+      end
+      build_common_options(opts, options, [:options, :payload, :json, :dry_run, :quiet, :remote])
+      opts.footer = "Create a new cypher."
+    end
+    optparse.parse!(args)
+    if args.count > 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "wrong number of arguments, expected 0-1 and got #{args.count}\n#{optparse}"
+      return 1
+    end
+    connect(options)
+    begin
+      payload = nil
+      if options[:payload]
+        payload = options[:payload]
+      else
+        # merge -O options into normally parsed options
+        params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options] && options[:options].keys.size > 0
+        
+        # support [key] as first argument
+        if args[0]
+          params['itemKey'] = args[0]
+        end
+        # Key
+        if !params['itemKey']
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'itemKey', 'fieldLabel' => 'Key', 'type' => 'text', 'required' => true, 'description' => cypher_key_help}], options)
+          params['itemKey'] = v_prompt['itemKey']
+        end
+
+        # Value
+        value_is_required = false
+        cypher_mount_type = params['itemKey'].split("/").first
+        if cypher_mount_type == ["secret", "password"].include?(cypher_mount_type)
+          value_is_required = true
+        end
+
+        if !params['itemValue']
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'itemValue', 'fieldLabel' => 'Value', 'type' => 'text', 'required' => value_is_required, 'description' => "Value for this cypher"}], options)
+          params['itemValue'] = v_prompt['itemValue']
+        end
+
+        # Lease
+        if !params['leaseTimeout']
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'leaseTimeout', 'fieldLabel' => 'Lease', 'type' => 'text', 'required' => false, 'description' => cypher_lease_help}], options)
+          params['leaseTimeout'] = v_prompt['leaseTimeout']
+        end
+        if !params['leaseTimeout'].to_s.empty?
+          params['leaseTimeout'] = params['leaseTimeout'].to_i
+        end
+
+        # construct payload
+        payload = {
+          'cypher' => params
+        }
+      end
+
+      if options[:dry_run]
+        print_dry_run @cypher_interface.dry.create(payload)
+        return
+      end
+      json_response = @cypher_interface.create(payload)
+      if options[:json]
+        print JSON.pretty_generate(json_response)
+        print "\n"
+      elsif !options[:quiet]
+        print_green_success "Added cypher"
+        # list([])
+        cypher_item = json_response['cypher']
+        get([cypher_item['id']])
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  # def update(args)
+  # end
+
+  # def decrypt(args)
+  # end
+
+  def remove(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      build_common_options(opts, options, [:account, :auto_confirm, :json, :dry_run, :quiet, :remote])
+      opts.footer = "Delete a cypher." + "\n" +
+                    "[id] is required. This is the id or key of a cypher."
+    end
+    optparse.parse!(args)
+
+    if args.count != 1
+      print_error Morpheus::Terminal.angry_prompt
+      puts_error  "wrong number of arguments, expected 1 and got #{args.count}\n#{optparse}"
+      return 1
+    end
+
+    connect(options)
+    begin
+      cypher_item = find_cypher_by_name_or_id(args[0])
+      return 1 if cypher_item.nil?
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the cypher #{cypher_item['itemKey']}?")
+        return 9, "aborted command"
+      end
+      if options[:dry_run]
+        print_dry_run @cypher_interface.dry.destroy(cypher_item["id"])
+        return
+      end
+      json_response = @cypher_interface.destroy(cypher_item["id"])
+      if options[:json]
+        print JSON.pretty_generate(json_response)
+        print "\n"
+      elsif !options[:quiet]
+        print_green_success "Deleted cypher #{cypher_item['itemKey']}"
+        # list([])
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      return 1
+    end
+  end
+
+  private
+
+  def find_cypher_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_cypher_by_id(val)
+    else
+      return find_cypher_by_name(val)
+    end
+  end
+
+  def find_cypher_by_id(id)
+    begin
+      
+      json_response = @cypher_interface.get(id.to_i)
+      return json_response['cypher']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Cypher not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_cypher_by_name(name)
+    # api supports name as alias for itemKey
+    json_response = @cypher_interface.list({name: name.to_s})
+    
+    cypher_items = json_response['cyphers']
+    if cypher_items.empty?
+      print_red_alert "Cypher not found by name #{name}"
+      return nil
+    elsif cypher_items.size > 1
+      print_red_alert "#{cypher_items.size} cyphers found by name #{name}"
+      rows = cypher_items.collect do |cypher_item|
+        {id: cypher_item['id'], name: cypher_item['name']}
+      end
+      print red
+      print as_pretty_table(rows, [:id, :name])
+      print reset,"\n"
+      return nil
+    else
+      return cypher_items[0]
+    end
+  end
+
+  def cypher_key_help
+    """
+Keys can have different behaviors depending on the specified mountpoint.
+Available Mountpoints:
+password - Generates a secure password of specified character length in the key pattern (or 15) with symbols, numbers, upper case, and lower case letters (i.e. password/15/mypass generates a 15 character password).
+tfvars - This is a module to store a tfvars file for terraform.
+secret - This is the standard secret module that stores a key/value in encrypted form.
+uuid - Returns a new UUID by key name when requested and stores the generated UUID by key name for a given lease timeout period.
+key - Generates a Base 64 encoded AES Key of specified bit length in the key pattern (i.e. key/128/mykey generates a 128-bit key)"""
+  end
+
+  def cypher_lease_help
+    """
+Lease time in MS (defaults to 32 days)
+Quick MS Time Reference:
+Day: 86400000
+Week: 604800000
+Month (30 days): 2592000000
+Year: 31536000000"""
+  end
+
+end
+