profitbricks 0.0.1

data/lib/profitbricks/extensions.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/.+::/, '').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/profitbricks/image.rb

@@ -0,0 +1,47 @@
+module Profitbricks
+  class Image < Profitbricks::Model
+
+    # Sets the OS Type of an individual HDD and/or CD-ROM/DVD image that has been uploaded on the ProfitBricks FTP server.  
+    # 
+    # @param [String] OS Type of the target HDD or CD-ROM/DVD image (WINDOWS, OTHER)
+    # @return [Image] Updated Image Object
+    def set_os_type(type)
+      raise ArgumentError.new(":os_type has to be either 'WINDOWS' or 'OTHER'") if !['WINDOWS', 'OTHER'].include? type
+      response = Profitbricks.request :set_image_os_type, "<imageId>#{self.id}</imageId><osType>#{type}</osType>"
+      @os_type = type
+      self
+    end
+    alias_method :os_type=, :set_os_type
+
+    class << self
+      # Returns information about a HDD or CD-ROM/DVD (ISO) image. 
+      #
+      # @param [Hash] options either name or id of the Image
+      # @option options [String] :name The name of the Image
+      # @option options [String] :id The id of the Image
+      # @return [Image] The found Image Object 
+      def find(options = {})
+        image = nil
+        if options[:name]
+          image = PB::Image.all().select { |d| d.name == options[:name] }.first
+          options[:id] = image.id if image
+        end
+        raise "Unable to locate the image named '#{options[:name]}'" unless options[:id]
+        image
+        # This does not work for public images
+        #response = Profitbricks.request :get_image, "<imageId>#{options[:id]}</imageId>"
+        #PB::Image.new(response.to_hash[:get_image_response][:return])
+      end
+      
+      # Outputs a list of all HDD and/or CD-ROM/DVD images existing on or uploaded to the Profit-Bricks FTP server. 
+      #
+      # @return [Array<Image>] List of all available Images
+      def all
+        resp = Profitbricks.request :get_all_images
+        resp.to_hash[:get_all_images_response][:return].collect do |dc|
+          PB::Image.new(dc)
+        end
+      end
+    end
+  end
+end

data/lib/profitbricks/ip_block.rb

@@ -0,0 +1,49 @@
+module Profitbricks
+  class IpBlock < Profitbricks::Model
+    attr_reader :ips
+
+    def initialize(hash)
+      if hash[:public_ips]
+        @ips = [hash.delete(:public_ips)].flatten.compact.collect { |ip| ip[:ip] }
+      end
+      super(hash)
+      @ips = [@ips] if @ips.class != Array
+    end
+
+    def id
+      @block_id
+    end
+
+    # Releases an existing block of reserved public IPs.
+    #
+    # @return [Boolean] true on success, false otherwise
+    def release
+      response = Profitbricks.request :release_public_ip_block, "<blockId>#{self.id}</blockId>"
+      return true if response.to_hash[:release_public_ip_block_response][:return]
+    end
+
+    class << self
+      # Returns a list of all public IP blocks reserved by the user, including the reserved IPs and connected NICs.
+      #
+      # @return [Array<IpBlock>] List of all IpBlocks
+      def all
+        response = Profitbricks.request :get_all_public_ip_blocks
+        datacenters = response.to_hash[:get_all_public_ip_blocks_response][:return]
+        [datacenters].flatten.compact.collect do |block|
+          PB::IpBlock.new(block)
+        end
+      end
+
+      # Reserves a specific amount of public IPs which can be manually assigned to a NIC by the user.
+      #
+      # @param [Fixnum] Block size / amount of IPs to reserve
+      # @return [IpBlock] The reserved IpBlock
+      def reserve(amount)
+        response = Profitbricks.request :reserve_public_ip_block, "<blockSize>#{amount}</blockSize>"
+        return PB::IpBlock.new(response.to_hash[:reserve_public_ip_block_response][:return])
+      end
+
+
+    end
+  end
+end

data/lib/profitbricks/model.rb

@@ -0,0 +1,102 @@
+module Profitbricks
+	class Model
+    @@associations = {}
+
+    def initialize(hash = {})
+      klass = self.class.to_s.underscore
+      hash.keys.each do |k|
+        attribute = k.to_s.sub("#{klass}_", '').to_sym
+        if @@associations[attribute]
+          initialize_association(attribute, @@associations[attribute], hash[k])
+        else
+          initialize_getter(attribute, type_cast(hash[k]))
+        end
+        
+      end
+    end
+
+    def reload
+      updated = self.class.find(:id => self.id)
+      update_attributes(updated)
+    end
+
+    def self.has_many(model)
+      klass = Profitbricks.get_class model[0..-2].camelcase
+      @@associations[model] = {:type => :collection, :class => klass}
+      define_method(model) { instance_variable_get("@#{model}") }
+    end
+
+    def self.belongs_to(model)
+      klass = Profitbricks.get_class model.to_s.camelcase
+      @@associations[model] = {:type => :belongs_to, :class => klass}
+      define_method(model) { instance_variable_get("@#{model}") }
+    end
+
+    def get_xml_and_update_attributes(hash, attributes=nil)
+      attributes = hash.keys if attributes.nil?
+      attributes.each do |a|
+        initialize_getter(a, hash[a]) if hash[a]
+      end
+      hash, attributes = self.class.expand_attributes(hash, attributes, self.class)
+      xml = self.class.build_xml(hash, attributes)
+    end
+
+    def self.get_xml_and_update_attributes(hash, attributes=[])
+      hash, attributes = expand_attributes(hash, attributes, name())
+      self.build_xml(hash, attributes)
+    end
+
+    private
+    def update_attributes(updated)
+      self.instance_variables.each do |var|
+        self.instance_variable_set(var, updated.instance_variable_get(var))
+      end
+      true
+    end
+
+    def type_cast(value)
+      return value.to_i if value =~ /^\d+$/
+      value
+    end
+
+    def self.build_xml(hash ,attributes)
+      attributes.collect do |a|
+        "<#{a.to_s.lower_camelcase}>#{hash[a]}</#{a.to_s.lower_camelcase}>" if hash[a]
+      end.join('')
+    end
+
+    def initialize_getter name, value=nil
+      self.class.send :define_method, name do 
+        instance_variable_get("@#{name}")
+      end
+      self.instance_variable_set("@#{name}", value) if value
+    end
+
+    def initialize_association name, association, value
+      if association[:type] == :collection
+        initialize_collection_association name, association, value
+      elsif association[:type] == :belongs_to
+        initialize_belongs_to_association name, association, value
+      end
+    end
+
+    def initialize_collection_association name, association, value
+      self.instance_variable_set("@#{name}", [])
+      [value].flatten.compact.each do |object|
+        instance_variable_get("@#{name}").send(:push, association[:class].send(:new, object))
+      end
+    end
+
+    def initialize_belongs_to_association name, association, value
+      self.instance_variable_set("@#{name}", association[:class].send(:new, value))
+    end
+
+    def self.expand_attributes(hash, attributes, klass=nil)
+      name =  hash.delete(:name)
+      hash["#{klass.to_s.underscore}_name"] = name
+      attributes.delete(:name)
+      attributes.push "#{klass.to_s.underscore}_name"
+      return hash, attributes
+    end
+	end
+end

data/lib/profitbricks/nic.rb

@@ -0,0 +1,103 @@
+module Profitbricks
+  class Ip < Profitbricks::Model; end;
+
+  class Nic < Profitbricks::Model
+
+    def initialize(hash)
+      super(hash)
+      @ips = [@ips] if @ips.class != Array
+    end
+
+    # Connects or disconnects an existing NIC to a public LAN to get internet access. 
+    #
+    # @param [Boolean] Internet access (trUe/false)
+    # @return [Boolean] true on success, false otherwise
+    def set_internet_access=(value)
+      xml = get_xml_and_update_attributes :data_center_id => self.data_center_id, :lan_id => self.lan_id, :land_id => self.lan_id, :internet_access => value
+      response = Profitbricks.request :set_internet_access, xml
+      return true if response.to_hash[:set_internet_access_response][:return]
+    end
+
+    # Changes the settings of an existing NIC. 
+    # 
+    # @param [Hash] options parameters to update
+    # @option options [Fixnum] :server_id Identifier of the target virtual server (required)
+    # @option options [Fixnum] :lan_id Identifier of the target LAN > 0 that is to be connected to the specified virtual server. If no LAN exists for such ID, a new LAN with the given ID will be created.
+    # @option options [String] :ip Public/private IP address.
+    # @option options [String] :name Names the NIC
+    # @return [Boolean] true on success, false otherwise
+    def update(options = {})
+      xml = "<arg0>"
+      options.merge!(:nic_id => self.id)
+      xml += get_xml_and_update_attributes options , [:nic_id, :lan_id, :server_id, :ip, :name]
+      xml += "</arg0>"
+      response = Profitbricks.request :update_nic, xml
+      return true if response.to_hash[:update_nic_response][:return]
+    end
+
+    # Adds an existing reserved public IP to a NIC. This operation is required, when dealing with reserved public IPs to ensure proper routing by the ProfitBricks cloud networking layer.
+    #
+    # @param [String] Reserved IP
+    def add_ip(ip)
+      response = Profitbricks.request :add_public_ip_to_nic, "<nicId>#{self.id}</nicId><ip>#{ip}</ip>"
+      @ips.push ip
+      return true if response.to_hash[:add_public_ip_to_nic_response][:return]
+    end
+
+    # Removes a reserved public IP from a NIC. This operation is required, when dealing with reserved public IPs to ensure proper routing by the ProfitBricks cloud networking layer.
+    #
+    # @param [String] Reserved IP
+    def remove_ip(ip)
+      response = Profitbricks.request :remove_public_ip_from_nic, "<nicId>#{self.id}</nicId><ip>#{ip}</ip>"
+      @ips.delete ip
+      return true if response.to_hash[:remove_public_ip_from_nic_response][:return]
+    end
+
+    # Deletes an existing NIC.
+    #
+    # @return [Boolean] true on success, false otherwise
+    def delete
+      response = Profitbricks.request :delete_nic, "<nicId>#{self.id}</nicId>"
+      return true if response.to_hash[:delete_nic_response][:return]
+    end
+
+    def ip
+      if @ips.length <= 1
+        @ips.first 
+      else
+        raise ArgumentError.new("This Nic has more then one IP assigned")
+      end
+    end
+
+    class << self
+      # Creates a NIC on an existing virtual server. 
+      # 
+      # The user can specify and assign local IPs manually to a NIC, which is connected to a Private LAN. Valid IP addresses for Private LANs are 10.0.0.0/8, 172.16.0.0/12 or 192.168.0.0/16. 
+      # In a Public LAN, a random DHCP IP address is assigned to each connected NIC by default. This IP Address is automatically generated and will change eventually, e.g. during a server reboot or while disconnecting and reconnecting a LAN to the internet. 
+      #
+      # @param [Hash] options parameters for the new NIC
+      # @option options [Fixnum] :server_id Identifier of the target virtual server (required)
+      # @option options [Fixnum] :lan_id Identifier of the target LAN > 0 that is to be connected to the specified virtual server. If no LAN exists for such ID, a new LAN with the given ID will be created. (required)
+      # @option options [String] :ip Public/private IP address.
+      # @option options [String] :name Names the NIC
+      # @return [Nic] The created NIC
+      def create(options = {})
+        xml = "<arg0>"
+        xml += get_xml_and_update_attributes options, [:server_id, :lan_id, :ip, :name]
+        xml += "</arg0>"
+        response = Profitbricks.request :create_nic, xml
+        self.find(:id => response.to_hash[:create_nic_return][:return][:nic_id])
+      end
+      
+      # Returns information about the state and configuration of an existing NIC. 
+      #
+      # @param [Hash] options currently just :id is supported
+      # @option options [String] :id The id of the NIC to locate
+      def find(options = {})
+        raise "Unable to locate the Nic named '#{options[:name]}'" unless options[:id]
+        response = Profitbricks.request :get_nic, "<nicId>#{options[:id]}</nicId>"
+        PB::Nic.new(response.to_hash[:get_nic_response][:return])
+      end
+    end
+  end
+end

data/lib/profitbricks/profitbricks.rb

@@ -0,0 +1,86 @@
+module Profitbricks
+  # Configure the Profitbricks API client
+  #
+  # @see Profitbricks::Config
+  def self.configure(&block)
+    Profitbricks::Config.save_responses = false
+    Profitbricks::Config.log = false
+    Profitbricks::Config.global_classes = true
+    yield Profitbricks::Config
+
+    Savon.configure do |config|
+      config.raise_errors = false 
+      config.log = Profitbricks::Config.log
+    end
+    HTTPI.log = false
+
+    @client = Savon::Client.new do |wsdl, http|
+      wsdl.endpoint = "https://api.profitbricks.com/1.1"
+      wsdl.document = "https://api.profitbricks.com/1.1/wsdl"
+      http.auth.basic Profitbricks::Config.username, Profitbricks::Config.password
+    end
+
+    Profitbricks.client = @client
+    if Profitbricks::Config.global_classes
+      Profitbricks.constants.select {|c| Class === Profitbricks.const_get(c)}.each do |klass|
+        next if klass == :Config
+        unless Kernel.const_defined?(klass)
+          Kernel.const_set(klass, Profitbricks.const_get(klass))
+        end
+      end
+    end
+  end
+
+  private 
+  def self.request(method, body=nil)
+    resp = Profitbricks.client.request method do
+      soap.body = body if body
+    end
+    self.store(method, body, resp.to_xml, resp.to_hash) if Profitbricks::Config.save_responses
+    if resp.soap_fault?
+      puts "Error during request '#{method}': #{resp.soap_fault.message}"
+      puts "------------------------------ Request XML -------------------------------"
+      puts body
+      puts "--------------------------------------------------------------------------"
+      puts "------------------------------ Response XML ------------------------------"
+      puts resp.to_xml
+      puts "--------------------------------------------------------------------------"
+      raise RuntimeError.new("Error during request '#{method}': #{resp.soap_fault.message}")
+    end
+    resp
+  end
+
+  def self.client=(client)
+    @client = client
+  end
+
+  def self.client
+    @client
+  end
+
+  def self.store(method, body, xml, json)
+    require 'digest/sha1'
+    hash = Digest::SHA1.hexdigest xml
+
+    unless Dir.exists?(File.expand_path("../../../spec/fixtures/#{method}", __FILE__))
+      Dir.mkdir(File.expand_path("../../../spec/fixtures/#{method}", __FILE__))
+    end
+    File.open(File.expand_path("../../../spec/fixtures/#{method}/#{hash}.xml", __FILE__), 'w').write(xml)
+    File.open(File.expand_path("../../../spec/fixtures/#{method}/#{hash}.json", __FILE__), 'w').write(JSON.dump(json))
+  end
+
+  def self.get_class name
+    klass = name
+    if Profitbricks.const_defined?(klass)
+      klass = Profitbricks.const_get(klass)
+    else
+      begin
+        require "profitbricks/#{name.downcase}"
+        klass = Profitbricks.const_get(klass)
+      rescue LoadError
+        raise LoadError.new("Invalid association, could not locate the class '#{name}'")
+      end
+    end
+    klass
+  end
+end  

data/lib/profitbricks/server.rb

@@ -0,0 +1,83 @@
+module Profitbricks
+  class Server < Profitbricks::Model
+    has_many :nics
+
+    # Deletes the virtual Server. 
+    # @return [Boolean] true on success, false otherwise
+    def delete
+      response = Profitbricks.request :delete_server, "<serverId>#{self.id}</serverId>"
+      return true if response.to_hash[:delete_server_response][:return]
+    end
+    
+    # Reboots the virtual Server (POWER CYCLE). 
+    # @return [Boolean] true on success, false otherwise
+    def reboot
+      response = Profitbricks.request :reboot_server, "<serverId>#{self.id}</serverId>"
+      return true if response.to_hash[:reboot_server_response][:return]
+    end
+
+    # Updates parameters of an existing virtual Server device. 
+    # @param [Hash] options parameters for the new server
+    # @option options [Fixnum] :cores Number of cores to be assigned to the specified server (required)
+    # @option options [Fixnum] :ram Number of RAM memory (in MiB) to be assigned to the server. Must be at least 256 and a multiple of it. (required)
+    # @option options [String]  :name Name of the server to be created
+    # @option options [String]  :boot_from_image_id Defines an existing CD-ROM/DVD image ID to be set as boot device of the server. A virtual CD-ROM/DVD drive with the mounted image will be connected to the server.
+    # @option options [String]  :boot_from_storage_id Defines an existing storage device ID to be set as boot device of the server. The storage will be connected to the server implicitly.
+    # @option options [String]  :os_type Sets the OS type of the server. (WINDOWS, OTHER) If left empty, the server will inherit the OS Type of its selected boot image / storage.
+    # @return [Boolean] true on success, false otherwise
+    def update(options = {})
+      return false if options.empty?
+      raise ArgumentError.new(":ram and :cores are mandatory options.") unless options[:ram] or options[:core]
+      raise ArgumentError.new(":ram has to be at least 256MiB and a multiple of it") if options[:ram] < 256 or (options[:ram] % 256) > 0
+      raise ArgumentError.new(":os_type has to be either 'WINDOWS' or 'OTHER'") if options[:os_type] and !['WINDOWS', 'OTHER'].include? options[:os_type]
+      xml = "<arg0><serverId>#{self.id}</serverId>"
+      xml += get_xml_and_update_attributes options, [:cores, :ram, :name, :boot_from_storage_id, :boot_from_image_id, :os_type]
+      xml += "</arg0>"
+      response = Profitbricks.request :update_server, xml
+      return true if response.to_hash[:update_server_response][:return]
+    end
+
+    class << self
+      # Creates a Virtual Server within an existing data center. Parameters can be specified to set up a 
+      # boot device and connect the server to an existing LAN or the Internet.
+      # 
+      # @param [Hash] options parameters for the new server
+      # @option options [Fixnum] :cores Number of cores to be assigned to the specified server (required)
+      # @option options [Fixnum] :ram Number of RAM memory (in MiB) to be assigned to the server. Must be at least 256 and a multiple of it. (required)
+      # @option options [String]  :name Name of the server to be created
+      # @option options [String]  :data_center_id Defines the data center wherein the server is to be created. If left empty, the server will be created in a new data center.
+      # @option options [String]  :boot_from_image_id Defines an existing CD-ROM/DVD image ID to be set as boot device of the server. A virtual CD-ROM/DVD drive with the mounted image will be connected to the server.
+      # @option options [String]  :boot_from_storage_id Defines an existing storage device ID to be set as boot device of the server. The storage will be connected to the server implicitly.
+      # @option options [Fixnum] :lan_id Connects the server to the specified LAN ID > 0. If the respective LAN does not exist, it is going to be created.
+      # @option options [Boolean] :internet_access Set to true to connect the server to the internet via the specified LAN ID. If the LAN is not specified, it is going to be created in the next available LAN ID, starting with LAN ID 1
+      # @option options [String]  :os_type Sets the OS type of the server. (WINDOWS, OTHER) If left empty, the server will inherit the OS Type of its selected boot image / storage.
+      # @return [Server] The created virtual server
+      def create(options = {})
+        raise ArgumentError.new("You must provide :cores and :ram") if options[:ram].nil? and options[:cores].nil?
+        raise ArgumentError.new(":ram has to be at least 256MiB and a multiple of it") if options[:ram] < 256 or (options[:ram] % 256) > 0
+        raise ArgumentError.new(":os_type has to be either 'WINDOWS' or 'OTHER'") if options[:os_type] and !['WINDOWS', 'OTHER'].include? options[:os_type]
+        xml = "<arg0>"
+        xml += get_xml_and_update_attributes options, 
+                    [:cores, :ram, :name, :boot_from_storage_id, :boot_from_image_id, :os_type, :internet_access, :lan_id]
+        xml += "</arg0>"
+        response = Profitbricks.request :create_server, xml
+        self.find(:id => response.to_hash[:create_server_return][:return][:server_id])
+      end
+
+      # Finds a virtual server
+      #
+      # @param [Hash] options currently just :id is supported
+      # @option options [String] :id The id of the server to locate
+      def find(options = {})
+        # FIXME
+        #if options[:name]
+        #  dc = PB::Server.all().select { |d| d.name == options[:name] }.first
+        #  options[:id] = dc.id if dc
+        #end
+        raise "Unable to locate the server named '#{options[:name]}'" unless options[:id]
+        response = Profitbricks.request :get_server, "<serverId>#{options[:id]}</serverId>"
+        PB::Server.new(response.to_hash[:get_server_response][:return])
+      end
+    end
+  end
+end