bosh_cli 1.3160.0 → 1.3163.0

data/lib/cli/commands/instances.rb

@@ -1,5 +1,3 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module Bosh::Cli::Command
   class Instances < Base
     usage 'instances'
@@ -9,7 +7,7 @@ module Bosh::Cli::Command
     option '--vitals', 'Return instance vitals information'
     option '--ps', "Return instance process information"
     option '--failing', "Only show failing ones"
-    def list()
+    def list
       auth_required
       deployment_required
       manifest = Bosh::Cli::Manifest.new(deployment, director)
@@ -30,7 +28,6 @@ module Bosh::Cli::Command
 
     def show_deployment(name, options={})
       instances = director.fetch_vm_state(name)
-      instance_count = instances.size
 
       if instances.empty?
         nl
@@ -39,43 +36,58 @@ module Bosh::Cli::Command
         return
       end
 
-      sorted = instances.sort do |a, b|
-        s = a['job_name'].to_s <=> b['job_name'].to_s
-        s = a['index'].to_i <=> b['index'].to_i if s == 0
-        s = a['resource_pool'].to_s <=> b['resource_pool'].to_s if s == 0
-        s
+      sorted = sort(instances)
+
+      instances_table, row_count = construct_table_to_display(options, sorted)
+
+      if options[:failing] && row_count == 0
+        nl
+        say('No failing instances')
+        nl
+        return
       end
 
+      legend = '(*) Bootstrap node'
+
+      nl
+      say(instances_table)
+      nl
+      say(legend)
+      nl
+      say('Instances total: %d' % row_count)
+    end
+
+    private
+
+    def construct_table_to_display(options, instances)
       row_count = 0
-      has_disk_cid = instances[0].has_key?('disk_cid')
+      has_disk_cid = instances.any? {|instance| instance.has_key?('disk_cid') }
+      has_az = instances.any? {|instance| instance.has_key?('az') }
       has_uptime = instances[0]['processes'] && instances[0]['processes'].size > 0 && instances[0]['processes'][0].has_key?('uptime')
       has_cpu = instances[0]['processes'] && instances[0]['processes'].size > 0 && instances[0]['processes'][0].has_key?('cpu')
+      instance_count = instances.size
+
+      result = table do |display_table|
 
-      instances_table = table do |t|
-        headings = ['Instance', 'State', 'Resource Pool', 'IPs']
+        headings = ['Instance', 'State']
+        if has_az
+          headings << 'AZ'
+        end
+        headings += ['VM Type', 'IPs']
         if options[:details]
+          headings << 'VM CID'
           if has_disk_cid
-            headings += ['VM CID', 'Disk CID', 'Agent ID', 'Resurrection']
-          else
-            headings += ['VM CID', 'Agent ID', 'Resurrection']
+            headings += ['Disk CID']
           end
+          headings += ['Agent ID', 'Resurrection']
         end
 
         if options[:dns]
           headings += ['DNS A records']
         end
 
-        if options[:vitals]
-          headings += [{:value => "Uptime", :alignment => :center}] if options[:ps] && has_uptime
-          headings += [{:value => "Load\n(avg01, avg05, avg15)", :alignment => :center}]
-          headings += [{:value => "CPU %\n(User, Sys, Wait)", :alignment => :center}]
-          headings += ["CPU %"] if options[:ps] && has_cpu
-          headings += ['Memory Usage', 'Swap Usage']
-          headings += ["System\nDisk Usage", "Ephemeral\nDisk Usage", "Persistent\nDisk Usage"]
-        end
-
-        last_job = ''
-        sorted.each do |instance|
+        instances_to_show = []
+        instances.each do |instance|
           if options[:failing]
             if options[:ps]
               instance['processes'].keep_if { |p| p['state'] != 'running' }
@@ -91,15 +103,56 @@ module Bosh::Cli::Command
             end
           end
 
+          instances_to_show << instance
+        end
+
+        if options[:vitals]
+          show_total = instance_count > 1 || instances_to_show[0]['processes'].size > 0
+
+          headings += [{:value => 'Uptime', :alignment => :center}] if options[:ps] && has_uptime && show_total
+          headings += [{:value => "Load\n(avg01, avg05, avg15)", :alignment => :center}]
+          headings += [{:value => "CPU %\n(User, Sys, Wait)", :alignment => :center}]
+          headings += ['CPU %'] if options[:ps] && has_cpu && show_total
+          headings += ['Memory Usage', 'Swap Usage']
+          headings += ["System\nDisk Usage", "Ephemeral\nDisk Usage", "Persistent\nDisk Usage"]
+        end
+        display_table.headings = headings
+
+        last_job = ''
+        instances_to_show.each do |instance|
           row_count += 1
 
-          job = "#{instance['job_name'] || 'unknown'}/#{instance['index'] || 'unknown'}"
+          job_name = instance['job_name'] || 'unknown'
+          index = instance['index'] || 'unknown'
+          job = if instance.has_key?('id')
+                  bootstrap = instance.fetch('bootstrap', false)
+                  if bootstrap
+                    "#{job_name}/#{index} (#{instance['id']})*"
+                  else
+                    "#{job_name}/#{index} (#{instance['id']})"
+                  end
+                else
+                  "#{job_name}/#{index}"
+                end
           ips = Array(instance['ips']).join("\n")
           dns_records = Array(instance['dns']).join("\n")
           vitals = instance['vitals']
+          az = instance['az'].nil? ? 'n/a' : instance['az']
+
+          row = [job, instance['job_state']]
+          if has_az
+            row << az
+          end
 
-          row = [job, instance['job_state'], instance['resource_pool'], ips]
-          t << :separator if row_count.between?(2, instance_count) && (options[:ps] || last_job != '' && instance['job_name'] != last_job)
+          if instance['resource_pool']
+            row << instance['resource_pool']
+          else
+            row << instance['vm_type']
+          end
+
+          row << ips
+
+          display_table << :separator if row_count.between?(2, instance_count) && (options[:ps] || last_job != '' && instance['job_name'] != last_job)
 
           if options[:details]
             if has_disk_cid
@@ -115,8 +168,8 @@ module Bosh::Cli::Command
 
           if options[:vitals]
             if vitals
-              cpu =  vitals['cpu']
-              mem =  vitals['mem']
+              cpu = vitals['cpu']
+              mem = vitals['mem']
               swap = vitals['swap']
               disk = vitals['disk']
 
@@ -140,7 +193,7 @@ module Bosh::Cli::Command
             else
               9.times { row << 'n/a' }
             end
-            t << row
+            display_table << row
 
             if options[:ps] && instance['processes']
               instance['processes'].each do |process|
@@ -149,6 +202,7 @@ module Bosh::Cli::Command
                   prow += ['','','']
                   prow << '' if has_disk_cid
                 end
+                prow << '' if has_az
                 if has_uptime
                   if process['uptime'] && process['uptime']['secs']
                     uptime = Integer(process['uptime']['secs'])
@@ -165,41 +219,37 @@ module Bosh::Cli::Command
                 prow << (process['cpu'] ? "#{process['cpu']['total']}%":'') if has_cpu
                 prow << (process['mem'] ? "#{process['mem']['percent']}% (#{pretty_size(process['mem']['kb'].to_i * 1024)})":'')
                 4.times { prow << '' }
-                t << prow
+                display_table << prow
               end
             end
           else
-            t << row
+            display_table << row
             if options[:ps] && instance['processes']
               instance['processes'].each do |process|
                 name = process['name']
                 state = process['state']
                 process_row = ["  #{name}", "#{state}"]
                 (headings.size - 2).times { process_row << '' }
-                t << process_row
+                display_table << process_row
               end
             end
           end
 
           last_job = instance['job_name'] || 'unknown'
-          if instance['processes'].size == 0 && instance_count == 1
-            headings.delete_at(4)
-            headings.delete_at(6)
-          end
         end
-        t.headings = headings
+        display_table.headings = headings
       end
 
-      if options[:failing] && row_count == 0
-        nl
-        say('No failing instances')
-        nl
-        return
+      return result, row_count
+    end
+
+    def sort(instances)
+      instances.sort do |instance1, instance2|
+        comparison = instance1['job_name'].to_s <=> instance2['job_name'].to_s
+        comparison = instance1['az'].to_s <=> instance2['az'].to_s if comparison == 0
+        comparison = instance1['index'].to_i <=> instance2['index'].to_i if comparison == 0
+        comparison
       end
-      nl
-      say(instances_table)
-      nl
-      say('Instances total: %d' % row_count )
     end
   end
 end

data/lib/cli/commands/job_management.rb

@@ -11,8 +11,8 @@ module Bosh::Cli
       usage 'start'
       desc 'Start all jobs/job/instance'
       option '--force', FORCE
-      def start_job(job = '*', index = nil)
-        change_job_state(:start, job, index)
+      def start_job(job = '*', index_or_id = nil)
+        change_job_state(:start, job, index_or_id)
       end
 
       # bosh stop
@@ -22,11 +22,11 @@ module Bosh::Cli
       option '--hard', 'Power off VM'
       option '--force', FORCE
       option '--skip-drain', SKIP_DRAIN
-      def stop_job(job = '*', index = nil)
+      def stop_job(job = '*', index_or_id = nil)
         if hard?
-          change_job_state(:detach, job, index)
+          change_job_state(:detach, job, index_or_id)
         else
-          change_job_state(:stop, job, index)
+          change_job_state(:stop, job, index_or_id)
         end
       end
 
@@ -35,8 +35,8 @@ module Bosh::Cli
       desc 'Restart all jobs/job/instance (soft stop + start)'
       option '--force', FORCE
       option '--skip-drain', SKIP_DRAIN
-      def restart_job(job = '*', index = nil)
-        change_job_state(:restart, job, index)
+      def restart_job(job = '*', index_or_id = nil)
+        change_job_state(:restart, job, index_or_id)
       end
 
       # bosh recreate
@@ -44,17 +44,17 @@ module Bosh::Cli
       desc 'Recreate all jobs/job/instance (hard stop + start)'
       option '--force', FORCE
       option '--skip-drain', SKIP_DRAIN
-      def recreate_job(job = '*', index = nil)
-        change_job_state(:recreate, job, index)
+      def recreate_job(job = '*', index_or_id = nil)
+        change_job_state(:recreate, job, index_or_id)
       end
 
       private
 
-      def change_job_state(state, job, index = nil)
+      def change_job_state(state, job, index_or_id = nil)
         auth_required
         manifest = parse_manifest(state)
         job_state = JobState.new(self, manifest, skip_drain: skip_drain?)
-        status, task_id, completion_desc = job_state.change(state, job, index, force?)
+        status, task_id, completion_desc = job_state.change(state, job, index_or_id, force?)
         task_report(status, task_id, completion_desc)
       end
 

data/lib/cli/commands/log_management.rb

@@ -11,28 +11,28 @@ module Bosh::Cli::Command
     option '--dir destination_directory', String, 'download directory'
     option '--all', 'deprecated'
 
-    def fetch_logs(job, index)
+    def fetch_logs(job, index_or_id)
       auth_required
 
       manifest = prepare_deployment_manifest(show_state: true)
-      check_arguments(index)
+      check_arguments
 
       logs_downloader = Bosh::Cli::LogsDownloader.new(director, self)
 
-      resource_id = fetch_log_resource_id(manifest.name, index, job)
-      logs_path = logs_downloader.build_destination_path(job, index, options[:dir] || Dir.pwd)
+      resource_id = fetch_log_resource_id(manifest.name, index_or_id, job)
+      logs_path = logs_downloader.build_destination_path(job, index_or_id, options[:dir] || Dir.pwd)
       logs_downloader.download(resource_id, logs_path)
     end
 
-    def fetch_log_resource_id(deployment_name, index, job)
-      resource_id = director.fetch_logs(deployment_name, job, index, log_type, filters)
+    private
+
+    def fetch_log_resource_id(deployment_name, index_or_id, job)
+      resource_id = director.fetch_logs(deployment_name, job, index_or_id, log_type, filters)
       err('Error retrieving logs') if resource_id.nil?
 
       resource_id
     end
 
-    private
-
     def agent_logs_wanted?
       options[:agent]
     end
@@ -41,11 +41,9 @@ module Bosh::Cli::Command
       options[:job]
     end
 
-    def check_arguments(index)
+    def check_arguments
       no_track_unsupported
 
-      err('Job index is expected to be a positive integer') if index !~ /^\d+$/
-
       if agent_logs_wanted? && options[:only]
         err('Custom filtering is not supported for agent logs')
       end

data/lib/cli/commands/maintenance.rb

@@ -1,5 +1,3 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module Bosh::Cli::Command
   class Maintenance < Base
 
@@ -17,34 +15,18 @@ module Bosh::Cli::Command
 
       remove_all = !!options[:all]
 
-      releases_to_keep = remove_all ? 0 : RELEASES_TO_KEEP
-      stemcells_to_keep = remove_all ? 0 : STEMCELLS_TO_KEEP
-
-      release_wording = pluralize(releases_to_keep, 'latest version')
-      stemcell_wording = pluralize(stemcells_to_keep, 'latest version')
-
-      desc = <<-EOS.gsub(/^ */, "")
-        Cleanup command will attempt to delete old unused
-        release versions and stemcells from your currently
-        targeted director at #{target_name.make_green}.
-
-        Only #{release_wording.make_green} of each release
-        and #{stemcell_wording.make_green} of each stemcell will be kept.
-
-        Releases and stemcells that are in use will not be affected.
-      EOS
-
-      nl
-      say(desc)
-      nl
-
-      err('Cleanup canceled') unless confirmed?
-
-      nl
-      cleanup_stemcells(stemcells_to_keep)
-      nl
-      cleanup_releases(releases_to_keep)
-
+      num_releases_to_keep = remove_all ? 0 : RELEASES_TO_KEEP
+      num_stemcells_to_keep = remove_all ? 0 : STEMCELLS_TO_KEEP
+
+      begin
+        director.cleanup({'remove_all' => remove_all})
+      rescue Bosh::Cli::ResourceNotFound
+        # old directors won't have `cleanup` endpoint, therefore use legacy endpoints
+        nl
+        cleanup_stemcells(num_stemcells_to_keep)
+        nl
+        cleanup_releases(num_releases_to_keep)
+      end
       nl
       say('Cleanup complete'.make_green)
     end
@@ -86,16 +68,10 @@ module Bosh::Cli::Command
 
       director.list_releases.each do |release|
         name = release['name']
-        if release['release_versions']
-          # reverse compatibility with old director response format
-          versions = release['release_versions'].map { |release_version| release_version['version'] }
-          currently_deployed = release['release_versions'].
-            select { |release_version| release_version['currently_deployed'] }.
-            map{ |release_version| release_version['version'] }
-        else
-          versions = release['versions']
-          currently_deployed = release['in_use']
-        end
+        versions = release['release_versions'].map { |release_version| release_version['version'] }
+        currently_deployed = release['release_versions']
+                               .select { |release_version| release_version['currently_deployed'] }
+                               .map { |release_version| release_version['version'] }
 
         version_tuples = versions.map do |v|
           {

data/lib/cli/commands/snapshot.rb

@@ -1,5 +1,3 @@
-# Copyright (c) 2009-2013 VMware, Inc.
-
 module Bosh::Cli::Command
   class Snapshot < Base
     usage 'snapshots'
@@ -11,18 +9,29 @@ module Bosh::Cli::Command
 
       snapshots = director.list_snapshots(deployment_name, job, index)
 
+      if snapshots.empty?
+        nl
+        say('No snapshots')
+        nl
+        return
+      end
+
       sorted = snapshots.sort do |a, b|
         s = a['job'].to_s <=> b['job'].to_s
-        s = a['index'].to_i <=> b['index'].to_i if s == 0
+        if a['uuid']
+          s = a['uuid'].to_i <=> b['uuid'].to_i if s == 0
+        else
+          s = a['index'].to_i <=> b['index'].to_i if s == 0
+        end
         s = a['created_at'].to_s <=> b['created_at'].to_s if s == 0
         s
       end
 
       snapshots_table = table do |t|
-        t.headings = ['Job/index', 'Snapshot CID', 'Created at', 'Clean']
+        t.headings = ['Job/ID', 'Snapshot CID', 'Created at', 'Clean']
 
         sorted.each do |snapshot|
-          job = "#{snapshot['job'] || 'unknown'}/#{snapshot['index'] || 'unknown'}"
+          job = "#{snapshot['job'] || 'unknown'}/#{snapshot['uuid'] || 'unknown'} (#{snapshot['index'] || 'unknown'})"
           t << [job, snapshot['snapshot_cid'], snapshot['created_at'], snapshot['clean']]
         end
       end