cloudstack-cli 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ebac401185a9bc2eff1e5e81bc4ebd41637bfde
-  data.tar.gz: 1624eba9dc6bc520eb321f27c46f5b561b14cea1
+  metadata.gz: e7f07e2763e1098aebc86ef957def19af52e6439
+  data.tar.gz: c7351b039d23832d297e18f4b3fad768f5dcf7f5
 SHA512:
-  metadata.gz: 4e93e35e1642aa22f1bcfd34fba600b5b71810ae6e4bbdc90fb740a2abfb74d2a75c0c7cd6eccffa06c1aa7d83a7b5b75048ab20ce715e43a4fa65384798ebf2
-  data.tar.gz: 4665df9fd113b2e200ff33c253d8c5686b30dd90fa1a323c02af1a9a7ebe32fe63877570b5cd597033510005a4d2b9c86400718d70b875351d3ec5915f512881
+  metadata.gz: a043f85b78500aafed6ae9fed0e38629f18aa0a564ab832fe91f907576da8bcf91bfa8bb4aa47cf5c1399bf8c8b14af70537d03eb1d434693b308ae727275783
+  data.tar.gz: f100042e728db5621e03dd6defd85fa7e4e80f8875f0d2daaddd44874dce6f85c5f9a69bea09fe364b066ff3af4818ca131da047029e744c47c4b950ad739e32

data/Gemfile.lock

@@ -6,7 +6,7 @@ PATH
 PATH
   remote: .
   specs:
-    cloudstack-cli (1.4.1)
+    cloudstack-cli (1.4.2)
       cloudstack_client (~> 1.3)
       thor (~> 0.19)
 

data/lib/cloudstack-cli/base.rb

@@ -80,7 +80,7 @@ module CloudstackCli
       end
 
       def filter_by(objects, key, value)
-        if objects.size < 2
+        if objects.size == 0
           return objects
         elsif !(keys = objects.map{|i| i.keys}.flatten.uniq).include?(key)
           say "WARNING: Filter invalid, no key \"#{key}\" found.", :yellow
@@ -88,7 +88,7 @@ module CloudstackCli
           return objects
         end
         objects.select do |object|
-          object[key.to_s] =~ /#{value}/i
+          object[key.to_s].to_s =~ /#{value}/i
         end
       rescue RegexpError => e
         say "ERROR: Invalid regular expression in filter - #{e.message}", :red
@@ -103,6 +103,15 @@ module CloudstackCli
         objects
       end
 
+      def add_filters_to_options(command)
+        options[:filter].each do |filter_key, filter_value|
+          if client.api.params(command).find {|param| param["name"] == filter_key.downcase }
+            options[filter_key.downcase] = filter_value.gsub(/[^\w\s\.-]/, '')
+            options[:filter].delete(filter_key)
+          end
+        end
+      end
+
       def parse_file(file, extensions = %w(.json .yaml .yml))
         handler = case File.extname(file)
         when ".json"

data/lib/cloudstack-cli/commands/account.rb

@@ -21,22 +21,31 @@ class Account < CloudstackCli::Base
   end
 
   desc 'list', 'list accounts'
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     accounts = client.list_accounts(listall: true)
     if accounts.size < 1
       puts "No accounts found."
     else
-      table = [%w(Name Type Domain State)]
-      accounts.each do |account|
-        table << [
-          account['name'],
-          TYPES[account['accounttype']],
-          account['domain'],
-          account['state']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({accounts: accounts}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(accounts: accounts)
+      else
+        table = [%w(Name Type Domain State)]
+        accounts.each do |account|
+          table << [
+            account['name'],
+            TYPES[account['accounttype']],
+            account['domain'],
+            account['state']
+          ]
+        end
+        print_table table
+        say "Total number of accounts: #{accounts.size}"
       end
-      print_table table
-      say "Total number of accounts: #{accounts.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/affinity_group.rb

@@ -6,22 +6,31 @@ class AffinityGroup < CloudstackCli::Base
   option :type
   option :listall
   option :keyword
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     affinity_groups = client.list_affinity_groups(options)
     if affinity_groups.size < 1
       say "No affinity groups found."
     else
-      table = [%w(Domain Account Name, Description, VMs)]
-      affinity_groups.each do |group|
-        table << [
-          group['domain'], group['account'],
-        	group['name'], group['description'],
-          group['virtualmachineIds'] ? group['virtualmachineIds'].size : nil
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({affinity_groups: affinity_groups}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(affinity_groups: affinity_groups)
+      else
+        table = [%w(Domain Account Name, Description, VMs)]
+        affinity_groups.each do |group|
+          table << [
+            group['domain'], group['account'],
+          	group['name'], group['description'],
+            group['virtualmachineIds'] ? group['virtualmachineIds'].size : nil
+          ]
+        end
+        print_table table
+        say "Total number of affinity groups: #{affinity_groups.size}"
       end
-      print_table table
-      say "Total number of affinity groups: #{affinity_groups.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/capacity.rb

@@ -13,7 +13,7 @@ class Capacity < CloudstackCli::Base
   }
 
   desc "list", "list system capacity"
-  option :zone, desc: "lists clusters by zone"
+  option :zone, desc: "list capacity by zone"
   option :type, desc: "specify type, see types for a list of types"
   def list
     resolve_zone if options[:zone]

data/lib/cloudstack-cli/commands/cluster.rb

@@ -2,22 +2,31 @@ class Cluster < CloudstackCli::Base
 
   desc 'list', 'list clusters'
   option :zone, desc: "lists clusters by zone"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone if options[:zone]
     clusters = client.list_clusters(options)
     if clusters.size < 1
       say "No clusters found."
     else
-      table = [%w(Name Pod_Name Type Zone State)]
-      clusters.each do |cluster|
-        table << [
-        	cluster['name'], cluster['podname'],
-          cluster['hypervisortype'], cluster['zonename'],
-          cluster['managedstate']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({clusters: clusters}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(clusters: clusters)
+      else
+        table = [%w(Name Pod_Name Type Zone State)]
+        clusters.each do |cluster|
+          table << [
+          	cluster['name'], cluster['podname'],
+            cluster['hypervisortype'], cluster['zonename'],
+            cluster['managedstate']
+          ]
+        end
+        print_table table
+        say "Total number of clusters: #{clusters.size}"
       end
-      print_table table
-      say "Total number of clusters: #{clusters.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/compute_offer.rb

@@ -2,13 +2,26 @@ class ComputeOffer < CloudstackCli::Base
 
   desc 'list', 'list compute offerings'
   option :domain, desc: "the domain associated with the compute offering"
+  option :format, default: "table",
+    enum: %w(table json yaml)
+  option :filter, type: :hash,
+    desc: "filter objects based on arrtibutes: (attr1:regex attr2:regex ...)"
   def list
     resolve_domain
+    add_filters_to_options("listServiceOfferings") if options[:filter]
     offerings = client.list_service_offerings(options)
+    offerings = filter_objects(offerings) if options[:filter]
     if offerings.size < 1
       puts "No offerings found."
     else
-      print_compute_offerings(offerings)
+      case options[:format].to_sym
+      when :yaml
+        puts({compute_offers: offerings}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(compute_offers: offerings)
+      else
+        print_compute_offerings(offerings)
+      end
     end
   end
 

data/lib/cloudstack-cli/commands/disk_offer.rb

@@ -2,23 +2,36 @@ class DiskOffer < CloudstackCli::Base
 
   desc 'list', 'list disk offerings'
   option :domain, desc: "the domain of the disk offering"
+  option :format, default: "table",
+    enum: %w(table json yaml)
+  option :filter, type: :hash,
+    desc: "filter objects based on arrtibutes: (attr1:regex attr2:regex ...)"
   def list
     resolve_domain
+    add_filters_to_options("listDiskOfferings") if options[:filter]
     offerings = client.list_disk_offerings(options)
+    offerings = filter_objects(offerings) if options[:filter]
     if offerings.size < 1
       puts "No offerings found."
     else
-      table = [["Name", "Displaytext", "Domain", "ID"]]
-      offerings.each do |offering|
-        table << [
-          offering["name"],
-          offering["displaytext"],
-          offering["domain"],
-          offering["id"]
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({disk_offers: offerings}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(disk_offers: offerings)
+      else
+        table = [["Name", "Displaytext", "Domain", "ID"]]
+        offerings.each do |offering|
+          table << [
+            offering["name"],
+            offering["displaytext"],
+            offering["domain"],
+            offering["id"]
+          ]
+        end
+        print_table table
+        say "Total number of offerings: #{offerings.size}"
       end
-      print_table table
-      say "Total number of offerings: #{offerings.size}"
     end
   end
 end

data/lib/cloudstack-cli/commands/domain.rb

@@ -1,17 +1,26 @@
 class Domain < CloudstackCli::Base
 
   desc 'list', 'list domains'
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     domains = client.list_domains
     if domains.size < 1
       puts "No domains found."
     else
-      table = [%w(Name Path)]
-      domains.each do |domain|
-        table << [domain['name'], domain['path']]
+      case options[:format].to_sym
+      when :yaml
+        puts({domains: domains}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(domains: domains)
+      else
+        table = [%w(Name Path)]
+        domains.each do |domain|
+          table << [domain['name'], domain['path']]
+        end
+        print_table table
+        say "Total number of domains: #{domains.size}"
       end
-      print_table table
-      say "Total number of domains: #{domains.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/host.rb

@@ -3,20 +3,29 @@ class Host < CloudstackCli::Base
   desc 'list', 'list hosts'
   option :zone, desc: "lists hosts by zone"
   option :type, desc: "the host type"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone if options[:zone]
     hosts = client.list_hosts(options)
     if hosts.size < 1
       say "No hosts found."
     else
-      table = [["Zone", "Type", "Cluster", "Name"]]
-      hosts.each do |host|
-        table << [
-        	host['zonename'], host['type'], host['clustername'], host['name']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({hosts: hosts}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(hosts: hosts)
+      else
+        table = [["Zone", "Type", "Cluster", "Name"]]
+        hosts.each do |host|
+          table << [
+          	host['zonename'], host['type'], host['clustername'], host['name']
+          ]
+        end
+        print_table table
+        say "Total number of hosts: #{hosts.size}"
       end
-      print_table table
-      say "Total number of hosts: #{hosts.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/ip_address.rb

@@ -29,6 +29,8 @@ class IpAddress < CloudstackCli::Base
   option :project
   option :account
   option :listall
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     resolve_project
@@ -36,12 +38,19 @@ class IpAddress < CloudstackCli::Base
     if addresses.size < 1
       say "No ip addresses found."
     else
-      table = [%w(ID Address Account Zone)]
-      addresses.each do |address|
-        table << [address["id"], address["ipaddress"], address["account"], address["zonename"]]
+      case options[:format].to_sym
+      when :yaml
+        puts({ip_addresses: addresses}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(ip_addresses: addresses)
+      else
+        table = [%w(ID Address Account Zone)]
+        addresses.each do |address|
+          table << [address["id"], address["ipaddress"], address["account"], address["zonename"]]
+        end
+        print_table table
+        say "Total number of addresses: #{addresses.size}"
       end
-      print_table table
-      say "Total number of addresses: #{addresses.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/iso.rb

@@ -6,28 +6,41 @@ class Iso < CloudstackCli::Base
   option :account, desc: 'account name'
   option :type, desc: 'type of ISO',
     enum: %w(featured self selfexecutable sharedexecutable executable community all)
+  option :format, default: "table",
+    enum: %w(table json yaml)
+  option :filter, type: :hash,
+    desc: "filter objects based on arrtibutes: (attr1:regex attr2:regex ...)"
   def list
+    add_filters_to_options("listIsos") if options[:filter]
     resolve_project
     resolve_zone
     resolve_account
     options[:isofilter] = options[:type]
     options.delete :type
     isos = client.list_isos(options)
+    isos = filter_objects(isos) if options[:filter]
     if isos.size < 1
       puts "No ISO's found."
     else
-      table = [%w(Name Zone Bootable Public Featured)]
-      isos.each do |iso|
-        table <<  [
-          iso['name'],
-          iso['zonename'],
-          iso['bootable'],
-          iso['ispublic'],
-          iso['isfeatured']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({isos: isos}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(isos: isos)
+      else
+        table = [%w(Name Zone Bootable Public Featured)]
+        isos.each do |iso|
+          table <<  [
+            iso['name'],
+            iso['zonename'],
+            iso['bootable'],
+            iso['ispublic'],
+            iso['isfeatured']
+          ]
+        end
+        print_table(table)
+        say "Total number of ISO's: #{isos.size}"
       end
-      print_table(table)
-      say "Total number of ISO's: #{isos.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/job.rb

@@ -1,22 +1,31 @@
 class Job < CloudstackCli::Base
 
   desc 'list', 'list async jobs'
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     jobs = client.list_async_jobs
     if jobs.size < 1
       say "No jobs found."
     else
-      table = [%w(Command Created Status ID User-ID)]
-      jobs.each do |job|
-        table << [
-          job['cmd'].split('.')[-1],
-          job['created'],
-          job['jobstatus'],
-          job['jobid'],
-          job['userid']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({jobs: jobs}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(jobs: jobs)
+      else
+        table = [%w(Command Created Status ID User-ID)]
+        jobs.each do |job|
+          table << [
+            job['cmd'].split('.')[-1],
+            job['created'],
+            job['jobstatus'],
+            job['jobid'],
+            job['userid']
+          ]
+        end
+        print_table table
       end
-      print_table table
     end
   end
 

data/lib/cloudstack-cli/commands/load_balancer.rb

@@ -2,24 +2,33 @@ class LoadBalancer < CloudstackCli::Base
 
   desc "list", "list load balancer rules"
   option :project
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_project
     rules = client.list_load_balancer_rules(options)
     if rules.size < 1
       puts "No load balancer rules found."
     else
-      table = [%w(Name Public-IP Public-Port Private-Port Algorithm)]
-      rules.each do |rule|
-        table << [
-          rule['name'],
-          rule['publicip'],
-          rule['publicport'],
-          rule['privateport'],
-          rule['algorithm']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({rules: rules}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(rules: rules)
+      else
+        table = [%w(Name Public-IP Public-Port Private-Port Algorithm)]
+        rules.each do |rule|
+          table << [
+            rule['name'],
+            rule['publicip'],
+            rule['publicport'],
+            rule['privateport'],
+            rule['algorithm']
+          ]
+        end
+        print_table table
+        say "Total number of rules: #{rules.count}"
       end
-      print_table table
-      say "Total number of rules: #{rules.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/network.rb

@@ -4,37 +4,47 @@ class Network < CloudstackCli::Base
   option :project, desc: 'the project name of the network'
   option :account, desc: 'the owner of the network'
   option :zone, desc: 'the name of the zone the network belongs to'
-  option :type, desc: 'the type of the network'
   option :showid, type: :boolean, desc: 'show the network id'
   option :showvlan, type: :boolean, desc: 'show the VLAN'
+  option :filter, type: :hash,
+    desc: "filter objects based on arrtibutes: (attr1:regex attr2:regex ...)"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone if options[:zone]
     resolve_project
+    add_filters_to_options("listNetworks") if options[:filter]
     networks = client.list_networks(options)
-
+    networks = filter_objects(networks) if options[:filter]
     if networks.size < 1
       puts "No networks found."
     else
-      networks = filter_by(networks, 'type', options[:type]) if options[:type]
-      table = [%w(Name Displaytext Account/Project Zone Domain State Type Offering)]
-      table[0] << "ID" if options[:showid]
-      table[0] << "VLAN" if options[:showvlan]
-      networks.each do |network|
-        table << [
-          network["name"],
-          network["displaytext"],
-          network["account"] || network["project"],
-          network["zonename"],
-          network["domain"],
-          network["state"],
-          network["type"],
-          network["networkofferingname"]
-        ]
-        table[-1] << network["id"] if options[:showid]
-        table[-1] << network["vlan"] if options[:showvlan]
+      case options[:format].to_sym
+      when :yaml
+        puts({networks: networks}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(networks: networks)
+      else
+        table = [%w(Name Displaytext Account/Project Zone Domain State Type Offering)]
+        table[0] << "ID" if options[:showid]
+        table[0] << "VLAN" if options[:showvlan]
+        networks.each do |network|
+          table << [
+            network["name"],
+            network["displaytext"],
+            network["account"] || network["project"],
+            network["zonename"],
+            network["domain"],
+            network["state"],
+            network["type"],
+            network["networkofferingname"]
+          ]
+          table[-1] << network["id"] if options[:showid]
+          table[-1] << network["vlan"] if options[:showvlan]
+        end
+        print_table table
+        say "Total number of networks: #{networks.count}"
       end
-      print_table table
-      say "Total number of networks: #{networks.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/physical_network.rb

@@ -2,6 +2,8 @@ class PhysicalNetwork < CloudstackCli::Base
 
   desc "list", "list physical networks"
   option :project
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_project
     networks = client.list_physical_networks(options)
@@ -9,17 +11,24 @@ class PhysicalNetwork < CloudstackCli::Base
     if networks.size < 1
       puts "No networks found"
     else
-      table = [['Name', 'State', 'Zone', 'ID']]
-      networks.each do |network|
-        table << [
-          network["name"],
-          network["state"],
-          zones.select{|zone| zone['id'] == network["zoneid"]}.first["name"],
-          network["id"]
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({networks: networks}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(networks: networks)
+      else
+        table = [['Name', 'State', 'Zone', 'ID']]
+        networks.each do |network|
+          table << [
+            network["name"],
+            network["state"],
+            zones.select{|zone| zone['id'] == network["zoneid"]}.first["name"],
+            network["id"]
+          ]
+        end
+        print_table table
+        say "Total number of networks: #{networks.count}"
       end
-      print_table table
-      say "Total number of networks: #{networks.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/pod.rb

@@ -2,21 +2,30 @@ class Pod < CloudstackCli::Base
 
   desc 'list', 'list pods'
   option :zone
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone
     pods = client.list_pods(options)
     if pods.size < 1
       say "No pods found."
     else
-      table = [["Name", "Start-IP", "End-IP", "Zone"]]
-      pods.each do |pod|
-        table << [
-        	pod['name'], pod['startip'],
-          pod['endip'], pod['zonename']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({pods: pods}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(pods: pods)
+      else
+        table = [["Name", "Start-IP", "End-IP", "Zone"]]
+        pods.each do |pod|
+          table << [
+          	pod['name'], pod['startip'],
+            pod['endip'], pod['zonename']
+          ]
+        end
+        print_table table
+        say "Total number of pods: #{pods.count}"
       end
-      print_table table
-      say "Total number of pods: #{pods.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/port_rule.rb

@@ -44,25 +44,34 @@ class PortRule < CloudstackCli::Base
 
   desc "list", "list portforwarding rules"
   option :project
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_project
     rules = client.list_port_forwarding_rules(options)
     if rules.size < 1
       puts "No rules found."
     else
-      table = [["IP", "Server", "Public-Port", "Private-Port", "Protocol", "State"]]
-      rules.each do |rule|
-        table << [
-          rule['ipaddress'],
-          rule['virtualmachinename'],
-          print_ports(rule, 'public'),
-          print_ports(rule, 'private'),
-          rule['protocol'],
-          rule['state']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({rules: rules}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(rules: rules)
+      else
+        table = [["IP", "Server", "Public-Port", "Private-Port", "Protocol", "State"]]
+        rules.each do |rule|
+          table << [
+            rule['ipaddress'],
+            rule['virtualmachinename'],
+            print_ports(rule, 'public'),
+            print_ports(rule, 'private'),
+            rule['protocol'],
+            rule['state']
+          ]
+        end
+        print_table table
+        say "Total number of rules: #{rules.count}"
       end
-      print_table table
-      say "Total number of rules: #{rules.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/project.rb

@@ -14,25 +14,34 @@ class Project < CloudstackCli::Base
 
   desc "list", "list projects"
   option :domain, desc: "List only resources belonging to the domain specified"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_domain
     projects = client.list_projects(options.merge listall: true)
     if projects.size < 1
       puts "No projects found."
     else
-      table = [%w(Name Displaytext VMs CPU Memory Domain)]
-      projects.each do |project|
-        table << [
-          project['name'],
-          project['displaytext'],
-          project['vmtotal'],
-          project['cputotal'],
-          project['memorytotal'] / 1024,
-          project['domain']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({projects: projects}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(projects: projects)
+      else
+        table = [%w(Name Displaytext VMs CPU Memory Domain)]
+        projects.each do |project|
+          table << [
+            project['name'],
+            project['displaytext'],
+            project['vmtotal'],
+            project['cputotal'],
+            project['memorytotal'] / 1024,
+            project['domain']
+          ]
+        end
+        print_table(table)
+        say "Total number of projects: #{projects.count}"
       end
-      print_table(table)
-      say "Total number of projects: #{projects.count}"
     end
   end
 

data/lib/cloudstack-cli/commands/region.rb

@@ -1,20 +1,29 @@
 class Region < CloudstackCli::Base
 
   desc 'list', 'list regions'
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     regions = client.list_regions
     if regions.size < 1
       say "No regions found."
     else
-      table = [%w(Name, Endpoint)]
-      regions.each do |region|
-        table << [
-        	region['name'], region['endpoint']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({regions: regions}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(regions: regions)
+      else
+        table = [%w(Name, Endpoint)]
+        regions.each do |region|
+          table << [
+          	region['name'], region['endpoint']
+          ]
+        end
+        print_table table
+        say "Total number of regions: #{regions.size}"
       end
-      print_table table
-      say "Total number of regions: #{regions.size}"
     end
   end
 
-end
+end

data/lib/cloudstack-cli/commands/resource_limit.rb

@@ -18,6 +18,8 @@ class ResourceLimit < CloudstackCli::Base
   option :account
   option :project
   option :type, desc: "specify type, see types for a list of types"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     resolve_project
@@ -34,8 +36,16 @@ class ResourceLimit < CloudstackCli::Base
         resource_to_s(limit, 'max')
       ]
     end
-    table = table.insert(0, header)
-    print_table table
+
+    case options[:format].to_sym
+    when :yaml
+      puts({resource_limits: limits}.to_yaml)
+    when :json
+      puts JSON.pretty_generate(resource_limits: limits)
+    else
+      table = table.insert(0, header)
+      print_table table
+    end
   end
 
   desc "refresh", "refresh resource counts"

data/lib/cloudstack-cli/commands/router.rb

@@ -167,9 +167,9 @@ class Router < CloudstackCli::Base
         options[:format] ||= "table"
         case options[:format].to_sym
         when :yaml
-          puts({'routers' => routers}.to_yaml)
+          puts({routers: routers}.to_yaml)
         when :json
-          say JSON.pretty_generate({ routers: routers })
+          puts JSON.pretty_generate(routers: routers)
         else
           table = [%w(
             Name Zone Account/Project IP Linklocal-IP Status Version

data/lib/cloudstack-cli/commands/snapshot.rb

@@ -6,6 +6,8 @@ class Snapshot < CloudstackCli::Base
   option :domain, desc: "the domain name of the snapshot's account"
   option :listall, default: true, desc: "list all resources the caller has rights on"
   option :state, desc: "filter snapshots by state"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     resolve_project
@@ -14,16 +16,23 @@ class Snapshot < CloudstackCli::Base
     if snapshots.size < 1
       say "No snapshots found."
     else
-      table = [%w(Account Name Volume Created Type State)]
-      snapshots = filter_by(snapshots, :state, options[:state]) if options[:state]
-      snapshots.each do |snapshot|
-        table << [
-        	snapshot['account'], snapshot['name'], snapshot['volumename'],
-        	snapshot['created'], snapshot['snapshottype'], snapshot['state']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({snapshots: snapshots}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(snapshots: snapshots)
+      else
+        table = [%w(Account Name Volume Created Type State)]
+        snapshots = filter_by(snapshots, :state, options[:state]) if options[:state]
+        snapshots.each do |snapshot|
+          table << [
+          	snapshot['account'], snapshot['name'], snapshot['volumename'],
+          	snapshot['created'], snapshot['snapshottype'], snapshot['state']
+          ]
+        end
+        print_table table
+        say "Total number of snapshots: #{snapshots.size}"
       end
-      print_table table
-      say "Total number of snapshots: #{snapshots.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/ssh_key_pair.rb

@@ -4,6 +4,8 @@ class SshKeyPair < CloudstackCli::Base
   option :listall, default: true
   option :account
   option :project
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     resolve_project
@@ -11,11 +13,18 @@ class SshKeyPair < CloudstackCli::Base
     if pairs.size < 1
       say "No ssh key pairs found."
     else
-      table = [["Name", "Fingerprint"]]
-      pairs.each do |pair|
-        table << [pair['name'], pair['fingerprint']]
+      case options[:format].to_sym
+      when :yaml
+        puts({ssh_key_pairs: pairs}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(ssh_key_pairs: pairs)
+      else
+        table = [["Name", "Fingerprint"]]
+        pairs.each do |pair|
+          table << [pair['name'], pair['fingerprint']]
+        end
+        print_table table
       end
-      print_table table
     end
   end
 

data/lib/cloudstack-cli/commands/storage_pool.rb

@@ -5,34 +5,43 @@ class StoragePool < CloudstackCli::Base
   option :name, desc: "name of the storage pool"
   option :keyword, desc: "list by keyword"
   option :state, desc: "filter by state (Up, Maintenance)"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone
     storage_pools = client.list_storage_pools(options)
     if storage_pools.size < 1
       say "No storage pools found."
     else
-      storage_pools = filter_by(storage_pools, "state", options[:state]) if options[:state]
-      table = [%w(Name Pod State Zone)]
-      table[0] << "Size [GB]"
-      table[0] << "Used [GB]"
-      table[0] << "Used [%]"
-      table[0] << "Alocated [GB]"
-      table[0] << "Alocated [%]"
-      table[0] << "Type"
-      storage_pools.each do |storage_pool|
-        total = storage_pool['disksizetotal'] / 1024**3
-        used = (storage_pool['disksizeused'] / 1024**3) rescue 0
-        allocated = (storage_pool['disksizeallocated'] / 1024**3) rescue 0
-        table << [
-        	storage_pool['name'], storage_pool['podname'],
-          storage_pool['state'], storage_pool['zonename'],
-          total, used, (100.0 / total * used).round(0),
-          allocated, (100.0 / total * allocated).round(0),
-          storage_pool['type']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({storage_pools: storage_pools}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(storage_pools: storage_pools)
+      else
+        storage_pools = filter_by(storage_pools, "state", options[:state]) if options[:state]
+        table = [%w(Name Pod State Zone)]
+        table[0] << "Size [GB]"
+        table[0] << "Used [GB]"
+        table[0] << "Used [%]"
+        table[0] << "Alocated [GB]"
+        table[0] << "Alocated [%]"
+        table[0] << "Type"
+        storage_pools.each do |storage_pool|
+          total = storage_pool['disksizetotal'] / 1024**3
+          used = (storage_pool['disksizeused'] / 1024**3) rescue 0
+          allocated = (storage_pool['disksizeallocated'] / 1024**3) rescue 0
+          table << [
+          	storage_pool['name'], storage_pool['podname'],
+            storage_pool['state'], storage_pool['zonename'],
+            total, used, (100.0 / total * used).round(0),
+            allocated, (100.0 / total * allocated).round(0),
+            storage_pool['type']
+          ]
+        end
+        print_table table
+        say "Total number of storage_pools: #{storage_pools.size}"
       end
-      print_table table
-      say "Total number of storage_pools: #{storage_pools.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/system_vm.rb

@@ -5,20 +5,29 @@ class SystemVm < CloudstackCli::Base
   option :state, desc: "state of the system VM"
   option :type, desc: "the system VM type.",
     enum: %w(consoleproxy secondarystoragevm)
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_zone
     vms = client.list_system_vms(options)
     if vms.size < 1
       say "No system VM's found."
     else
-      table = [%w(Name Zone State Type)]
-      vms.each do |vm|
-        table << [
-          vm['name'], vm['zonename'], vm['state'], vm['systemvmtype']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({system_vms: vms}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(system_vms: vms)
+      else
+        table = [%w(Name Zone State Type)]
+        vms.each do |vm|
+          table << [
+            vm['name'], vm['zonename'], vm['state'], vm['systemvmtype']
+          ]
+        end
+        print_table table
+        say "Total number of system VM's: #{vms.size}"
       end
-      print_table table
-      say "Total number of system VM's: #{vms.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/template.rb

@@ -6,6 +6,8 @@ class Template < CloudstackCli::Base
   option :type,
     enum: %w(featured self self-executable executable community all),
     default: "featured"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list(type='featured')
     resolve_project
     resolve_zone
@@ -14,19 +16,26 @@ class Template < CloudstackCli::Base
     if templates.size < 1
       puts "No templates found."
     else
-      table = [%w(Name Created Zone Featured Public Format)]
-      templates.each do |template|
-        table << [
-          template['name'],
-          Time.parse(template['created']).strftime("%F"),
-          template['zonename'],
-          template['isfeatured'],
-          template['ispublic'],
-          template['format']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({templates: templates}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(templates: templates)
+      else
+        table = [%w(Name Created Zone Featured Public Format)]
+        templates.each do |template|
+          table << [
+            template['name'],
+            Time.parse(template['created']).strftime("%F"),
+            template['zonename'],
+            template['isfeatured'],
+            template['ispublic'],
+            template['format']
+          ]
+        end
+        print_table(table)
+        say "Total number of templates: #{templates.size}"
       end
-      print_table(table)
-      say "Total number of templates: #{templates.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/user.rb

@@ -3,21 +3,30 @@ class User < CloudstackCli::Base
   desc 'list', 'list users'
   option :listall
   option :account
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_account
     users = client.list_users(options)
     if users.size < 1
       say "No users found."
     else
-      table = [["Account", "Type", "Name", "Email", "State", "Domain"]]
-      users.each do |user|
-        table << [
-          user['account'], Account::TYPES[user['accounttype']], "#{user['firstname']} #{user['lastname']}",
-          user['email'], user['state'], user['domain']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({users: users}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(users: users)
+      else
+        table = [["Account", "Type", "Name", "Email", "State", "Domain"]]
+        users.each do |user|
+          table << [
+            user['account'], Account::TYPES[user['accounttype']], "#{user['firstname']} #{user['lastname']}",
+            user['email'], user['state'], user['domain']
+          ]
+        end
+        print_table table
+        say "Total number of users: #{users.size}"
       end
-      print_table table
-      say "Total number of users: #{users.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/virtual_machine.rb

@@ -19,6 +19,7 @@ class VirtualMachine < CloudstackCli::Base
   option :format, default: "table",
     enum: %w(table json yaml)
   def list
+    add_filters_to_options("listVirtualMachines") if options[:filter]
     resolve_account
     resolve_project
     resolve_zone
@@ -269,9 +270,9 @@ class VirtualMachine < CloudstackCli::Base
     def print_virtual_machines(virtual_machines)
       case options[:format].to_sym
       when :yaml
-        puts({'virtual_machines' => virtual_machines}.to_yaml)
+        puts({virtual_machines: virtual_machines}.to_yaml)
       when :json
-        say JSON.pretty_generate({ virtual_machines: virtual_machines })
+        puts JSON.pretty_generate(virtual_machines: virtual_machines)
       else
         with_i_name = virtual_machines.first['instancename']
         with_h_name = virtual_machines.first['hostname']

data/lib/cloudstack-cli/commands/volume.rb

@@ -7,30 +7,43 @@ class Volume < CloudstackCli::Base
   option :keyword, desc: 'list by keyword'
   option :name, desc: 'name of the disk volume'
   option :type, desc: 'type of disk volume (ROOT or DATADISK)'
+  option :filter, type: :hash,
+    desc: "filter objects based on arrtibutes: (attr1:regex attr2:regex ...)"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     resolve_project
     resolve_account
     resolve_zone
+    add_filters_to_options("listVolumes") if options[:filter]
     volumes = client.list_volumes(options)
+    volumes = filter_objects(volumes) if options[:filter]
     if volumes.size < 1
       say "No volumes found."
     else
-      table = [%w(Name Type Size VM Storage Offeringname Zone Status)]
-      table.first << 'Project' if options[:project]
-      volumes.each do |volume|
-        table << [
-          volume['name'], volume['type'],
-          (volume['size'] / 1024**3).to_s + 'GB',
-          volume['vmname'],
-          volume['storage'],
-          volume['diskofferingname'],
-          volume['zonename'],
-          volume['state']
-        ]
-        table.last << volume['project'] if options[:project]
+      case options[:format].to_sym
+      when :yaml
+        puts({volumes: volumes}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(volumes: volumes)
+      else
+        table = [%w(Name Type Size VM Storage Offeringname Zone Status)]
+        table.first << 'Project' if options[:project]
+        volumes.each do |volume|
+          table << [
+            volume['name'], volume['type'],
+            (volume['size'] / 1024**3).to_s + 'GB',
+            volume['vmname'],
+            volume['storage'],
+            volume['diskofferingname'],
+            volume['zonename'],
+            volume['state']
+          ]
+          table.last << volume['project'] if options[:project]
+        end
+        print_table(table)
+        say "Total number of volumes: #{volumes.size}"
       end
-      print_table(table)
-      say "Total number of volumes: #{volumes.size}"
     end
   end
 

data/lib/cloudstack-cli/commands/zone.rb

@@ -1,21 +1,30 @@
 class Zone < CloudstackCli::Base
 
   desc "list", "list zones"
+  option :format, default: "table",
+    enum: %w(table json yaml)
   def list
     zones = client.list_zones
     if zones.size < 1
       puts "No projects found"
     else
-      table = [%w(Name Network-Type Description)]
-      zones.each do |zone|
-        table << [
-          zone['name'],
-          zone['networktype'],
-          zone['description']
-        ]
+      case options[:format].to_sym
+      when :yaml
+        puts({zones: zones}.to_yaml)
+      when :json
+        puts JSON.pretty_generate(zones: zones)
+      else
+        table = [%w(Name Network-Type Description)]
+        zones.each do |zone|
+          table << [
+            zone['name'],
+            zone['networktype'],
+            zone['description']
+          ]
+        end
+        print_table(table)
       end
     end
-    print_table(table)
   end
 
 end

data/lib/cloudstack-cli/version.rb

@@ -1,3 +1,3 @@
 module CloudstackCli
-  VERSION = "1.4.1"
+  VERSION = "1.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloudstack-cli
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors:
 - Nik Wolfgramm