cloudstack-cli 0.0.1

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

@@ -0,0 +1,15 @@
+class Project < Thor
+
+  desc "list", "list projects"
+  def list
+    cs_cli = CloudstackCli::Helper.new
+    projects = cs_cli.projects
+    if projects.size < 1
+      puts "No projects found"
+    else
+      projects.each do |project|
+        puts "#{project['name']} - #{project['displaytext']} - #{project['domain']}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+class Publicip < Thor
+
+  desc "remove ID", "remove public IP address"
+  def remove(id)
+    cs_cli = CloudstackCli::Helper.new
+    puts "OK" if cs_cli.remove_publicip(id)
+  end
+
+end

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

@@ -0,0 +1,94 @@
+class Router < Thor
+	include CommandLineReporter
+
+	desc "list", "list virtual routers"
+  option :project
+  option :account
+  option :status, desc: "Running or Stopped"
+  option :redundant_state, desc: "MASTER, BACKUP or UNKNOWN"
+  option :listall, type: :boolean
+  option :text, type: :boolean, desc: "text output (only the instance name)"
+  def list
+		cs_cli = CloudstackCli::Helper.new
+   	if options[:project]
+    	project = cs_cli.projects.select { |p| p['name'] == options[:project] }.first
+     	raise "Project '#{options[:project]}' not found" unless project
+     	projectid = project['id']
+   	end
+
+		routers = cs_cli.list_routers(
+			{
+				account: options[:account], 
+				projectid: projectid,
+				status: options[:status],
+			}, 
+			options[:redundant_state]
+		)
+
+
+		if options[:listall]
+			projects = cs_cli.projects
+			projects.each do |project|
+		  	routers = routers + cs_cli.list_routers(
+		  		{
+		  			account: options[:account],
+		  			projectid: project['id'],
+		  			status: options[:status]
+		  		},
+		  		options[:redundant_state]
+		  	)
+		  end
+		end
+
+		if options[:text]
+			puts routers.map {|r| r['name']}.join(" ")
+		else
+		  puts "Total number of routers: #{routers.size}"
+			table(border: true) do
+	    	row do
+	    		column 'ID', width: 40
+	        column 'Name'
+	        column 'Zone'
+	        column 'Account', width: 14 unless options[:project]
+	        column 'Project', width: 14 if options[:listall] || options[:project]
+	        column 'Redundant State'
+	        column 'Linklocal IP', width: 15
+	        column 'Status'
+	      end
+	      routers.each do |router|
+	        row do
+	        	column router["id"]
+	          column router["name"]
+	          column router["zonename"]
+	          column router["account"] unless options[:project]
+	          column router["project"] if options[:listall] || options[:project]
+	          column router["redundantstate"]
+	          column router["linklocalip"]
+	          column router["state"]
+	        end
+	      end
+	    end
+	  end
+
+  end
+
+  desc "stop NAME", "stop virtual router"
+  option :project
+
+  def stopall
+
+  end
+
+  desc "start NAME", "start virtual router"
+  option :project
+  def start
+
+  end
+
+  desc "destroy ID", "destroy virtual router"
+  def destroy(id)
+  	cs_cli = CloudstackCli::Helper.new
+  	puts "OK" if cs_cli.destroy_router(name)
+  end
+
+end

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

@@ -0,0 +1,65 @@
+class Server < Thor
+
+  desc "list", "list servers"
+  option :listall, :type => :boolean
+  option :text, :type => :boolean
+  option :project
+  option :account
+  def list
+    cs_cli = CloudstackCli::Helper.new
+    if options[:project]
+      project = cs_cli.projects.select { |p| p['name'] == options[:project] }.first
+      exit_now! "Project '#{options[:project]}' not found" unless project
+      options[:project_id] = project['id']
+      options[:account] = nil
+    end
+    servers = cs_cli.virtual_machines(options)
+    if servers.size < 1
+      puts "No servers found"
+    else
+      if options[:text]
+        servers.each do |server|
+          puts "#{server['name']} - #{server['state']} - #{server['domain']}"
+        end
+      else
+        cs_cli.virtual_machines_table(servers)
+      end
+    end
+  end
+
+  desc "create NAME", "create a server"
+  option :zone, :required => true
+  option :template, :required => true
+  option :offering, :required => true
+  option :networks, :type => :array, :required => true
+  option :project
+  option :port_forwarding, :type => :array, :aliases => :pf, :default => [], :description => "public_ip:port"
+  option :interactive, :type => :boolean
+  def create(name)
+    CloudstackCli::Cli.new.bootstrap_server(
+        name,
+        options[:zone],
+        options[:template],
+        options[:offering],
+        options[:networks],
+        options[:port_forwarding],
+        options[:project]
+      )
+  end
+
+  desc "stop NAME", "stop a server"
+  def stop(name)
+    CloudstackCli::Cli.new.stop_server(name)
+  end
+
+  desc "start NAME", "start a server"
+  def start(name)
+    CloudstackCli::Cli.new.start_server(name)
+  end
+
+  desc "reboot NAME", "reboot a server"
+  def restart(name)
+    CloudstackCli::Cli.new.reboot_server(name)
+  end
+
+end

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

@@ -0,0 +1,16 @@
+class Stack < Thor
+
+	desc "create STACKFILE", "create a stack of servers"
+  def create(stackfile)
+    CloudstackCli::Cli.new.bootstrap_server(
+        name,
+        options[:zone],
+        options[:template],
+        options[:offering],
+        options[:networks],
+        options[:port_forwarding],
+        options[:project]
+      )
+  end
+
+end

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

@@ -0,0 +1,25 @@
+class Template < Thor
+
+  desc 'list', 'list templates by type [featured|self|self-executable|executable|community]' 
+  option :project
+  def list(type='featured')
+    cs_cli = CloudstackCli::Helper.new
+    
+    if options[:project]
+      project = cs_cli.projects.select { |p| p['name'] == options[:project] }.first
+      exit_now! "Project '#{options[:project]}' not found" unless project
+    end
+    
+    exit_now! "unsupported template type '#{type}'" unless
+      %w(featured self self-executable executable community).include? type
+    templates = cs_cli.templates(type, project ? project['id'] : nil)
+    if templates.size < 1
+      puts "No templates found"
+    else
+      templates.each do |template|
+        puts template['name']
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,20 @@
+class Volume < Thor
+  desc "list", "list networks"
+  option :project
+  def list
+    cs_cli = CloudstackCli::Helper.new
+    if options[:project]
+      project = cs_cli.projects.select { |p| p['name'] == options[:project] }.first
+      raise "Project '#{options[:project]}' not found" unless project
+    end
+    
+    networks = cs_cli.networks(project ? project['id'] : nil)
+    if networks.size < 1
+      puts "No networks found"
+    else
+      networks.each do |network|
+        puts "#{network['name']} - #{network['displaytext']} #{' - Default' if network['isdefault']}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class Zone < Thor
+
+  desc "list", "list zones"
+  def list
+    cs_cli = CloudstackCli::Helper.new
+    zones = cs_cli.zones
+    if zones.size < 1
+      puts "No projects found"
+    else
+      zones.each do |zone|
+        puts "#{zone['name']} - #{zone['description']}"
+      end
+    end
+  end
+
+end

data/lib/cloudstack-cli/helper.rb

@@ -0,0 +1,236 @@
+module CloudstackCli
+  class Helper
+    include CommandLineReporter
+
+    attr_reader :cs
+
+    def initialize 
+	    @cs = CloudstackClient::Connection.new(
+	      options[:cloudstack_url],
+	      options[:cloudstack_api_key],
+	      options[:cloudstack_secret_key]
+	    )
+    end
+
+    def remove_publicip(id)
+      @cs.disassociate_ip_address(id)
+    end
+
+    def domains(name = nil)
+      @cs.list_domains(name)
+    end
+
+    def server_offerings(domain = nil)
+      @server_offerings ||= @cs.list_service_offerings(domain)
+    end
+
+    def create_offering(params)
+      @cs.create_offering(params)
+    end
+
+    def delete_offering(id)
+      @cs.delete_offering(id)
+    end
+
+    def update_offering(args)
+      @cs.update_offering(args)
+    end
+    
+    def templates(type = 'featured', project_id)
+      @templates ||= @cs.list_templates(type, project_id)
+    end
+
+    def projects
+      @projects ||= @cs.list_projects
+    end
+
+    def zones
+      @zones ||= @cs.list_zones
+    end
+
+    def networks(project_id = nil)
+      @cs.list_networks(project_id)
+    end
+
+    def physical_networks
+      @cs.list_physical_networks
+    end
+
+    def volumes(project_id = nil)
+      @cs.list_volumes(project_id)
+    end
+    
+    def virtual_machines(options = {})
+      @cs.list_servers(options)
+    end
+    
+    def virtual_machines_table(vms)
+      table(border: true) do
+        row do
+          column 'Name', width: 20
+          column 'State'
+          column 'Offering', align: 'right'
+          column 'Template', align: 'right', width: 30
+          column 'IP\'s', width: 14
+          column 'Project'
+          column 'Account'
+        end
+        vms.each do |vm|
+          row do
+            column vm['name']
+            column vm['state']
+            column vm['serviceofferingname']
+            column vm['templatename']
+            column vm['nic'].map { |nic| nic['ipaddress']}.join(" ")
+            column vm['project']
+            column vm['account']
+          end
+        end
+      end
+    end
+
+    def bootstrap_server(name, zone, template, offering, networks, pf_rules = [], project = nil)
+  		puts "Create server #{name}...".color(:yellow)
+  		server = @cs.create_server(
+  			name,
+  			offering,
+  			template,
+  			zone,
+  			networks,
+  			project
+  		)
+
+  		puts
+  		puts "Server #{server["name"]} has been created.".color(:green)
+  		puts
+  		puts "Make sure the server is running...".color(:yellow)
+  		@cs.wait_for_server_state(server["id"], "Running")
+  		puts "OK!".color(:green)
+  		puts
+  		puts "Get the fqdn of the server...".color(:yellow)
+  		server_fqdn = @cs.get_server_fqdn(server)
+  		puts "FQDN is #{server_fqdn}".color(:green)
+
+  		if pf_rules.size > 0
+  			puts
+  			pf_rules.each do |pf_rule|
+          ip = pf_rule.split(":")[0]
+  				ip_addr = @cs.get_public_ip_address(ip)
+  				port = pf_rule.split(":")[1]
+  			  	print "Create port forwarding rule #{ip}:#{port} ".color(:yellow)
+  			  	@cs.create_port_forwarding_rule(ip_addr["id"], port, 'TCP', port, server["id"])
+  			  	puts
+  			end
+  		end
+
+  		puts
+  		puts "Complete!".color(:green)
+    end
+
+    def stop_server(name)
+      @cs.stop_server(name)
+    end
+
+    def start_server(name)
+      @cs.start_server(name)
+    end
+
+    def reboot_server(name)
+      @cs.reboot_server(name)
+    end
+
+    def list_accounts(name = nil)
+      @cs.list_accounts({ name: name })
+    end 
+
+    def list_load_balancer_rules(project = nil)
+      @cs.list_load_balancer_rules(project)
+    end
+
+    def create_load_balancer_rule(name, ip, private_port, public_port, options = {})
+      puts "Create rule #{name}...".color(:yellow)
+      @cs.create_load_balancer_rule(name, ip, private_port, public_port, options = {})
+      puts "OK!".color(:green)
+    end
+
+    def assign_to_load_balancer_rule(id, names)
+      puts "Add #{names.join(', ')} to rule #{id}...".color(:yellow)
+      rule = @cs.assign_to_load_balancer_rule(id, names)
+      if rule['success']
+        puts "OK!".color(:green)
+      else
+        puts "Failed!".color(:red)
+      end
+    end
+
+    def list_routers(args, redundant_state = nil)
+      routers = @cs.list_routers(args)
+      if redundant_state
+       return  routers.select {|r| r['redundantstate'].downcase == redundant_state.downcase }
+      end
+      routers
+    end
+
+    def destroy_router(id)
+      @cs.destroy_router(id)
+    end
+
+    def options
+    	 @options ||= CloudstackClient::ConnectionHelper.load_configuration()
+    end
+
+    def print_options(options, attr = 'name')
+    	options.to_enum.with_index(1).each do |option, i|
+    	   puts "#{i}: #{option[attr]}"
+    	end 	
+    end
+
+    def interactive
+      ARGV.clear 
+    	puts
+    	puts %{We are going to deploy a new server and...
+    	 - assign a public IP address
+    	 - create a firewall rule for SSH and HTTP access
+    	 - connect to the server and install the puppet client}.color(:magenta)
+    	puts
+
+    	print "Please provide a name for the new server".background(:blue)
+    	puts " (spaces or special characters are NOT allowed): "
+    	server_name = gets.chomp
+
+    	if projects.size > 0
+    	  puts "Select a project".background(:blue)
+    	  print_options(projects)
+    	  project = gets.chomp.to_i - 1
+    	end
+
+    	puts "Select a computing offering:".background(:blue)
+    	print_options(server_offerings)
+    	service_offering = gets.chomp.to_i - 1
+
+    	puts "Select a template:".background(:blue)
+    	print_options(templates)
+    	template = gets.chomp.to_i - 1
+
+    	puts "Select a availability zone:".background(:blue)
+    	print_options(zones)
+    	zone = gets.chomp.to_i - 1
+	
+    	# FIXME: show only networks in selected zone
+    	puts "Select a network:".background(:blue)
+    	project_id = projects[project]['id'] rescue nil
+    	networks = @cs.list_networks(project_id)
+    	print_options(networks)
+    	network = gets.chomp.to_i - 1
+
+    	bootstrap_server(
+    	  server_name,
+    	  zones[zone]["name"],
+    	  templates[template]["name"],
+    	  server_offerings[service_offering]["name"],
+    	  [networks[network]["name"]],
+    	  projects[project]["name"]
+    	)
+    end
+  end
+end