fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/hp/models/compute_v2/servers.rb

@@ -0,0 +1,56 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/server'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Servers < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::HPV2::Server
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          details = filters.delete(:details)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          if details
+            data = service.list_servers_detail(non_aliased_filters).body['servers']
+          else
+            data = service.list_servers(non_aliased_filters).body['servers']
+          end
+          load(data)
+        end
+
+        # Creates a new server and populates ssh keys
+        # service.servers.bootstrap :name => 'my-server',
+        #                           :flavor_id => service.flavors.first.id,
+        #                           :image_id => service.images.find {|img| img.name =~ /Ubuntu/}.id,
+        #                           :public_key_path => '~/.ssh/my_public_key.pub',
+        #                           :private_key_path => '~/.ssh/my_private_key'
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready?  && !public_ip_address.empty?}
+          server.setup(:password => server.password)
+          server
+        end
+
+        def get(server_id)
+          if server = service.get_server_details(server_id).body['server']
+            new(server)
+          end
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/volume_attachment.rb

@@ -0,0 +1,42 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class HPV2
+      class VolumeAttachment < Fog::Model
+
+        identity  :id
+
+        attribute :server_id, :aliases => 'serverId'
+        attribute :volume_id, :aliases => 'volumeId'
+        attribute :device
+
+        def initialize(new_attributes = {})
+          super(new_attributes)
+          # server_id needs to be the same as the server from the attachments collection
+          server_id = server.id if server
+          self
+        end
+
+        def save
+          requires :server_id, :volume_id, :device
+          data = service.attach_volume(server_id, volume_id, device)
+          merge_attributes(data.body['volumeAttachment'])
+          true
+        end
+
+        def destroy
+          requires :server_id, :volume_id
+          service.detach_volume(server_id, volume_id)
+          true
+        end
+        alias :detach :destroy
+
+      private
+        def server
+          collection.server
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/volume_attachments.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/volume_attachment'
+
+module Fog
+  module Compute
+    class HPV2
+      class VolumeAttachments < Fog::Collection
+
+        model Fog::Compute::HPV2::VolumeAttachment
+
+        attr_accessor :server
+
+        def all
+          requires :server
+          data = service.list_server_volumes(server.id).body['volumeAttachments']
+          load(data)
+        end
+
+        def get(volume_id)
+          requires :server
+          if data = service.get_server_volume_details(server.id, volume_id).body['volumeAttachment']
+            new(data)
+          end
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/models/dns/domain.rb

@@ -0,0 +1,55 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class DNS
+
+      class Domain < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :email
+        attribute :ttl
+        attribute :serial
+        attribute :created_at
+        attribute :updated_at
+
+        def destroy
+          requires :id
+          service.delete_domain(id)
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::HP::DNS::Records.new({
+              :service  => service,
+              :domain   => self
+            })
+          end
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          ### Inconsistent API behavior - does not return 'domain'
+          merge_attributes(service.create_domain(self.name, self.email, attributes).body)
+          true
+        end
+
+        def update
+          requires :id
+          ### Inconsistent API behavior - does not return 'domain'
+          merge_attributes(service.update_domain(id, attributes).body)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/dns/domains.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/hp/models/dns/domain'
+
+module Fog
+  module HP
+    class DNS
+
+      class Domains < Fog::Collection
+
+        model Fog::HP::DNS::Domain
+
+        def all
+          load(service.list_domains.body['domains'])
+        end
+
+        def get(domain_id)
+          ### Inconsistent API - does not return a 'domain'
+          if domain = service.get_domain(domain_id).body
+            new(domain)
+          end
+        rescue Fog::HP::DNS::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/dns/record.rb

@@ -0,0 +1,59 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class DNS
+
+      class Record < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :domain_id
+        attribute :type
+        attribute :ttl
+        attribute :data
+        attribute :priority
+        attribute :created_at
+        attribute :updated_at
+
+        def initialize(new_attributes = {})
+          super(new_attributes)
+          self.domain_id = domain.id if domain
+          self
+        end
+
+        def destroy
+          requires :id, :domain_id
+          service.delete_record(self.domain_id, id)
+          true
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def domain
+          collection.domain
+        end
+
+        def create
+          requires :domain_id
+          ### Inconsistent API behavior - does not return 'record'
+          merge_attributes(service.create_record(self.domain_id, self.name, self.type, self.data, attributes).body)
+          true
+        end
+
+        def update
+          requires :id, :domain_id
+          ### Inconsistent API behavior - does not return 'record'
+          merge_attributes(service.update_record(self.domain_id, id, attributes).body)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/dns/records.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/hp/models/dns/record'
+
+module Fog
+  module HP
+    class DNS
+
+      class Records < Fog::Collection
+
+        model Fog::HP::DNS::Record
+
+        attr_accessor :domain
+
+        def all
+          requires :domain
+          load(service.list_records_in_a_domain(domain.id).body['records'])
+        end
+
+        def get(record_id)
+          requires :domain
+          ### Inconsistent API - does not return a 'record'
+          if record = service.get_record(domain.id, record_id).body
+            new(record)
+          end
+        rescue Fog::HP::DNS::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/algorithm.rb

@@ -0,0 +1,24 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class LB
+      class Algorithm < Fog::Model
+        identity :name
+
+        def destroy
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def create(params)
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def save
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/algorithms.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/hp/models/lb/algorithm'
+
+module Fog
+  module HP
+    class LB
+      class Algorithms < Fog::Collection
+        model Fog::HP::LB::Algorithm
+
+        def all
+          data = service.list_algorithms.body['algorithms']
+          load(data)
+        end
+
+        def get(name)
+          data = service.list_algorithms.body['algorithms']
+          algorithm = data.detect {|algo| algo['name'] == name}
+          new(algorithm)
+        rescue Fog::HP::LB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/load_balancer.rb

@@ -0,0 +1,83 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class LB
+
+      class LoadBalancer < Fog::Model
+        identity  :id
+
+        attribute :name
+        attribute :protocol
+        attribute :port
+        attribute :algorithm
+        attribute :status
+        attribute :status_description, :aliases => 'statusDescription'
+        attribute :nodes
+        attribute :virtual_ips, :aliases => 'virtualIps'
+        attribute :node_count,  :aliases => 'nodeCount'
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at , :aliases => 'updated'
+
+        def destroy
+          requires :id
+          service.delete_load_balancer(id)
+          true
+        end
+
+        def ready?
+          self.status == 'ACTIVE'
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        def nodes
+          @nodes ||= begin
+            Fog::HP::LB::Nodes.new({
+              :service  => service,
+              :load_balancer   => self
+            })
+          end
+        end
+
+        def nodes=(new_nodes=[])
+          nodes.load(new_nodes)
+        end
+
+        private
+
+        def create
+          requires :name, :nodes
+
+          options = {}
+          options['virtualIps'] = virtual_ips if virtual_ips
+          options['port']       = port if port
+          options['protocol']   = protocol if protocol
+          options['algorithm']  = algorithm if algorithm
+          merge_attributes(service.create_load_balancer(name, nodes_to_hash, options).body)
+          true
+        end
+
+        def update
+          requires :id
+
+          options = {}
+          options['name']       = name if name
+          options['algorithm']  = algorithm if algorithm
+          service.update_load_balancer(id, options).body
+          true
+        end
+
+        def nodes_to_hash
+          if nodes
+            nodes.collect do |node|
+              { 'address' => node.address, 'port' => node.port, 'condition' => node.condition }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/load_balancers.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/hp/models/lb/load_balancer'
+
+module Fog
+  module HP
+    class LB
+      class LoadBalancers < Fog::Collection
+        model Fog::HP::LB::LoadBalancer
+
+        def all
+          data = service.list_load_balancers.body['loadBalancers']
+          load(data)
+        end
+
+        def get(lb_id)
+          ### Inconsistent API - does not return a 'loadBalancer'
+          lb = service.get_load_balancer(lb_id).body
+          new(lb)
+        rescue Fog::HP::LB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/node.rb

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class LB
+      class Node < Fog::Model
+
+        identity  :id
+
+        attribute :address
+        attribute :port
+        attribute :condition
+        attribute :status
+
+        def destroy
+          requires :id, :load_balancer
+          service.delete_load_balancer_node(load_balancer.id, id)
+          true
+        end
+
+        def ready?
+          self.status == 'ONLINE'
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def load_balancer
+          collection.load_balancer
+        end
+
+        def create
+          requires :load_balancer, :address, :port
+          options = {}
+          options['condition'] = condition if condition
+          data = service.create_load_balancer_node(load_balancer.id, address, port, options)
+          merge_attributes(data.body['nodes'][0])
+          true
+        end
+
+        def update
+          requires :id, :load_balancer, :condition
+          service.update_load_balancer_node(load_balancer.id, id, condition)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/nodes.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/hp/models/lb/node'
+
+module Fog
+  module HP
+    class LB
+      class Nodes < Fog::Collection
+
+        model Fog::HP::LB::Node
+
+        attr_accessor :load_balancer
+
+        def all
+          requires :load_balancer
+          data = service.list_load_balancer_nodes(load_balancer.id).body['nodes']
+          load(data)
+        end
+
+        def get(node_id)
+          requires :load_balancer
+          node = service.get_load_balancer_node(load_balancer.id, node_id).body
+          new(node)
+        rescue Fog::HP::LB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/protocol.rb

@@ -0,0 +1,25 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class LB
+      class Protocol < Fog::Model
+        identity :name
+        attribute :port
+
+        def destroy
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def create(params)
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def save
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/protocols.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/hp/models/lb/protocol'
+
+module Fog
+  module HP
+    class LB
+      class Protocols < Fog::Collection
+        model Fog::HP::LB::Protocol
+
+        def all
+          data = service.list_protocols.body['protocols']
+          load(data)
+        end
+
+        def get(name)
+          data = service.list_protocols.body['protocols']
+          protocol = data.detect {|p| p['name'] == name}
+          new(protocol)
+        rescue Fog::HP::LB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/virtual_ip.rb

@@ -0,0 +1,34 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class LB
+      class VirtualIp < Fog::Model
+        identity :id
+
+        attribute :address
+        attribute :ip_version, :alias => 'ipVersion'
+        attribute :type
+
+        def destroy
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def create(params)
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        def save
+          raise Fog::HP::LB::NotFound.new('Operation not allowed.')
+        end
+
+        private
+
+        def load_balancer
+          collection.load_balancer
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/lb/virtual_ips.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/hp/models/lb/virtual_ip'
+
+module Fog
+  module HP
+    class LB
+      class VirtualIps < Fog::Collection
+
+        model Fog::HP::LB::VirtualIp
+
+        attr_accessor :load_balancer
+
+        def all
+          requires :load_balancer
+
+          data = service.list_load_balancer_virtual_ips(load_balancer.id).body['virtualIps']
+          load(data)
+        end
+
+        def get(vip_id)
+          requires :load_balancer
+
+          data = service.list_load_balancer_virtual_ips(load_balancer.id).body['virtualIps']
+          vip = data.detect {|vip| vip['id'].to_s == vip_id}
+          new(vip)
+        rescue Fog::HP::LB::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end