profitbricks 0.9.9 → 1.0.0

data/lib/profitbricks/ip_block.rb

@@ -18,8 +18,8 @@ module Profitbricks
     #
     # @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]
+      response = Profitbricks.request :release_public_ip_block, block_id: self.id
+      return true
     end
 
     class << self
@@ -28,8 +28,7 @@ module Profitbricks
       # @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|
+        [response].flatten.compact.collect do |block|
           PB::IpBlock.new(block)
         end
       end
@@ -39,8 +38,8 @@ module Profitbricks
       # @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])
+        response = Profitbricks.request :reserve_public_ip_block, block_size: amount
+        return PB::IpBlock.new(response)
       end
 
 

data/lib/profitbricks/load_balancer.rb

@@ -12,12 +12,10 @@ module Profitbricks
     # @return [Boolean] true on success, false otherwise
     def update(options = {})
       options.merge!(:load_balancer_id=> self.id)
-      xml = "<arg0>"
-      xml += get_xml_and_update_attributes options, [:load_balancer_id, :ip, :name, :algorithm]
-      xml += "</arg0>"
-      response = Profitbricks.request :update_load_balancer, xml
+      options[:load_balancer_name] = options.delete :name
+      response = Profitbricks.request :update_load_balancer, options
       self.reload
-      return true if response.to_hash[:update_load_balancer_response][:return]
+      return true
     end
 
     # Adds new servers to the Load Balancer within the respective LAN.
@@ -31,14 +29,10 @@ module Profitbricks
     # @return [Boolean] true on success, false otherwise
     def register_servers(servers)
       raise "You have to provide at least one server" unless servers
-      options = {:load_balancer_id => self.id}
-      xml = get_xml_and_update_attributes options, [:load_balancer_id]
-      servers.each do |server|
-        xml += "<serverIds>#{server.id}</serverIds>"
-      end
-      response = Profitbricks.request :register_servers_on_load_balancer, xml
-      update_attributes(response.to_hash[:register_servers_on_load_balancer_response][:return])
-      return true if response.to_hash[:register_servers_on_load_balancer_response][:return]
+      options = {load_balancer_id: self.id, server_ids: servers.collect(&:id)}
+      response = Profitbricks.request :register_servers_on_load_balancer, options
+      self.reload
+      return true
     end
 
     # Removes servers from the load balancer
@@ -51,13 +45,9 @@ module Profitbricks
     # @return [Boolean] true on success, false otherwise
     def deregister_servers(servers)
       raise "You have to provide at least one server" unless servers
-      options = {:load_balancer_id => self.id}
-      xml = get_xml_and_update_attributes options, [:load_balancer_id]
-      servers.each do |server|
-        xml += "<serverIds>#{server.id}</serverIds>"
-      end
-      response = Profitbricks.request :deregister_servers_on_load_balancer, xml
-      return true if response.to_hash[:deregister_servers_on_load_balancer_response][:return]
+      options = {load_balancer_id: self.id, server_ids: servers.collect(&:id)}
+      response = Profitbricks.request :deregister_servers_on_load_balancer, options
+      return true
     end
 
     # Enables the load balancer to distribute traffic to the specified servers.
@@ -66,13 +56,9 @@ module Profitbricks
     # @return [Boolean] true on success, false otherwise
     def activate_servers(servers)
       raise "You have to provide at least one server" unless servers
-      options = {:load_balancer_id => self.id}
-      xml = get_xml_and_update_attributes options, [:load_balancer_id]
-      servers.each do |server|
-        xml += "<serverIds>#{server.id}</serverIds>"
-      end
-      response = Profitbricks.request :activate_load_balancing_on_servers, xml
-      return true if response.to_hash[:activate_load_balancing_on_servers_response][:return]
+      options = {load_balancer_id: self.id, server_ids: servers.collect(&:id)}
+      response = Profitbricks.request :activate_load_balancing_on_servers, options
+      return true
     end
 
     # Disables the load balancer to distribute traffic to the specified servers.
@@ -81,13 +67,9 @@ module Profitbricks
     # @return [Boolean] true on success, false otherwise
     def deactivate_servers(servers)
       raise "You have to provide at least one server" unless servers
-      options = {:load_balancer_id => self.id}
-      xml = get_xml_and_update_attributes options, [:load_balancer_id]
-      servers.each do |server|
-        xml += "<serverIds>#{server.id}</serverIds>"
-      end
-      response = Profitbricks.request :deactivate_load_balancing_on_servers, xml
-      return true if response.to_hash[:deactivate_load_balancing_on_servers_response][:return]
+      options = {load_balancer_id: self.id, server_ids: servers.collect(&:id)}
+      response = Profitbricks.request :deactivate_load_balancing_on_servers, options
+      return true
     end
 
     # Deletes an existing load balancer. 
@@ -96,8 +78,8 @@ module Profitbricks
     #
     # @return [Boolean] true on success, false otherwise
     def delete
-      response = Profitbricks.request :delete_load_balancer, "<loadBalancerId>#{self.id}</loadBalancerId>"
-      return true if response.to_hash[:delete_load_balancer_response][:return]
+      Profitbricks.request :delete_load_balancer, load_balancer_id: self.id
+      return true
     end
 
     class << self
@@ -116,16 +98,9 @@ module Profitbricks
       # @option options [Array<Server>] :servers Array of servers to connect to the LoadBalancer
       # @return [LoadBalancer] The created LoadBalancer
       def create(options = {})
-        xml = "<arg0>"
-        xml += get_xml_and_update_attributes options, [:data_center_id, :lan_id, :ip, :name, :algorithm]
-        unless options[:servers].nil?
-          options[:servers].each do |server|
-            xml += "<serverIds>#{server.id}</serverIds>"
-          end
-        end
-        xml += "</arg0>"
-        response = Profitbricks.request :create_load_balancer, xml
-        self.find(:id => response.to_hash[:create_load_balancer_response][:return][:load_balancer_id])
+        options[:server_ids] = options.delete(:servers).collect(&:id) if options[:servers]
+        response = Profitbricks.request :create_load_balancer, options
+        self.find(:id => response[:load_balancer_id])
       end
       
       # Returns information about a virtual load balancer.
@@ -135,8 +110,8 @@ module Profitbricks
       # @return [LoadBalancer] The found LoadBalancer
       def find(options = {})
         raise "Unable to locate the LoadBalancer named '#{options[:name]}'" unless options[:id]
-        response = Profitbricks.request :get_load_balancer, "<loadBalancerId>#{options[:id]}</loadBalancerId>"
-        PB::LoadBalancer.new(response.to_hash[:get_load_balancer_response][:return])
+        response = Profitbricks.request :get_load_balancer, load_balancer_id: options[:id]
+        PB::LoadBalancer.new(response)
       end
     end
   end

data/lib/profitbricks/model.rb

@@ -28,21 +28,6 @@ module Profitbricks
     def self.belongs_to(model, options = {})
       klass = Profitbricks.get_class model.to_s, options
       @@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
 
     def attributes
@@ -54,6 +39,12 @@ module Profitbricks
     end
 
     private
+    def update_attributes_from_hash(updated)
+      updated.keys.each do |a|
+        initialize_getter(a, updated[a])
+        self.instance_variable_set("@#{a}", updated[a])
+      end
+    end
     def update_attributes(updated)
       self.instance_variables.each do |var|
         self.instance_variable_set(var, updated.instance_variable_get(var))
@@ -66,12 +57,6 @@ module Profitbricks
       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}")
@@ -95,19 +80,7 @@ module Profitbricks
     end
 
     def initialize_belongs_to_association name, association, value
-      self.instance_variable_set("@#{name}", association[:class].send(:new, value, self))
-    end
-
-    def self.expand_attributes(hash, attributes, klass=nil)
-      [:name, :algorithm].each do |a|
-        deleted =  hash.delete(a)
-        if deleted
-          hash["#{klass.to_s.underscore}_#{a.to_s}"] = deleted
-          attributes.delete(a)
-          attributes.push "#{klass.to_s.underscore}_#{a.to_s}"
-        end
-      end
-      return hash, attributes
+      initialize_getter name, association[:class].send(:new, value, self)
     end
-	end
+  end
 end

data/lib/profitbricks/nic.rb

@@ -13,9 +13,8 @@ module Profitbricks
     # @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]
+      response = Profitbricks.request :set_internet_access, data_center_id: self.data_center_id, lan_id: self.lan_id, internet_access: value
+      return true
     end
 
     # Changes the settings of an existing NIC. 
@@ -27,38 +26,36 @@ module Profitbricks
     # @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]
+      update_attributes_from_hash options
+      options[:nic_name] = options.delete :name if options[:name]
+      response = Profitbricks.request :update_nic, options.merge(:nic_id => self.id)
+      return true
     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>"
+      response = Profitbricks.request :add_public_ip_to_nic, nic_id: self.id, ip: ip
       @ips.push ip
-      return true if response.to_hash[:add_public_ip_to_nic_response][:return]
+      return true
     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>"
+      response = Profitbricks.request :remove_public_ip_from_nic, nic_id: self.id, ip: ip
       @ips.delete ip
-      return true if response.to_hash[:remove_public_ip_from_nic_response][:return]
+      return true
     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]
+      response = Profitbricks.request :delete_nic, nic_id: self.id
+      return true
     end
 
     def ip
@@ -82,11 +79,9 @@ module Profitbricks
       # @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])
+        options[:nic_name] = options.delete :name if options[:name]
+        response = Profitbricks.request :create_nic, options
+        self.find(:id => response[:nic_id])
       end
       
       # Returns information about the state and configuration of an existing NIC. 
@@ -95,8 +90,8 @@ module Profitbricks
       # @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])
+        response = Profitbricks.request :get_nic, nic_id: options[:id]
+        PB::Nic.new(response)
       end
     end
   end

data/lib/profitbricks/profitbricks.rb

@@ -1,4 +1,8 @@
 module Profitbricks
+  NEED_PREFIX = [:create_nic, :create_load_balancer, :update_storage, :create_storage,
+                 :update_data_center, :rom_drive, :update_nic, :create_server,
+                 :update_load_balancer, :connect_storage_to_server, :update_server]
+
   # Configure the Profitbricks API client
   #
   # @see Profitbricks::Config
@@ -9,21 +13,21 @@ module Profitbricks
     Profitbricks::Config.polling_interval = 1
     yield Profitbricks::Config
 
-    Savon.configure do |config|
-      config.raise_errors = false 
-      config.log = Profitbricks::Config.log
-      config.pretty_print_xml = true
-    end
     HTTPI.log = false
 
-    @client = Savon::Client.new do |wsdl, http|
-      wsdl.endpoint = "https://api.profitbricks.com/1.2"
-      wsdl.document = "https://api.profitbricks.com/1.2/wsdl"
-      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && !ENV['SSL_CERT_DIR']
-        puts "Warning: SSL certificate verification has been disabled"
-        http.auth.ssl.verify_mode = :none
-      end
-      http.auth.basic Profitbricks::Config.username, Profitbricks::Config.password
+    @client = Savon::Client.new do |globals|
+      globals.wsdl "https://api.profitbricks.com/1.2/wsdl"
+      globals.convert_request_keys_to :lower_camelcase
+      globals.raise_errors true 
+      globals.log Profitbricks::Config.log
+      globals.pretty_print_xml true
+
+      # Looks like ssl verifycation works with current jruby
+      #if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && !ENV['SSL_CERT_DIR']
+      #  puts "Warning: SSL certificate verification has been disabled"
+      #  globals.ssl_verify_mode = :none
+      #end
+      globals.basic_auth [Profitbricks::Config.username, Profitbricks::Config.password]
     end
 
     Profitbricks.client = @client
@@ -38,22 +42,26 @@ module Profitbricks
   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}"
+  def self.request(method, options={})
+    begin
+      message = if NEED_PREFIX.include? method
+        { arg0: options }
+      else
+        options
+      end
+      resp = Profitbricks.client.call(method, message: message)
+      self.store(method, message, resp.to_xml, resp.to_hash) if Profitbricks::Config.save_responses
+    rescue Savon::SOAPFault => error
+      puts "Error during request '#{method}': #{error.to_s}"
       puts "------------------------------ Request XML -------------------------------"
-      puts body
+      puts message
       puts "--------------------------------------------------------------------------"
-      puts "------------------------------ Response XML ------------------------------"
-      puts resp.to_xml
+      puts "------------------------------ Response ----------------------------------"
+      puts error.to_hash
       puts "--------------------------------------------------------------------------"
-      raise RuntimeError.new("Error during request '#{method}': #{resp.soap_fault.message}")
+      raise RuntimeError.new("Error during request '#{method}': #{error.to_s}")
     end
-    resp
+    (resp.body["#{method}_response".to_sym] || resp.body["#{method}_return".to_sym])[:return]
   end
 
   def self.client=(client)
@@ -83,10 +91,10 @@ module Profitbricks
       klass = Profitbricks.const_get(klass)
     else
       begin
-        require "profitbricks/#{name.downcase}"
+        require "profitbricks/#{klass.downcase}"
         klass = Profitbricks.const_get(klass)
       rescue LoadError
-        raise LoadError.new("Invalid association, could not locate the class '#{name}'")
+        raise LoadError.new("Invalid association, could not locate the class '#{klass}'")
       end
     end
     klass

data/lib/profitbricks/rule.rb

@@ -4,8 +4,8 @@ module Profitbricks
     #
     # @return [Boolean] true on success, false otherwise
     def delete
-      response = Profitbricks.request :remove_firewall_rules, "<firewallRuleIds>#{self.id}</firewallRuleIds>"
-      return true if response[:remove_firewall_rules_response][:return]
+      response = Profitbricks.request :remove_firewall_rules, firewall_rule_ids: self.id
+      return true
     end
   end
 end

data/lib/profitbricks/server.rb

@@ -1,19 +1,53 @@
 module Profitbricks
   class Server < Profitbricks::Model
     has_many :nics
+    has_many :connected_storages, :class_name => :storage
 
     # 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]
+      Profitbricks.request :delete_server, server_id: self.id
+      return true
     end
     
-    # Reboots the virtual Server (POWER CYCLE). 
+    # Reboots an existing virtual server (SOFT REBOOT). 
     # @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]
+      @virtual_machine_state = 'NOSTATE'
+      Profitbricks.request :reboot_server, server_id: self.id
+      return true
+    end
+
+    # Resets an existing virtual server (POWER CYCLE).
+    # @return [Boolean] true on success, false otherwise
+    def reset
+      @virtual_machine_state = 'NOSTATE'
+      Profitbricks.request :reset_server, server_id: self.id
+      return true
+    end
+
+    # Starts an existing virtual server
+    # @return [Boolean] true on success, false otherwise
+    def start
+      @virtual_machine_state = 'NOSTATE'
+      Profitbricks.request :start_server, server_id: self.id
+      return true
+    end
+
+    # Stops an existing virtual server (HARD power off) 
+    # @return [Boolean] true on success, false otherwise
+    def power_off
+      @virtual_machine_state = 'SHUTOFF'
+      Profitbricks.request :power_off_server, server_id: self.id
+      return true
+    end
+
+    # Stops an existing virtual server gracefully (SOFT stop)
+    # @return [Boolean] true on success, false otherwise
+    def shutdown
+      @virtual_machine_state = 'SHUTDOWN'
+      Profitbricks.request :shutdown_server, server_id: self.id
+      return true
     end
 
     # Updates parameters of an existing virtual Server device. 
@@ -31,11 +65,11 @@ module Profitbricks
       raise ArgumentError.new(":ram has to be at least 256MiB and a multiple of it") if options[:ram] and (options[:ram] < 256 or (options[:ram] % 256) > 0)
       raise ArgumentError.new(":availability_zone has to be either 'AUTO', 'ZONE_1', or 'ZONE_2'") if options[:availability_zone] and !['AUTO', 'ZONE_1', 'ZONE_2'].include? options[:availability_zone]
       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, :availability_zone, :os_type]
-      xml += "</arg0>"
-      response = Profitbricks.request :update_server, xml
-      return true if response.to_hash[:update_server_response][:return]
+      update_attributes_from_hash options
+      options[:server_name] = options.delete :name if options[:name]
+      options[:server_id] = self.id
+      response = Profitbricks.request :update_server, options
+      return true
     end
 
     # Checks if the Server is running
@@ -53,13 +87,54 @@ module Profitbricks
       end
     end
 
+    # Checks if the Server was successfully provisioned
+    #
+    # @return [Boolean] true if the Server was provisioned, false otherwise
+    def provisioned?
+      self.reload
+      if @provisioning_state == 'AVAILABLE'
+        true
+      else
+        false
+      end
+    end
+
+    # Blocks until the Server is provisioned
+    def wait_for_provisioning
+      while !self.provisioned?
+        sleep Profitbricks::Config.polling_interval
+      end
+    end
+
     # Creates a Nic for the current Server, automatically sets the :server_id
     # @see Profitbricks::Nic#create
     def create_nic(options)
       Nic.create(options.merge(:server_id => self.id))
     end
 
+    # Helper method to get a list of all public IP adresses
+    #
+    # @return [Array <String>] Array of all public IP adresses
+    def public_ips
+      filter_nics_and_return_ips {|nic| nic.internet_access == true }
+    end
+
+    # Helper method to get a list of all private IP adresses
+    #
+    # @return [Array <String>] Array of all private IP adresses
+    def private_ips
+      filter_nics_and_return_ips {|nic| nic.internet_access == false }
+    end
+
+
     class << self
+      # Returns a list of all Servers created by the user.
+      # 
+      # @return [Array <Server>] Array of all available Servers
+      def all
+        DataCenter.all.collect(&:servers).flatten.compact
+      end
+
       # 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.
       # 
@@ -80,12 +155,9 @@ module Profitbricks
         raise ArgumentError.new(":ram has to be at least 256MiB and a multiple of it") if options[:ram].to_i < 256 or (options[:ram].to_i % 256) > 0
         raise ArgumentError.new(":availability_zone has to be either 'AUTO', 'ZONE_1', or 'ZONE_2'") if options[:availability_zone] and !['AUTO', 'ZONE_1', 'ZONE_2'].include? options[:availability_zone]
         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, :data_center_id, :availability_zone]
-        xml += "</arg0>"
-        response = Profitbricks.request :create_server, xml
-        self.find(:id => response.to_hash[:create_server_return][:return][:server_id])
+        options[:server_name] = options.delete :name if options[:name]
+        response = Profitbricks.request :create_server, options
+        self.find(:id => response[:server_id])
       end
 
       # Finds a virtual server
@@ -99,9 +171,15 @@ module Profitbricks
         #  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])
+        response = Profitbricks.request :get_server, server_id: options[:id]
+        PB::Server.new(response)
       end
     end
+
+    private
+    def filter_nics_and_return_ips(&block)
+      return [] if self.nics.nil?
+      self.nics.select { |nic| yield nic }.collect(&:ips).flatten
+    end 
   end
 end