fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/hp/requests/dns/delete_record.rb

@@ -0,0 +1,36 @@
+module Fog
+  module HP
+    class DNS
+      class Real
+        # Delete a DNS Record
+        #
+        # ==== Parameters
+        # * 'domain_id'<~String> - UUId of domain for record
+        # * 'record_id'<~String> - UUId of record to delete
+        #
+        def delete_record(domain_id, record_id)
+          request(
+              :expects => 200,
+              :method  => 'DELETE',
+              :path    => "domains/#{domain_id}/records/#{record_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_record(domain_id, record_id)
+          response = Excon::Response.new
+          if list_records_in_a_domain(domain_id).body['records'].detect { |_| _['id'] == record_id }
+            response.status = 200
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/dns/get_domain.rb

@@ -0,0 +1,43 @@
+module Fog
+  module HP
+    class DNS
+
+      # Get details for existing DNS domain
+      #
+      # ==== Parameters
+      # * domain_id<~String> - UUId of the domain to get
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'id'<~String> - UUID of the domain
+      #     * 'name'<~String> - Name of the domain
+      #     * 'ttl'<~Integer> - TTL for the domain
+      #     * 'email'<~String> - Email for the domain
+      #     * 'serial'<~Integer> - Serial number for the domain
+      #     * 'created_at'<~String> - created date time stamp
+      class Real
+        def get_domain(domain_id)
+          request(
+              :expects => 200,
+              :method  => 'GET',
+              :path    => "domains/#{domain_id}"
+          )
+        end
+      end
+      class Mock
+
+        def get_domain(domain_id)
+          response = Excon::Response.new
+          if domain = list_domains.body['domains'].detect { |_| _['id'] == domain_id }
+            response.status = 200
+            response.body = domain
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/dns/get_record.rb

@@ -0,0 +1,47 @@
+module Fog
+  module HP
+    class DNS
+      class Real
+
+        # Get details of an existing DNS record
+        #
+        # ==== Parameters
+        # * 'domain_id'<~String> - UUId of domain for record
+        # * 'record_id'<~String> - UUId of record to get
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'id'<~String> - UUID of the record
+        #     * 'name'<~String> - Name of the record
+        #     * 'description'<~String> - Description for the record
+        #     * 'type'<~String> - Type of the record
+        #     * 'domain_id'<~String> - UUId of the domain
+        #     * 'ttl'<~Integer> - TTL of the record
+        #     * 'data'<~String> - Data required by the record
+        #     * 'priority'<~Integer> - Priority for the record
+        #     * 'created_at'<~String> - created date time stamp
+        #     * 'updated_at'<~String> - updated date time stamp
+        def get_record(domain_id, record_id)
+          request(
+              :expects => 200,
+              :method  => 'GET',
+              :path    => "domains/#{domain_id}/records/#{record_id}"
+          )
+        end
+      end
+      class Mock
+        def get_record(domain_id, record_id)
+          response = Excon::Response.new
+          if record = list_records_in_a_domain(domain_id).body['records'].detect { |_| _['id'] == record_id }
+            response.status = 200
+            response.body = record
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/dns/get_servers_hosting_domain.rb

@@ -0,0 +1,62 @@
+module Fog
+  module HP
+    class DNS
+      class Real
+        # Get authoritative nameservers for existing DNS domain
+        #
+        # ==== Parameters
+        # * domain_id<~String> - UUId of the domain to get nameservers for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'nameservers'<~Array>:
+        #       * 'id'<~String> - UUID of the domain
+        #       * 'name'<~String> - Name of the domain
+        #       * 'ttl'<~Integer> - TTL for the domain
+        #       * 'email'<~String> - Email for the domain
+        #       * 'serial'<~Integer> - Serial number for the domain
+        #       * 'created_at'<~String> - created date time stamp
+        def get_servers_hosting_domain(domain_id)
+          request(
+              :expects => 200,
+              :method  => 'GET',
+              :path    => "domains/#{domain_id}/servers"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def get_servers_hosting_domain(domain_id)
+          response = Excon::Response.new
+          if list_domains.body['domains'].detect { |_| _['id'] == domain_id }
+            response.status = 200
+            response.body   = { 'servers' => dummy_servers }
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+        end
+
+        def dummy_servers
+          [
+              {
+                  'id'         => Fog::HP::Mock.uuid.to_s,
+                  'name'       => 'ns1.provider.com.',
+                  'created_at' => '2012-01-01T13:32:20Z',
+                  'updated_at' => '2012-01-01T13:32:20Z'
+              },
+              {
+                  'id'         => Fog::HP::Mock.uuid.to_s,
+                  'name'       => 'ns2.provider.com.',
+                  'created_at' => '2012-01-01T13:32:20Z',
+                  'updated_at' => '2012-01-01T13:32:20Z'
+              },
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/dns/list_domains.rb

@@ -0,0 +1,38 @@
+module Fog
+  module HP
+    class DNS
+      class Real
+        # List all DNS domains
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'domains'<~Array>:
+      #       * 'id'<~String> - UUID of the domain
+      #       * 'name'<~String> - Name of the domain
+      #       * 'ttl'<~Integer> - TTL for the domain
+      #       * 'email'<~String> - Email for the domain
+      #       * 'serial'<~Integer> - Serial number for the domain
+      #       * 'created_at'<~String> - created date time stamp
+        def list_domains
+          request(
+              :expects => 200,
+              :method  => 'GET',
+              :path    => 'domains'
+          )
+        end
+
+      end
+
+      class Mock
+        def list_domains
+          response        = Excon::Response.new
+          domains = self.data[:domains].values
+          response.status = 200
+          response.body = { 'domains' => domains }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/dns/list_records_in_a_domain.rb

@@ -0,0 +1,55 @@
+module Fog
+  module HP
+    class DNS
+      class Real
+        # List DNS records for a given domain
+        #
+        # ==== Parameters
+        # * 'domain_id'<~String> - UUId of domain for record
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'records'<~Array>:
+        #       * 'id'<~String> - UUID of the record
+        #       * 'name'<~String> - Name of the record
+        #       * 'description'<~String> - Description for the record
+        #       * 'type'<~String> - Type of the record
+        #       * 'domain_id'<~String> - UUID of the domain
+        #       * 'ttl'<~Integer> - TTL of the record
+        #       * 'data'<~String> - Data required by the record
+        #       * 'priority'<~Integer> - Priority for the record
+        #       * 'created_at'<~String> - created date time stamp
+        #       * 'updated_at'<~String> - updated date time stamp
+        def list_records_in_a_domain(domain_id)
+          request(
+              :expects => 200,
+              :method  => 'GET',
+              :path    => "domains/#{domain_id}/records"
+          )
+        end
+
+      end
+      class Mock
+        def list_records_in_a_domain(domain_id)
+          response = Excon::Response.new
+          if domain = list_domains.body['domains'].detect { |_| _['id'] == domain_id }
+            response.status = 200
+            response.body = { 'records' => records_for_domain(domain_id) }
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+          response
+        end
+
+        def records_for_domain(domain_id)
+          rdata = data[:records].select { |_,v| v['domain_id'] == domain_id}
+          records = []
+          rdata.each { |_,v| records << v }
+          records
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/dns/update_domain.rb

@@ -0,0 +1,62 @@
+module Fog
+  module HP
+    class DNS
+
+      class Real
+        # Update an existing DNS domain
+        #
+        # ==== Parameters
+        # * domain_id<~String> - UUId of domain to delete
+        # * options<~Hash>:
+        #   * 'name'<~String> - Name of domain
+        #   * 'description'<~String> - Description for the domain
+        #   * 'ttl'<~String> - TTL for the domain
+        #   * 'email'<~String> - email for the domain
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'id'<~String> - UUID of the domain
+        #     * 'name'<~String> - Name of the domain
+        #     * 'description'<~String> - Description for the domain
+        #     * 'ttl'<~Integer> - TTL for the domain
+        #     * 'email'<~String> - Email for the domain
+        #     * 'serial'<~Integer> - Serial number for the domain
+        #     * 'created_at'<~String> - created date time stamp
+        def update_domain(domain_id, options={})
+          data = {}
+          l_options = [:name, :description, :ttl, :email]
+          l_options.select{|o| options[o]}.each do |key|
+            data[key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'PUT',
+            :path    => "domains/#{domain_id}"
+          )
+        end
+      end
+
+      class Mock
+        def update_domain(domain_id, options={})
+          response = Excon::Response.new
+          if domain = list_domains.body['domains'].detect { |_| _['id'] == domain_id }
+
+            domain['name']          = options[:name]   if options[:name]
+            domain['description']   = options[:description]   if options[:description]
+            domain['ttl']           = options[:ttl]    if options[:ttl]
+            domain['email']         = options[:email]  if options[:email]
+
+            response.status = 200
+            response.body   = domain
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/dns/update_record.rb

@@ -0,0 +1,70 @@
+module Fog
+  module HP
+    class DNS
+
+      class Real
+        # Update an existing DNS record
+        #
+        # ==== Parameters
+        # * 'domain_id'<~String> - UUId of domain of record
+        # * 'record_id'<~String> - UUId of record to update
+        # * options<~Hash>:
+        #   * 'name'<~String> - Name of record
+        #   * 'description'<~String> - Description for the record
+        #   * 'type'<~String> - Type of the record i.e. 'A'
+        #   * 'data'<~String> - Data required by the record
+        #   * 'priority'<~Integer> - Priority
+        #   * 'ttl'<~Integer> - TTL of the record
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'id'<~String> - UUID of the record
+        #     * 'name'<~String> - Name of the record
+        #     * 'description'<~String> - Description for the record
+        #     * 'type'<~String> - Type of the record
+        #     * 'domain_id'<~String> - UUID of the domain
+        #     * 'ttl'<~Integer> - TTL of the record
+        #     * 'data'<~String> - Data required by the record
+        #     * 'priority'<~Integer> - Priority for the record
+        #     * 'created_at'<~String> - created date time stamp
+        #     * 'updated_at'<~String> - updated date time stamp
+        def update_record(domain_id, record_id, options={})
+          data = {}
+          l_options = [:name, :description, :type, :data, :priority, :ttl]
+          l_options.select{|o| options[o]}.each do |key|
+            data[key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'PUT',
+            :path    => "domains/#{domain_id}/records/#{record_id}"
+          )
+        end
+
+      end
+
+      class Mock
+        def update_record(domain_id, record_id, options)
+          response = Excon::Response.new
+          if record = list_records_in_a_domain(domain_id).body['records'].detect { |_| _['id'] == record_id }
+            record['name']      = options[:name]      if options[:name]
+            record['type']      = options[:type]      if options[:type]
+            record['data']      = options[:data]      if options[:data]
+            record['priority']  = options[:priority]  if options[:priority]
+
+            response.status = 200
+            response.body   = record
+            response
+          else
+            raise Fog::HP::DNS::NotFound
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/lb/create_load_balancer.rb

@@ -0,0 +1,110 @@
+module Fog
+  module HP
+    class LB
+
+      # Create a new load balancer
+      #
+      # ==== Parameters
+      # * 'name'<~String> - Name of the load balancer
+      # * 'nodes'<~ArrayOfHash> - Nodes for the load balancer
+      #   * 'address'<~String> - Address for the node
+      #   * 'port'<~String> - Port for the node
+      # * options<~Hash>:
+      #   * 'port'<~String> - Port for the load balancer, defaults to '80'
+      #   * 'protocol'<~String> - Protocol for the load balancer, defaults to 'HTTP'
+      #   * 'algorithm'<~String> - Algorithm for the load balancer, defaults to 'ROUND_ROBIN'
+      #   * 'virtualIps'<~ArrayOfHash> - Virtual IPs for the load balancer
+      #     * 'id'<~String> - UUId for the virtual IP
+      #     * 'address'<~String> - Address for the virtual IP
+      #     * 'type'<~String> - Type for the virtual IP
+      #     * 'ipVersion'<~String> - IP Version for the virtual IP
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'id'<~String> - UUID of the load balancer
+      #     * 'name'<~String> - Name of the load balancer
+      #     * 'protocol'<~String> - Protocol for the load balancer
+      #     * 'port'<~String> - Port for the load balancer
+      #     * 'algorithm'<~String> - Algorithm for the load balancer
+      #     * 'status'<~String> - Status for the load balancer
+      #     * 'created'<~String> - created date time stamp
+      #     * 'updated'<~String> - updated date time stamp
+      #     * 'nodes'<~ArrayOfHash> - Nodes for the load balancer
+      #       * 'address'<~String> - Address for the node
+      #       * 'port'<~String> - Port for the node
+      #     * 'virtualIps'<~ArrayOfHash> - Virtual IPs for the load balancer
+      #       * 'id'<~String> - UUId for the virtual IP
+      #       * 'address'<~String> - Address for the virtual IP
+      #       * 'type'<~String> - Type for the virtual IP
+      #       * 'ipVersion'<~String> - IP Version for the virtual IP
+      class Real
+        def create_load_balancer(name, nodes, options={})
+          ### Inconsistent behavior. Should be passing in as a 'loadbalancer' => {'name', 'nodes'}
+          data = {
+            'name'  => name,
+            'nodes' => nodes
+          }
+          l_options = ['port', 'protocol', 'algorithm']
+          l_options.select{|o| options[o]}.each do |key|
+            data[key] = options[key]
+          end
+
+          if options['virtualIps']
+            data['virtualIps'] = []
+            for vip in options['virtualIps']
+              data['virtualIps'] << vip
+            end
+          end
+
+          response = request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'POST',
+            :path    => 'loadbalancers'
+          )
+          response
+        end
+      end
+
+      class Mock
+        def create_load_balancer(name, nodes, options={})
+          ### Call: {"name" => "my-shiny-lb1", "nodes" => [{"address" => "15.185.1.1", "port" => "80"}]}
+          response = Excon::Response.new
+          response.status = 202
+          # add the id, and other attributes that are added by the system
+          nodes.each do |n|
+            n['id']         = Fog::HP::Mock.uuid.to_s
+            n['condition']  = 'ENABLED'
+            n['status']     = 'ONLINE'
+          end
+          data = {
+              'id'        => Fog::HP::Mock.uuid.to_s,
+              'name'      => name,
+              'protocol'  => options['protocol'] || 'HTTP',
+              'port'      => options['port'] || '80',
+              'algorithm' => options['algorithm'] || 'ROUND_ROBIN',
+              'status'    => 'ACTIVE',
+              'created'   => '2012-01-01T13:32:20Z',
+              'updated'   => '2012-01-01T13:32:20Z',
+              'nodes'     => nodes
+          }
+          if (!options['virtualIps'].nil? && !options['virtualIps'].empty?)
+            data['virtualIps'] = options['virtualIps']
+          else
+            data['virtualIps'] = [{
+                             'ipVersion' => 'IPV4',
+                             'type' => 'PUBLIC',
+                             'id' => Fog::HP::Mock.uuid.to_s,
+                             'address' => Fog::HP::Mock.ip_address
+                          }]
+          end
+
+          self.data[:lbs][data['id']] = data
+          response.body = data
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/lb/create_load_balancer_node.rb

@@ -0,0 +1,72 @@
+module Fog
+  module HP
+    class LB
+
+      # Create a new load balancer node
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of load balancer to create node for
+      # * 'address'<~String> - Address for the node
+      # * 'port'<~String> - Port for the node
+      # * options<~Hash>:
+      #   * 'condition'<~String> - Condition for the node. Valid values are ['ENABLED', 'DISABLED']
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'nodes'<~Array>:
+      #       * 'id'<~String> - UUID of the node
+      #       * 'address'<~String> - Address for the node
+      #       * 'port'<~String> - Port for the node
+      #       * 'condition'<~String> - Condition for the node. Valid values are ['ENABLED', 'DISABLED']
+      #       * 'status'<~String> - Status for the node
+      class Real
+        def create_load_balancer_node(load_balancer_id, address, port, options={})
+          data = {
+            'nodes' => [
+                {
+                    'address' => address,
+                    'port'    => port
+                }
+            ]
+          }
+          if options['condition']
+            data['nodes'][0]['condition'] = options['condition']
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'POST',
+            :path    => "loadbalancers/#{load_balancer_id}/nodes"
+          )
+
+        end
+      end
+      class Mock
+        def create_load_balancer_node(load_balancer_id, address, port, options={})
+          response = Excon::Response.new
+          if get_load_balancer(load_balancer_id)
+            response.status = 202
+
+            data = {
+                'id'        => Fog::HP::Mock.uuid.to_s,
+                'address'   => address,
+                'port'      => port,
+                'condition' => options['condition'] || 'ENABLED',
+                'status'    => 'ONLINE'
+            }
+
+            self.data[:lbs][load_balancer_id]['nodes'] << data
+            response.body = {'nodes' => [data]}
+            response
+          else
+            raise Fog::HP::LB::NotFound
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/fog/hp/requests/lb/delete_load_balancer.rb

@@ -0,0 +1,36 @@
+module Fog
+  module HP
+      class LB
+
+        # Delete an existing load balancer
+        #
+        # ==== Parameters
+        # * 'load_balancer_id'<~String> - UUId of load balancer to delete
+        #
+        class Real
+
+          def delete_load_balancer(load_balancer_id)
+            request(
+                :expects => 202,
+                :method  => 'DELETE',
+                :path    => "loadbalancers/#{load_balancer_id}"
+            )
+          end
+
+        end
+
+        class Mock
+          def delete_load_balancer(load_balancer_id)
+            response = Excon::Response.new
+            if list_load_balancers.body['loadBalancers'].detect { |_| _['id'] == load_balancer_id }
+              response.status = 202
+              response
+            else
+              raise Fog::HP::LB::NotFound
+            end
+          end
+
+        end
+      end
+  end
+end

data/lib/fog/hp/requests/lb/delete_load_balancer_node.rb

@@ -0,0 +1,47 @@
+module Fog
+  module HP
+    class LB
+
+      # Delete an existing load balancer node
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of load balancer for the node
+      # * 'node_id'<~String> - UUId of node to delete
+      #
+      class Real
+
+        def delete_load_balancer_node(load_balancer_id, node_id)
+          request(
+            :expects => 202,
+            :method  => 'DELETE',
+            :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
+          )
+        end
+
+      end
+      class Mock
+
+        def delete_load_balancer_node(load_balancer_id, node_id)
+          response = Excon::Response.new
+          if get_load_balancer(load_balancer_id)
+            if get_load_balancer_node(load_balancer_id, node_id)
+              response.status = 202
+              nodes = delete_node(load_balancer_id, node_id)
+              self.data[:lbs][load_balancer_id]['nodes'] = nodes
+              response
+            else
+              raise Fog::HP::LB::NotFound
+            end
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+
+        def delete_node(load_balancer_id, node_id)
+          nodes = list_load_balancer_nodes(load_balancer_id).body['nodes']
+          nodes.reject {|n| n['id'] == node_id}
+        end
+      end
+    end
+  end
+end