fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

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

@@ -0,0 +1,60 @@
+module Fog
+  module HP
+    class LB
+
+      # Get details for an existing load balancer
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of the load balancer to get
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'loadBalancers'<~Array>:
+      #       * '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
+      #       * 'statusDescription'<~String> - Desc. of Status for the load balancer
+      #       * 'created'<~String> - created date time stamp
+      #       * 'updated'<~String> - updated date time stamp
+      #       * 'nodeCount'<~Integer> - Nodes attached to the load balancer
+      #       * 'nodes'<~ArrayOfHash> - Nodes for the load balancer
+      #         * 'id'<~String> - UUId for the node
+      #         * 'address'<~String> - Address for the node
+      #         * 'port'<~String> - Port for the node
+      #         * 'condition'<~String> - Condition for the node e.g. 'ENABLED'
+      #         * 'status'<~String> - Status for the node e.g. 'ONLINE'
+      #       * '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 get_load_balancer(load_balancer_id)
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => "loadbalancers/#{load_balancer_id}"
+          )
+        end
+
+      end
+      class Mock
+        def get_load_balancer(load_balancer_id)
+          response = Excon::Response.new
+          if lb = list_load_balancers.body['loadBalancers'].detect { |_| _['id'] == load_balancer_id }
+            response.status = 200
+            response.body = lb
+            response
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module HP
+    class LB
+      class Real
+
+      # Get details for an existing load balancer node
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of the load balancer to get
+      # * 'node_id'<~String> - UUId of node to get
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'id'<~String> - UUId for the node
+      #     * 'address'<~String> - Address for the node
+      #     * 'port'<~String> - Port for the node
+      #     * 'condition'<~String> - Condition for the node e.g. 'ENABLED'
+      #     * 'status'<~String> - Status for the node e.g. 'ONLINE'
+        def get_load_balancer_node(load_balancer_id, node_id)
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
+          )
+        end
+      end
+
+      class Mock
+        def get_load_balancer_node(load_balancer_id, node_id)
+          response = Excon::Response.new
+          if get_load_balancer(load_balancer_id)
+           if node = find_node(load_balancer_id, node_id)
+             response.status = 200
+             response.body = node
+             response
+           else
+             raise Fog::HP::LB::NotFound
+           end
+          else
+            raise Fog::HP::LB::NotFound
+          end
+
+        end
+
+        def find_node(load_balancer_id, node_id)
+          nodes = list_load_balancer_nodes(load_balancer_id).body['nodes']
+          nodes.detect {|n| n['id'] == node_id}
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  module HP
+    class LB
+
+      # List algorithms
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'algorithms'<~Array>:
+      #       * 'name'<~String> - Name of the algorithm
+      class Real
+        def list_algorithms
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'algorithms'
+          )
+        end
+      end
+      class Mock
+        def list_algorithms
+          response = Excon::Response.new
+          algorithms  = self.data[:algorithms].values
+          response.status = 200
+          response.body = { 'algorithms' => algorithms }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module HP
+    class LB
+
+      # List limits
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'limits'<~Hash>:
+      #       * 'absolute'<~Hash>:
+      #         * 'values'<~Hash>:
+      #           * 'maxLoadBalancerNameLength'<~Integer> - Limit of the name of the load balancer
+      #           * 'maxLoadBalancers'<~Integer> - Limit of the number of the load balancer
+      #           * 'maxVIPsPerLoadBalancer'<~Integer> - Limit of the virtual IPs per load balancer
+      #           * 'maxNodesPerLoadBalancer'<~Integer> - Limit of the nodes per load balancer
+      class Real
+
+        def list_limits
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'limits'
+          )
+        end
+
+      end
+      class Mock
+        def list_limits
+          response        = Excon::Response.new
+          limits          = self.data[:limits].values
+          response.status = 200
+          response.body   = { 'limits' => limits }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module HP
+    class LB
+
+      # List all load balancer nodes
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'nodes'<~Array>: Nodes for the load balancer
+      #       * 'id'<~String> - UUId for the node
+      #       * 'address'<~String> - Address for the node
+      #       * 'port'<~String> - Port for the node
+      #       * 'condition'<~String> - Condition for the node e.g. 'ENABLED'
+      #       * 'status'<~String> - Status for the node e.g. 'ONLINE'
+      class Real
+        def list_load_balancer_nodes(load_balancer_id)
+          response = request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => "loadbalancers/#{load_balancer_id}/nodes"
+          )
+          response
+        end
+      end
+      class Mock
+        def list_load_balancer_nodes(load_balancer_id)
+          response = Excon::Response.new
+          if lb = get_load_balancer(load_balancer_id).body
+            response.status = 200
+            response.body   = {'nodes' => lb['nodes']}
+            response
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module HP
+    class LB
+
+      # List virtual IPs for an existing load balancer
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of the load balancer to get virtual IPs for
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'virtualIps'<~Array>:
+      #       * 'id'<~String> - UUId for the virtual IP
+      #       * 'address'<~String> - Address for the virtual IP
+      #       * 'type'<~String> - Type for the virtual IP e.g. 'PUBLIC'
+      #       * 'ipVersion'<~String> - Version for virtual IP e.g. 'IPV4', 'IPV6'
+      class Real
+        def list_load_balancer_virtual_ips(load_balancer_id)
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => "loadbalancers/#{load_balancer_id}/virtualips"
+          )
+        end
+
+      end
+      class Mock
+        def list_load_balancer_virtual_ips(load_balancer_id)
+          response = Excon::Response.new
+          if lb_data = get_load_balancer(load_balancer_id)
+            virtual_ips = lb_data.body['virtualIps']
+            response.status = 200
+            response.body   = { 'virtualIps' => virtual_ips }
+            response
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module HP
+    class LB
+
+      # List all load balancers
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'loadBalancers'<~Array>:
+      #       * '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
+      #       * 'nodeCount'<~Integer> - Nodes attached to the load balancer
+      class Real
+        def list_load_balancers
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'loadbalancers'
+          )
+        end
+
+      end
+      class Mock
+        def list_load_balancers
+          response = Excon::Response.new
+          lbs = self.data[:lbs].values
+          response.status = 200
+          response.body = { 'loadBalancers' => lbs }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module HP
+    class LB
+
+      # List protocols
+      #
+      # ==== Returns
+      # * response<~Excon::Response>:
+      #   * body<~Hash>:
+      #     * 'protocols'<~Array>:
+      #       * 'name'<~String> - Name of the protocol
+      #       * 'port'<~String> - Port of the protocol
+      class Real
+        def list_protocols
+          response = request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'protocols'
+          )
+          response
+        end
+      end
+      class Mock
+        def list_protocols
+          response = Excon::Response.new
+          protocols  = self.data[:protocols].values
+          response.status = 200
+          response.body   = { 'protocols' => protocols }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module HP
+    class LB
+      class Real
+
+        def list_versions
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => ''
+          )
+        end
+      end
+      class Mock
+
+        def list_versions
+          response        = Excon::Response.new
+          versions       = self.data[:versions].values
+          response.status = 200
+          response.body   = { 'versions' => versions }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module HP
+    class LB
+
+      # Update an existing load balancer
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of the load balancer to update
+      # * options<~Hash>:
+      #   * 'name'<~String> - Name for the load balancer
+      #   * 'algorithm'<~String> - Algorithm for the load balancer
+      class Real
+        def update_load_balancer(load_balancer_id, options={})
+          data = {}
+          l_options = ['name', 'algorithm']
+          l_options.select{|o| options[o]}.each do |key|
+            data[key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'PUT',
+            :path    => "loadbalancers/#{load_balancer_id}"
+          )
+        end
+
+      end
+      class Mock
+        def update_load_balancer(load_balancer_id, options={})
+          response = Excon::Response.new
+          if lb = list_load_balancers.body['loadBalancers'].detect { |_| _['id'] == load_balancer_id }
+
+            lb['name']      = options['name']      if options['name']
+            lb['algorithm'] = options['algorithm'] if options['algorithm']
+
+            response.status = 202
+            response.body   = ''
+            response
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module HP
+    class LB
+
+      # Update an existing load balancer node
+      #
+      # ==== Parameters
+      # * 'load_balancer_id'<~String> - UUId of the load balancer to update
+      # * 'node_id'<~String> - UUId of node to update
+      # * options<~Hash>:
+      #   * 'condition'<~String> - Condition for the node. Valid values are []'ENABLED', 'DISABLED']
+      class Real
+
+        def update_load_balancer_node(load_balancer_id, node_id, condition)
+          data = {
+            'condition' => condition
+          }
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 202,
+            :method  => 'PUT',
+            :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
+          )
+
+        end
+      end
+      class Mock
+        def update_load_balancer_node(load_balancer_id, node_id, condition)
+          response = Excon::Response.new
+          if lb_data = get_load_balancer(load_balancer_id)
+            if get_load_balancer_node(load_balancer_id, node_id)
+              nodes = update_node(lb_data, node_id, condition)
+              self.data[:lbs][load_balancer_id]['nodes'] = nodes
+              response.status = 202
+              response
+            else
+              raise Fog::HP::LB::NotFound
+            end
+          else
+            raise Fog::HP::LB::NotFound
+          end
+        end
+
+        def update_node(lb_data, node_id, condition)
+          nodes = lb_data.body['nodes']
+          node = nodes.select {|n| n['id'] == node_id}.first
+          # update the node attributes
+          if node
+            node['condition'] = condition
+            node['status'] = condition == 'ENABLED' ? 'ONLINE' : 'OFFLINE'
+          end
+          new_nodes = nodes.reject {|n| n['id'] == node_id}
+          new_nodes << node
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/requests/network/add_router_interface.rb

@@ -0,0 +1,75 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Add an internal router interface, thus attaching a subnet or a port to an existing router
+        #
+        # ==== Parameters
+        # * 'router_id'<~String>: - UUId for the router
+        # * 'subnet_id'<~String>: - UUId for the subnet (Either a subnet or a port can be passed, not both)
+        # * 'port_id'<~String>: - UUId for the port (Either a subnet or a port can be passed, not both)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'subnet_id'<~String>: - UUId for the subnet
+        #     * 'port_id'<~String>: - UUId for the port
+        def add_router_interface(router_id, subnet_id=nil, port_id=nil, options = {})
+          # Either a subnet or a port can be passed, not both
+          if (subnet_id && port_id) || (subnet_id.nil? && port_id.nil?)
+            raise ArgumentError.new('Either a subnet or a port can be passed, not both')
+          end
+          if subnet_id
+            data = { 'subnet_id' => subnet_id }
+          elsif port_id
+            data = { 'port_id' => port_id }
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 200,
+            :method   => 'PUT',
+            :path     => "routers/#{router_id}/add_router_interface"
+          )
+        end
+      end
+
+      class Mock
+        def add_router_interface(router_id, subnet_id=nil, port_id=nil, options = {})
+          response = Excon::Response.new
+          if list_routers.body['routers'].detect {|_| _['id'] == router_id}
+            # Either a subnet or a port can be passed, not both
+            if (subnet_id && port_id) || (subnet_id.nil? && port_id.nil?)
+              raise ArgumentError.new('Either a subnet or a port can be passed, not both')
+            end
+
+            if port_id.nil?
+              # create a new port
+              resp = create_port(self.data[:networks].keys[0], {:name => "New Port #{rand(10)}"})
+              port_id = resp.body['port']['id']
+            end
+
+            data = {
+              'subnet_id' => subnet_id || Fog::HP::Mock.uuid.to_s,
+              'port_id'   => port_id
+            }
+
+            # so either way if I pass a subnet or a port,
+            # it basically adds the router uuid to the port's device_id
+            # and sets device_owner to network:router_interface
+            self.data[:ports][port_id]['device_id'] = router_id
+            self.data[:ports][port_id]['device_owner'] = 'network:router_interface'
+
+            response.status = 200
+            response.body = data
+            response
+          else
+            raise Fog::HP::Network::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/network/associate_floating_ip.rb

@@ -0,0 +1,71 @@
+module Fog
+  module HP
+    class Network
+
+      class Real
+        # Associate port with floating ip
+        #
+        # ==== Parameters
+        #   * 'floating_ip_id'<~String>: - UUId of the floating IP address to associate with
+        #   * 'port_id'<~String>: - Port to associate with the floating IP
+        # * options<~Hash>:
+        #   * 'fixed_ip_address'<~String>: - Fixed IP address to associate with the floating IP. Mandatory, if the port has multiple IP addresses
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * floatingip<~Array>:
+        #       * 'id'<~String>: - UUId for the floating ip
+        #       * 'tenant_id'<~String>: - TenantId that owns the floating ip
+        #       * 'floating_network_id'<~String>: - UUId of the external network
+        #       * 'router_id'<~String>: - Id of the router, null if not assigned
+        #       * 'fixed_ip_address'<~String>: - Fixed IP address associated to the floating IP, null if not assigned
+        #       * 'floating_ip_address'<~String>: - Floating IP address
+        #       * 'port_id'<~String>: - Port associated to the floating IP, null if not assigned
+        def associate_floating_ip(floating_ip_id, port_id, options = {})
+          data = {
+            'floatingip' => {
+              'port_id'    => port_id
+            }
+          }
+          l_options = [:fixed_ip_address]
+          l_options.select{|o| options[o]}.each do |key|
+            data['floatingip'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 200,
+            :method   => 'PUT',
+            :path     => "floatingips/#{floating_ip_id}"
+          )
+        end
+      end
+
+      class Mock
+        def associate_floating_ip(floating_ip_id, port_id, options = {})
+          response = Excon::Response.new
+          if list_floating_ips.body['floatingips'].detect {|_| _['id'] == floating_ip_id}
+            response.status = 201
+            data = {
+              'id'                  => floating_ip_id,
+              'port_id'             => port_id,
+              'router_id'           => Fog::HP::Mock.uuid.to_s,
+              'tenant_id'           => Fog::Mock.random_numbers(14).to_s,
+              'floating_network_id' => Fog::HP::Mock.uuid.to_s,
+              'fixed_ip_address'    => options[:fixed_ip_address] || Fog::HP::Mock.ip_address.to_s,
+              'floating_ip_address' => Fog::HP::Mock.ip_address.to_s
+            }
+
+            self.data[:floating_ips][data['id']] = data
+            response.body = { 'floatingip' => data }
+            response
+          else
+            raise Fog::HP::Network::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end