cloudstack-cli 0.0.1

data/lib/cloudstack-cli/version.rb

@@ -0,0 +1,3 @@
+module CloudstackCli
+  VERSION = "0.0.1"
+end

data/lib/cloudstack-client/client.rb

@@ -0,0 +1,871 @@
+# CloudstackClient by Nik Wolfgramm (<nik.wolfgramm@swisstxt.ch>) based on 
+# knife-cloudstack by Ryan Holmes (<rholmes@edmunds.com>), KC Braunschweig (<kcbraunschweig@gmail.com>)
+# 
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rubygems'
+require 'base64'
+require 'openssl'
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'yaml'
+
+module CloudstackClient
+  class Connection
+
+    @@async_poll_interval = 2.0
+    @@async_timeout = 300
+
+    def initialize(api_url, api_key, secret_key)
+      @api_url = api_url
+      @api_key = api_key
+      @secret_key = secret_key
+      @use_ssl = api_url.start_with? "https"
+    end
+
+    ##
+    # Finds the server with the specified name.
+
+    def get_server(name, project_id=nil)
+      params = {
+          'command' => 'listVirtualMachines',
+          'name' => name
+      }
+      params['projectid'] = project_id if project_id
+      json = send_request(params)
+      machines = json['virtualmachine']
+
+      if !machines || machines.empty? then
+        return nil
+      end
+
+      machines.select {|m| m['name'] == name }.first
+    end
+
+    def get_server_state(id)
+      params = {
+          'command' => 'listVirtualMachines',
+          'id' => id
+      }
+      json = send_request(params)
+      machine_state = json['virtualmachine'][0]['state']
+
+      if !machine_state || machine_state.empty? then
+        return nil
+      end
+
+      machine_state
+    end
+
+    def wait_for_server_state(id, state)
+      while get_server_state(id) != state
+        print '..'
+        sleep 5 
+      end
+      state
+    end
+
+    ##
+    # Finds the public ip for a server
+
+    def get_server_public_ip(server, cached_rules=nil)
+      return nil unless server
+
+      # find the public ip
+      nic = get_server_default_nic(server) || {}
+      if nic['type'] == 'Virtual' then
+        ssh_rule = get_ssh_port_forwarding_rule(server, cached_rules)
+        ssh_rule ? ssh_rule['ipaddress'] : nil
+      else
+        nic['ipaddress']
+      end
+    end
+
+    ##
+    # Returns the fully qualified domain name for a server.
+
+    def get_server_fqdn(server)
+      return nil unless server
+
+      nic = get_server_default_nic(server) || {}
+      networks = list_networks(server['projectid']) || {}
+
+      id = nic['networkid']
+      network = networks.select { |net|
+        net['id'] == id
+      }.first
+      return nil unless network
+
+      "#{server['name']}.#{network['networkdomain']}"
+    end
+
+    def get_server_default_nic(server)
+      server['nic'].each do |nic|
+        return nic if nic['isdefault']
+      end
+    end
+
+    ##
+    # Lists all the servers in your account.
+
+    def list_servers(options = {})
+      params = {
+        'command' => 'listVirtualMachines',
+      }
+      if options[:listall]
+        params['listAll'] = true
+        params['projectId'] = -1
+        options[:account] = nil
+      end
+      params['projectid'] = options[:project_id] if options[:project_id]
+      if options[:account]
+        params['domainid'] = list_accounts({name: options[:account]}).first["domainid"]
+        params['account'] = options[:account]
+      end
+
+      json = send_request(params)
+      json['virtualmachine'] || []
+    end
+
+    ##
+    # Deploys a new server using the specified parameters.
+
+    def create_server(host_name, service_name, template_name, zone_name=nil, network_names=[], project_name=nil)
+      if host_name then
+        if get_server(host_name) then
+          puts "Error: Server '#{host_name}' already exists."
+          exit 1
+        end
+      end
+
+      service = get_service_offering(service_name)
+      if !service then
+        puts "Error: Service offering '#{service_name}' is invalid"
+        exit 1
+      end
+
+      template = get_template(template_name)
+      if !template then
+        puts "Error: Template '#{template_name}' is invalid"
+        exit 1
+      end
+
+      zone = zone_name ? get_zone(zone_name) : get_default_zone
+      if !zone then
+        msg = zone_name ? "Zone '#{zone_name}' is invalid" : "No default zone found"
+        puts "Error: #{msg}"
+        exit 1
+      end
+
+      if project_name
+        project = get_project(project_name)
+        if !project then
+          msg = "Project '#{project_name}' is invalid"
+          puts "Error: #{msg}"
+          exit 1
+        end
+      end
+
+      networks = []
+      network_names.each do |name|
+        network = project_name ? get_network(name, project['id']) : get_network(name)
+        if !network then
+          puts "Error: Network '#{name}' not found"
+          exit 1
+        end
+        networks << network
+      end
+      if networks.empty? then
+        networks << get_default_network
+      end
+      if networks.empty? then
+        puts "No default network found"
+        exit 1
+      end
+      network_ids = networks.map { |network|
+        network['id']
+      }
+
+      params = {
+          'command' => 'deployVirtualMachine',
+          'serviceOfferingId' => service['id'],
+          'templateId' => template['id'],
+          'zoneId' => zone['id'],
+          'networkids' => network_ids.join(',')
+      }
+      params['name'] = host_name if host_name
+      params['projectid'] = project['id'] if project_name
+
+      json = send_async_request(params)
+      json['virtualmachine']
+    end
+
+    ##
+    # Stops the server with the specified name.
+    #
+
+    def stop_server(name, forced=nil)
+      server = get_server(name)
+      if !server || !server['id'] then
+        puts "Error: Virtual machine '#{name}' does not exist"
+        exit 1
+      end
+
+      params = {
+          'command' => 'stopVirtualMachine',
+          'id' => server['id']
+      }
+      params['forced'] = true if forced
+
+      json = send_async_request(params)
+      json['virtualmachine']
+    end
+
+    ##
+    # Start the server with the specified name.
+    #
+
+    def start_server(name)
+      server = get_server(name)
+      if !server || !server['id'] then
+        puts "Error: Virtual machine '#{name}' does not exist"
+        exit 1
+      end
+
+      params = {
+          'command' => 'startVirtualMachine',
+          'id' => server['id']
+      }
+
+      json = send_async_request(params)
+      json['virtualmachine']
+    end
+
+    ##
+    # Reboot the server with the specified name.
+    #
+
+    def reboot_server(name)
+      server = get_server(name)
+      if !server || !server['id'] then
+        puts "Error: Virtual machine '#{name}' does not exist"
+        exit 1
+      end
+
+      params = {
+          'command' => 'rebootVirtualMachine',
+          'id' => server['id']
+      }
+
+      json = send_async_request(params)
+      json['virtualmachine']
+    end
+
+    ##
+    # Finds the service offering with the specified name.
+
+    def get_service_offering(name)
+
+      # TODO: use name parameter
+      # listServiceOfferings in CloudStack 2.2 doesn't seem to work
+      # when the name parameter is specified. When this is fixed,
+      # the name parameter should be added to the request.
+      params = {
+          'command' => 'listServiceOfferings'
+      }
+      json = send_request(params)
+
+      services = json['serviceoffering']
+      return nil unless services
+
+      services.each { |s|
+        if s['name'] == name then
+          return s
+        end
+      }
+
+      nil
+    end
+
+    ##
+    # Lists all available service offerings.
+
+    def list_service_offerings(domain = nil)
+      params = {
+          'command' => 'listServiceOfferings'
+      }
+
+      if domain
+        params['domainid'] = list_domains(domain).first["id"]
+      end
+
+      json = send_request(params)
+      json['serviceoffering'] || []
+    end
+
+    ##
+    # Create a service offering.
+
+    def create_offering(args)
+      params = {
+          'command' => 'createServiceOffering',
+          'name' => args[:name],
+          'cpunumber' => args[:cpunumber],
+          'cpuspeed' => args[:cpuspeed],
+          'displaytext' => args[:displaytext],
+          'memory' => args[:memory]
+      }
+
+      if args['domain']
+        params['domainid'] = list_domains(args['domain']).first["id"]
+      end
+
+      params['tags'] = args[:tags] if args[:tags]
+      params['offerha'] = 'true' if args[:ha]
+
+      json = send_request(params)
+      json['serviceoffering'].first
+    end
+
+    ##
+    # Delete a service offering.
+
+    def delete_offering(id)
+      params = {
+          'command' => 'deleteServiceOffering',
+          'id' => id
+      }
+
+      json = send_request(params)
+      json['success']
+    end
+
+    def update_offering(args)
+      params = {
+          'command' => 'updateServiceOffering',
+          'id' => args['id']
+      }
+      params['name'] = args['name'] if args['name']
+      params['displaytext'] = args['displaytext'] if args['displaytext']
+      params['sortkey'] = args['sortkey'] if args['sortkey']
+
+      json = send_request(params)
+      json['serviceoffering']
+    end
+
+    ##
+    # Finds the template with the specified name.
+
+    def get_template(name)
+
+      # TODO: use name parameter
+      # listTemplates in CloudStack 2.2 doesn't seem to work
+      # when the name parameter is specified. When this is fixed,
+      # the name parameter should be added to the request.
+      params = {
+          'command' => 'listTemplates',
+          'templateFilter' => 'executable'
+      }
+      json = send_request(params)
+
+      templates = json['template']
+      if !templates then
+        return nil
+      end
+
+      templates.each { |t|
+        if t['name'] == name then
+          return t
+        end
+      }
+
+      nil
+    end
+
+    ##
+    # Lists all templates that match the specified filter.
+    #
+    # Allowable filter values are:
+    #
+    # * featured - templates that are featured and are public
+    # * self - templates that have been registered/created by the owner
+    # * self-executable - templates that have been registered/created by the owner that can be used to deploy a new VM
+    # * executable - all templates that can be used to deploy a new VM
+    # * community - templates that are public
+
+    def list_templates(filter, project_id = nil)
+      filter ||= 'featured'
+      params = {
+          'command' => 'listTemplates',
+          'templateFilter' => filter
+      }
+      params['projectid'] = project_id if project_id
+      
+      json = send_request(params)
+      json['template'] || []
+    end
+
+    ##
+    # Finds the network with the specified name.
+
+    def get_network(name, project_id = nil)
+      params = {
+          'command' => 'listNetworks',
+          'listall' => true
+      }
+      params['projectid'] = project_id if project_id
+      json = send_request(params)
+
+      networks = json['network']
+      return nil unless networks
+
+      networks.each { |n|
+        if n['name'] == name then
+          return n
+        end
+      }
+
+      nil
+    end
+
+    ##
+    # Finds the default network.
+
+    def get_default_network
+      params = {
+          'command' => 'listNetworks',
+          'isDefault' => true
+      }
+      json = send_request(params)
+
+      networks = json['network']
+      return nil if !networks || networks.empty?
+
+      default = networks.first
+      return default if networks.length == 1
+
+      networks.each { |n|
+        if n['type'] == 'Direct' then
+          default = n
+          break
+        end
+      }
+
+      default
+    end
+
+    ##
+    # Lists all available networks.
+
+    def list_networks(project_id = nil)
+      params = {
+          'command' => 'listNetworks',
+          'listall' => true,
+      }
+      params['projectid'] = project_id if project_id
+      json = send_request(params)
+      json['network'] || []
+    end
+
+    ##
+    # Lists all physical networks.
+
+    def list_physical_networks
+      params = {
+          'command' => 'listPhysicalNetworks',
+      }
+      json = send_request(params)
+      json['physicalnetwork'] || []
+    end
+
+    ##
+    # Lists all volumes.
+
+    def list_volumes(project_id = nil)
+      params = {
+          'command' => 'listVolumes',
+          'listall' => true,
+      }
+      params['projectid'] = project_id if project_id
+      json = send_request(params)
+      json['network'] || []
+    end
+
+    ##
+    # Finds the zone with the specified name.
+
+    def get_zone(name)
+      params = {
+          'command' => 'listZones',
+          'available' => 'true'
+      }
+      json = send_request(params)
+
+      networks = json['zone']
+      return nil unless networks
+
+      networks.each { |z|
+        if z['name'] == name then
+          return z
+        end
+      }
+
+      nil
+    end
+
+    ##
+    # Finds the default zone for your account.
+
+    def get_default_zone
+      params = {
+          'command' => 'listZones',
+          'available' => 'true'
+      }
+      json = send_request(params)
+
+      zones = json['zone']
+      return nil unless zones
+
+      zones.first
+    end
+
+    ##
+    # Lists all available zones.
+
+    def list_zones
+      params = {
+          'command' => 'listZones',
+          'available' => 'true'
+      }
+      json = send_request(params)
+      json['zone'] || []
+    end
+
+    ##
+    # Finds the public ip address for a given ip address string.
+
+    def get_public_ip_address(ip_address)
+      params = {
+          'command' => 'listPublicIpAddresses',
+          'ipaddress' => ip_address
+      }
+      json = send_request(params)
+      ip_address = json['publicipaddress']
+
+      return nil unless ip_address
+      ip_address.first
+    end
+
+
+    ##
+    # Acquires and associates a public IP to an account.
+
+    def associate_ip_address(network_id)
+      params = {
+          'command' => 'associateIpAddress',
+          'networkid' => network_id
+      }
+
+      json = send_async_request(params)
+      json['ipaddress']
+    end
+
+    ##
+    # Disassociates an ip address from the account.
+    #
+    # Returns true if successful, false otherwise.
+
+    def disassociate_ip_address(id)
+      params = {
+          'command' => 'disassociateIpAddress',
+          'id' => id
+      }
+      json = send_async_request(params)
+      json['success']
+    end
+
+    ##
+    # Lists all port forwarding rules.
+
+    def list_port_forwarding_rules(ip_address_id=nil)
+      params = {
+          'command' => 'listPortForwardingRules'
+      }
+      params['ipAddressId'] = ip_address_id if ip_address_id
+      json = send_request(params)
+      json['portforwardingrule']
+    end
+
+    ##
+    # Gets the SSH port forwarding rule for the specified server.
+
+    def get_ssh_port_forwarding_rule(server, cached_rules=nil)
+      rules = cached_rules || list_port_forwarding_rules || []
+      rules.find_all { |r|
+        r['virtualmachineid'] == server['id'] &&
+            r['privateport'] == '22'&&
+            r['publicport'] == '22'
+      }.first
+    end
+
+    ##
+    # Creates a port forwarding rule.
+
+    def create_port_forwarding_rule(ip_address_id, private_port, protocol, public_port, virtual_machine_id)
+      params = {
+          'command' => 'createPortForwardingRule',
+          'ipAddressId' => ip_address_id,
+          'privatePort' => private_port,
+          'protocol' => protocol,
+          'publicPort' => public_port,
+          'virtualMachineId' => virtual_machine_id
+      }
+      json = send_async_request(params)
+      json['portforwardingrule']
+    end
+
+    ##
+    # Get project by name.
+
+    def get_project(name)
+      params = {
+          'command' => 'listProjects',
+          'name' => name,
+          'listall' => true,
+      }
+      json = send_request(params)
+      json['project'] ? json['project'].first : nil
+    end
+
+    ##
+    # Lists projects.
+            
+    def list_projects
+      params = {
+          'command' => 'listProjects',
+          'listall' => true,
+      }
+      json = send_request(params)
+      json['project'] || []
+    end
+
+    ##
+    # List loadbalancer rules
+
+    def list_load_balancer_rules(name = nil, project_name = nil)    
+      params = {
+        'command' => 'listLoadBalancerRules',
+      }
+      params['name'] = name if name
+
+      if project_name
+        project = get_project(project_name)
+        params['projectid'] = project['id']
+      end
+
+      json = send_request(params)
+      json['loadbalancerrule'] || []
+    end
+
+    ##
+    # Creates a load balancing rule.
+
+    def create_load_balancer_rule(name, publicip, private_port, public_port, options = {})
+      params = {
+          'command' => 'createLoadBalancerRule',
+          'name' => name,
+          'privateport' => private_port,
+          'publicport' => public_port,
+          'publicipid' => get_public_ip_address(publicip)['id']
+      }
+      params['algorithm'] = options[:algorithm] || 'roundrobin'
+      params['openfirewall'] = options[:openfirewall] || true
+
+      json = send_async_request(params)
+      json['LoadBalancerRule']
+    end
+
+    ##
+    # Assigns virtual machine or a list of virtual machines to a load balancer rule.
+
+    def assign_to_load_balancer_rule(name, vm_names)
+      id = list_load_balancer_rules(name).first['id']
+
+      vm_ids = vm_names.map do |vm|
+        get_server(vm)['id']
+      end
+
+      params = {
+          'command' => 'assignToLoadBalancerRule',
+          'id' => id,
+          'virtualmachineids' => vm_ids.join(',')
+      }
+      json = send_async_request(params)
+    end
+
+    ##
+    # Lists all virtual routers.
+
+    def list_routers(args = {:account => nil, :zone => nil, :projectid => nil, :status => nil, :name => nil})
+      params = {
+          'command' => 'listRouters',
+          'listall' => 'true',
+          'isrecursive' => 'true'
+      }
+      params['zone'] = args[:zone] if args[:zone]
+      params['projectid'] = args[:projectid] if args[:projectid]
+      params['state'] = args[:status] if args[:status]
+      params['name'] = args[:name] if args[:name]
+      if args[:account]
+        params['domainid'] = list_accounts({name: args[:account]}).first["domainid"]
+        params['account'] = args[:account]
+      end
+
+      json = send_request(params)
+      json['router'] || []
+    end
+
+    ##
+    # Destroy virtual router.
+
+    def destroy_router(id)
+      params = {
+        'command' => 'destroyRouter',
+        'id' => id
+      }
+
+      json = send_request(params)
+      json['router'].first
+    end
+
+    ##
+    # Lists accounts.
+
+    def list_accounts(args = { :name => nil })
+      params = {
+        'command' => 'listAccounts',
+        'listall' => 'true',
+        'isrecursive' => 'true'
+      }
+      params['name'] = args[:name] if args[:name]
+
+      json = send_request(params)
+      json['account'] || []
+    end
+
+    ##
+    # List domains.
+
+    def list_domains(name = nil)
+      params = {
+        'command' => 'listDomains',
+        'listall' => 'true',
+        'isrecursive' => 'true'
+      }
+      params['name'] = name if name
+
+      json = send_request(params)
+      json['domain'] || []
+    end
+
+    ##
+    # Sends a synchronous request to the CloudStack API and returns the response as a Hash.
+    #
+    # The wrapper element of the response (e.g. mycommandresponse) is discarded and the
+    # contents of that element are returned.
+
+    def send_request(params)
+      params['response'] = 'json'
+      params['apiKey'] = @api_key
+
+      params_arr = []
+      params.sort.each { |elem|
+        params_arr << elem[0].to_s + '=' + CGI.escape(elem[1].to_s).gsub('+', '%20').gsub(' ','%20')
+      }
+      data = params_arr.join('&')
+      signature = OpenSSL::HMAC.digest('sha1', @secret_key, data.downcase)
+      signature = Base64.encode64(signature).chomp
+      signature = CGI.escape(signature)
+
+      url = "#{@api_url}?#{data}&signature=#{signature}"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = @use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      begin
+        response = http.request(Net::HTTP::Get.new(uri.request_uri))
+      rescue
+        puts "Error connecting to API:"
+        puts "#{@api_url} is not reachable"
+        exit 1
+      end
+
+      if !response.is_a?(Net::HTTPOK) then
+        puts "Error #{response.code}: #{response.message}"
+        puts JSON.pretty_generate(JSON.parse(response.body))
+        puts "URL: #{url}"
+        exit 1
+      end
+
+      json = JSON.parse(response.body)
+      json[params['command'].downcase + 'response']
+    end
+
+    ##
+    # Sends an asynchronous request and waits for the response.
+    #
+    # The contents of the 'jobresult' element are returned upon completion of the command.
+
+    def send_async_request(params)
+
+      json = send_request(params)
+
+      params = {
+          'command' => 'queryAsyncJobResult',
+          'jobId' => json['jobid']
+      }
+
+      max_tries = (@@async_timeout / @@async_poll_interval).round
+      max_tries.times do
+        json = send_request(params)
+        status = json['jobstatus']
+
+        print "."
+
+        if status == 1 then
+          return json['jobresult']
+        elsif status == 2 then
+          print "\n"
+          puts "Request failed (#{json['jobresultcode']}): #{json['jobresult']}"
+          exit 1
+        end
+
+        STDOUT.flush
+        sleep @@async_poll_interval
+      end
+
+      print "\n"
+      puts "Error: Asynchronous request timed out"
+      exit 1
+    end
+
+  end # class
+end