cloudstack-cli 0.15.1 → 1.0.0.rc1

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

@@ -1,18 +1,22 @@
 class LoadBalancer < CloudstackCli::Base
-  
+
   desc "list", "list load balancer rules"
   option :project
   def list
-    project = find_project if options[:project]
-    rules = client.list_load_balancer_rules(
-      { project_name: project ? project['name'] : nil }
-    )
+    resolve_project
+    rules = client.list_load_balancer_rules(options)
     if rules.size < 1
       puts "No load balancer rules found."
     else
-      table = [["Name", "Public-IP", "Public-Port"]]
+      table = [%w(Name Public-IP Public-Port Private-Port Algorithm)]
       rules.each do |rule|
-        table << [rule['name'], rule['publicip'], rule['publicport']]
+        table << [
+          rule['name'],
+          rule['publicip'],
+          rule['publicport'],
+          rule['privateport'],
+          rule['algorithm']
+        ]
       end
       print_table table
       say "Total number of rules: #{rules.count}"
@@ -24,31 +28,65 @@ class LoadBalancer < CloudstackCli::Base
   option :ip, required: true
   option :public_port, required: true
   option :private_port
+  option :algorithm,
+    enum: %w(source roundrobin leastconn),
+    default: "roundrobin"
+  option :open_firewall, type: :boolean
+  option :cidr_list
+  option :protocol
   def create(name)
-    project = find_project
+    resolve_project
+    ip_options = {ip_address: options[:ip]}
+    ip_options[:project_id] = options[:project_id] if options[:project_id]
+    unless ip = client.list_public_ip_addresses(ip_options).first
+      say "Error: IP #{options[:ip]} not found.", :red
+      exit 1
+    end
     options[:private_port] = options[:public_port] if options[:private_port] == nil
+    options[:name] = name
+    options[:publicip_id] = ip['id']
     say "Create rule #{name}...", :yellow
-    rule = client.create_load_balancer_rule(
-      name,
-      options[:ip],
-      options[:private_port],
-      options[:public_port],
-    )
-    say "OK!", :green
+    rule = client.create_load_balancer_rule(options)
+    say " OK!", :green
   end
 
-  desc "add NAME", "assign servers to balancer rule"
-  option :servers, required: true, type: :array, desc: 'server names'
+  desc "add LB-NAME", "assign servers to balancer rule"
+  option :servers,
+    required: true,
+    type: :array,
+    desc: "server names"
+  option :project
   def add(name)
-    say "Add #{names.join(', ')} to rule #{id}...", :yellow
-    rule = client.assign_to_load_balancer_rule(
-      name,
-      options[:servers],
+    resolve_project
+    default_args = options.dup
+    default_args.delete(:servers)
+
+    servers = options[:servers].map do |server|
+      client.list_virtual_machines(default_args.merge(name: server)).first
+    end.compact
+
+    unless servers.size > 0
+      say "No servers found with the following name(s): #{options[:servers].join(', ')}", :yellow
+      exit 1
+    end
+
+    unless rule = client.list_load_balancer_rules(default_args.merge(name: name)).first
+      say "Error: LB rule with name #{name} not found.", :red
+      exit 1
+    end
+
+    say "Add #{servers.map{|s| s['name']}.join(', ')} to rule #{name} ", :yellow
+    lb = client.assign_to_load_balancer_rule(
+      {
+        id: rule['id'],
+        virtualmachine_ids: servers.map{|s| s['id']}.join(',')
+      }.merge(default_args)
     )
-    if rule['success']
-      say "OK!", :green
+
+    if lb['success']
+      say " OK.", :green
     else
-      say "Failed!", :red
+      say " Failed.", :red
     end
   end
-end
+end

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

@@ -3,37 +3,19 @@ class Network < CloudstackCli::Base
   desc "list", "list networks"
   option :project, desc: 'the project name of the network'
   option :account, desc: 'the owner of the network'
-  option :zone, desc: 'typehe name of the zone the network belongs to'
+  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'
   def list
-    project = find_project if options[:project]
-    if options[:zone]
-      unless zone = client.get_zone(options[:zone])
-        say "Zone '#{options[:zone]}' not found.", :red
-        exit 1
-      end
-      zone_id = zone['id']
-    end
-
-    networks = []
-    if project
-      networks = client.list_networks(project_id: project['id'], zone_id: zone_id)
-    elsif options[:account]
-      networks = client.list_networks(account: options[:account], zone_id: zone_id)
-    else
-      networks = client.list_networks(zone_id: zone_id)
-      networks += client.list_networks(project_id: -1, zone_id: zone_id)
-    end
-
-    if options[:type]
-      networks = filter_by(networks, 'type', options[:type])
-    end
+    resolve_zone if options[:zone]
+    resolve_project
+    networks = client.list_networks(options)
 
     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]
@@ -56,72 +38,45 @@ class Network < CloudstackCli::Base
     end
   end
 
-  desc "default", "get the default network"
-  option :zone
-  def default
-    network = client.get_default_network(options[:zone])
-    unless network
-      puts "No default network found."
-    else
-      table = [["Name", "Displaytext", "Domain", "Zone"]]
-      table[0] << "ID" if options[:showid]
-        table << [
-          network["name"],
-          network["displaytext"],
-          network["domain"],
-          network["zonename"]
-        ]
-        table[-1] << network["id"] if options[:showid]
-      print_table table
-    end
-  end
-
   desc "show NAME", "show detailed infos about a network"
   option :project
   def show(name)
-    if options[:project]
-      if options[:project].downcase == "all"
-        options[:project_id] = -1
-      else
-        project = find_project
-        options[:project_id] = project['id']
-      end
+    resolve_project
+    unless network = client.list_networks(options).find {|n| n['name'] == name}
+      say "Error: No network with name '#{name}' found.", :red
+      exit
     end
-    unless server = client.get_network(name, options[:project_id])
-      puts "No network found."
-    else
-      table = server.map do |key, value|
-        [ set_color("#{key}:", :yellow), "#{value}" ]
-      end
-      print_table table
+    table = network.map do |key, value|
+      [ set_color("#{key}:", :yellow), "#{value}" ]
     end
+    print_table table
   end
 
   desc "restart NAME", "restart network"
-  option :cleanup, type: :boolean, default: true
+  option :cleanup, type: :boolean, default: false
+  option :project
   def restart(name)
-    network = client.get_network(name)
-    network = client.get_network(name, -1) unless network
-    unless network
-      say "Network #{name} not found."
+    resolve_project
+    unless network = client.list_networks(options).find {|n| n['name'] == name}
+      say "Network with name '#{name}' not found."
       exit 1
     end
     if yes? "Restart network \"#{network['name']}\" (cleanup=#{options[:cleanup]})?"
-      p client.restart_network(network['id'], options[:cleanup])
+      client.restart_network(id: network['id'], cleanup: options[:cleanup])
     end
   end
 
   desc "delete NAME", "delete network"
+  option :project
   def delete(name)
-    network = client.get_network(name)
-    network = client.get_network(name, -1) unless network
-    unless network
-      say "Network \"#{name}\" not found."
+    resolve_project
+    unless network = client.list_networks(options).find {|n| n['name'] == name}
+      say "Error: Network with name '#{name}' not found.", :red
       exit 1
     end
-    if yes? "Destroy network \"#{network['name']}\"?"
-      p client.delete_network(network['id'])
+    if yes? "Delete network \"#{network['name']}\"?"
+      client.delete_network(id: network['id'])
     end
   end
 
-end
+end

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

@@ -3,8 +3,8 @@ class PhysicalNetwork < CloudstackCli::Base
   desc "list", "list physical networks"
   option :project
   def list
-    project = find_project if options[:project]
-    networks = client.list_physical_networks
+    resolve_project
+    networks = client.list_physical_networks(options)
     zones = client.list_zones
     if networks.size < 1
       puts "No networks found"
@@ -14,7 +14,7 @@ class PhysicalNetwork < CloudstackCli::Base
         table << [
           network["name"],
           network["state"],
-          zones.select{|zone| zone['id'] == network["zoneid"]}.first["name"], 
+          zones.select{|zone| zone['id'] == network["zoneid"]}.first["name"],
           network["id"]
         ]
       end
@@ -23,4 +23,4 @@ class PhysicalNetwork < CloudstackCli::Base
     end
   end
 
-end
+end

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

@@ -1,7 +1,9 @@
 class Pod < CloudstackCli::Base
 
   desc 'list', 'list pods'
+  option :zone
   def list
+    resolve_zone
     pods = client.list_pods(options)
     if pods.size < 1
       say "No pods found."
@@ -18,4 +20,4 @@ class Pod < CloudstackCli::Base
     end
   end
 
-end
+end

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

@@ -1,6 +1,6 @@
 class PortRule < CloudstackCli::Base
 
-  desc "create SERVER", "create portforwarding rules for a given server"
+  desc "create VM-NAME", "create portforwarding rules for a given VM"
   option :rules, type: :array,
     required: true,
     desc: "Port Forwarding Rules [public_ip]:port ...",
@@ -9,38 +9,44 @@ class PortRule < CloudstackCli::Base
   option :project
   option :keyword, desc: "list by keyword"
   def create(server_name)
-    projectid = find_project['id'] if options[:project]
-    unless server = client.get_server(server_name, projectid)
+    resolve_project
+    unless server = client.list_virtual_machines(name: server_name, project_id: options[:project_id]).first
       error "Server #{server_name} not found."
       exit 1
     end
-    frontendip = nil
     options[:rules].each do |pf_rule|
       ip = pf_rule.split(":")[0]
-      if ip != ''
-        ip_addr = client.get_public_ip_address(ip, projectid)
-        unless ip_addr
-          say "Error: IP #{ip} not found.", :red
+      unless ip == ''
+        unless ip_addr = client.list_public_ip_addresses(ipaddress: ip, project_id: options[:project_id]).first
+          say "Error: IP #{ip} not found.", :yellow
           next
         end
       else
-        ip_addr = frontendip ||= client.associate_ip_address(
-          client.get_network(options[:network], projectid)
+        say "Assign a new IP address ", :yellow
+        say(" OK", :green) if ip_addr = client.associate_ip_address(
+          networkid: client.list_networks(
+            project_id: options[:project_id]
+          ).find {|n| n['name'] == options[:network]}['id'],
+          project_id: options[:project_id]
         )
       end
       port = pf_rule.split(":")[1]
-      puts
-      say "Create port forwarding rule #{ip_addr["ipaddress"]}:#{port} for server #{server_name}.", :yellow
-      client.create_port_forwarding_rule(ip_addr["id"], port, 'TCP', port, server["id"])
-      puts
+      say "Create port forwarding rule #{ip_addr["ipaddress"]}:#{port} for server #{server_name} ", :yellow
+      say(" OK.", :green) if client.create_port_forwarding_rule(
+        ipaddress_id: ip_addr["id"],
+        public_port: port,
+        private_port: port,
+        virtualmachine_id: server["id"],
+        protocol: "TCP"
+      )
     end
   end
 
   desc "list", "list portforwarding rules"
   option :project
   def list
-    project_id = find_project['id'] if options[:project]
-    rules = client.list_port_forwarding_rules(ip_address_id=nil, project_id)
+    resolve_project
+    rules = client.list_port_forwarding_rules(options)
     if rules.size < 1
       puts "No rules found."
     else
@@ -69,4 +75,4 @@ class PortRule < CloudstackCli::Base
       end
     end
   end
-end
+end

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

@@ -2,8 +2,8 @@ class Project < CloudstackCli::Base
 
   desc "show NAME", "show detailed infos about a project"
   def show(name)
-    unless project = client.get_project(name)
-      puts "No project with name #{name} found."
+    unless project = client.list_projects(name: name, listall: true).first
+      say "Error: No project with name '#{name}' found.", :red
     else
       table = project.map do |key, value|
         [ set_color("#{key}", :yellow), "#{value}" ]
@@ -14,7 +14,7 @@ class Project < CloudstackCli::Base
 
   desc "list", "list projects"
   def list
-    projects = client.list_projects
+    projects = client.list_projects(listall: true)
     if projects.size < 1
       puts "No projects found."
     else
@@ -29,25 +29,24 @@ class Project < CloudstackCli::Base
 
   desc "list_accounts PROJECT_NAME", "show accounts belonging to a project"
   def list_accounts(name)
-    unless project = client.get_project(name)
-      say "No project with name #{name} found."
+    unless project = client.list_projects(name: name, listall: true).first
+      say "Error: No project with name '#{name}' found.", :red
     else
-      accounts = client.list_project_accounts(project['id'], options)
+      accounts = client.list_project_accounts(project_id: project['id'])
       if accounts.size < 1
         say "No project accounts found."
       else
-        table = [%w(Name Type Domain State)]
+        table = [%w(Account-Name Account-Type Role Domain)]
         accounts.each do |account|
           table << [
-            account['name'],
-            TYPES[account['accounttype']],
-            account['domain'],
-            account['state']
+            account['account'],
+            Account::TYPES[account['accounttype']],
+            account['role'],
+            account['domain']
           ]
         end
         print_table table
         say "Total number of project accounts: #{accounts.size}"
-        print_table table
       end
     end
   end

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

@@ -19,6 +19,8 @@ class ResourceLimit < CloudstackCli::Base
   option :project
   option :type, desc: "specify type, see types for a list of types"
   def list
+    resolve_account
+    resolve_project
     limits = client.list_resource_limits(options)
     table = []
     header = options[:project] ? ["Project"] : ["Account"]
@@ -42,7 +44,9 @@ class ResourceLimit < CloudstackCli::Base
   option :project, desc: "refresh resource for a specified project"
   option :type, desc: "specify type, see types for a list of types"
   def refresh
-    set_domain_id if options[:domain]
+    resolve_domain
+    resolve_account
+    resolve_project
     options[:resource_type] = options[:type] if options[:type]
 
     unless ['domain_id', 'account', 'project'].any? {|k| options.key?(k)}
@@ -69,7 +73,9 @@ class ResourceLimit < CloudstackCli::Base
     desc: "Maximum resource limit.",
     required: true
   def update
-    set_domain_id if options[:domain]
+    resolve_domain
+    resolve_account
+    resolve_project
     options[:resource_type] = options[:type]
 
     unless ['domain_id', 'account', 'project'].any? {|k| options.key?(k)}
@@ -106,16 +112,6 @@ class ResourceLimit < CloudstackCli::Base
       value.to_s
     end
 
-    def set_domain_id
-      domains = client.list_domains(options[:domain])
-      if domains.size < 1
-        say "Domain #{options[:domain]} not found.", :red
-        exit -1
-      else
-        options[:domain_id] = domains.first['id']
-      end
-    end
-
   end
 
 end

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

@@ -7,35 +7,26 @@ class Router < CloudstackCli::Base
   option :status, desc: "the status of the router"
   option :redundant_state, desc: "the state of redundant virtual router",
     enum: %w(master backup fault unknown)
-  option :listall, type: :boolean, desc: "list all routers"
+  option :listall, type: :boolean, desc: "list all routers", default: true
   option :showid, type: :boolean, desc: "display the router ID"
-	option :reverse, type: :boolean, default: false, desc: "reverse listing of routers"
+  option :reverse, type: :boolean, default: false, desc: "reverse listing of routers"
   option :command,
     desc: "command to execute for each router",
     enum: %w(START STOP REBOOT)
-	option :concurrency, type: :numeric, default: 10, aliases: '-C',
-		desc: "number of concurrent command to execute"
+  option :concurrency, type: :numeric, default: 10, aliases: '-C',
+    desc: "number of concurrent command to execute"
   def list
-    projectid = find_project['id'] if options[:project]
-    routers = client.list_routers(
-      {
-        account: options[:account],
-        projectid: projectid,
-        status: options[:status],
-        zone: options[:zone]
-      }
-    )
+    resolve_project
+    resolve_zone
+    resolve_account
+
+    routers = client.list_routers(options)
 
     if options[:listall]
       projects = client.list_projects
       projects.each do |project|
         routers = routers + client.list_routers(
-          {
-            account: options[:account],
-            projectid: project['id'],
-            status: options[:status],
-            zone: options[:zone]
-          }
+          options.merge(projectid: project['id'])
         )
       end
     end
@@ -54,69 +45,69 @@ class Router < CloudstackCli::Base
         exit 1
       end
       exit unless yes?("\n#{command.capitalize} the router(s) above? [y/N]:", :magenta)
-			routers.each_slice(options[:concurrency]) do | batch |
-	      jobs = batch.map do |router|
-	        {id: client.send("#{command}_router", router['id'], async: false)['jobid'], name: "#{command.capitalize} router #{router['name']}"}
-	      end
-	      puts
-	      watch_jobs(jobs)
-			end
+      routers.each_slice(options[:concurrency]) do | batch |
+        jobs = batch.map do |router|
+          {id: client.send("#{command}_router", router['id'], async: false)['jobid'], name: "#{command.capitalize} router #{router['name']}"}
+        end
+        puts
+        watch_jobs(jobs)
+      end
     end
   end
 
   desc "stop NAME [NAME2 ..]", "stop virtual router(s)"
-  option :force, desc: "stop without asking", type: :boolean, aliases: '-f'
+  option :force, desc: "stop without confirmation", type: :boolean, aliases: '-f'
   def stop(*names)
     routers = names.map {|name| get_router(name)}
     print_routers(routers)
     exit unless options[:force] || yes?("\nStop router(s) above? [y/N]:", :magenta)
     jobs = routers.map do |router|
-      {id: client.stop_router(router['id'], async: false)['jobid'], name: "Stop router #{router['name']}"}
+      {id: client.stop_router({id: router['id']}, {sync: true})['jobid'], name: "Stop router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
   end
 
   desc "start NAME [NAME2 ..]", "start virtual router(s)"
-  option :force, desc: "start without asking", type: :boolean, aliases: '-f'
+  option :force, desc: "start without confirmation", type: :boolean, aliases: '-f'
   def start(*names)
     routers = names.map {|name| get_router(name)}
     print_routers(routers)
     exit unless options[:force] || yes?("\nStart router(s) above? [y/N]:", :magenta)
     jobs = routers.map do |router|
-      {id: client.start_router(router['id'], async: false)['jobid'], name: "Start router #{router['name']}"}
+      {id: client.start_router({id: router['id']}, {sync: true})['jobid'], name: "Start router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
   end
 
   desc "reboot NAME [NAME2 ..]", "reboot virtual router(s)"
-  option :force, desc: "start without asking", type: :boolean, aliases: '-f'
+  option :force, desc: "start without confirmation", type: :boolean, aliases: '-f'
   def reboot(*names)
-    routers = names.map {|name| get_router(name)}
+    routers = names.map {|name| client.list_routers(name: name).first}
     print_routers(routers)
     exit unless options[:force] || yes?("\nReboot router(s) above? [y/N]:", :magenta)
     jobs = routers.map do |router|
-      {id: client.reboot_router(router['id'], async: false)['jobid'], name: "Reboot router #{router['name']}"}
+      {id: client.reboot_router({id: router['id']}, {sync: true})['jobid'], name: "Reboot router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
   end
 
-  desc "restart NAME [NAME2 ..]", "restart virtual router(s) (stop and start)"
-  option :force, desc: "restart without asking", type: :boolean, aliases: '-f'
-  def restart(*names)
+  desc "stop_start NAME [NAME2 ..]", "stops and starts virtual router(s)"
+  option :force, desc: "stop_start without confirmation", type: :boolean, aliases: '-f'
+  def stop_start(*names)
     routers = names.map {|name| get_router(name)}
     print_routers(routers)
     exit unless options[:force] || yes?("\nRestart router(s) above? [y/N]:", :magenta)
     jobs = routers.map do |router|
-      {id: client.stop_router(router['id'], async: false)['jobid'], name: "Stop router #{router['name']}"}
+      {id: client.stop_router({id: router['id']}, {sync: true})['jobid'], name: "Stop router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
 
     jobs = routers.map do |router|
-      {id: client.start_router(router['id'], async: false)['jobid'], name: "Start router #{router['name']}"}
+      {id: client.start_router({id: router['id']}, {sync: true})['jobid'], name: "Start router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
@@ -131,7 +122,7 @@ class Router < CloudstackCli::Base
     print_routers(routers)
     exit unless options[:force] || yes?("\nDestroy router(s) above? [y/N]:", :magenta)
     jobs = routers.map do |router|
-      {id: client.destroy_router(router['id'], async: false)['jobid'], name: "Destroy router #{router['name']}"}
+      {id: client.destroy_router({id: router['id']}, {sync: true})['jobid'], name: "Destroy router #{router['name']}"}
     end
     puts
     watch_jobs(jobs)
@@ -140,8 +131,8 @@ class Router < CloudstackCli::Base
   no_commands do
 
     def get_router(name)
-      unless router = client.get_router(name)
-        unless router = client.get_router(name, -1)
+      unless router = client.list_routers(name: name, listall: true).first
+        unless router = client.list_routers(name: name, project_id: -1).first
          say "Can't find router with name #{name}.", :red
          exit 1
         end
@@ -154,7 +145,7 @@ class Router < CloudstackCli::Base
         say "No routers found."
       else
         table = [[
-          'Name', 'Zone', 'Account', 'Project', 'Redundant-State', 'IP', 'Linklocal IP', 'Status', 'Redundant', 'ID'
+          'Name', 'Zone', 'Account', 'Project', 'Redundant-State', 'IP', 'Linklocal IP', 'Status', 'Redundant', 'OfferingID', 'Offering', 'ID'
         ]]
         table[0].delete('ID') unless options[:showid]
         routers.each do |router|
@@ -168,6 +159,8 @@ class Router < CloudstackCli::Base
             router["linklocalip"],
             router["state"],
             router["isredundantrouter"],
+            router["serviceofferingid"],
+            router["serviceofferingname"],
             router["id"]
           ]
           table[-1].delete_at(-1) unless table[0].index "ID"

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

@@ -4,8 +4,11 @@ class Snapshot < CloudstackCli::Base
   option :account
   option :project
   option :domain
-  option :listall
+  option :listall, default: true
   def list
+    resolve_account
+    resolve_project
+    resolve_domain
     snapshots = client.list_snapshots(options)
     if snapshots.size < 1
       say "No snapshots found."
@@ -22,4 +25,4 @@ class Snapshot < CloudstackCli::Base
     end
   end
 
-end
+end