fog 1.17.0 → 1.18.0

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'

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

@@ -1,5 +1,6 @@
 require 'fog/core/model'
 require 'fog/hp/models/storage/files'
+require 'fog/hp/models/storage/metadata'
 
 module Fog
   module Storage
@@ -7,12 +8,16 @@ module Fog
 
       class Directory < Fog::Model
 
-        identity  :key,       :aliases => 'name'
+        identity  :key,               :aliases => 'name'
 
-        attribute :bytes,     :aliases => 'X-Container-Bytes-Used'
-        attribute :count,     :aliases => 'X-Container-Object-Count'
-        attribute :sync_to,   :aliases => 'X-Container-Sync-To'
-        attribute :sync_key,  :aliases => 'X-Container-Sync-Key'
+        attribute :bytes,             :aliases => 'X-Container-Bytes-Used'
+        attribute :count,             :aliases => 'X-Container-Object-Count'
+        attribute :sync_to,           :aliases => 'X-Container-Sync-To'
+        attribute :sync_key,          :aliases => 'X-Container-Sync-Key'
+        attribute :web_index,         :aliases => 'X-Container-Meta-Web-Index'
+        attribute :web_listings,      :aliases => 'X-Container-Meta-Web-Listings'
+        attribute :web_listings_css,  :aliases => 'X-Container-Meta-Web-Listings-Css'
+        attribute :web_error,         :aliases => 'X-Container-Meta-Web-Error'
 
         def initialize(attributes = {})
             @read_acl  = []
@@ -96,6 +101,21 @@ module Fog
           true
         end
 
+        def metadata
+          @metadata ||= begin
+            Fog::Storage::HP::Metadata.new({
+              :service => service,
+              :parent => self
+            })
+          end
+        end
+
+        def metadata=(new_metadata={})
+          metas = []
+          new_metadata.each_pair {|k,v| metas << {'key' => k, 'value' => v} }
+          metadata.load(metas)
+        end
+
         def destroy
           requires :key
           service.delete_container(key)
@@ -234,6 +254,16 @@ module Fog
           options.merge!(service.perm_acl_to_header(@read_acl, @write_acl))
           options.merge!({'X-Container-Sync-To' => self.sync_to}) unless self.sync_to.nil?
           options.merge!({'X-Container-Sync-Key' => self.sync_key}) unless self.sync_key.nil?
+          options.merge!({'X-Container-Meta-Web-Index' => self.web_index}) unless self.web_index.nil?
+          options.merge!({'X-Container-Meta-Web-Listings' => self.web_listings})
+          options.merge!({'X-Container-Meta-Web-Listings-Css' => self.web_listings_css}) unless self.web_listings_css.nil?
+          options.merge!({'X-Container-Meta-Web-Error' => self.web_error}) unless self.web_error.nil?
+          # get the metadata and merge them in
+          meta_hash = {}
+          metadata.each { |meta| meta_hash.store(meta.key, meta.value) }
+          if meta_hash
+            options.merge!(meta_hash)
+          end
           service.put_container(key, options)
           # Added an extra check to see if CDN is enabled for the container
           if (!service.cdn.nil? && service.cdn.enabled?)
@@ -241,8 +271,9 @@ module Fog
             if @cdn_enable
               # check to make sure that the container exists. If yes, cdn enable it.
               begin response = service.cdn.head_container(key)
-                ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
-                service.cdn.post_container(key, {'X-CDN-Enabled' => 'True'})
+                if response.headers['X-Cdn-Enabled'] == 'False'
+                  service.cdn.post_container(key, {'X-Cdn-Enabled' => 'True'})
+                end
               rescue Fog::CDN::HP::NotFound
                 service.cdn.put_container(key)
               rescue Excon::Errors::SocketError
@@ -252,7 +283,9 @@ module Fog
               # check to make sure that the container exists. If yes, cdn disable it.
               begin response = service.cdn.head_container(key)
                 ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
-                service.cdn.post_container(key, {'X-CDN-Enabled' => 'False'})
+                if response.headers['X-Cdn-Enabled'] == 'True'
+                  service.cdn.post_container(key, {'X-Cdn-Enabled' => 'False'})
+                end
               rescue Fog::CDN::HP::NotFound
                 # just continue, as container is not cdn-enabled.
               rescue Excon::Errors::SocketError