fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/hp/models/network/floating_ip.rb

@@ -0,0 +1,45 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class FloatingIp < Fog::Model
+        identity :id
+
+        attribute :floating_network_id
+        attribute :port_id
+        attribute :tenant_id
+        attribute :router_id
+        attribute :fixed_ip_address
+        attribute :floating_ip_address
+
+        def destroy
+          requires :id
+          service.delete_floating_ip(id)
+          true
+        end
+
+        def associate_port(port_id, options={})
+          requires :id
+          merge_attributes(service.associate_floating_ip(id, port_id, options).body['floatingip'])
+          true
+        end
+
+        def disassociate_port(options={})
+          requires :id
+          merge_attributes(service.disassociate_floating_ip(id, options).body['floatingip'])
+          true
+        end
+
+        def save
+          requires :floating_network_id
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          merge_attributes(service.create_floating_ip(floating_network_id, attributes).body['floatingip'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/floating_ips.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/floating_ip'
+
+module Fog
+  module HP
+    class Network
+
+      class FloatingIps < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::FloatingIp
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_floating_ips(non_aliased_filters).body['floatingips'])
+        end
+
+        def get(floating_ip_id)
+          if floating_ip = service.get_floating_ip(floating_ip_id).body['floatingip']
+            new(floating_ip)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/network.rb

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class Network < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :tenant_id
+        attribute :status
+        attribute :shared
+        attribute :admin_state_up
+        attribute :router_external,    :aliases => 'router:external'
+
+        def destroy
+          requires :id
+          service.delete_network(id)
+          true
+        end
+
+        def ready?
+          self.status == 'ACTIVE'
+        end
+
+        def subnets
+          @subnets ||= begin
+            Fog::HP::Network::Subnets.new({
+              :service => service,
+              :filters => {:network_id => self.id}
+            })
+          end
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          merge_attributes(service.create_network(attributes).body['network'])
+          true
+        end
+
+        def update
+          requires :id
+          merge_attributes(service.update_network(id, attributes).body['network'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/networks.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/network'
+
+module Fog
+  module HP
+    class Network
+
+      class Networks < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::Network
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_networks(non_aliased_filters).body['networks'])
+        end
+
+        def get(network_id)
+          if network = service.get_network(network_id).body['network']
+            new(network)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/port.rb

@@ -0,0 +1,54 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class Port < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :network_id
+        attribute :tenant_id
+        attribute :fixed_ips
+        attribute :mac_address
+        attribute :status
+        attribute :admin_state_up
+        attribute :device_id
+        attribute :device_owner
+        attribute :security_groups
+
+        def destroy
+          requires :id
+          service.delete_port(id)
+          true
+        end
+
+        def ready?
+          self.status == 'ACTIVE'
+        end
+
+        def save
+          requires :network_id
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          requires :network_id
+          merge_attributes(service.create_port(network_id, attributes).body['port'])
+          true
+        end
+
+        def update
+          requires :id, :network_id
+          merge_attributes(service.update_port(id, attributes).body['port'])
+          true
+        end
+
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/ports.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/port'
+
+module Fog
+  module HP
+    class Network
+
+      class Ports < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::Port
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_ports(non_aliased_filters).body['ports'])
+        end
+
+        def get(port_id)
+          if port = service.get_port(port_id).body['port']
+            new(port)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/router.rb

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class Router < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :tenant_id
+        attribute :external_gateway_info
+        attribute :admin_state_up
+        attribute :status
+
+        def destroy
+          requires :id
+          service.delete_router(id)
+          true
+        end
+
+        def add_interface(subnet_id=nil, port_id=nil, options={})
+          requires :id
+          begin
+            service.add_router_interface(id, subnet_id, port_id, options).body['router']
+            true
+          rescue ArgumentError, Fog::HP::Network::NotFound
+            false
+          end
+        end
+
+        def remove_interface(subnet_id=nil, port_id=nil, options={})
+          requires :id
+          begin
+            service.remove_router_interface(id, subnet_id, port_id, options)
+            true
+          rescue ArgumentError, Fog::HP::Network::NotFound
+            false
+          end
+        end
+
+        def ready?
+          self.status == 'ACTIVE'
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          merge_attributes(service.create_router(attributes).body['router'])
+          true
+        end
+
+        def update
+          requires :id
+          merge_attributes(service.update_router(id, attributes).body['router'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/routers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/router'
+
+module Fog
+  module HP
+    class Network
+
+      class Routers < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::Router
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_routers(non_aliased_filters).body['routers'])
+        end
+
+        def get(router_id)
+          if router = service.get_router(router_id).body['router']
+            new(router)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/security_group.rb

@@ -0,0 +1,30 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class SecurityGroup < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :security_group_rules
+        attribute :tenant_id
+
+        def destroy
+          requires :id
+          service.delete_security_group(id)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          merge_attributes(service.create_security_group(attributes).body['security_group'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/security_group_rule.rb

@@ -0,0 +1,35 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class SecurityGroupRule < Fog::Model
+        identity :id
+
+        attribute :security_group_id
+        attribute :direction
+        attribute :protocol
+        attribute :port_range_min
+        attribute :port_range_max
+        attribute :remote_ip_prefix
+        attribute :ethertype
+        attribute :remote_group_id
+        attribute :tenant_id
+
+        def destroy
+          requires :id
+          service.delete_security_group_rule(id)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          merge_attributes(service.create_security_group_rule(security_group_id, direction, attributes).body['security_group_rule'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/security_group_rules.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/security_group_rule'
+
+module Fog
+  module HP
+    class Network
+
+      class SecurityGroupRules < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::SecurityGroupRule
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_security_group_rules(non_aliased_filters).body['security_group_rules'])
+        end
+
+        def get(sec_group_rule_id)
+          if sec_group_rule = service.get_security_group_rule(sec_group_rule_id).body['security_group_rule']
+            new(sec_group_rule)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/security_groups.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/security_group'
+
+module Fog
+  module HP
+    class Network
+
+      class SecurityGroups < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::SecurityGroup
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_security_groups(non_aliased_filters).body['security_groups'])
+        end
+
+        def get(security_group_id)
+          if security_group = service.get_security_group(security_group_id).body['security_group']
+            new(security_group)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/subnet.rb

@@ -0,0 +1,49 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class Network
+
+      class Subnet < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :network_id
+        attribute :cidr
+        attribute :ip_version
+        attribute :tenant_id
+        attribute :dns_nameservers
+        attribute :allocation_pools
+        attribute :host_routes
+        attribute :gateway_ip
+        attribute :enable_dhcp
+
+        def destroy
+          requires :id
+          service.delete_subnet(id)
+          true
+        end
+
+        def save
+          requires :network_id, :cidr, :ip_version
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          requires :network_id, :cidr, :ip_version
+          merge_attributes(service.create_subnet(network_id, cidr, ip_version, attributes).body['subnet'])
+          true
+        end
+
+        def update
+          requires :id
+          merge_attributes(service.update_subnet(id, attributes).body['subnet'])
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/network/subnets.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/hp/models/network/subnet'
+
+module Fog
+  module HP
+    class Network
+
+      class Subnets < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::Network::Subnet
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          load(service.list_subnets(non_aliased_filters).body['subnets'])
+        end
+
+        def get(subnet_id)
+          if subnet = service.get_subnet(subnet_id).body['subnet']
+            new(subnet)
+          end
+        rescue Fog::HP::Network::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/storage/directories.rb

@@ -49,7 +49,7 @@ module Fog
           write_header = nil
           directory = new(:key => key)
           for key, value in data.headers
-            if ['X-Container-Bytes-Used', 'X-Container-Object-Count', 'X-Container-Sync-To', 'X-Container-Sync-Key'].include?(key)
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count', 'X-Container-Sync-To', 'X-Container-Sync-Key', 'X-Container-Meta-Web-Index', 'X-Container-Meta-Web-Listings', 'X-Container-Meta-Web-Listings-Css', 'X-Container-Meta-Web-Error'].include?(key)
               directory.merge_attributes(key => value)
             end
             if key == 'X-Container-Read'