cloudstack-cli 0.15.1 → 1.0.0.rc1

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

@@ -1,10 +1,12 @@
 class SshKeyPair < CloudstackCli::Base
 
   desc "list", 'list ssh key pairs'
-  option :listall
+  option :listall, default: true
   option :account
   option :project
   def list
+    resolve_account
+    resolve_project
     pairs = client.list_ssh_key_pairs(options)
     if pairs.size < 1
       say "No ssh key pairs found."
@@ -21,7 +23,10 @@ class SshKeyPair < CloudstackCli::Base
   option :account
   option :project
   def create(name)
-    pair = client.create_ssh_key_pair(name, options)
+    resolve_account
+    resolve_project
+    options[:name] = name
+    pair = client.create_ssh_key_pair(options)
     say "Name : #{pair['name']}"
     say "Fingerprint : #{pair['fingerprint']}"
     say "Privatekey:"
@@ -33,17 +38,23 @@ class SshKeyPair < CloudstackCli::Base
   option :project
   option :public_key, required: true, desc: "path to public_key file"
   def register(name)
+    resolve_account
+    resolve_project
+    options[:name] = name
     if File.exist?(options[:public_key])
       public_key = IO.read(options[:public_key])
     else
       say("Can't open public key #{options[:public_key]}", :red)
       exit 1
     end
-    pair = client.register_ssh_key_pair(name, public_key, options)
+    pair = client.register_ssh_key_pair(options)
     say "Name : #{pair['name']}"
     say "Fingerprint : #{pair['fingerprint']}"
     say "Privatekey:"
     say pair['privatekey']
+  rescue => e
+    say "Failed to register key: #{e.message}", :red
+    exit 1
   end
 
   desc 'delete NAME', 'delete ssh key pair'
@@ -51,8 +62,11 @@ class SshKeyPair < CloudstackCli::Base
   option :project
   option :force, aliases: '-f', desc: "delete without asking"
   def delete(name)
+    resolve_account
+    resolve_project
+    options[:name] = name
     if options[:force] || yes?("Delete ssh key pair #{name}?", :yellow)
-      if client.delete_ssh_key_pair(name, options)['success'] == "true"
+      if client.delete_ssh_key_pair(options)['success'] == "true"
         say("OK", :green)
       else
         say("Failed", :red)
@@ -60,5 +74,5 @@ class SshKeyPair < CloudstackCli::Base
       end
     end
   end
-  
-end
+
+end

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

@@ -1,42 +1,44 @@
 class Stack < CloudstackCli::Base
 
-  desc "create STACKFILE", "create a stack of servers"
+  desc "create STACKFILE", "create a stack of VMs"
   def create(stackfile)
     stack = parse_file(stackfile)
+    project_id = find_project_by_name(stack["project"])
+
     say "Create stack #{stack["name"]}...", :green
-    projectid = find_project(stack["project"])['id'] if stack["project"]
     jobs = []
-    client.verbose = false
     stack["servers"].each do |instance|
       string_to_array(instance["name"]).each do |name|
-        server = client.get_server(name, project_id: projectid)
+        server = client.list_virtual_machines(name: name, project_id: project_id).first
         if server
-          say "Server #{name} (#{server["state"]}) already exists.", :yellow
+          say "VM #{name} (#{server["state"]}) already exists.", :yellow
           jobs << {
             id: 0,
-            name: "Create server #{name}",
+            name: "Create VM #{name}",
             status: 1
           }
         else
+          options = {
+            name: name,
+            displayname: instance["decription"],
+            zone: instance["zone"] || stack["zone"],
+            template: instance["template"],
+            iso: instance["iso"] ,
+            offering: instance["offering"],
+            networks: load_string_or_array(instance["networks"]),
+            project: stack["project"],
+            disk_offering: instance["disk_offering"],
+            size: instance["disk_size"],
+            group: instance["group"] || stack["group"],
+            keypair: instance["keypair"] || stack["keypair"],
+            sync: true
+          }
           jobs << {
-            id: client.create_server(
-              {
-                name: name,
-                displayname: instance["decription"],
-                zone: instance["zone"] || stack["zone"],
-                template: instance["template"],
-                iso: instance["iso"] ,
-                offering: instance["offering"],
-                networks: load_string_or_array(instance["networks"]),
-                project: stack["project"],
-                disk_offering: instance["disk_offering"],
-                disk_size: instance["disk_size"],
-                group: instance["group"] || stack["group"],
-                keypair: instance["keypair"] || stack["keypair"],
-                sync: true
-              }
+            id: client.deploy_virtual_machine(
+              vm_options_to_params(options),
+              {sync: true}
             )['jobid'],
-            name: "Create server #{name}"
+            name: "Create VM #{name}"
           }
         end
       end
@@ -48,11 +50,11 @@ class Stack < CloudstackCli::Base
     stack["servers"].each do |instance|
       string_to_array(instance["name"]).each do |name|
         if port_rules = string_to_array(instance["port_rules"])
-          server = client(quiet: true).get_server(name, project_id: projectid)
+          server = client.list_virtual_machines(name: name, project_id: project_id).first
           create_port_rules(server, port_rules, false).each_with_index do |job_id, index|
             jobs << {
               id: job_id,
-              name: "Create port forwarding rules (#{port_rules[index]}) for server #{name}"
+              name: "Create port forwarding rules (#{port_rules[index]}) for VM #{name}"
             }
           end
         end
@@ -62,39 +64,35 @@ class Stack < CloudstackCli::Base
     say "Finished.", :green
   end
 
-  desc "destroy STACKFILE", "destroy a stack of servers"
+  desc "destroy STACKFILE", "destroy a stack of VMs"
   option :force,
     desc: "destroy without asking",
     type: :boolean,
     default: false,
     aliases: '-f'
   option :expunge,
-    desc: "expunge servers immediately",
+    desc: "expunge VMs immediately",
     type: :boolean,
     default: false,
     aliases: '-E'
   def destroy(stackfile)
-    stack = parse_stackfile(stackfile)
-    projectid = find_project(stack["project"])['id'] if stack["project"]
-    client.verbose = false
+    stack = parse_file(stackfile)
+    project_id = find_project_by_name(stack["project"])
     servers = []
     stack["servers"].each do |server|
       string_to_array(server["name"]).each {|name| servers << name}
     end
 
-    if options[:force] || yes?("Destroy the following servers #{servers.join(', ')}? [y/N]:", :yellow)
+    if options[:force] || yes?("Destroy the following VM #{servers.join(', ')}? [y/N]:", :yellow)
       jobs = []
       servers.each do |name|
-        server = client(quiet: true).get_server(name, project_id: projectid)
-        if server
+        if server = client.list_virtual_machines(name: name, project_id: project_id).first
           jobs << {
-            id: client.destroy_server(
-              server['id'], {
-                sync: true,
-                expunge: options[:expunge]
-              }
+            id: client.destroy_virtual_machine(
+              { id: server['id'], expunge: options[:expunge] },
+              { sync: true }
             )['jobid'],
-            name: "Destroy server #{name}"
+            name: "Destroy VM #{name}"
           }
         end
       end
@@ -104,6 +102,18 @@ class Stack < CloudstackCli::Base
   end
 
   no_commands do
+    def find_project_by_name(name)
+      if name
+        unless project_id = client.list_projects(name: name).first['id']
+          say "Error: Project '#{name}' not found.", :red
+          exit 1
+        end
+      else
+        project_id = nil
+      end
+      project_id
+    end
+
     def load_string_or_array(item)
      item.is_a?(Array) ? item : [item]
     end

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

@@ -1,11 +1,12 @@
 class StoragePool < CloudstackCli::Base
 
-  desc 'list', 'list storage_pool'
+  desc 'list', 'list storage_pools'
   option :zone, desc: "zone name for the storage pool"
   option :name, desc: "name of the storage pool"
   option :keyword, desc: "list by keyword"
-  option :state, desc: "filter by state (Up, Maintenance)" 
+  option :state, desc: "filter by state (Up, Maintenance)"
   def list
+    resolve_zone
     storage_pools = client.list_storage_pools(options)
     if storage_pools.size < 1
       say "No storage pools found."
@@ -35,4 +36,4 @@ class StoragePool < CloudstackCli::Base
     end
   end
 
-end
+end

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

@@ -6,6 +6,7 @@ class SystemVm < CloudstackCli::Base
   option :type, desc: "the system VM type.",
     enum: %w(consoleproxy secondarystoragevm)
   def list
+    resolve_zone
     vms = client.list_system_vms(options)
     if vms.size < 1
       say "No system VM's found."
@@ -23,8 +24,7 @@ class SystemVm < CloudstackCli::Base
 
   desc 'show NAME', 'show system VM'
   def show(name)
-    vms = client.list_system_vms
-    unless vm = filter_by(vms, 'name', name).first
+    unless vm = client.list_system_vms(name: name).first
       say "No system vm with name #{name} found."
     else
       table = vm.map do |key, value|
@@ -36,37 +36,34 @@ class SystemVm < CloudstackCli::Base
 
   desc "start NAME", "start a system VM"
   def start(name)
-    vms = client.list_system_vms
-    unless vm = filter_by(vms, 'name', name).first
+    unless vm = client.list_system_vms(name: name).first
       say "No system vm with name #{name} found."
     else
       say("Starting system VM #{name}", :magenta)
-      client.start_system_vm(vm['id'])
-      puts
+      client.start_system_vm(id: vm['id'])
+      say " OK.", :green
     end
   end
 
   desc "stop NAME", "stop a system VM"
   def stop(name)
-    vms = client.list_system_vms(options)
-    unless vm = filter_by(vms, 'name', name).first
+    unless vm = client.list_system_vms(name: name).first
       say "No system vm with name #{name} found."
     else
       exit unless options[:force] || yes?("Stop system VM #{name}? [y/N]:", :magenta)
-      client.stop_system_vm(vm['id'])
-      puts
+      client.stop_system_vm(id: vm['id'])
+      say " OK.", :green
     end
   end
 
   desc "reboot NAME", "reboot a system VM"
   def reboot(name)
-    vms = client.list_system_vms(options)
-    unless vm = filter_by(vms, 'name', name).first
+    unless vm = client.list_system_vms(name: name).first
       say "No system vm with name #{name} found."
     else
       exit unless options[:force] || yes?("Reboot system VM #{name}? [y/N]:", :magenta)
-      client.reboot_system_vm(vm['id'])
-      puts
+      client.reboot_system_vm(id: vm['id'])
+      say " OK.", :green
     end
   end
 

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

@@ -1,24 +1,21 @@
 class Template < CloudstackCli::Base
 
-  desc 'list [TYPE]', 'list templates by type [featured|self|self-executable|executable|community], default is featured' 
+  desc 'list', 'list templates'
   option :project
   option :zone
+  option :type,
+    enum: %w(featured self self-executable executable community all),
+    default: "featured"
   def list(type='featured')
-    project = find_project if options[:project]
-    unless %w(featured self self-executable executable community).include? type
-      say "unsupported template type '#{type}'", :red
-      exit 1
-    end
-    zone = client.get_zone(options[:zone]) if options[:zone]
-    templates = client.list_templates(
-      filter: type,
-      project_id: project ? project['id'] : nil,
-      zone_id: zone ? zone['id'] : nil
-    )
+    resolve_project
+    resolve_zone
+    options[:template_filter] = options[:type]
+    options.delete(:filter)
+    templates = client.list_templates(options)
     if templates.size < 1
       puts "No templates found."
     else
-      table = [["Name", "Zone", "Format"]]
+      table = [%w(Name Zone Format)]
       templates.each do |template|
         table <<  [template['name'], template['zonename'], template['format']]
       end
@@ -27,4 +24,4 @@ class Template < CloudstackCli::Base
     end
   end
 
-end
+end

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

@@ -1,15 +1,10 @@
 class User < CloudstackCli::Base
 
-  USER_TYPES = {
-    0 => 'user',
-    1 => 'domain-admin',
-    2 => 'admin'
-  }
-
   desc 'list', 'list users'
   option :listall
   option :account
   def list
+    resolve_account
     users = client.list_users(options)
     if users.size < 1
       say "No users found."
@@ -17,7 +12,7 @@ class User < CloudstackCli::Base
       table = [["Account", "Type", "Name", "Email", "State", "Domain"]]
       users.each do |user|
         table << [
-          user['account'], USER_TYPES[user['accounttype']], "#{user['firstname']} #{user['lastname']}",
+          user['account'], Account::TYPES[user['accounttype']], "#{user['firstname']} #{user['lastname']}",
           user['email'], user['state'], user['domain']
         ]
       end
@@ -25,5 +20,5 @@ class User < CloudstackCli::Base
       say "Total number of users: #{users.size}"
     end
   end
-  
-end
+
+end

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

@@ -0,0 +1,243 @@
+class VirtualMachine < CloudstackCli::Base
+
+  desc "list", "list virtual machines"
+  option :account, desc: "name of the account"
+  option :project, desc: "name of the project"
+  option :zone, desc: "the name of the availability zone"
+  option :state, desc: "state of the virtual machine"
+  option :listall, desc: "list all virtual machines", default: true
+  option :storage_id, desc: "the storage ID where vm's volumes belong to"
+  option :keyword, desc: "filter by keyword"
+  option :command,
+    desc: "command to execute for the given virtual machines",
+    enum: %w(START STOP REBOOT)
+  option :concurrency, type: :numeric, default: 10, aliases: '-C',
+    desc: "number of concurrent command to execute"
+  option :format, default: "table",
+    enum: %w(table json yaml)
+  def list
+    resolve_account
+    resolve_project
+    resolve_zone
+    command = options[:command].downcase if options[:command]
+    options.delete(:command)
+    virtual_machines = client.list_virtual_machines(options)
+    if virtual_machines.size < 1
+      puts "No virtual_machines found."
+    else
+      print_virtual_machines(virtual_machines)
+      execute_virtual_machines_commands(command, virtual_machines) if command
+    end
+  end
+
+  desc "list_from_file FILE", "list virtual machines from file"
+  option :command,
+  desc: "command to execute for the given virtual machines",
+  enum: %w(START STOP REBOOT)
+  option :concurrency, type: :numeric, default: 10, aliases: '-C',
+  desc: "number of concurrent command to execute"
+  option :format, default: :table, enum: %w(table json yaml)
+  def list_from_file(file)
+    virtual_machines = parse_file(file)["virtual_machines"]
+    if virtual_machines.size < 1
+      puts "No virtual machines found."
+    else
+      print_virtual_machines(virtual_machines)
+      execute_virtual_machines_commands(virtual_machines) if options[:command]
+    end
+  end
+
+  desc "show NAME", "show detailed infos about a virtual machine"
+  option :project
+  def show(name)
+    resolve_project
+    options[:name] = name
+    unless virtual_machine = client.list_virtual_machines(options).first
+      puts "No virtual machine found."
+    else
+      table = virtual_machine.map do |key, value|
+        [ set_color("#{key}:", :yellow), "#{value}" ]
+      end
+      print_table table
+    end
+  end
+
+  desc "create NAME [NAME2 ...]", "create virtual machine(s)"
+  option :template, aliases: '-t', desc: "name of the template"
+  option :iso, desc: "name of the iso template"
+  option :offering, aliases: '-o', required: true, desc: "computing offering name"
+  option :zone, aliases: '-z', required: true, desc: "availability zone name"
+  option :networks, aliases: '-n', type: :array, desc: "network names"
+  option :project, aliases: '-p', desc: "project name"
+  option :port_rules, aliases: '-pr', type: :array,
+    default: [],
+    desc: "Port Forwarding Rules [public_ip]:port ..."
+  option :disk_offering, desc: "disk offering (data disk for template, root disk for iso)"
+  option :disk_size, desc: "disk size in GB"
+  option :hypervisor, desc: "only used for iso deployments, default: vmware"
+  option :keypair, desc: "the name of the ssh keypair to use"
+  option :group, desc: "group name"
+  option :account, desc: "account name"
+  def create(*names)
+    vm_options_to_params
+
+    say "Start deploying virtual machine#{ "s" if names.size > 1 }...", :green
+    jobs = names.map do |name|
+      if virtual_machine = client.list_virtual_machines(name: name, project_id: options[:project_id]).first
+        say "virtual_machine #{name} (#{virtual_machine["state"]}) already exists.", :yellow
+        job = {
+          id: 0,
+          name: "Create virtual machine #{name}",
+          status: 1
+        }
+      else
+        job = {
+          id: client.deploy_virtual_machine(options, {sync: true})['jobid'],
+          name: "Create virtual_machine #{name}"
+        }
+      end
+      job
+    end
+    watch_jobs(jobs)
+    if options[:port_rules].size > 0
+      say "Create port forwarding rules...", :green
+      jobs = []
+      names.each do |name|
+        virtual_machine = client.list_virtual_machine(name: name, project_id: options[:project_id]).first
+        create_port_rules(virtual_machine, options[:port_rules], false).each_with_index do |job_id, index|
+          jobs << {
+            id: job_id,
+            name: "Create port forwarding ##{index + 1} rules for virtual machine #{virtual_machine['name']}"
+          }
+        end
+      end
+      watch_jobs(jobs)
+    end
+    say "Finished.", :green
+  end
+
+  desc "destroy NAME [NAME2 ..]", "destroy virtual_machine(s)"
+  option :project
+  option :force, desc: "destroy without asking", type: :boolean, aliases: '-f'
+  option :expunge, desc: "expunge virtual_machine immediately", type: :boolean, default: false, aliases: '-E'
+  def destroy(*names)
+    resolve_project
+    names.each do |name|
+      unless virtual_machine = client.list_virtual_machines(options.merge(name: name, listall: true)).first
+        say "Virtual machine #{name} not found.", :red
+      else
+        ask = "Destroy #{name} (#{virtual_machine['state']})? [y/N]:"
+        if options[:force] || yes?(ask, :yellow)
+          say "destroying #{name} "
+          client.destroy_virtual_machine(
+            id: virtual_machine["id"],
+            expunge: options[:expunge]
+          )
+          puts
+        end
+      end
+    end
+  end
+
+  desc "create_interactive", "interactive creation of a virtual_machine with network access"
+  def create_interactive
+    bootstrap_server_interactive
+  end
+
+  desc "stop NAME", "stop a virtual_machine"
+  option :project
+  option :force
+  def stop(name)
+    resolve_project
+    options[:name] = name
+    options[:listall] = true
+    exit unless options[:force] || yes?("Stop virtual machine #{name}? [y/N]:", :magenta)
+    unless virtual_machine = client.list_virtual_machines(options).first
+      say "Virtual machine #{name} not found.", :red
+      exit 1
+    end
+    client.stop_virtual_machine(id: virtual_machine['id'])
+    puts
+  end
+
+  desc "start NAME", "start a virtual_machine"
+  option :project
+  def start(name)
+    resolve_project
+    options[:name] = name
+    options[:listall] = true
+    unless virtual_machine = client.list_virtual_machines(options).first
+      say "Virtual machine #{name} not found.", :red
+      exit 1
+    end
+    say("Starting virtual_machine #{name}", :magenta)
+    client.start_virtual_machine(id: virtual_machine['id'])
+    puts
+  end
+
+  desc "reboot NAME", "reboot a virtual_machine"
+  option :project
+  option :force
+  def reboot(name)
+    resolve_project
+    options[:name] = name
+    options[:listall] = true
+    unless virtual_machine = client.list_virtual_machines(options).first
+      say "Virtual machine #{name} not found.", :red
+      exit 1
+    end
+    exit unless options[:force] || yes?("Reboot virtual_machine #{name}? [y/N]:", :magenta)
+    client.reboot_virtual_machine(id: virtual_machine['id'])
+    puts
+  end
+
+  no_commands do
+
+    def print_virtual_machines(virtual_machines)
+      case options[:format].to_sym
+      when :yaml
+        puts({'virtual_machines' => virtual_machines}.to_yaml)
+      when :json
+        say JSON.pretty_generate(virtual_machines: virtual_machines)
+      else
+        table = [["Name", "State", "Offering", "Zone", options[:project_id] ? "Project" : "Account", "IP's"]]
+        virtual_machines.each do |virtual_machine|
+          table << [
+            virtual_machine['name'],
+            virtual_machine['state'],
+            virtual_machine['serviceofferingname'],
+            virtual_machine['zonename'],
+            options[:project_id] ? virtual_machine['project'] : virtual_machine['account'],
+            virtual_machine['nic'].map { |nic| nic['ipaddress']}.join(' ')
+          ]
+        end
+        print_table table
+        say "Total number of virtual_machines: #{virtual_machines.count}"
+      end
+    end
+
+    def execute_virtual_machines_commands(command, virtual_machines)
+      unless %w(start stop reboot).include?(command)
+        say "\nCommand #{options[:command]} not supported.", :red
+        exit 1
+      end
+      exit unless yes?("\n#{command.capitalize} the virtual_machine(s) above? [y/N]:", :magenta)
+      virtual_machines.each_slice(options[:concurrency]) do | batch |
+        jobs = batch.map do |virtual_machine|
+          {
+            id: client.send(
+              "#{command}_virtual_machine",
+              { id: virtual_machine['id'] },
+              { sync: true }
+            )['jobid'],
+            name: "#{command.capitalize} virtual_machine #{virtual_machine['name']}"
+          }
+        end
+        puts
+        watch_jobs(jobs)
+      end
+    end
+
+  end # no_commands
+
+end