morpheus-cli 4.2.16 → 4.2.21

data/lib/morpheus/cli/deploy.rb

@@ -0,0 +1,374 @@
+require 'morpheus/cli/cli_command'
+require 'yaml'
+
+class Morpheus::Cli::Deploy
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::DeploymentsHelper
+
+  set_command_name :deploy
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @instances_interface = @api_client.instances
+    @deploy_interface = @api_client.deploy
+    @deployments_interface = @api_client.deployments
+  end
+
+  def handle(args)
+    options={}
+    optparse = Morpheus::Cli::OptionParser.new do|opts|
+      opts.banner = "Usage: morpheus deploy [environment]"
+      build_common_options(opts, options, [:auto_confirm, :remote, :dry_run])
+      opts.footer = <<-EOT
+Deploy to an instance using the morpheus.yml file, located in the working directory.
+[environment] is optional. Merge settings under environments.{environment}. Default is no environment.
+
+First this parses the morpheus.yml file and merges the specified environment settings.
+The specified instance must exist and the specified version must not exist.
+If the settings are valid, the new deployment version will be created and 
+all the specified files are uploaded to the new deployment version.
+Finally, it deploys the new version to the instance.
+
+The morpheus.yml should be located in the working directory.
+This file contains the information necessary to perform a deployment via the cli.
+
+File Settings
+==================
+
+* name - (required) The instance name we are deploying to and, by default, name of the deployment being created.
+* version - (required) The version identifier of the deployment being created (userVersion)
+* deployment - The name of the deployment being created, name is used by default
+* script - The initial script to run before looking for files to upload.
+* files - List of file patterns to use for uploading files and their target destination. 
+          Each item should contain path and pattern, path may be relative to the working directory, default pattern is: '**/*'
+* options - Map of deployment options depending on deployment type
+* post_script - A post operation script to be run on the local machine
+* stage_only - If set to true the deploy will only be staged and not actually run
+* environments - Map of objects that contain nested properties for each environment name
+
+It is possible to nest these properties in an "environments" map to override based on a passed environment.
+
+Example
+==================
+
+name: neatsite
+version: 5.0
+script: "rake build"
+files: 
+- path: build
+environments:
+  production:
+    files:
+    - path: production-build
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:0, max:1)
+    options[:options]['name'] = args[0] if args[0]
+    connect(options)
+    payload = {}
+    
+    environment = default_deploy_environment
+    if args.count > 0
+      environment = args[0]
+    end
+    if load_deploy_file().nil?
+      raise_command_error "Morpheus Deploy File `morpheus.yml` not detected. Please create one and try again."
+    end
+
+    # Parse and validate config, need instance + deployment + version + files
+    # name can be specified as a single value for both instance and deployment
+
+    deploy_args = merged_deploy_args(environment)
+
+    instance_name = deploy_args['name']
+    if deploy_args['instance'].is_a?(String)
+      instance_name = deploy_args['instance']
+    end
+    if instance_name.nil?
+      raise_command_error "Instance not specified. Please specify the instance name and try again."
+    end
+
+    deployment_name = deploy_args['name'] || instance_name
+    if deploy_args['deployment'].is_a?(String)
+      deployment_name = deploy_args['deployment']
+    end
+    
+    version_number = deploy_args['version']
+    if version_number.nil?
+      raise_command_error "Version not specified. Please specify the version and try again."
+    end
+
+    instance_results = @instances_interface.list(name: instance_name)
+    if instance_results['instances'].empty?
+      raise_command_error "Instance not found by name '#{instance_name}'"
+    end
+    instance = instance_results['instances'][0]
+    instance_id = instance['id']
+
+    # ok do it
+    # fetch/create deployment, create deployment version, upload files, and deploy it to instance.
+
+    print_h1 "Morpheus Deployment"
+
+    columns = {
+      "Instance" => :name,
+      "Deployment" => :deployment,
+      "Version" => :version,
+      "Script" => :script,
+      "Post Script" => :post_script,
+      "Files" => :files,
+      "Environment" => :environment,
+    }
+    pretty_file_config = deploy_args['files'].collect {|it|
+      [(it['path'] ? "path: #{it['path']}" : nil), (it['pattern'] ? "pattern: #{it['pattern']}" : nil)].compact.join(", ")
+    }.join(", ")
+    deploy_settings = {
+      :name => instance_name,
+      :deployment => deployment_name,
+      :version => version_number,
+      :script => deploy_args['script'],
+      :post_script => deploy_args['post_script'],
+      :files => pretty_file_config,
+      # :files => deploy_args['files'],
+      # :files => deploy_files.size,
+      # :file_config => (deploy_files.size == 1 ? deploy_files[0][:destination] : deploy_args['files'])
+      :environment => environment
+    }
+    columns.delete("Script") if deploy_settings[:script].nil?
+    columns.delete("Post Script") if deploy_settings[:post_script].nil?
+    columns.delete("Environment") if deploy_settings[:environment].nil?
+    print_description_list(columns, deploy_settings)
+    print reset, "\n"
+
+    if !deploy_args['script'].nil?
+      # do this for dry run too since this is usually what creates the files to be uploaded
+      print cyan, "Executing Pre Deploy Script...", reset, "\n"
+      puts "running command: #{deploy_args['script']}"
+      if !system(deploy_args['script'])
+        raise_command_error "Error executing pre script..."
+      end
+    end
+
+    # Find Files to Upload
+    deploy_files = []
+    if deploy_args['files'].nil? || deploy_args['files'].empty? || !deploy_args['files'].is_a?(Array)
+      raise_command_error "Files not specified. Please specify files array, each item may specify a path or pattern of file(s) to upload"
+    else
+      #print "\n",cyan, "Finding Files...", reset, "\n"
+      current_working_dir = Dir.pwd
+      deploy_args['files'].each do |fmap|
+        Dir.chdir(fmap['path'] || current_working_dir)
+        files = Dir.glob(fmap['pattern'] || '**/*')
+        files.each do |file|
+          if File.file?(file)
+            destination = file.split("/")[0..-2].join("/")
+            # deploy_files << {filepath: File.expand_path(file), destination: destination}
+            deploy_files << {filepath: File.expand_path(file), destination: file}
+          end
+        end
+      end
+      #print cyan, "Found #{deploy_files.size} Files to Upload!", reset, "\n"
+      Dir.chdir(current_working_dir)
+    end
+
+    if deploy_files.empty?
+      raise_command_error "0 files found for: #{deploy_args['files'].inspect}"
+    else
+      print cyan, "Found #{deploy_files.size} Files to Upload!", reset, "\n"
+    end
+
+    unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to create deployment version #{version_number} (#{deploy_files.size} #{deploy_files.size == 1 ? 'file' : 'files'}) and deploy it to instance #{instance['name']}?")
+      return 9, "aborted command"
+    end
+    
+    # Find or Create Deployment
+    deployment = nil
+    deployments = @deployments_interface.list(name: deployment_name)['deployments']
+
+    @instances_interface.setopts(options)
+    @deploy_interface.setopts(options)
+    @deployments_interface.setopts(options)
+
+    if deployments.size > 1
+      raise_command_error "#{deployments.size} deployment versions found by deployment '#{name}'"
+    elsif deployments.size == 1
+      deployment = deployments[0]
+      # should update here, eg description
+    else
+      # create it
+      payload = {
+        'deployment' => {
+          'name' => deployment_name
+        } 
+      }
+      payload['deployment']['description'] = deploy_args['description'] if deploy_args['description']
+      
+      if options[:dry_run]
+        print_dry_run @deployments_interface.dry.create(payload)
+        # return 0, nil
+        deployment = {'id' => ':deploymentId', 'name' => deployment_name}
+      else
+        json_response = @deployments_interface.create(payload)
+        deployment = json_response['deployment']
+      end
+    end
+
+    # Find or Create Deployment Version
+    # Actually, for now this this errors if the version already exists, but it should update it.
+
+    @deployments_interface = @api_client.deployments
+    deployment_version = nil
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.list_versions(deployment['id'], {userVersion: version_number})
+      # return 0, nil
+      #deployment_versions =[{'id' => ':versionId', 'version' => version_number}]
+      deployment_versions = []
+    else
+      deployment_versions = @deployments_interface.list_versions(deployment['id'], {userVersion: version_number})['versions']
+      @deployments_interface.setopts(options)
+    end
+    
+
+    if deployment_versions.size > 0
+      raise_command_error "Deployment '#{deployment['name']}' version '#{version_number}' already exists. Specify a new version or delete the existing version."
+    # if deployment_versions.size > 1
+    #   raise_command_error "#{deployment_versions.size} versions found by version '#{name}'"
+    # elsif deployment_versions.size == 1
+    #   deployment_version = deployment_versions[0]
+    #   # should update here, eg description
+    else
+      # create it
+      payload = {
+        'version' => {
+          'userVersion' => version_number,
+          'deployType' => (deploy_args['type'] || deploy_args['deployType'] || 'file')
+        } 
+      }
+      payload['version']['fetchUrl'] = deploy_args['fetchUrl'] if deploy_args['fetchUrl']
+      payload['version']['gitUrl'] = deploy_args['gitUrl'] if deploy_args['gitUrl']
+      payload['version']['gitRef'] = deploy_args['gitRef'] if deploy_args['gitRef']
+      
+      if options[:dry_run]
+        print_dry_run @deployments_interface.dry.create_version(deployment['id'], payload)
+        # return 0, nil
+        deployment_version = {'id' => ':versionId', 'version' => version_number}
+      else
+        json_response = @deployments_interface.create_version(deployment['id'], payload)
+        deployment_version = json_response['version']
+      end
+    end
+
+    
+    # Upload Files
+    if deploy_files && !deploy_files.empty?
+      print "\n",cyan, "Uploading #{deploy_files.size} Files...", reset, "\n"
+      current_working_dir = Dir.pwd
+      deploy_files.each do |f|
+        destination = f[:destination]
+        if options[:dry_run]
+          print_dry_run @deployments_interface.upload_file(deployment['id'], deployment_version['id'], f[:filepath], f[:destination])
+        else
+          print cyan,"  - Uploading #{f[:destination]} ...", reset if !options[:quiet]
+          upload_result = @deployments_interface.upload_file(deployment['id'], deployment_version['id'], f[:filepath], f[:destination])
+          #print green + "SUCCESS" + reset + "\n" if !options[:quiet]
+          print reset, "\n" if !options[:quiet]
+        end
+      end
+      print cyan, "Upload Complete!", reset, "\n"
+      Dir.chdir(current_working_dir)
+    else
+      print "\n",cyan, "0 files to upload", reset, "\n"
+    end
+
+    # TODO: support deploying other deployTypes too, git and fetch
+
+    if !deploy_args['post_script'].nil?
+      print cyan, "Executing Post Script...", reset, "\n"
+      puts "running command: #{deploy_args['post_script']}"
+      if !system(deploy_args['post_script'])
+        raise_command_error "Error executing post script..."
+      end
+    end
+
+    # JD: restart for evars eh?
+    if deploy_args['env']
+      evars = []
+      deploy_args['env'].each_pair do |key, value|
+        evars << {name: key, value: value, export: false}
+      end
+      payload = {envs: evars}
+      if options[:dry_run]
+        print_dry_run @instances_interface.dry.create_env(instance_id, payload)
+        print_dry_run @instances_interface.dry.restart(instance_id)
+      else
+        @instances_interface.create_env(instance_id, payload)
+        @instances_interface.restart(instance_id)
+      end
+    end
+    # Create the AppDeploy, this does the deploy async (as of 4.2.2-3)
+    payload = {'appDeploy' => {} }
+    payload['appDeploy']['versionId'] = deployment_version['id']
+    if deploy_args['options']
+      payload['appDeploy']['config'] = deploy_args['options']
+    end
+    # stageOnly means do not actually deploy yet, can invoke @deploy_interface.deploy(deployment['id']) later
+    # there is no cli command for that yet though..
+    stage_only = deploy_args['stage_deploy'] || deploy_args['stage_only'] || deploy_args['stageOnly']
+    if stage_only
+      payload['appDeploy']['stageOnly'] = true
+    end
+    app_deploy_id = nil
+    if options[:dry_run]
+      print_dry_run @deploy_interface.dry.create(instance_id, payload)
+      # return 0, nil
+      app_deploy_id = ':appDeployId'
+    else
+      # Create a new appDeploy record, without stageOnly, this actually does the deployment
+      print cyan, "Deploying #{deployment_name} version #{version_number} to instance #{instance_name} ...", reset, "\n"
+      deploy_result = @deploy_interface.create(instance_id, payload)
+      app_deploy = deploy_result['appDeploy']
+      app_deploy_id = app_deploy['id']
+      print_green_success "Deploy Successful!"
+    end
+    return 0, nil
+  end
+
+  protected
+
+  # Loads a morpheus.yml file from within the current working directory.
+  # This file contains information necessary to perform a deployment via the cli.
+  #
+  # === Example File Attributes
+  # * +script+ - The initial script to run before uploading files
+  # * +name+ - The instance name we are deploying to (can be overridden in CLI)
+  # * +files+ - List of file patterns to use for uploading files and their target destination
+  # * +options+ - Map of deployment options depending on deployment type
+  # * +post_script+ - A post operation script to be run on the local machine
+  # * +stage_deploy+ - If set to true the deploy will only be staged and not actually run
+  #
+  # +NOTE: + It is also possible to nest these properties in an "environments" map to override based on a passed environment deploy name
+  #
+  def load_deploy_file
+    if !File.exist? "morpheus.yml"
+      puts "No morpheus.yml file detected in the current directory. Nothing to do."
+      return nil
+    end
+
+    @deploy_file = YAML.load_file("morpheus.yml")
+    return @deploy_file
+  end
+
+  def merged_deploy_args(environment)
+    deploy_args = @deploy_file.reject { |key,value| key == 'environment'}
+    if environment && !@deploy_file['environment'].nil? && !@deploy_file['environment'][environment].nil?
+      deploy_args = deploy_args.merge(@deploy_file['environment'][environment])
+    end
+    return deploy_args
+  end
+
+  def default_deploy_environment
+    nil
+  end
+
+end

data/lib/morpheus/cli/deployments.rb

@@ -1,12 +1,12 @@
-require 'io/console'
-require 'rest_client'
-require 'optparse'
 require 'morpheus/cli/cli_command'
 
 class Morpheus::Cli::Deployments
   include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::DeploymentsHelper
 
-  register_subcommands :list, :add, :update, :remove, {:versions => 'list_versions'}
+  register_subcommands :list, :get, :add, :update, :remove
+  register_subcommands :list_versions, :get_version, :add_version, :update_version, :remove_version
+  alias_subcommand :versions, :'list-versions'
 
   def initialize()
     # @appliance_name, @appliance_url = Morpheus::Cli::Remote.active_appliance
@@ -14,7 +14,7 @@ class Morpheus::Cli::Deployments
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
-    @deployments_interface = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url).deployments
+    @deployments_interface = @api_client.deployments
   end
 
   def handle(args)
@@ -23,264 +23,588 @@ class Morpheus::Cli::Deployments
 
   def list(args)
     options = {}
+    params = {}
+    ref_ids = []
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage()
-      build_common_options(opts, options, [:list, :json, :dry_run, :remote])
+      opts.banner = subcommand_usage("[search]")
+      build_standard_list_options(opts, options)
+      opts.footer = "List deployments."
     end
     optparse.parse!(args)
     connect(options)
-    begin
-      params = {}
-      [:phrase, :offset, :max, :sort, :direction].each do |k|
-        params[k] = options[k] unless options[k].nil?
-      end
-      @deployments_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @deployments_interface.dry.list(params)
-        return
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.list(params)
+      return
+    end
+    json_response = @deployments_interface.list(params)
+    deployments = json_response['deployments']
+    render_response(json_response, options, 'deployments') do
+      print_h1 "Morpheus Deployments", parse_list_subtitles(options), options
+      if deployments.empty?
+        print cyan,"No deployments found.",reset,"\n"
+      else
+        print as_pretty_table(deployments, deployment_column_definitions.upcase_keys!, options)
+        print_results_pagination(json_response)
       end
-      json_response = @deployments_interface.list(params)
-      if options[:json]
-        puts JSON.pretty_generate(json_response)
+      print reset,"\n"
+    end
+    if deployments.empty?
+      return 1, "no deployments found"
+    else
+      return 0, nil
+    end
+  end
+
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[deployment]")
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a specific deployment.
+[deployment] is required. This is the name or id of a deployment.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    id_list = parse_id_list(args)
+    # lookup IDs if names are given
+    id_list = id_list.collect do |id|
+      if id.to_s =~ /\A\d{1,}\Z/
+        id
       else
-        deployments = json_response['deployments']
-        print_h1 "Morpheus Deployments"
-        if deployments.empty?
-          print cyan,"No deployments found.",reset,"\n"
+        deployment = find_deployment_by_name(id)
+        if deployment
+          deployment['id']
         else
-          print cyan
-          rows = deployments.collect do |deployment|
-            {name: deployment['name'], id: deployment['id'], description: deployment['description'], updated: format_local_dt(deployment['lastUpdated'])}
-          end
-          columns = [:id, :name, :description, :updated]
-          print as_pretty_table(rows, columns, options)
+          raise_command_error "deployment not found for name '#{id}'"
         end
-        print reset,"\n"
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+    end
+    return run_command_for_each_arg(id_list) do |arg|
+      _get(arg, params, options)
     end
   end
 
+  def _get(id, params, options)
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.get(id, params)
+      print_dry_run @deployments_interface.dry.list_versions(id, {})
+      return
+    end
+    json_response = @deployments_interface.get(id, params)
+    deployment_versions = @deployments_interface.list_versions(id)['versions']
+    deployment = json_response['deployment']
+    render_response(json_response, options, 'deployment') do
+      print_h1 "Deployment Details", [], options
+      print cyan
+      print_description_list(deployment_column_definitions, deployment)
+      print_h2 "Versions", options
+      if deployment_versions.empty?
+        print cyan,"No versions found.",reset,"\n"
+      else
+        print as_pretty_table(deployment_versions, deployment_version_column_definitions.upcase_keys!, options)
+        print_results_pagination({'size' => deployment_versions.size(), 'total' => deployment['versionCount']}, {:label => "version", :n_label => "versions"})
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
   def list_versions(args)
+    params = {}
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage("[name] versions")
-      build_common_options(opts, options, [:list, :json, :dry_run, :remote])
+      opts.banner = subcommand_usage("[deployment] [search]")
+      build_standard_list_options(opts, options)
+      opts.footer = <<-EOT
+List versions of a specific deployment.
+[deployment] is required. This is the name or id of a deployment.
+EOT
     end
     optparse.parse!(args)
-    if args.count < 1
-      puts optparse
-      exit 1
-    end
+    verify_args!(args:args, optparse:optparse, min:1,max:2)
     deployment_name  = args[0]
+    if args.count > 1
+      options[:phrase] = args[1]
+    end
     connect(options)
-    begin
-      params = {}
-      [:phrase, :offset, :max, :sort, :direction].each do |k|
-        params[k] = options[k] unless options[k].nil?
-      end
-      deployment = find_deployment_by_name_or_id(deployment_name)
-      exit 1 if deployment.nil?
-      @deployments_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @deployments_interface.dry.list_versions(deployment['id'],params)
-        return
-      end
-      json_response = @deployments_interface.list_versions(deployment['id'],params)
-      if options[:json]
-        puts JSON.pretty_generate(json_response)
+    params.merge!(parse_list_options(options))
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.list(params)
+      return
+    end
+    deployment = find_deployment_by_name_or_id(deployment_name)
+    exit 1 if deployment.nil?
+    json_response = @deployments_interface.list_versions(deployment['id'], params)
+    deployment_versions = json_response['versions']
+    render_response(json_response, options, 'versions') do
+      print_h1 "Deployment Versions", ["#{deployment['name']}"] + parse_list_subtitles(options), options
+      if deployment_versions.empty?
+        print cyan,"No versions found.",reset,"\n"
       else
-        versions = json_response['versions']
-        print_h1 "Deployment Versions: #{deployment['name']}"
-        if versions.empty?
-          print cyan,"No deployment versions found.",reset,"\n"
-        else
-          print cyan
-          rows = versions.collect do |version|
-            {version: version['userVersion'], type: version['deployType'], updated: format_local_dt(version['lastUpdated'])}
-          end
-          columns = [:version, :type, :updated]
-          print as_pretty_table(rows, columns, options)
-        end
-        print reset,"\n"
+        print as_pretty_table(deployment_versions, deployment_version_column_definitions.upcase_keys!, options)
+        print_results_pagination(json_response)
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+      print reset,"\n"
+    end
+    if deployment_versions.empty?
+      return 1, "no versions found"
+    else
+      return 0, nil
     end
   end
 
-  def update(args)
-    deployment_name = args[0]
+  def add(args)
     options = {}
-    account_name = nil
+    params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[name] [options]")
-      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+      build_option_type_options(opts, options, add_deployment_option_types)
+      build_option_type_options(opts, options, add_deployment_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new deployment.
+EOT
     end
     optparse.parse!(args)
-    if args.count < 1
-      puts optparse
-      exit 1
-    end
+    verify_args!(args:args, optparse:optparse, min:0, max:1)
+    options[:options]['name'] = args[0] if args[0]
     connect(options)
-    begin
-      deployment = find_deployment_by_name_or_id(deployment_name)
-      exit 1 if deployment.nil?
-
-      #params = Morpheus::Cli::OptionTypes.prompt(add_user_option_types, options[:options], @api_client, options[:params]) # options[:params] is mysterious
-      params = options[:options] || {}
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'deployment' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'deployment' => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_deployment_option_types, options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(add_deployment_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload['deployment'].deep_merge!(params)
+    end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.create(payload)
+      return 0, nil
+    end
+    json_response = @deployments_interface.create(payload)
+    deployment = json_response['deployment']
+    render_response(json_response, options, 'deployment') do
+      print_green_success "Added deployment #{deployment['name']}"
+      return _get(deployment["id"], {}, options)
+    end
+    return 0, nil
+  end
 
-      if params.empty?
-        puts optparse
-        option_lines = update_deployment_option_types().collect {|it| "\t-O #{it['fieldContext'] ? (it['fieldContext'] + '.') : ''}#{it['fieldName']}=\"value\"" }.join("\n")
-        puts "\nAvailable Options:\n#{option_lines}\n\n"
-        exit 1
+  def update(args)
+    options = {}
+    params = {}
+    payload = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[deployment] [options]")
+      build_option_type_options(opts, options, update_deployment_option_types)
+      build_option_type_options(opts, options, update_deployment_advanced_option_types)
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Update a deployment.
+[deployment] is required. This is the name or id of a deployment.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    deployment = find_deployment_by_name_or_id(args[0])
+    return 1 if deployment.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'deployment' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'deployment' => parse_passed_options(options)})
+      # do not prompt on update
+      v_prompt = Morpheus::Cli::OptionTypes.no_prompt(update_deployment_option_types, options[:options], @api_client, options[:params])
+      v_prompt.deep_compact!
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(update_deployment_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload.deep_merge!({'deployment' => params})
+      if payload['deployment'].empty? # || options[:no_prompt]
+        raise_command_error "Specify at least one option to update.\n#{optparse}"
       end
+    end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.update(deployment['id'], payload)
+      return
+    end
+    json_response = @deployments_interface.update(deployment['id'], payload)
+    deployment = json_response['deployment']
+    render_response(json_response, options, 'deployment') do
+      print_green_success "Updated deployment #{deployment['name']}"
+      return _get(deployment["id"], {}, options)
+    end
+    return 0, nil
+  end
 
-      #puts "parsed params is : #{params.inspect}"
-      deployment_keys = ['name','description']
-      changes_payload = (params.select {|k,v| deployment_keys.include?(k) })
-      deployment_payload = deployment
-      if changes_payload
-        deployment_payload.merge!(changes_payload)
-      end
+  def remove(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[deployment] [options]")
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete a deployment.
+[deployment] is required. This is the name or id of a deployment.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    deployment = find_deployment_by_name_or_id(args[0])
+    return 1 if deployment.nil?
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.destroy(deployment['id'], params)
+      return
+    end
+    json_response = @deployments_interface.destroy(deployment['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed deployment #{deployment['name']}"
+    end
+    return 0, nil
+  end
 
+  def get_version(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[deployment] [version] [options]")
+      build_option_type_options(opts, options, add_deployment_version_option_types)
+      build_option_type_options(opts, options, add_deployment_version_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new deployment version.
+[deployment] is required. This is the name or id of a deployment.
+[version] is required. This is the deployment version identifier
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:2)
+    connect(options)
 
-      payload = {deployment: deployment_payload}
-      @deployments_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @deployments_interface.dry.update(deployment['id'], payload)
-        return
+    deployment = find_deployment_by_name_or_id(args[0])
+    return 1 if deployment.nil?
+    id = args[1]
+    if id.to_s =~ /\A\d{1,}\Z/
+      id = id.to_i
+    else
+      deployment_version = find_deployment_version_by_name(deployment['id'], id)
+      if deployment_version
+        id = deployment_version['id']
+      else
+        # raise_command_error "deployment not found for name '#{id}'"
+        return 1, "deployment version not found for name '#{id}'"
       end
-      response = @deployments_interface.update(deployment['id'], payload)
-      if options[:json]
-        print JSON.pretty_generate(json_response)
-        if !response['success']
-          exit 1
-        end
+    end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.get_version(deployment['id'], id, params)
+      return
+    end
+    json_response = @deployments_interface.get_version(deployment['id'], id, params)
+    deployment_version = json_response['version']
+    render_response(json_response, options, 'version') do
+      # print_h1 "Deployment Version Details", [deployment['name']], options
+      print_h1 "Deployment Version Details", [], options
+      print cyan
+      #columns = deployment_version_column_definitions
+      columns = {
+        "ID" => 'id',
+        "Deployment" => lambda {|it| deployment['name'] },
+        "Version" => 'userVersion',
+        "Deploy Type" => lambda {|it| it['deployType'] },
+        "URL" => lambda {|it| 
+          if it['deployType'] == 'fetch'
+            "#{it['fetchUrl']}"
+          elsif it['deployType'] == 'git'
+            "#{it['gitUrl']}"
+          end
+        },
+        "Ref" => lambda {|it| 
+          if it['deployType'] == 'git'
+            "#{it['gitRef']}"
+          end
+        },
+        "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+        "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+      }
+      if deployment_version['deployType'] == 'git'
+        columns['Git URL'] = columns['URL']
+      elsif deployment_version['deployType'] == 'fetch'
+        columns['Fetch URL'] = columns['URL']
+        columns.delete('Ref')
       else
-        print "\n", cyan, "Deployment #{response['deployment']['name']} updated", reset, "\n\n"
+        columns.delete('URL')
+        columns.delete('Ref')
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+      print_description_list(columns, deployment_version)
+      print reset,"\n"
     end
+    return 0, nil
   end
 
-  def add(args)
+  def add_version(args)
     options = {}
+    params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage("[name]")
-      opts.on( '-d', '--description DESCRIPTION', "Description" ) do |val|
-        options[:description] = val
-      end
-      build_common_options(opts, options, [:options, :json, :dry_run, :remote])
+      opts.banner = subcommand_usage("[deployment] [version] [options]")
+      build_option_type_options(opts, options, add_deployment_version_option_types)
+      build_option_type_options(opts, options, add_deployment_version_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new deployment version.
+[deployment] is required. This is the name or id of a deployment.
+[version] is required. This is the deployment version identifier
+EOT
     end
     optparse.parse!(args)
-    if args.count < 1
-      puts optparse
-      exit 1
-    end
-    deployment_name = args[0]
+    verify_args!(args:args, optparse:optparse, min:0, max:2)
     connect(options)
-    begin
-      payload = {deployment: {name: deployment_name, description: options[:description]}}
-      @deployments_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @deployments_interface.dry.create(payload)
-        return
-      end
-      json_response = @deployments_interface.create(payload)
-      if options[:json]
-        print JSON.pretty_generate(json_response)
-      else
-        print "\n", cyan, "Deployment #{json_response['deployment']['name']} created successfully", reset, "\n\n"
-      end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+    deployment = nil
+    if args[0]
+      deployment = find_deployment_by_name_or_id(args[0])
+      return 1 if deployment.nil?
+    else
+      deployment_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'deploymentId', 'fieldLabel' => 'Deployment', 'type' => 'select', 'required' => true, 'description' => 'Deployment to add version to', 'optionSource' => lambda { |api_client, api_params|
+        @deployments_interface.list(max:10000)['deployments'].collect {|it|
+          {'name' => it['name'], 'value' => it['id']}
+        }
+      }}], options[:options])['deploymentId']
+      deployment = {'id' => deployment_id.to_i}
+    end
+    options[:options]['userVersion'] = args[1] if args[1]
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'version' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'version' => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_deployment_version_option_types, options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(add_deployment_version_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload['version'].deep_merge!(params)
+    end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.create_version(deployment['id'], payload)
+      return 0, nil
+    end
+    json_response = @deployments_interface.create_version(deployment['id'], payload)
+    deployment_version = json_response['version']
+    render_response(json_response, options, 'version') do
+      print_green_success "Added deployment version #{deployment_version['userVersion']}"
+      return get_version([deployment["id"], deployment_version['id']] + (options[:remote] ? ["-r",options[:remote]] : []))
     end
   end
 
-  def remove(args)
+  def update_version(args)
     options = {}
+    params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage("[name]")
-      build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :remote])
+      opts.banner = subcommand_usage("[deployment] [version] [options]")
+      build_option_type_options(opts, options, update_deployment_version_option_types)
+      build_option_type_options(opts, options, update_deployment_version_advanced_option_types)
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Update a deployment version.
+[deployment] is required. This is the name or id of a deployment.
+[version] is required. This is the deployment version identifier
+EOT
     end
     optparse.parse!(args)
-    if args.count < 1
-      puts optparse
-      exit 1
+    verify_args!(args:args, optparse:optparse, min:0, max:2)
+    connect(options)
+    deployment = find_deployment_by_name_or_id(args[0])
+    return 1 if deployment.nil?
+    deployment_version = find_deployment_version_by_name_or_id(deployment['id'], args[1])
+    return 1 if deployment_version.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'version' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'version' => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.no_prompt(update_deployment_version_option_types, options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(update_deployment_version_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload['version'].deep_merge!(params)
+    end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.update_version(deployment['id'], deployment_version['id'], payload)
+      return 0, nil
+    end
+    json_response = @deployments_interface.update_version(deployment['id'], deployment_version['id'], payload)
+    deployment_version = json_response['version']
+    render_response(json_response, options, 'version') do
+      print_green_success "Updated deployment version #{deployment_version['userVersion']}"
+      return get_version([deployment["id"], deployment_version['id']] + (options[:remote] ? ["-r",options[:remote]] : []))
+    end
+  end
+
+  def remove_version(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[deployment] [version] [options]")
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete a deployment version.
+[deployment] is required. This is the name or id of a deployment.
+[version] is required. This is the version identifier of a deployment version.
+EOT
     end
-    deployment_name = args[0]
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:2)
     connect(options)
-    begin
-      deployment = find_deployment_by_name_or_id(deployment_name)
-      exit 1 if deployment.nil?
-      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the deployment #{deployment['name']}?")
-        exit
-      end
-      @deployments_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @deployments_interface.dry.destroy(deployment['id'])
-        return
-      end
-      json_response = @deployments_interface.destroy(deployment['id'])
-      if options[:json]
-        print JSON.pretty_generate(json_response)
+    deployment = find_deployment_by_name_or_id(args[0])
+    return 1 if deployment.nil?
+    id = args[1]
+
+    if id.to_s =~ /\A\d{1,}\Z/
+      id = id.to_i
+    else
+      deployment_version = find_deployment_version_by_name(deployment['id'], id)
+      if deployment_version
+        id = deployment_version['id']
       else
-        print "\n", cyan, "Deployment #{deployment['name']} removed", reset, "\n\n"
+        # raise_command_error "deployment not found for '#{id}'"
+        return 1, "deployment version not found for '#{id}'"
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
     end
+    @deployments_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @deployments_interface.dry.destroy(deployment['id'], params)
+      return
+    end
+    json_response = @deployments_interface.destroy(deployment['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed deployment version #{deployment_version['userVersion']}"
+    end
+    return 0, nil
   end
 
-
   private
-  def find_deployment_by_name_or_id(val)
-    raise "find_deployment_by_name_or_id passed a bad name: #{val.inspect}" if val.to_s == ''
-    results = @deployments_interface.get(val)
-    result = nil
-    if !results['deployments'].nil? && !results['deployments'].empty?
-      result = results['deployments'][0]
-    elsif val.to_i.to_s == val
-      results = @deployments_interface.get(val.to_i)
-      result = results['deployment']
-    end
-    if result.nil?
-      print_red_alert "Deployment not found by '#{val}'"
-      return nil
-    end
-    return result
+
+  def deployment_column_definitions
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Versions" => lambda {|it| it['versionCount'] },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  # this is not so simple, need to first choose select instance, host or provider
+  def add_deployment_option_types
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
+      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'displayOrder' => 1}
+    ]
+  end
+
+  def add_deployment_advanced_option_types
+    []
   end
 
-  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
+  def update_deployment_option_types
+    add_deployment_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
   end
 
-  def update_deployment_option_types()
+  def update_deployment_advanced_option_types
+    add_deployment_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+  ## Deployment Versions
+
+  def deployment_version_column_definitions
+    {
+      "ID" => 'id',
+      "Version" => 'userVersion',
+      "Deploy Type" => lambda {|it| it['deployType'] },
+      "URL" => lambda {|it| 
+        if it['deployType'] == 'fetch'
+          "#{it['fetchUrl']}"
+        elsif it['deployType'] == 'git'
+          "#{it['gitUrl']}"
+        end
+      },
+      "Ref" => lambda {|it| 
+        if it['deployType'] == 'git'
+          "#{it['gitRef']}"
+        end
+      },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  # this is not so simple, need to first choose select instance, host or provider
+  def add_deployment_version_option_types
     [
-      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 0},
-      {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false, 'displayOrder' => 1}
+      {'fieldName' => 'userVersion', 'fieldLabel' => 'Version', 'type' => 'text', 'required' => true, 'displayOrder' => 1, 'description' => 'This is the deployment version identifier (userVersion)'},
+      {'fieldName' => 'deployType', 'fieldLabel' => 'Deploy Type', 'type' => 'select', 'optionSource' => 'deployTypes', 'required' => true, 'displayOrder' => 1, 'description' => 'This is the deployment version identifier (userVersion)', 'defaultValue' => 'file', 'code' => 'deployment.deployType'},
+      {'fieldName' => 'fetchUrl', 'fieldLabel' => 'Fetch URL', 'type' => 'select', 'optionSource' => 'deployTypes', 'required' => true, 'displayOrder' => 1, 'description' => 'The URL to fetch the deployment file(s) from.', 'dependsOnCode' => 'deployment.deployType:fetch'},
+      {'fieldName' => 'gitUrl', 'fieldLabel' => 'Git URL', 'type' => 'string', 'required' => true, 'displayOrder' => 1, 'description' => 'The URL to fetch the deployment file(s) from.', 'dependsOnCode' => 'deployment.deployType:git'},
+      {'fieldName' => 'gitRef', 'fieldLabel' => 'Git Ref', 'type' => 'string', 'displayOrder' => 1, 'description' => 'The Git Reference to use, this the branch or tag name, defaults to master.', 'dependsOnCode' => 'deployment.deployType:git'}
     ]
   end
+
+  def add_deployment_version_advanced_option_types
+    []
+  end
+
+  def update_deployment_version_option_types
+    add_deployment_version_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+  def update_deployment_version_advanced_option_types
+    add_deployment_version_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
 end