fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/lib/fog/cloudsigma/models/fwpolicies.rb

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/cloudsigma/models/fwpolicy'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Fwpolicies < Fog::Collection
+        model Fog::Compute::CloudSigma::FWPolicy
+
+        def all
+          resp = service.list_fwpolicies
+          data = resp.body['objects']
+          load(data)
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/fog/cloudsigma/models/fwpolicy.rb

@@ -0,0 +1,21 @@
+require 'fog/cloudsigma/nested_model'
+require 'fog/core/collection'
+require 'fog/cloudsigma/models/rule'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class FWPolicy < Fog::CloudSigma::CloudsigmaModel
+        identity :uuid
+        attribute :name, :type => :string
+        attribute :meta
+        attribute :owner
+        attribute :resource_uri, :type => :string
+        attribute :servers, :type => :array
+        model_attribute_array :rules, Rule
+      end
+
+
+    end
+  end
+end

data/lib/fog/cloudsigma/models/rule.rb

@@ -0,0 +1,21 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Rule < Fog::CloudSigma::CloudsigmaModel
+        attribute :action, :type => :string
+        attribute :comment, :type => :string
+        attribute :direction, :type => :string
+        attribute :dst_ip, :type => :string
+        attribute :dst_port, :type => :integer
+        attribute :ip_proto, :type => :string
+        attribute :src_ip, :type => :string
+        attribute :src_port, :type => :string
+
+
+      end
+    end
+  end
+end
+

data/lib/fog/cloudsigma/requests/list_fwpolicies.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class CloudSigma
+      class Real
+        def list_fwpolicies
+          list_request('fwpolicies/detail/')
+        end
+      end
+
+      class Mock
+        def list_fwpolicies
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute.rb

@@ -24,13 +24,13 @@ module Fog
       when :rackspace
         version = attributes.delete(:version) 
         version = version.to_s.downcase.to_sym unless version.nil?
-        if version == :v2
-          require 'fog/rackspace/compute_v2'
-           Fog::Compute::RackspaceV2.new(attributes)
-        else
+        if version == :v1
           Fog::Logger.deprecation "First Gen Cloud Servers are deprecated. Please use `:version => :v2` attribute to use Next Gen Cloud Servers."
           require 'fog/rackspace/compute'
           Fog::Compute::Rackspace.new(attributes)
+        else
+          require 'fog/rackspace/compute_v2'
+          Fog::Compute::RackspaceV2.new(attributes)
         end
       when :stormondemand
         require 'fog/storm_on_demand/compute'
@@ -38,6 +38,9 @@ module Fog
       when :vcloud
         require 'fog/vcloud/compute'
         Fog::Vcloud::Compute.new(attributes)
+      when :vcloud_director
+        require 'fog/vcloud_director/compute'
+        Fog::VcloudDirector::Compute.new(attributes)
       else
         if self.providers.include?(provider)
           require "fog/#{provider}/compute"

data/lib/fog/core.rb

@@ -47,3 +47,4 @@ require 'fog/cdn'
 require 'fog/dns'
 require 'fog/network'
 require 'fog/storage'
+require 'fog/orchestration'

data/lib/fog/core/errors.rb

@@ -101,6 +101,9 @@ An alternate file may be used by placing its path in the FOG_RC environment vari
   :libvirt_ip_command:
   :ibm_username:
   :ibm_password:
+  :vcloud_director_host:
+  :vcloud_director_username:
+  :vcloud_director_password:
 #
 # End of Fog Credentials File
 #######################################################

data/lib/fog/dynect/dns.rb

@@ -19,12 +19,14 @@ module Fog
       request :delete_record
       request :delete_zone
       request :get_node_list
+      request :get_all_records
       request :get_record
       request :get_zone
       request :post_record
       request :post_session
       request :post_zone
       request :put_zone
+      request :put_record
 
       class JobIncomplete < Error; end
 
@@ -70,7 +72,7 @@ module Fog
           @path       = options[:path]        || '/REST'
           @persistent = options[:persistent]  || false
           @scheme     = options[:scheme]      || 'https'
-          @version    = options[:version]     || '2.3.1'
+          @version    = options[:version]     || '3.5.2'
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
 

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

@@ -14,36 +14,48 @@ module Fog
         def all(options = {})
           requires :zone
           data = []
-          service.get_node_list(zone.domain, options).body['data'].each do |fqdn|
-            records = service.get_record('ANY', zone.domain, fqdn).body['data']
-
-            # data in format ['/REST/xRecord/domain/fqdn/identity]
-            records.map! do |record|
-              tokens = record.split('/')
-              {
-                :identity => tokens.last,
-                :fqdn     => fqdn,
-                :type     => tokens[2][0...-6] # everything before 'Record'
-              }
-            end
-
-            data.concat(records)
-          end
+          service.get_all_records(zone.domain, options).body['data'].each do |url|
+            (_, _, t, _, fqdn, id) = url.split('/')
+            type = t.gsub(/Record$/, '')
+
+            # leave out the default, read only records
+            # by putting this here we don't make the secondary request for these records
+            next if ['NS', 'SOA'].include?(type)
 
-          # leave out the default, read only records
-          data = data.reject {|record| ['NS', 'SOA'].include?(record[:type])}
+            record = service.get_record(type, zone.domain, fqdn, 'record_id' => id).body['data']
+
+            data << {
+              :identity => record['record_id'],
+              :fqdn => record['fqdn'],
+              :type => record['record_type'],
+              :rdata => record['rdata']
+            }
+          end
 
           load(data)
         end
 
         def get(record_id)
-          # FIXME: can this be done more efficiently?
-          all.detect {|record| record.identity == record_id}
+          requires :zone
+
+          list = service.get_all_records(zone.domain, {}).body['data']
+          url = list.detect { |e| e =~ /\/#{record_id}$/ }
+          return unless url
+          (_, _, t, _, fqdn, id) = url.split('/')
+          type = t.gsub(/Record$/, '')
+          record = service.get_record(type, zone.domain, fqdn, 'record_id' => id).body['data']
+
+          new({
+            :identity => record['record_id'],
+            :fqdn => record['fqdn'],
+            :type => record['record_type'],
+            :rdata => record['rdata']
+          })
         end
 
         def new(attributes = {})
           requires :zone
-          super({ :zone => zone }.merge!(attributes))
+          super({:zone => zone}.merge!(attributes))
         end
 
       end

data/lib/fog/dynect/requests/dns/get_all_records.rb

@@ -0,0 +1,56 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Get one or more node lists
+        #
+        # ==== Parameters
+        # * zone<~String> - zone to lookup node lists for
+        # * options<~Hash>
+        #   * fqdn<~String> - fully qualified domain name of node to lookup
+
+        def get_all_records(zone, options = {})
+          requested_fqdn = options['fqdn'] || options[:fqdn]
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :method   => :get,
+            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
+          )
+        end
+      end
+
+      class Mock
+        def get_all_records(zone, options = {})
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          response = Excon::Response.new
+          response.status = 200
+
+          data = [zone[:zone]]
+
+          if fqdn = options[:fqdn]
+            data = data | zone[:records].collect { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
+          else
+            data = data | zone[:records].collect { |type, records| records.collect { |record| record[:fqdn] } }.flatten
+          end
+
+          response.body = {
+            "status" => "success",
+            "data" => data,
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => "get_tree: Here is your zone tree",
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dynect/requests/dns/get_node_list.rb

@@ -16,7 +16,7 @@ module Fog
             :expects  => 200,
             :idempotent => true,
             :method   => :get,
-            :path     => ['NodeList', zone, requested_fqdn].compact.join('/')
+            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
           )
         end
       end

data/lib/fog/dynect/requests/dns/put_record.rb

@@ -0,0 +1,76 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Update or replace a record
+        #
+        # ==== Parameters
+        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
+        # * zone<~String> - zone of record
+        # * rdata<~Hash> - rdata for record
+        # * options<~Hash>: (options vary by type, listing below includes common parameters)
+        #   * ttl<~Integer> - ttl for the record, defaults to zone ttl
+
+        def put_record(type, zone, fqdn, rdata, options = {})
+          options.merge!('rdata' => rdata)
+          type.to_s.upcase!
+          options = {"#{type}Records" => [options]} unless options['record_id']
+          path = ["#{type}Record", zone, fqdn].join('/')
+          path += "/#{options.delete('record_id')}" if options['record_id']
+          request(
+            :body     => Fog::JSON.encode(options),
+            :expects  => 200,
+            :method   => :put,
+            :path     => path
+          )
+        end
+      end
+
+      class Mock
+        def put_record(type, zone, fqdn, rdata, options = {})
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          records = zone[:records]
+          record_id = zone[:next_record_id]
+          zone[:next_record_id] += 1
+
+          record = {
+            :type => type,
+            :zone => zone,
+            :fqdn => fqdn,
+            :rdata => rdata,
+            :ttl => options[:ttl] || zone[:ttl],
+            :record_id => record_id
+          }
+
+          records[type] << record
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            "status" => "success",
+            "data" => {
+              "zone" => record[:zone][:zone],
+              "ttl" => record[:ttl],
+              "fqdn" => record[:fqdn],
+              "record_type" => record[:type],
+              "rdata" => record[:rdata],
+              "record_id" => record[:record_id]
+           },
+           "job_id" => Fog::Dynect::Mock.job_id,
+           "msgs" => [{
+             "INFO"=>"add: Record added",
+             "SOURCE"=>"BLL",
+             "ERR_CD"=>nil,
+             "LVL"=>"INFO"
+           }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/compute/flavors.rb

@@ -15,8 +15,8 @@ module Fog
           load(data)
         end
 
-        def get(identity)
-          data = connection.get_machine_type(identity).body
+        def get(identity, zone_name = nil)
+          data = connection.get_machine_type(identity, zone_name).body
           new(data)
         rescue Excon::Errors::NotFound
           nil

data/lib/fog/google/requests/compute/get_machine_type.rb

@@ -4,7 +4,7 @@ module Fog
 
       class Mock
 
-        def get_machine_type(machine_type_name)
+        def get_machine_type(machine_type_name, zone_name = nil)
           Fog::Mock.not_implemented
         end
 
@@ -12,9 +12,14 @@ module Fog
 
       class Real
 
-        def get_machine_type(machine_type_name)
+        def get_machine_type(machine_type_name, zone_name = nil)
+          zone_name = list_zones.body['items'].first['name'] if zone_name.nil?
+          if zone_name.start_with? 'http'
+            zone_name = zone_name.split('/')[-1]
+          end
           api_method = @compute.machine_types.get
           parameters = {
+            'zone' => zone_name,
             'project' => 'google',
             'machineType' => machine_type_name
           }

data/lib/fog/joyent/compute.rb

@@ -165,7 +165,7 @@ module Fog
           end
 
           response
-        rescue Excon::Errors::Error => e
+        rescue Excon::Errors::HTTPStatusError => e
           raise_if_error!(e.request, e.response)
         end
 

data/lib/fog/linode/models/compute/server.rb

@@ -19,7 +19,7 @@ module Fog
         end
 
         def public_ip_address
-          ips.find{|ip| ip.ip !~ /^192/}.ip
+          ips.find{|ip| ip.ip !~ /^192\.168\./}.ip
         end
 
         def disks

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

@@ -18,7 +18,7 @@ module Fog
           load(data)
         end
 
-        def get(key)
+        def get(key, options = {})
           if ::File.directory?(service.path_to(key))
             new(:key => key)
           else

data/lib/fog/openstack.rb

@@ -48,6 +48,7 @@ module Fog
     service(:storage, 'openstack/storage', 'Storage')
     service(:volume,  'openstack/volume',  'Volume')
     service(:metering,  'openstack/metering',  'Metering')
+    service(:orchestration,  'openstack/orchestration',  'Orchestration')
 
     def self.authenticate(options, connection_options = {})
       case options[:openstack_auth_uri].path