fog 1.9.0 → 1.10.0

data/lib/fog/hp/requests/storage/put_shared_object.rb

@@ -0,0 +1,85 @@
+module Fog
+  module Storage
+    class HP
+      class Real
+
+        # Create a new object in a shared container
+        #
+        # ==== Parameters
+        # * shared_container_url<~String> - Shared url for the container
+        # * object<~String> - Name of the object
+        # * options<~Hash> - header options
+        #
+        def put_shared_object(shared_container_url, object_name, data, options = {}, &block)
+          # split up the shared object url
+          uri = URI.parse(shared_container_url)
+          path   = uri.path
+
+          data = Fog::Storage.parse_data(data)
+          headers = data[:headers].merge!(options)
+          if block_given?
+            headers['Transfer-Encoding'] = 'chunked'
+            headers.delete('Content-Length')
+            return shared_request(
+              :request_block     => block,
+              :expects  => 201,
+              :headers  => headers,
+              :method   => 'PUT',
+              :path     => "#{path}/#{Fog::HP.escape(object_name)}"
+            )
+          end
+          if headers.has_key?('Transfer-Encoding')
+            headers.delete('Content-Length')
+          end
+          response = shared_request(
+            :body     => data[:body],
+            :expects  => 201,
+            :headers  => headers,
+            :method   => 'PUT',
+            :path     => "#{path}/#{Fog::HP.escape(object_name)}"
+          )
+          response
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def put_shared_object(shared_container_url, object_name, data, options = {}, &block)
+          response = Excon::Response.new
+          data = Fog::Storage.parse_data(data)
+          unless data[:body].is_a?(String)
+            data[:body] = data[:body].read
+          end
+          response.status = 201
+          object = {
+            :body             => data[:body],
+            'Content-Type'    => options['Content-Type'] || data[:headers]['Content-Type'],
+            'ETag'            => Fog::HP::Mock.etag,
+            'Key'             => object_name,
+            'Date'            => Fog::Time.now.to_date_header,
+            'Content-Length'  => options['Content-Length'] || data[:headers]['Content-Length'],
+          }
+
+          for key, value in options
+            case key
+            when 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-MD5', 'Expires', /^X-Object-Meta-/
+              object[key] = value
+            end
+          end
+
+          response.headers = {
+            'Content-Length'  => object['Content-Length'],
+            'Content-Type'    => object['Content-Type'],
+            'ETag'            => object['ETag'],
+            'Date'            => object['Date']
+          }
+
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/storage.rb

@@ -5,28 +5,42 @@ module Fog
   module Storage
     class HP < Fog::Service
 
-      requires    :hp_secret_key, :hp_account_id, :hp_tenant_id
-      recognizes  :hp_auth_uri, :hp_servicenet, :hp_cdn_ssl, :hp_cdn_uri, :persistent, :connection_options, :hp_use_upass_auth_style, :hp_auth_version
+      requires    :hp_secret_key, :hp_tenant_id, :hp_avl_zone
+      recognizes  :hp_auth_uri, :hp_cdn_ssl, :hp_cdn_uri
+      recognizes  :persistent, :connection_options
+      recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
+      recognizes  :hp_access_key, :hp_account_id  # :hp_account_id is deprecated use hp_access_key instead
 
       secrets     :hp_secret_key
 
       model_path 'fog/hp/models/storage'
       model       :directory
       collection  :directories
+      model       :shared_directory
+      collection  :shared_directories
       model       :file
       collection  :files
+      model       :shared_file
+      collection  :shared_files
 
       request_path 'fog/hp/requests/storage'
       request :delete_container
       request :delete_object
+      request :delete_shared_object
       request :get_container
       request :get_containers
       request :get_object
+      request :get_object_temp_url
+      request :get_shared_container
+      request :get_shared_object
       request :head_container
       request :head_containers
       request :head_object
+      request :head_shared_container
+      request :head_shared_object
       request :put_container
       request :put_object
+      request :put_shared_object
 
       module Utils
 
@@ -34,11 +48,12 @@ module Fog
           unless @hp_cdn_uri.nil?
             @cdn ||= Fog::CDN.new(
               :provider       => 'HP',
-              :hp_account_id  => @hp_account_id,
+              :hp_access_key  => @hp_access_key,
               :hp_secret_key  => @hp_secret_key,
               :hp_auth_uri    => @hp_auth_uri,
               :hp_cdn_uri     => @hp_cdn_uri,
               :hp_tenant_id   => @hp_tenant_id,
+              :hp_avl_zone    => @hp_avl_zone,
               :connection_options => @connection_options
             )
             if @cdn.enabled?
@@ -53,35 +68,118 @@ module Fog
           "#{@scheme}://#{@host}:#{@port}#{@path}"
         end
 
-        def acl_to_header(acl)
+        def public_url(container=nil, object=nil)
+          public_url = nil
+          unless container.nil?
+            if object.nil?
+              # return container public url
+              public_url = "#{url}/#{Fog::HP.escape(container)}"
+            else
+              # return object public url
+              public_url = "#{url}/#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
+            end
+          end
+          public_url
+        end
+
+        def perm_to_acl(perm, users=[])
+          read_perm_acl = []
+          write_perm_acl = []
+          valid_public_perms  = ['pr', 'pw', 'prw']
+          valid_account_perms = ['r', 'w', 'rw']
+          valid_perms = valid_public_perms + valid_account_perms
+          unless valid_perms.include?(perm)
+            raise ArgumentError.new("permission must be one of [#{valid_perms.join(', ')}]")
+          end
+          # tackle the public access differently
+          if valid_public_perms.include?(perm)
+            case perm
+              when "pr"
+                read_perm_acl = [".r:*",".rlistings"]
+              when "pw"
+                write_perm_acl = ["*"]
+              when "prw"
+                read_perm_acl = [".r:*",".rlistings"]
+                write_perm_acl = ["*"]
+            end
+          elsif valid_account_perms.include?(perm)
+            # tackle the user access differently
+            unless (users.nil? || users.empty?)
+              # return the correct acls
+              tenant_id = "*"  # this might change later
+              acl_array = users.map { |u| "#{tenant_id}:#{u}" }
+              #acl_string = acl_array.join(',')
+              case perm
+                when "r"
+                  read_perm_acl = acl_array
+                when "w"
+                  write_perm_acl = acl_array
+                when "rw"
+                  read_perm_acl = acl_array
+                  write_perm_acl = acl_array
+              end
+            end
+          end
+          return read_perm_acl, write_perm_acl
+        end
+
+        def perm_acl_to_header(read_perm_acl, write_perm_acl)
           header = {}
-          case acl
-            when "private"
-              header['X-Container-Read']  = ""
-              header['X-Container-Write'] = ""
-            when "public-read"
-              header['X-Container-Read']  = ".r:*,.rlistings"
-            when "public-write"
-              header['X-Container-Write'] = "*"
-            when "public-read-write"
-              header['X-Container-Read']  = ".r:*,.rlistings"
-              header['X-Container-Write'] = "*"
+          if read_perm_acl.nil? && write_perm_acl.nil?
+            header = {'X-Container-Read' => "", 'X-Container-Write' => ""}
+          elsif !read_perm_acl.nil? && write_perm_acl.nil?
+            header = {'X-Container-Read' => "#{read_perm_acl.join(',')}", 'X-Container-Write' => ""}
+          elsif read_perm_acl.nil? && !write_perm_acl.nil?
+            header = {'X-Container-Read' => "", 'X-Container-Write' => "#{write_perm_acl.join(',')}"}
+          elsif !read_perm_acl.nil? && !write_perm_acl.nil?
+            header = {'X-Container-Read' => "#{read_perm_acl.join(',')}", 'X-Container-Write' => "#{write_perm_acl.join(',')}"}
           end
           header
         end
 
-        def header_to_acl(read_header=nil, write_header=nil)
-          acl = nil
-          if read_header.nil? && write_header.nil?
-            acl = nil
-          elsif !read_header.nil? && read_header.include?(".r:*") && write_header.nil?
-            acl = "public-read"
-          elsif !write_header.nil? && write_header.include?("*") && read_header.nil?
-            acl = "public-write"
-          elsif !read_header.nil? && read_header.include?(".r:*") && !write_header.nil? && write_header.include?("*")
-            acl = "public-read-write"
+        def header_to_perm_acl(read_header=nil, write_header=nil)
+          read_h, write_h = nil
+          read_h = read_header.split(',') unless read_header.nil?
+          write_h = write_header.split(',') unless write_header.nil?
+          return read_h, write_h
+        end
+
+        def generate_object_temp_url(container, object, expires_secs, method)
+          return unless (container && object && expires_secs && method)
+
+          # POST not allowed
+          allowed_methods = %w{GET PUT HEAD}
+          unless allowed_methods.include?(method)
+            raise ArgumentError.new("Invalid method '#{method}' specified. Valid methods are: #{allowed_methods.join(', ')}")
           end
+
+          expires = (Time.now + expires_secs.to_i).to_i
+
+          # split up the storage uri
+          uri = URI.parse(@hp_storage_uri)
+          host   = uri.host
+          path   = uri.path
+          port   = uri.port
+          scheme = uri.scheme
+
+          # do not encode before signature generation, encode after
+          sig_path = "#{path}/#{container}/#{object}"
+          encoded_path = "#{path}/#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
+
+          string_to_sign = "#{method}\n#{expires}\n#{sig_path}"
+          # Only works with 1.9+ Not compatible with 1.8.7
+          #signed_string = Digest::HMAC.hexdigest(string_to_sign, @hp_secret_key, Digest::SHA1)
+          # Compatible with 1.8.7 onwards
+          hmac = OpenSSL::HMAC.new(@hp_secret_key, OpenSSL::Digest::SHA1.new)
+          signed_string = hmac.update(string_to_sign).hexdigest
+
+          signature = @hp_tenant_id.to_s + ":" + @hp_access_key.to_s + ":" + signed_string
+          signature = Fog::HP.escape(signature)
+
+          # generate the temp url using the signature and expiry
+          temp_url = "#{scheme}://#{host}:#{port}#{encoded_path}?temp_url_sig=#{signature}&temp_url_expires=#{expires}"
         end
+
       end
 
       class Mock
@@ -108,16 +206,25 @@ module Fog
 
         def initialize(options={})
           require 'mime/types'
+          # deprecate hp_account_id
+          if options[:hp_account_id]
+            Fog::Logger.deprecation(":hp_account_id is deprecated, please use :hp_access_key instead.")
+            @hp_access_key = options.delete(:hp_account_id)
+          end
+          @hp_access_key = options[:hp_access_key]
+          unless @hp_access_key
+            raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
+          end
           @hp_secret_key = options[:hp_secret_key]
-          @hp_account_id = options[:hp_account_id]
+          @hp_tenant_id = options[:hp_tenant_id]
         end
 
         def data
-          self.class.data[@hp_account_id]
+          self.class.data[@hp_access_key]
         end
 
         def reset_data
-          self.class.data.delete(@hp_account_id)
+          self.class.data.delete(@hp_access_key)
         end
 
       end
@@ -128,16 +235,25 @@ module Fog
 
         def initialize(options={})
           require 'mime/types'
+          # deprecate hp_account_id
+          if options[:hp_account_id]
+            Fog::Logger.deprecation(":hp_account_id is deprecated, please use :hp_access_key instead.")
+            options[:hp_access_key] = options.delete(:hp_account_id)
+          end
+          @hp_access_key = options[:hp_access_key]
+          unless @hp_access_key
+            raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
+          end
           @hp_secret_key = options[:hp_secret_key]
-          @hp_account_id = options[:hp_account_id]
           @hp_auth_uri   = options[:hp_auth_uri]
           @hp_cdn_ssl    = options[:hp_cdn_ssl]
           @connection_options = options[:connection_options] || {}
           ### Set an option to use the style of authentication desired; :v1 or :v2 (default)
           auth_version = options[:hp_auth_version] || :v2
-          ### Pass the service type for object storage to the authentication call
-          options[:hp_service_type] = "object-store"
+          ### Pass the service name for object storage to the authentication call
+          options[:hp_service_type] = "Object Storage"
           @hp_tenant_id = options[:hp_tenant_id]
+          @hp_avl_zone  = options[:hp_avl_zone]
 
           ### Make the authentication call
           if (auth_version == :v2)
@@ -157,12 +273,11 @@ module Fog
           @auth_token = credentials[:auth_token]
 
           uri = URI.parse(@hp_storage_uri)
-          @host   = options[:hp_servicenet] == true ? "snet-#{uri.host}" : uri.host
+          @host   = uri.host
           @path   = uri.path
           @persistent = options[:persistent] || false
           @port   = uri.port
           @scheme = uri.scheme
-          Excon.ssl_verify_peer = false if options[:hp_servicenet] == true
 
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
@@ -195,6 +310,33 @@ module Fog
           response
         end
 
+        # this request is used only for get_shared_container and get_shared_object calls
+        def shared_request(params, parse_json = true, &block)
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{params[:path]}",
+            }), &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::HP::NotFound.slurp(error)
+            when Excon::Errors::Forbidden
+              Fog::HP::Errors::Forbidden.slurp(error)
+            else
+              error
+            end
+          end
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = Fog::JSON.decode(response.body)
+          end
+          response
+        end
+
       end
     end
   end

data/lib/fog/identity.rb

@@ -11,16 +11,17 @@ module Fog
       when :rackspace
         require 'fog/rackspace/identity'
         Fog::Rackspace::Identity.new(attributes)
-      when :openstack
-        require 'fog/openstack/identity'
-        Fog::Identity::OpenStack.new(attributes)
       else
+        if self.providers.include?(provider)
+          require "fog/#{provider}/identity"
+          return Fog::Identity.const_get(Fog.providers[provider]).new(attributes)
+        end
         raise ArgumentError.new("#{provider} has no identity service")
       end
     end
 
     def self.providers
-      Fog.services[:idenity]
+      Fog.services[:identity]
     end
 
   end

data/lib/fog/image.rb

@@ -7,13 +7,12 @@ module Fog
 
     def self.new(attributes)
       attributes = attributes.dup # Prevent delete from having side effects
-      case provider = attributes.delete(:provider).to_s.downcase.to_sym
-      when :openstack
-        require 'fog/openstack/image'
-        Fog::Image::OpenStack.new(attributes)
-      else
-        raise ArgumentError.new("#{provider} has no identity service")
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+      if self.providers.include?(provider)
+        require "fog/#{provider}/image"
+        return Fog::Image.const_get(Fog.providers[provider]).new(attributes)
       end
+      raise ArgumentError.new("#{provider} has no identity service")
     end
 
     def self.providers

data/lib/fog/internet_archive.rb

@@ -0,0 +1,290 @@
+require 'fog/core'
+require 'fog/internet_archive/signaturev4'
+
+module Fog
+  module InternetArchive
+
+    COMPLIANT_BUCKET_NAMES = /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\-(?![\.])){1,61}[a-z0-9]$/
+
+    DOMAIN_NAME = 'us.archive.org'
+
+    extend Fog::Provider
+
+    service(:storage, 'internet_archive/storage', 'Storage')
+
+    def self.indexed_param(key, values)
+      params = {}
+      unless key.include?('%d')
+        key << '.%d'
+      end
+      [*values].each_with_index do |value, index|
+        if value.respond_to?('keys')
+          k = format(key, index + 1)
+          value.each do | vkey, vvalue |
+            params["#{k}.#{vkey}"] = vvalue
+          end
+        else
+          params[format(key, index + 1)] = value
+        end
+      end
+      params
+    end
+
+    def self.serialize_keys(key, value, options = {})
+      case value
+      when Hash
+        value.each do | k, v |
+          options.merge!(serialize_keys("#{key}.#{k}", v))
+        end
+        return options
+      when Array
+        value.each_with_index do | it, idx |
+          options.merge!(serialize_keys("#{key}.member.#{(idx + 1)}", it))
+        end
+        return options
+      else
+        return {key => value}
+      end
+    end
+
+    def self.indexed_request_param(name, values)
+      idx = -1
+      Array(values).inject({}) do |params, value|
+        params["#{name}.#{idx += 1}"] = value
+        params
+      end
+    end
+
+    def self.indexed_filters(filters)
+      params = {}
+      filters.keys.each_with_index do |key, key_index|
+        key_index += 1
+        params[format('Filter.%d.Name', key_index)] = key
+        [*filters[key]].each_with_index do |value, value_index|
+          value_index += 1
+          params[format('Filter.%d.Value.%d', key_index, value_index)] = value
+        end
+      end
+      params
+    end
+
+    def self.escape(string)
+      string.gsub(/([^a-zA-Z0-9_.\-~]+)/) {
+        "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
+      }
+    end
+
+    def self.signed_params(params, options = {})
+      params.merge!({
+        'AWSAccessKeyId'    => options[:ia_access_key_id],
+        'SignatureMethod'   => 'HmacSHA256',
+        'SignatureVersion'  => '2',
+        'Timestamp'         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        'Version'           => options[:version]
+      })
+
+      params.merge!({
+        'SecurityToken'     => options[:ia_session_token]
+      }) if options[:ia_session_token]
+
+      body = ''
+      for key in params.keys.sort
+        unless (value = params[key]).nil?
+          body << "#{key}=#{escape(value.to_s)}&"
+        end
+      end
+      string_to_sign = "POST\n#{options[:host]}:#{options[:port]}\n#{options[:path]}\n" << body.chop
+      signed_string = options[:hmac].sign(string_to_sign)
+      body << "Signature=#{escape(Base64.encode64(signed_string).chomp!)}"
+
+      body
+    end
+
+    class Mock
+
+      def self.arn(vendor, account_id, path, region = nil)
+        "arn:aws:#{vendor}:#{region}:#{account_id}:#{path}"
+      end
+
+      def self.availability_zone(region)
+        "#{region}#{Fog::Mock.random_selection('abcd', 1)}"
+      end
+
+      def self.box_usage
+        sprintf("%0.10f", rand / 100).to_f
+      end
+
+      def self.console_output
+        # "[ 0.000000] Linux version 2.6.18-xenU-ec2-v1.2 (root@domU-12-31-39-07-51-82) (gcc version 4.1.2 20070626 (Red Hat 4.1.2-13)) #2 SMP Wed Aug 19 09:04:38 EDT 2009"
+        Base64.decode64("WyAwLjAwMDAwMF0gTGludXggdmVyc2lvbiAyLjYuMTgteGVuVS1lYzItdjEu\nMiAocm9vdEBkb21VLTEyLTMxLTM5LTA3LTUxLTgyKSAoZ2NjIHZlcnNpb24g\nNC4xLjIgMjAwNzA2MjYgKFJlZCBIYXQgNC4xLjItMTMpKSAjMiBTTVAgV2Vk\nIEF1ZyAxOSAwOTowNDozOCBFRFQgMjAwOQ==\n")
+      end
+
+      def self.dns_name_for(ip_address)
+        "ec2-#{ip_address.gsub('.','-')}.compute-1.amazonaws.com"
+      end
+
+      def self.private_dns_name_for(ip_address)
+        "ip-#{ip_address.gsub('.','-')}.ec2.internal"
+      end
+
+      def self.image
+        path = []
+        (rand(3) + 2).times do
+          path << Fog::Mock.random_letters(rand(9) + 8)
+        end
+        {
+          "imageOwnerId"   => Fog::Mock.random_letters(rand(5) + 4),
+          "blockDeviceMapping" => [],
+          "productCodes"   => [],
+          "kernelId"       => kernel_id,
+          "ramdiskId"      => ramdisk_id,
+          "imageState"     => "available",
+          "imageId"        => image_id,
+          "architecture"   => "i386",
+          "isPublic"       => true,
+          "imageLocation"  => path.join('/'),
+          "imageType"      => "machine",
+          "rootDeviceType" => ["ebs","instance-store"][rand(2)],
+          "rootDeviceName" => "/dev/sda1"
+        }
+      end
+
+      def self.image_id
+        "ami-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.key_fingerprint
+        fingerprint = []
+        20.times do
+          fingerprint << Fog::Mock.random_hex(2)
+        end
+        fingerprint.join(':')
+      end
+
+      def self.instance_id
+        "i-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.ip_address
+        ip = []
+        4.times do
+          ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
+        end
+        ip.join('.')
+      end
+
+      def self.private_ip_address
+        ip_address.gsub(/^\d{1,3}\./,"10.")
+      end
+
+      def self.kernel_id
+        "aki-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.key_material
+        OpenSSL::PKey::RSA.generate(1024).to_s
+      end
+
+      def self.owner_id
+        Fog::Mock.random_numbers(12)
+      end
+
+      def self.ramdisk_id
+        "ari-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.request_id
+        request_id = []
+        request_id << Fog::Mock.random_hex(8)
+        3.times do
+          request_id << Fog::Mock.random_hex(4)
+        end
+        request_id << Fog::Mock.random_hex(12)
+        request_id.join('-')
+      end
+      class << self
+        alias :reserved_instances_id :request_id
+        alias :reserved_instances_offering_id :request_id
+        alias :sqs_message_id :request_id
+        alias :sqs_sender_id :request_id
+      end
+
+      def self.reservation_id
+        "r-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.snapshot_id
+        "snap-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.volume_id
+        "vol-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.security_group_id
+        "sg-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.network_interface_id
+        "eni-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.internet_gateway_id
+        "igw-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.dhcp_options_id
+        "dopt-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.vpc_id
+        "vpc-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.subnet_id
+        "subnet-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.zone_id
+        "zone-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.change_id
+        "change-#{Fog::Mock.random_hex(8)}"
+      end
+      def self.nameservers
+        [
+          'ns-2048.awsdns-64.com',
+          'ns-2049.awsdns-65.net',
+          'ns-2050.awsdns-66.org',
+          'ns-2051.awsdns-67.co.uk'
+        ]
+      end
+
+      def self.key_id(length=21)
+        #Probably close enough
+        Fog::Mock.random_selection('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',length)
+      end
+
+      def self.rds_address(db_name,region)
+        "#{db_name}.#{Fog::Mock.random_letters(rand(12) + 4)}.#{region}.rds.amazonaws.com"
+      end
+    end
+
+    def self.parse_security_group_options(group_name, options)
+      options ||= Hash.new
+      if group_name.is_a?(Hash)
+        options = group_name
+      elsif group_name
+        if options.key?('GroupName')
+          raise Fog::Compute::InternetArchive::Error, 'Arguments specified both group_name and GroupName in options'
+        end
+        options = options.clone
+        options['GroupName'] = group_name
+      end
+      name_specified = options.key?('GroupName') && !options['GroupName'].nil?
+      group_id_specified = options.key?('GroupId') && !options['GroupId'].nil?
+      unless name_specified || group_id_specified
+        raise Fog::Compute::InternetArchive::Error, 'Neither GroupName nor GroupId specified'
+      end
+      if name_specified && group_id_specified
+        options.delete('GroupName')
+      end
+      options
+    end
+  end
+end