bosh_cli 0.19.1 → 0.19.2

data/lib/cli/commands/ssh.rb

@@ -22,9 +22,10 @@ module Bosh::Cli::Command
           args.shift
         end
       rescue ArgumentError, TypeError
+        # No index given
       end
 
-      ["public_key", "gateway_host", "gateway_user"].each do |option|
+      %w(public_key gateway_host gateway_user).each do |option|
         pos = args.index("--#{option}")
         if pos
           options[option] = args[pos + 1]
@@ -98,13 +99,13 @@ module Bosh::Cli::Command
                                    encrypt_password(password))
 
       unless results && results.kind_of?(Array) && !results.empty?
-        err("Error setting up ssh, #{results.inspect}, " \
+        err("Error setting up ssh, #{results.inspect}, " +
             "check task logs for more details")
       end
 
       results.each do |result|
         unless result.kind_of?(Hash)
-          err("Unexpected results #{results.inspect}, " \
+          err("Unexpected results #{results.inspect}, " +
               "check task logs for more details")
         end
       end

data/lib/cli/commands/stemcell.rb

@@ -59,19 +59,9 @@ module Bosh::Cli::Command
 
       say("\nUploading stemcell...\n")
 
-      status, message = director.upload_stemcell(stemcell.stemcell_file)
-
-      responses = {
-        :done => "Stemcell uploaded and created",
-        :non_trackable => "Uploaded stemcell but director at '#{target}' " +
-                          "doesn't support creation tracking",
-        :track_timeout => "Uploaded stemcell but timed out out " +
-                          "while tracking status",
-        :error => "Uploaded stemcell but received an error " +
-                  "while tracking status",
-      }
+      status, _ = director.upload_stemcell(stemcell.stemcell_file)
 
-      say(responses[status] || "Cannot upload stemcell: #{message}")
+      task_report(status, "Stemcell uploaded and created")
     end
 
     def list
@@ -147,41 +137,31 @@ module Bosh::Cli::Command
 
       url = yaml[stemcell_name]["url"]
       size = yaml[stemcell_name]["size"]
-      pBar = ProgressBar.new(stemcell_name, size)
-      pBar.file_transfer_mode
+      progress_bar = ProgressBar.new(stemcell_name, size)
+      progress_bar.file_transfer_mode
       File.open("#{stemcell_name}", "w") { |file|
         @http_client.get(url) do |chunk|
           file.write(chunk)
-          pBar.inc(chunk.size)
+          progress_bar.inc(chunk.size)
         end
       }
-      pBar.finish
+      progress_bar.finish
       puts("Download complete.")
     end
 
     def delete(name, version)
       auth_required
 
-      say("You are going to delete stemcell `#{name} (#{version})'".red)
+      say("You are going to delete stemcell `#{name}/#{version}'".red)
 
       unless confirmed?
         say("Canceled deleting stemcell".green)
         return
       end
 
-      status, message = director.delete_stemcell(name, version)
-
-      responses = {
-        :done => "Deleted stemcell #{name} (#{version})",
-        :non_trackable => "Stemcell delete in progress but director " +
-                          "at '#{target}' doesn't support task tracking",
-        :track_timeout => "Timed out out while tracking " +
-                          "stemcell deletion progress",
-        :error => "Attempted to delete stemcell but received an error " +
-                  "while tracking status",
-      }
+      status, _ = director.delete_stemcell(name, version)
 
-      say(responses[status] || "Cannot delete stemcell: #{message}")
+      task_report(status, "Deleted stemcell `#{name}/#{version}'")
     end
   end
 end

data/lib/cli/config.rb

@@ -107,8 +107,8 @@ module Bosh::Cli
     #     deployment file.
     def set_deployment(deployment_file_path)
       raise MissingTarget, "Must have a target set." if target.nil?
-      @config_file["deployment"] = { } if is_old_deployment_config?
-      @config_file["deployment"] ||= { }
+      @config_file["deployment"] = {} if is_old_deployment_config?
+      @config_file["deployment"] ||= {}
       @config_file["deployment"][target] = deployment_file_path
     end
 

data/lib/cli/core_ext.rb

@@ -108,7 +108,10 @@ module BoshStringExtensions
   end
 
   def colorize(color_code)
-    if Bosh::Cli::Config.colorize && COLOR_CODES[color_code]
+    if Bosh::Cli::Config.output.tty? &&
+       Bosh::Cli::Config.colorize &&
+       COLOR_CODES[color_code]
+
       "#{COLOR_CODES[color_code]}#{self}\e[0m"
     else
       self

data/lib/cli/deployment_helper.rb

@@ -163,7 +163,7 @@ module Bosh::Cli
       end
 
       if old_stemcells.size != new_stemcells.size
-        say("Stemcell update seems to be inconsistent with current " +
+        say("Stemcell update seems to be inconsistent with current ".red +
             "deployment. Please carefully review changes above.".red)
         unless confirmed?("Are you sure this configuration is correct?")
           cancel_deployment

data/lib/cli/director.rb

@@ -47,12 +47,15 @@ module Bosh
 
       def create_user(username, password)
         payload = JSON.generate("username" => username, "password" => password)
-        response_code, body = post("/users", "application/json", payload)
+        response_code, _ = post("/users", "application/json", payload)
         response_code == 204
       end
 
-      def upload_stemcell(filename)
-        upload_and_track("/stemcells", "application/x-compressed", filename)
+      def upload_stemcell(filename, options = {})
+        options = options.dup
+        options[:content_type] = "application/x-compressed"
+
+        upload_and_track(:post, "/stemcells", filename, options)
       end
 
       def get_version
@@ -92,6 +95,17 @@ module Bosh
         get_json("/releases/#{name}")
       end
 
+      def match_packages(manifest_yaml)
+        url = "/packages/matches"
+        status, body = post(url, "text/yaml", manifest_yaml)
+
+        if status == 200
+          JSON.parse(body)
+        else
+          err(parse_error_message(status, body))
+        end
+      end
+
       def get_deployment(name)
         status, body = get_json_with_status("/deployments/#{name}")
         if status == 404
@@ -108,43 +122,65 @@ module Bosh
         body
       end
 
-      def upload_release(filename)
-        upload_and_track("/releases", "application/x-compressed", filename)
+      def upload_release(filename, options = {})
+        options = options.dup
+        options[:content_type] = "application/x-compressed"
+
+        upload_and_track(:post, "/releases", filename, options)
       end
 
       def delete_stemcell(name, version, options = {})
-        request_and_track(:delete, "/stemcells/#{name}/#{version}")
+        options = options.dup
+        request_and_track(:delete, "/stemcells/#{name}/#{version}", options)
       end
 
       def delete_deployment(name, options = {})
+        options = options.dup
+        force = options.delete(:force)
+
         url = "/deployments/#{name}"
-        query_params = []
-        query_params << "force=true" if options[:force]
-        url += "?#{query_params.join("&")}" if query_params.size > 0
 
-        request_and_track(:delete, url)
+        extras = []
+        extras << "force=true" if force
+
+        request_and_track(:delete, add_query_string(url, extras), options)
       end
 
       def delete_release(name, options = {})
-        url = "/releases/#{name}"
+        options = options.dup
+        force = options.delete(:force)
+        version = options.delete(:version)
 
-        query_params = []
-        query_params << "force=true" if options[:force]
-        query_params << "version=#{options[:version]}" if options[:version]
+        url = "/releases/#{name}"
 
-        url += "?#{query_params.join("&")}" if query_params.size > 0
+        extras = []
+        extras << "force=true" if force
+        extras << "version=#{version}" if version
 
-        request_and_track(:delete, url)
+        request_and_track(:delete, add_query_string(url, extras), options)
       end
 
       def deploy(manifest_yaml, options = {})
+        options = options.dup
+
+        recreate = options.delete(:recreate)
+        options[:content_type] = "text/yaml"
+        options[:payload] = manifest_yaml
+
         url = "/deployments"
-        url += "?recreate=true" if options[:recreate]
-        request_and_track(:post, url, "text/yaml", manifest_yaml)
+
+        extras = []
+        extras << "recreate=true" if recreate
+
+        request_and_track(:post, add_query_string(url, extras), options)
       end
 
-      def setup_ssh(deployment_name, job, index, user, public_key, password)
+      def setup_ssh(deployment_name, job, index, user,
+                    public_key, password, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/ssh"
+
         payload = {
           "command" => "setup",
           "deployment_name" => deployment_name,
@@ -159,17 +195,19 @@ module Bosh
           }
         }
 
-        status, task_id, output =
-          request_and_track(:post, url, "application/json",
-                            JSON.generate(payload), :log_type => "result")
+        options[:payload] = JSON.generate(payload)
+        options[:content_type] = "application/json"
 
-        return nil if status != :done || task_id.nil?
+        status, task_id = request_and_track(:post, url, options)
 
-        JSON.parse(output)
+        # TODO: this needs to be done in command handler, not in director.rb
+        return nil if status != :done
+        JSON.parse(get_task_result_log(task_id))
       end
 
-      def cleanup_ssh(deployment_name, job, user_regex, indexes)
-        indexes ||= []
+      def cleanup_ssh(deployment_name, job, user_regex, indexes, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/ssh"
 
         payload = {
@@ -177,68 +215,90 @@ module Bosh
           "deployment_name" => deployment_name,
           "target" => {
             "job" => job,
-            "indexes" => indexes.compact
+            "indexes" => (indexes || []).compact
           },
           "params" => { "user_regex" => user_regex }
         }
 
-        request_and_track(:post, url, "application/json",
-                          JSON.generate(payload))
+        options[:payload] = JSON.generate(payload)
+        options[:content_type] = "application/json"
+
+        request_and_track(:post, url, options)
       end
 
       def change_job_state(deployment_name, manifest_yaml,
-          job_name, index, new_state)
+                           job_name, index, new_state, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/jobs/#{job_name}"
         url += "/#{index}" if index
         url += "?state=#{new_state}"
-        request_and_track(:put, url, "text/yaml", manifest_yaml)
+
+        options[:payload] = manifest_yaml
+        options[:content_type] = "text/yaml"
+
+        request_and_track(:put, url, options)
       end
 
+      # TODO: should pass 'force' with options, not as a separate argument
       def rename_job(deployment_name, manifest_yaml, old_name, new_name,
-                     force = nil)
+                     force = false, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/jobs/#{old_name}"
 
-        rename_params = ["new_name=#{new_name}"]
-        rename_params << "force=true" if force
+        extras = []
+        extras << "new_name=#{new_name}"
+        extras << "force=true" if force
 
-        url += "?#{rename_params.join("&")}" if rename_params.size > 0
-        request_and_track(:put, url, "text/yaml",
-                          manifest_yaml, :log_type => "event")
+        options[:content_type] = "text/yaml"
+        options[:payload] = manifest_yaml
+
+        request_and_track(:put, add_query_string(url, extras), options)
       end
 
-      def fetch_logs(deployment_name, job_name, index, log_type, filters = nil)
+      def fetch_logs(deployment_name, job_name, index, log_type,
+                     filters = nil, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/jobs/#{job_name}"
         url += "/#{index}/logs?type=#{log_type}&filters=#{filters}"
 
-        status, task_id = request_and_track(:get, url)
-        return nil if status != :done || task_id.nil?
+        status, task_id = request_and_track(:get, url, options)
+
+        # TODO: this should be done in command handler, not in director.rb
+        return nil if status != :done
         get_task_result(task_id)
       end
 
-      def fetch_vm_state(deployment_name)
+      def fetch_vm_state(deployment_name, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/vms?format=full"
 
-        status, task_id, output =
-          request_and_track(:get, url, nil, nil, :log_type => "result")
+        status, task_id = request_and_track(:get, url, options)
 
-        if status != :done || task_id.nil?
+        # TODO: this should be done in command handler, not in director.rb
+        if status != :done
           raise DirectorError, "Failed to fetch VMs information from director"
         end
 
+        output = get_task_result_log(task_id)
+
         output.to_s.split("\n").map do |vm_state|
           JSON.parse(vm_state)
         end
       end
 
       def download_resource(id)
-        status, tmp_file, headers = get("/resources/#{id}", nil,
-                                        nil, {}, :file => true)
+        status, tmp_file, _ = get("/resources/#{id}",
+                                  nil, nil, {}, :file => true)
 
         if status == 200
           tmp_file
         else
-          raise DirectorError, "Cannot download resource `#{id}': " +
-            "HTTP status #{status}"
+          raise DirectorError,
+                "Cannot download resource `#{id}': HTTP status #{status}"
         end
       end
 
@@ -269,9 +329,11 @@ module Bosh
         get_json(url)
       end
 
-      def perform_cloud_scan(deployment_name)
+      def perform_cloud_scan(deployment_name, options = {})
+        options = options.dup
         url = "/deployments/#{deployment_name}/scans"
-        request_and_track(:post, url)
+
+        request_and_track(:post, url, options)
       end
 
       def list_problems(deployment_name)
@@ -279,14 +341,18 @@ module Bosh
         get_json(url)
       end
 
-      def apply_resolutions(deployment_name, resolutions)
+      def apply_resolutions(deployment_name, resolutions, options = {})
+        options = options.dup
+
         url = "/deployments/#{deployment_name}/problems"
-        request_and_track(:put, url, "application/json",
-                          JSON.generate("resolutions" => resolutions))
+        options[:content_type] = "application/json"
+        options[:payload] = JSON.generate("resolutions" => resolutions)
+
+        request_and_track(:put, url, options)
       end
 
       def get_current_time
-        status, body, headers = get("/info")
+        _, _, headers = get("/info")
         Time.parse(headers[:date]) rescue nil
       end
 
@@ -320,11 +386,16 @@ module Bosh
         get_task(task_id)["result"]
       end
 
+      def get_task_result_log(task_id)
+        log, _ = get_task_output(task_id, 0, "result")
+        log
+      end
+
       def get_task_output(task_id, offset, log_type = nil)
         uri = "/tasks/#{task_id}/output"
         uri += "?type=#{log_type}" if log_type
 
-        headers = { "Range" => "bytes=#{offset}-" }
+        headers = {"Range" => "bytes=#{offset}-"}
         response_code, body, headers = get(uri, nil, nil, headers)
 
         if response_code == 206 &&
@@ -349,20 +420,28 @@ module Bosh
         end
       end
 
-      def request_and_track(method, uri, content_type = nil,
-                            payload = nil,options = {})
-        http_status, body, headers = request(method, uri, content_type, payload)
+      # Perform director HTTP request and track director task (if request
+      # started one).
+      # @param [Symbol] method HTTP method
+      # @param [String] uri URI
+      # @param [Hash] options Request and tracking options
+      def request_and_track(method, uri, options = {})
+        options = options.dup
+
+        content_type = options.delete(:content_type)
+        payload = options.delete(:payload)
+        track_opts = options
+
+        http_status, _, headers = request(method, uri, content_type, payload)
         location = headers[:location]
         redirected = http_status == 302
         task_id = nil
-        output = nil
 
         if redirected
           if location =~ /\/tasks\/(\d+)\/?$/ # Looks like we received task URI
             task_id = $1
-            tracker = Bosh::Cli::TaskTracker.new(self, task_id, options)
+            tracker = Bosh::Cli::TaskTracker.new(self, task_id, track_opts)
             status = tracker.track
-            output = tracker.output
           else
             status = :non_trackable
           end
@@ -370,13 +449,12 @@ module Bosh
           status = :failed
         end
 
-        [status, task_id, output]
+        [status, task_id]
       end
 
-      def upload_and_track(uri, content_type, filename, options = {})
+      def upload_and_track(method, uri, filename, options = {})
         file = FileWithProgressBar.open(filename, "r")
-        method = options[:method] || :post
-        request_and_track(method, uri, content_type, file, options)
+        request_and_track(method, uri, options.merge(:payload => file))
       ensure
         file.stop_progress_bar if file
       end
@@ -384,6 +462,8 @@ module Bosh
       def request(method, uri, content_type = nil, payload = nil,
                   headers = {}, options = {})
         headers = headers.dup
+        tmp_file = nil
+
         headers["Content-Type"] = content_type if content_type
 
         if options[:file]
@@ -429,16 +509,14 @@ module Bosh
       end
 
       def parse_error_message(status, body)
-        parsed_body = JSON.parse(body.to_s)
+        parsed_body = JSON.parse(body.to_s) rescue {}
 
         if parsed_body["code"] && parsed_body["description"]
-          "Director error %s: %s" % [parsed_body["code"],
-                                     parsed_body["description"]]
+          "Error %s: %s" % [parsed_body["code"],
+                            parsed_body["description"]]
         else
-          "Director error (HTTP %s): %s" % [status, body]
+          "HTTP %s: %s" % [status, body]
         end
-      rescue JSON::ParserError
-        "Director error (HTTP %s): %s" % [status, body]
       end
 
       private
@@ -463,7 +541,7 @@ module Bosh
 
       rescue HTTPClient::BadResponseError => e
         err("Received bad HTTP response from director: #{e}")
-      rescue URI::Error, SocketError, Errno::ECONNREFUSED, SystemCallError
+      rescue URI::Error, SocketError, SystemCallError
         raise # We handle these upstream
       rescue => e
         # httpclient (sadly) doesn't have a generic exception
@@ -478,13 +556,21 @@ module Bosh
       end
 
       def get_json_with_status(url)
-        status, body, headers = get(url, "application/json")
+        status, body, _ = get(url, "application/json")
         body = JSON.parse(body) if status == 200
         [status, body]
       rescue JSON::ParserError
         raise DirectorError, "Cannot parse director response: #{body}"
       end
 
+      def add_query_string(url, parts)
+        if parts.size > 0
+          "#{url}?#{parts.join("&")}"
+        else
+          url
+        end
+      end
+
     end
 
     class FileWithProgressBar < ::File