azure-storage 0.12.3.preview → 0.13.0.preview

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8698a09fa46c65d7407493f269ea6c5446e12d99
-  data.tar.gz: ef47aa9a97b2391a46a5aed571c91105251609da
+  metadata.gz: 2a070f6404238f71f22cb9b6d6cf520710da9d3e
+  data.tar.gz: 47aa7276488561d83324937bbd5622c368491ce3
 SHA512:
-  metadata.gz: 04ad168a8c0618869c1f93ef570de15191648dcc48e87912c0630547b6843f6b25e2ddd3fcffe6797d8a66d6acb81495fd6072bad8c5f6d62f4b0f596009d75d
-  data.tar.gz: 8953cd7851fd19f94a7f5d81ed1114ff646a0761a4263c5aba48b3662c57cb0d4763680f0a1fd1dff90e5d2d8ed7d750fdde14ba57353ab237d1d521ca38d8aa
+  metadata.gz: 9747b0fee5eed2dfa431cdfcfbf6bbec93b8de3fe2d21397c4638595a547e05b557c28324ee967e80e13a015b9b4fa43c78a2aa8e9cb913e133fa54ff44b3b2a
+  data.tar.gz: b2aa8f4ce38f1d1e56aa4408bc73ad7516d5b6577b3bcf914ed16343eb434e0864f577d066b166bfb22cea71e6eaed9c1164d5c4816b8447fd576ad785ec1ea4

data/lib/azure/storage/blob/block.rb

@@ -36,7 +36,7 @@ module Azure::Storage
       attr_accessor :size
       attr_accessor :type
     end
-    
+
     # Public: Creates a new block blob or updates the content of an existing block blob.
     #
     # Updating an existing block blob overwrites any existing metadata on the blob

data/lib/azure/storage/default.rb

@@ -28,7 +28,7 @@ require 'azure/storage/version'
 module Azure::Storage
   module Default
     # Default REST service (STG) version number
-    STG_VERSION = '2015-04-05'
+    STG_VERSION = '2016-05-31'
 
     # The number of default concurrent requests for parallel operation.
     DEFAULT_PARALLEL_OPERATION_THREAD_COUNT = 1
@@ -47,13 +47,13 @@ module Azure::Storage
     # Default HTTP port.
     DEFAULT_HTTP_PORT = 80
     # Default HTTPS port.
-    DEFAULT_HTTPS_PORT= 443
+    DEFAULT_HTTPS_PORT = 443
 
     # Marker for atom metadata.
     XML_METADATA_MARKER = '$'
     # Marker for atom value.
     XML_VALUE_MARKER = '_'
-    
+
     def os
       host_os = RbConfig::CONFIG['host_os']
       case host_os
@@ -69,17 +69,17 @@ module Azure::Storage
         "Unknown #{host_os}"
       end
     end
-      
+
     module_function :os
 
     # Default User Agent header string
     USER_AGENT = "Azure-Storage/#{Azure::Storage::Version.to_uas} (Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}; #{os})".freeze
-    
+
     class << self
       def options
-        Hash[Azure::Storage::Configurable.keys.map{|key| [key, send(key)]}]
+        Hash[Azure::Storage::Configurable.keys.map { |key| [key, send(key)] }]
       end
-      
+
       # Default storage access key
       # @return [String]
       def storage_access_key
@@ -91,7 +91,7 @@ module Azure::Storage
       def storage_account_name
         ENV['AZURE_STORAGE_ACCOUNT']
       end
-      
+
       # Default storage connection string
       # @return [String]
       def storage_connection_string
@@ -121,7 +121,7 @@ module Azure::Storage
       def storage_queue_host
         ENV['AZURE_STORAGE_QUEUE_HOST']
       end
-      
+
       # Default storage file host
       # @return [String]
       def storage_file_host
@@ -405,6 +405,9 @@ module Azure::Storage
     # Constant representing the type for an entity property.
     ODATA_TYPE_MARKER = '$'
 
+    # Constant representing the hash key of etag for an entity property in JSON.
+    ODATA_ETAG = 'odata.etag'
+
     # The value to set the maximum data service version header.
     DEFAULT_DATA_SERVICE_VERSION = '3.0;NetFx'
 
@@ -414,6 +417,12 @@ module Azure::Storage
     # The name of the special table used to store tables.
     TABLE_SERVICE_TABLE_NAME = 'Tables'
 
+    # The key of partition key in hash
+    PARTITION_KEY = 'PartitionKey'
+
+    # The key of row key in hash
+    ROW_KEY = 'RowKey'
+
     # Operations
     module Operations
       RETRIEVE = 'RETRIEVE'
@@ -447,7 +456,7 @@ module Azure::Storage
     LAST_MODIFIED = 'Last-Modified'
 
     # The data service version.
-    DATA_SERVICE_VERSION = 'dataserviceversion'
+    DATA_SERVICE_VERSION = 'DataServiceVersion'
 
     # The maximum data service version.
     MAX_DATA_SERVICE_VERSION = 'maxdataserviceversion'
@@ -555,7 +564,7 @@ module Azure::Storage
     CONTENT_RANGE = 'cache-range'
 
     # The ContentType header.
-    CONTENT_TYPE = 'content-type'
+    CONTENT_TYPE = 'Content-Type'
 
     # The header that specifies blob content type.
     BLOB_CONTENT_TYPE = 'x-ms-blob-content-type'
@@ -594,8 +603,7 @@ module Azure::Storage
     INCLUDE_SNAPSHOTS_VALUE = 'include'
 
     # Specifies that the content-type is JSON.
-    JSON_CONTENT_TYPE_VALUE = 'application/json;'
-
+    JSON_CONTENT_TYPE_VALUE = 'application/json'
 
     # The header that specifies lease ID.
     LEASE_ID = 'x-ms-lease-id'
@@ -715,7 +723,7 @@ module Azure::Storage
     LEASE_ACTION = 'x-ms-lease-action'
 
     # The accept header.
-    ACCEPT = 'accept'
+    ACCEPT = 'Accept'
 
     # The accept charset header.
     ACCEPT_CHARSET = 'Accept-Charset'
@@ -743,10 +751,18 @@ module Azure::Storage
 
     # The append blob committed block header.
     BLOB_COMMITTED_BLOCK_COUNT = 'x-ms-blob-committed-block-count'
+
+    # The returned response payload should be with no metadata.
+    ODATA_NO_META = 'application/json;odata=nometadata'
+
+    # The returned response payload should be with minimal metadata.
+    ODATA_MIN_META = 'application/json;odata=minimalmetadata'
+
+    # The returned response payload should be with full metadata.
+    ODATA_FULL_META = 'application/json;odata=fullmetadata'
   end
 
   module QueryStringConstants
-
     # Query component for SAS API version.
     API_VERSION = 'api-version'
 
@@ -872,6 +888,9 @@ module Azure::Storage
 
     # The ending Partition Key for tableSAS URI's.
     ENDRK = 'erk'
+
+    # ACL
+    ACL = 'acl'
   end
 
   module StorageServiceClientConstants

data/lib/azure/storage/service/storage_service.rb

@@ -49,7 +49,7 @@ module Azure::Storage
         super(signer, account_name, options)
       end
 
-      def call(method, uri, body=nil, headers={}, options={})
+      def call(method, uri, body=nil, headers={}, options = {})
         super(method, uri, body, StorageService.common_headers(options).merge(headers))
       end
 

data/lib/azure/storage/table/batch.rb

@@ -106,12 +106,15 @@ module Azure::Storage
       end
 
       protected
-      def add_operation(method, uri, body=nil, headers=nil)
+      def add_operation(method, uri, body = nil, headers = nil)
         op = {
-          :method => method, 
-          :uri => uri, 
-          :body => body, 
-          :headers => headers
+          method: method,
+          uri: uri,
+          body: body,
+          headers: headers.merge(
+            HeaderConstants::CONTENT_TYPE => HeaderConstants::JSON_CONTENT_TYPE_VALUE,
+            HeaderConstants::DATA_SERVICE_VERSION => TableConstants::DEFAULT_DATA_SERVICE_VERSION
+          )
         }
         operations.push op
       end
@@ -141,13 +144,9 @@ module Azure::Storage
             case operation[:method]
             when :post
               # entity from body
-              result = Azure::Storage::Table::Serialization.hash_from_entry_xml(response[:body])
+              entity = Azure::Storage::Table::Serialization.entity_from_json(response[:body])
 
-              entity = Azure::Storage::Table::Entity.new
-              entity.table = table
-              entity.updated = result[:updated]
-              entity.etag = response[:headers]["etag"] || result[:etag]
-              entity.properties = result[:properties]
+              entity.etag = response[:headers]["etag"] if entity.etag.nil?
 
               new_responses.push entity
             when :put, :merge
@@ -172,31 +171,27 @@ module Azure::Storage
         body.add_line "Content-Type: multipart/mixed; boundary=#{changeset_id}"
         body.add_line ""
 
-        content_id = 1
         operations.each { |op|
           body.add_line "--#{changeset_id}"
           body.add_line "Content-Type: application/http"
           body.add_line "Content-Transfer-Encoding: binary"
           body.add_line ""
           body.add_line "#{op[:method].to_s.upcase} #{op[:uri]} HTTP/1.1"
-          body.add_line "Content-ID: #{content_id}"
 
           if op[:headers]
-            op[:headers].each { |k,v|
-                body.add_line "#{k}: #{v}"
+            op[:headers].each { |k, v|
+              body.add_line "#{k}: #{v}"
             }
           end
-          
+
           if op[:body]
-            body.add_line "Content-Type: application/atom+xml;type=entry"
             body.add_line "Content-Length: #{op[:body].bytesize}"
             body.add_line ""
             body.add_line op[:body]
           else
             body.add_line ""
-          end 
+          end
 
-          content_id += 1
         }
         body.add_line "--#{changeset_id}--"
         body.add_line "--#{batch_id}--"
@@ -207,81 +202,105 @@ module Azure::Storage
       # ==== Attributes
       #
       # * +row_key+       - String. The row key
-      # * +entity_values+ - Hash. A hash of the name/value pairs for the entity. 
+      # * +entity_values+ - Hash. A hash of the name/value pairs for the entity.
+      # * +options+       - Hash. Optional parameters. 
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:accept+              - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                             :no_meta
+      #                             :min_meta
+      #                             :full_meta
+      # * +:prefer+              - String. Specifies whether the response should include the inserted entity in the payload. Possible values are:
+      #                             HeaderConstants::PREFER_CONTENT
+      #                             HeaderConstants::PREFER_NO_CONTENT
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179433
       public
-      def insert(row_key, entity_values)
+      def insert(row_key, entity_values, options = {})
         check_entity_key(row_key)
 
-        body = Azure::Storage::Table::Serialization.hash_to_entry_xml({ 
-            "PartitionKey" => partition, 
+        headers = { HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]) }
+        headers[HeaderConstants::PREFER] = options[:prefer] unless options[:prefer].nil?
+
+        body = Azure::Storage::Table::Serialization.hash_to_json({
+            "PartitionKey" => partition,
             "RowKey" => row_key
-          }.merge(entity_values) ).to_xml
+          }.merge(entity_values)
+        )
 
-        add_operation(:post, @table_service.entities_uri(table), body)
+        add_operation(:post, @table_service.entities_uri(table), body, headers)
         self
       end
 
-      # Public: Updates an existing entity in a table. The Update Entity operation replaces 
+      # Public: Updates an existing entity in a table. The Update Entity operation replaces
       # the entire entity and can be used to remove properties.
       #
       # ==== Attributes
       #
       # * +row_key+       - String. The row key
-      # * +entity_values+ - Hash. A hash of the name/value pairs for the entity. 
-      # * +options+       - Hash. Optional parameters. 
+      # * +entity_values+ - Hash. A hash of the name/value pairs for the entity.
+      # * +options+       - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * :if_match              - String. A matching condition which is required for update (optional, Default="*")
-      # * :create_if_not_exists  - Boolean. If true, and partition_key and row_key do not reference and existing entity, 
+      # * :create_if_not_exists  - Boolean. If true, and partition_key and row_key do not reference and existing entity,
       #   that entity will be inserted. If false, the operation will fail. (optional, Default=false)
+      # * +:accept+              - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                             :no_meta
+      #                             :min_meta
+      #                             :full_meta
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179427
       public
-      def update(row_key, entity_values, options={})
+      def update(row_key, entity_values, options = {})
         check_entity_key(row_key)
 
         uri = @table_service.entities_uri(table, partition, row_key)
 
-        headers = {}
+        headers = { HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]) }
         headers["If-Match"] = options[:if_match] || "*" unless options[:create_if_not_exists]
 
-        body = Azure::Storage::Table::Serialization.hash_to_entry_xml(entity_values).to_xml
+        body = Azure::Storage::Table::Serialization.hash_to_json(entity_values)
 
         add_operation(:put, uri, body, headers)
         self
       end
-      
+
       # Public: Updates an existing entity by updating the entity's properties. This operation
       # does not replace the existing entity, as the update_entity operation does.
       #
       # ==== Attributes
       #
       # * +row_key+         - String. The row key
-      # * +entity_values+   - Hash. A hash of the name/value pairs for the entity. 
-      # * +options+         - Hash. Optional parameters. 
+      # * +entity_values+   - Hash. A hash of the name/value pairs for the entity.
+      # * +options+         - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +if_match+              - String. A matching condition which is required for update (optional, Default="*")
-      # * +create_if_not_exists+  - Boolean. If true, and partition_key and row_key do not reference and existing entity, 
+      # * +create_if_not_exists+  - Boolean. If true, and partition_key and row_key do not reference and existing entity,
       #   that entity will be inserted. If false, the operation will fail. (optional, Default=false)
-      # 
+      # * +:accept+              - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                             :no_meta
+      #                             :min_meta
+      #                             :full_meta
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179392
       public
-      def merge(row_key, entity_values, options={})
+      def merge(row_key, entity_values, options = {})
         check_entity_key(row_key)
 
         uri = @table_service.entities_uri(table, partition, row_key)
 
-        headers = {}
+        headers = { HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]) }
         headers["If-Match"] = options[:if_match] || "*" unless options[:create_if_not_exists]
 
-        body = Azure::Storage::Table::Serialization.hash_to_entry_xml(entity_values).to_xml
+        body = Azure::Storage::Table::Serialization.hash_to_json(entity_values)
 
         add_operation(:merge, uri, body, headers)
         self
@@ -293,11 +312,11 @@ module Azure::Storage
       #
       # * +row_key+               - String. The row key
       # * +entity_values+         - Hash. A hash of the name/value pairs for the entity.
-      # 
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/hh452241
       public
       def insert_or_merge(row_key, entity_values)
-        merge(row_key, entity_values, { :create_if_not_exists => true })
+        merge(row_key, entity_values, create_if_not_exists: true)
         self
       end
 
@@ -306,12 +325,12 @@ module Azure::Storage
       # ==== Attributes
       #
       # * +row_key+               - String. The row key
-      # * +entity_values+         - Hash. A hash of the name/value pairs for the entity. 
-      # 
+      # * +entity_values+         - Hash. A hash of the name/value pairs for the entity.
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/hh452242
       public
       def insert_or_replace(row_key, entity_values)
-        update(row_key, entity_values, { :create_if_not_exists => true })
+        update(row_key, entity_values, create_if_not_exists: true)
         self
       end
 
@@ -320,19 +339,27 @@ module Azure::Storage
       # ==== Attributes
       #
       # * +row_key+       - String. The row key
-      # * +options+       - Hash. Optional parameters. 
+      # * +options+       - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +if_match+      - String. A matching condition which is required for update (optional, Default="*")
+      # * +:accept+              - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                             :no_meta
+      #                             :min_meta
+      #                             :full_meta
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd135727
       public
-      def delete(row_key, options={})
-        add_operation(:delete, @table_service.entities_uri(table, partition, row_key), nil, {"If-Match"=> options[:if_match] || "*"})
+      def delete(row_key, options = {})
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]),
+          "If-Match" => options[:if_match] || "*"
+        }
+        add_operation(:delete, @table_service.entities_uri(table, partition, row_key), nil, headers)
         self
       end
     end
   end
-end
+end

data/lib/azure/storage/table/edmtype.rb

@@ -68,13 +68,7 @@ module Azure::Storage
         when "Edm.Binary"
           Base64.encode64(value.to_s).chomp("\n")
         when "Edm.DateTime"
-          value.xmlschema(7)
-        when "Edm.Boolean"
-          if value.nil?
-            ''
-          else
-            value == true ? '1' : '0'
-          end
+          to_edm_time(value)
         else
           value.to_s
         end
@@ -113,7 +107,7 @@ module Azure::Storage
       # type  - String. The Edm datatype
       #
       # Returns an typed object
-      def self.unserialize_query_value(value, type)
+      def self.deserialize_value(value, type)
         case type
         when "Edm.DateTime"
           Time.parse(value)
@@ -122,15 +116,20 @@ module Azure::Storage
         when "Edm.Int32", "Edm.Int64"
           Integer(value)
         when "Edm.Boolean"
-          /true/i === value
+          value == true || value == 'true' ? true : false
         when "Edm.Guid"
           GUID.new(value.to_s)
         when "Edm.Binary"
           Base64.decode64(value.to_s).force_encoding("BINARY")
         else
-          value.to_s
+          value == '' ? nil : value.to_s
         end
       end
+
+      def self.to_edm_time(value)
+        date = value.is_a?(Time) ? value : Time.parse(value)
+        date.utc.strftime('%Y-%m-%dT%H:%M:%S.%6N0Z')
+      end
     end
   end
 end

data/lib/azure/storage/table/entity.rb

@@ -31,8 +31,6 @@ module Azure::Storage
         yield self if block_given?
       end
 
-      attr_accessor :table
-      attr_accessor :updated
       attr_accessor :etag
       attr_accessor :properties
     end

data/lib/azure/storage/table/serialization.rb

@@ -25,93 +25,95 @@ require 'azure/storage/service/serialization'
 
 require 'azure/storage/table/guid'
 require 'azure/storage/table/edmtype'
+require 'azure/storage/table/entity'
 
 require 'time'
 require 'date'
-
-module Azure::Storage
-  module Table
-    module Serialization
-      include Azure::Storage::Service::Serialization
-
-      def self.hash_to_entry_xml(hash, id=nil, xml=Nokogiri::XML::Builder.new(:encoding => 'UTF-8'))
-        entry_namespaces = {
-          'xmlns' => 'http://www.w3.org/2005/Atom',
-          'xmlns:m' => 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata',
-          'xmlns:d' => 'http://schemas.microsoft.com/ado/2007/08/dataservices'
-        }
-
-        xml.entry entry_namespaces do |entry|
-            id ? entry.id(id): entry.id
-            entry.updated Time.now.xmlschema 
-            entry.title
-            entry.author do |author|
-              author.name
-            end
-          hash_to_content_xml(hash, entry)
+require 'json'
+
+module Azure
+  module Storage
+    module Table
+      # This is a class that serializes the request/response body for table
+      # service.
+      module Serialization
+        include Azure::Storage::Service::Serialization
+
+        def self.hash_to_json(h)
+          newhash = {}
+          h.map do |key, val|
+            type = Table::EdmType.property_type(val)
+            type_key = key.is_a?(Symbol) ? key.to_s + TableConstants::ODATA_TYPE_SUFFIX : key + TableConstants::ODATA_TYPE_SUFFIX
+            newhash[key] = EdmType::serialize_value(type, val)
+            newhash[type_key] = type unless type.nil? || type.empty? || h.key?(type_key)
+          end
+          JSON newhash
         end
 
-        xml
-      end
-
-      def self.hash_to_content_xml(hash, xml=Nokogiri::XML::Builder.new(:encoding => 'UTF-8'))
-        xml.send('content', :type => 'application/xml') do |content|
-          content.send('m:properties') do |properties|
-            hash.each do |key, val|
-              key = key.encode('UTF-8') if key.is_a? String and !key.encoding.names.include?('BINARY')
-              val = val.encode('UTF-8') if val.is_a? String and !val.encoding.names.include?('BINARY')
+        def self.table_entries_from_json(json)
+          table_entries_from_hash(hash_from_json(json))
+        end
 
-              type = Azure::Storage::Table::EdmType.property_type(val)
-              attributes = {}
-              attributes['m:type'] = type unless type.nil? || type.empty?
+        def self.hash_from_json(json)
+          JSON.parse(json)
+        end
 
-              if val.nil?
-                attributes['m:null'] = 'true'
-                properties.send("d:#{key}", attributes)
-              else
-                properties.send("d:#{key}", Azure::Storage::Table::EdmType.serialize_value(type, val), attributes)
-              end
+        def self.table_entries_from_hash(h)
+          values = []
+          if h['value']
+            h['value'].each do |name|
+              values.push(name)
             end
+          elsif h['TableName']
+            values = h
           end
+          values
         end
 
-        xml
-      end
+        def self.entity_from_json(json)
+          entity_from_hash(hash_from_json(json))
+        end
 
-      def self.entries_from_feed_xml(xml)
-        xml = slopify(xml)
-        expect_node('feed', xml)
+        def self.entities_from_json(json)
+          entities_hash = hash_from_json(json)
+          entities_hash['value'].nil? ? [entity_from_hash(entities_hash)] : entities_from_hash(entities_hash)
+        end
 
-        return nil unless (xml > 'entry').any?
-        
-        results = []
-        
-        if (xml > 'entry').count == 0
-          results.push hash_from_entry_xml((xml > 'entry'))
-        else
-          (xml > 'entry').each do |entry|
-            results.push hash_from_entry_xml(entry)
-          end
+        def self.entities_from_hash(h)
+          entities = []
+          h['value'].each { |entity_hash|
+            entities.push(entity_from_hash(entity_hash))
+          }
+          entities
         end
 
-        results
-      end
+        def self.entity_from_hash(h)
+          Entity.new do |entity|
+            entity.etag = h.delete(TableConstants::ODATA_ETAG)
+            properties = {}
+            h.each do |k, v|
+              type = h[k + TableConstants::ODATA_TYPE_SUFFIX]
+              properties[k] = EdmType::deserialize_value(v, type.nil? ? EdmType::property_type(v) : type)
+            end
+            entity.properties = properties
+          end
+        end
 
-      def self.hash_from_entry_xml(xml)
-        xml = slopify(xml)
-        expect_node('entry', xml)
-        result = {}
-        result[:etag] = xml['etag']
-        result[:updated] = Time.parse((xml > 'updated').text) if (xml > 'updated').any?
-        properties = {} 
-        if (xml > 'content').any?
-          (xml > 'content').first.first_element_child.element_children.each do |prop|
-            properties[prop.name] = prop.text != '' ? Azure::Storage::Table::EdmType.unserialize_query_value(prop.text, prop['m:type']) : prop['null'] ? nil : ''
+        def self.get_accept_string(accept_type = :min_meta)
+          case accept_type
+          when :no_meta
+            HeaderConstants::ODATA_NO_META
+          when :min_meta
+            HeaderConstants::ODATA_MIN_META
+          when :full_meta
+            HeaderConstants::ODATA_FULL_META
+          when nil
+            HeaderConstants::ODATA_MIN_META
+          else
+            accept_type
           end
         end
-        result[:properties] = properties
-        result
       end
     end
   end
-end
+end

data/lib/azure/storage/table/table_service.rb

@@ -52,16 +52,26 @@ module Azure::Storage
       # * +:timeout+                 - Integer. A timeout in seconds.
       # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
       #                                in the analytics logs when storage analytics logging is enabled.
+      # * +:accept+                  - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                                 :no_meta
+      #                                 :min_meta
+      #                                 :full_meta 
+      # * +:prefer+                  - String. Specifies whether the response should include the inserted entity in the payload. Possible values are:
+      #                                 HeaderConstants::PREFER_CONTENT
+      #                                 HeaderConstants::PREFER_NO_CONTENT
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd135729
       #
       # @return [nil] on success
       def create_table(table_name, options={})
-        query = { }
-        query['timeout'] = options[:timeout].to_s if options[:timeout]
 
-        body = Table::Serialization.hash_to_entry_xml({"TableName" => table_name}).to_xml
-        call(:post, collection_uri(query), body, {}, options)
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]),
+        }
+        headers[HeaderConstants::PREFER] = options[:prefer] unless options[:prefer].nil?
+        body = Serialization.hash_to_json({"TableName" => table_name})
+
+        call(:post, collection_uri(new_query(options)), body, headers, options)
         nil
       end
 
@@ -83,10 +93,8 @@ module Azure::Storage
       #
       # Returns nil on success
       def delete_table(table_name, options={})
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
 
-        call(:delete, table_uri(table_name, query), nil, {}, options)
+        call(:delete, table_uri(table_name, new_query(options)), nil, {}, options)
         nil
       end
 
@@ -106,12 +114,11 @@ module Azure::Storage
       #
       # Returns the last updated time for the table
       def get_table(table_name, options={})
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
-
-        response = call(:get, table_uri(table_name, query), nil, {}, options)
-        results = Table::Serialization.hash_from_entry_xml(response.body)
-        results[:updated]
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(:full_meta),
+        }
+        response = call(:get, table_uri(table_name, new_query(options)), nil, headers, options)
+        results = Table::Serialization.table_entries_from_json(response.body)
       rescue => e
         raise_with_response(e, response)
       end
@@ -130,21 +137,27 @@ module Azure::Storage
       # * +:timeout+                 - Integer. A timeout in seconds.
       # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
       #                                in the analytics logs when storage analytics logging is enabled.
+      # * +:accept+                  - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                                 :no_meta
+      #                                 :min_meta
+      #                                 :full_meta
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179405
       #
       # Returns an array with an extra continuation_token property on success
       def query_tables(options={})
-        query = { }
-        query["NextTableName"] = options[:next_table_token] if options[:next_table_token]
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
+        query = new_query(options)
+        query[TableConstants::NEXT_TABLE_NAME] = options[:next_table_token] if options[:next_table_token]
         uri = collection_uri(query)
 
-        response = call(:get, uri, nil, {}, options)
-        entries = Table::Serialization.entries_from_feed_xml(response.body) || []
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]),
+        }
 
+        response = call(:get, uri, nil, headers, options)
+        entries = Table::Serialization.table_entries_from_json(response.body) || []
         values = Azure::Service::EnumerationResults.new(entries)
-        values.continuation_token = response.headers["x-ms-continuation-NextTableName"]
+        values.continuation_token = response.headers[TableConstants::CONTINUATION_NEXT_TABLE_NAME]
         values
       rescue => e
         raise_with_response(e, response)
@@ -168,13 +181,13 @@ module Azure::Storage
       #
       # Returns a list of Azure::Storage::Entity::SignedIdentifier instances
       def get_table_acl(table_name, options={})
-        query = { 'comp' => 'acl'}
-        query['timeout'] = options[:timeout].to_s if options[:timeout]
+        query = new_query(options)
+        query[QueryStringConstants::COMP] = QueryStringConstants::ACL
 
         response = call(:get, generate_uri(table_name, query), nil, {'x-ms-version' => '2012-02-12'}, options)
 
         signed_identifiers = []
-        signed_identifiers = Table::Serialization.signed_identifiers_from_xml response.body unless response.body == nil or response.body.length < 1
+        signed_identifiers = Table::Serialization.signed_identifiers_from_xml response.body unless response.body == nil || response.body.length < 1
         signed_identifiers
       rescue => e
         raise_with_response(e, response)
@@ -199,8 +212,8 @@ module Azure::Storage
       #
       # Returns nil on success
       def set_table_acl(table_name, options={})
-        query = { 'comp' => 'acl'}
-        query['timeout'] = options[:timeout].to_s if options[:timeout]
+        query = new_query(options)
+        query[QueryStringConstants::COMP] = QueryStringConstants::ACL
 
         uri = generate_uri(table_name, query)
         body = nil
@@ -223,27 +236,26 @@ module Azure::Storage
       #
       # Accepted key/value pairs in options parameter are:
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
+      # * +:accept+                  - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                                 :no_meta
+      #                                 :min_meta
+      #                                 :full_meta
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179433
       #
       # Returns a Azure::Storage::Entity::Table::Entity
-      def insert_entity(table_name, entity_values, options={})
-        body = Table::Serialization.hash_to_entry_xml(entity_values).to_xml
-
-        query = { }
-        query['timeout'] = options[:timeout].to_s if options[:timeout]
-
-        response = call(:post, entities_uri(table_name, nil, nil, query), body, {}, options)
-        result = Table::Serialization.hash_from_entry_xml(response.body)
-
-        Entity.new do |entity|
-          entity.table = table_name
-          entity.updated = result[:updated]
-          entity.etag = response.headers['etag'] || result[:etag]
-          entity.properties = result[:properties]
-        end
+      def insert_entity(table_name, entity_values, options = {})
+        body = Table::Serialization.hash_to_json(entity_values)
+        time = EdmType::to_edm_time(Time.now)
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept])
+        }
+        response = call(:post, entities_uri(table_name, nil, nil, new_query(options)), body, headers, options)
+        result = Table::Serialization.entity_from_json(response.body)
+        result.etag = response.headers[HeaderConstants::ETAG] if result.etag.nil?
+        result
       rescue => e
         raise_with_response(e, response)
       end
@@ -265,86 +277,79 @@ module Azure::Storage
       # * +:top+                     - Integer. A limit for the number of results returned (optional)
       # * +:continuation_token+      - Hash. The continuation token.
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
+      # * +:accept+                  - String. Specifies the accepted content-type of the response payload. Possible values are:
+      #                                 :no_meta
+      #                                 :min_meta
+      #                                 :full_meta 
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179421
       #
       # Returns an array with an extra continuation_token property on success
-      def query_entities(table_name, options={})
-        query ={}
-        query["$select"] = options[:select].join ',' if options[:select]
-        query["$filter"] = options[:filter] if options[:filter]
-        query["$top"] = options[:top].to_s if options[:top] unless options[:partition_key] and options[:row_key]
-        query["NextPartitionKey"] = options[:continuation_token][:next_partition_key] if options[:continuation_token] and options[:continuation_token][:next_partition_key]
-        query["NextRowKey"] = options[:continuation_token][:next_row_key] if options[:continuation_token] and options[:continuation_token][:next_row_key]
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
+      def query_entities(table_name, options = {})
+        query = new_query(options)
+        query[QueryStringConstants::SELECT] = options[:select].join ',' if options[:select]
+        query[QueryStringConstants::FILTER] = options[:filter] if options[:filter]
+        query[QueryStringConstants::TOP] = options[:top].to_s if options[:top] unless options[:partition_key] && options[:row_key]
+        query[QueryStringConstants::NEXT_PARTITION_KEY] = options[:continuation_token][:next_partition_key] if options[:continuation_token] && options[:continuation_token][:next_partition_key]
+        query[QueryStringConstants::NEXT_ROW_KEY] = options[:continuation_token][:next_row_key] if options[:continuation_token] && options[:continuation_token][:next_row_key]
 
         uri = entities_uri(table_name, options[:partition_key], options[:row_key], query)
-        response = call(:get, uri, nil, {"DataServiceVersion" => "2.0;NetFx"}, options)
-
-        entities = Azure::Service::EnumerationResults.new
-
-        results = (options[:partition_key] and options[:row_key]) ? [Table::Serialization.hash_from_entry_xml(response.body)] : Table::Serialization.entries_from_feed_xml(response.body)
-        
-        results.each do |result|
-          entity = Entity.new do |e|
-            e.table = table_name
-            e.updated = result[:updated]
-            e.etag = response.headers["etag"] || result[:etag]
-            e.properties = result[:properties]
-          end
-          entities.push entity
-        end if results
+
+        headers = {
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept])
+        }
+
+        response = call(:get, uri, nil, headers, options)
+
+        entities = Azure::Service::EnumerationResults.new.push(*Table::Serialization.entities_from_json(response.body))
 
         entities.continuation_token = nil
-        entities.continuation_token = { 
-          :next_partition_key=> response.headers["x-ms-continuation-NextPartitionKey"], 
-          :next_row_key => response.headers["x-ms-continuation-NextRowKey"]
-          } if response.headers["x-ms-continuation-NextPartitionKey"]
+        entities.continuation_token = {
+          next_partition_key: response.headers[TableConstants::CONTINUATION_NEXT_PARTITION_KEY],
+          next_row_key: response.headers[TableConstants::CONTINUATION_NEXT_ROW_KEY]
+        } if response.headers[TableConstants::CONTINUATION_NEXT_PARTITION_KEY]
 
         entities
       rescue => e
         raise_with_response(e, response)
       end
 
-      # Public: Updates an existing entity in a table. The Update Entity operation replaces 
+      # Public: Updates an existing entity in a table. The Update Entity operation replaces
       # the entire entity and can be used to remove properties.
       #
       # ==== Attributes
       #
       # * +table_name+               - String. The table name
       # * +entity_values+            - Hash. A hash of the name/value pairs for the entity.
-      # * +options+                  - Hash. Optional parameters. 
+      # * +options+                  - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +:if_match+                - String. A matching condition which is required for update (optional, Default="*")
-      # * +:create_if_not_exists+    - Boolean. If true, and partition_key and row_key do not reference and existing entity, 
+      # * +:create_if_not_exists+    - Boolean. If true, and partition_key and row_key do not reference and existing entity,
       #                                that entity will be inserted. If false, the operation will fail. (optional, Default=false)
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179427
       #
-      # Returns the ETag for the entity on success 
-      def update_entity(table_name, entity_values, options={})
+      # Returns the ETag for the entity on success
+      def update_entity(table_name, entity_values, options = {})
         if_match = "*"
         if_match = options[:if_match] if options[:if_match]
 
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
-
-        uri = entities_uri(table_name, 
+        uri = entities_uri(table_name,
           entity_values[:PartitionKey] || entity_values['PartitionKey'],
-          entity_values[:RowKey] || entity_values["RowKey"], query)
+          entity_values[:RowKey] || entity_values["RowKey"], new_query(options))
 
         headers = {}
         headers["If-Match"] = if_match || "*" unless options[:create_if_not_exists]
 
-        body = Table::Serialization.hash_to_entry_xml(entity_values).to_xml
+        body = Table::Serialization.hash_to_json(entity_values)
 
         response = call(:put, uri, body, headers, options)
         response.headers["etag"]
@@ -359,36 +364,33 @@ module Azure::Storage
       #
       # * +table_name+               - String. The table name
       # * +entity_values+            - Hash. A hash of the name/value pairs for the entity.
-      # * +options+                  - Hash. Optional parameters. 
+      # * +options+                  - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +:if_match+                - String. A matching condition which is required for update (optional, Default="*")
-      # * +:create_if_not_exists+    - Boolean. If true, and partition_key and row_key do not reference and existing entity, 
+      # * +:create_if_not_exists+    - Boolean. If true, and partition_key and row_key do not reference and existing entity,
       #                                that entity will be inserted. If false, the operation will fail. (optional, Default=false)
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
-      # 
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/dd179392
-      # 
-      # Returns the ETag for the entity on success 
-      def merge_entity(table_name, entity_values, options={})
+      #
+      # Returns the ETag for the entity on success
+      def merge_entity(table_name, entity_values, options = {})
         if_match = "*"
         if_match = options[:if_match] if options[:if_match]
 
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
-
-        uri = entities_uri(table_name, 
+        uri = entities_uri(table_name,
           entity_values[:PartitionKey] || entity_values['PartitionKey'],
-          entity_values[:RowKey] || entity_values['RowKey'], query)
+          entity_values[:RowKey] || entity_values['RowKey'], new_query(options))
 
-        headers = { "X-HTTP-Method"=> "MERGE" }
+        headers = { "X-HTTP-Method" => "MERGE" }
         headers["If-Match"] = if_match || "*" unless options[:create_if_not_exists]
 
-        body = Table::Serialization.hash_to_entry_xml(entity_values).to_xml
+        body = Table::Serialization.hash_to_json(entity_values)
 
         response = call(:post, uri, body, headers, options)
         response.headers["etag"]
@@ -402,19 +404,19 @@ module Azure::Storage
       #
       # * +table_name+               - String. The table name
       # * +entity_values+            - Hash. A hash of the name/value pairs for the entity.
-      # * +options+                  - Hash. Optional parameters. 
+      # * +options+                  - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
-      # 
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/hh452241
-      # 
-      # Returns the ETag for the entity on success 
-      def insert_or_merge_entity(table_name, entity_values, options={})
+      #
+      # Returns the ETag for the entity on success
+      def insert_or_merge_entity(table_name, entity_values, options = {})
         options[:create_if_not_exists] = true
         merge_entity(table_name, entity_values, options)
       end
@@ -425,19 +427,19 @@ module Azure::Storage
       #
       # * +table_name+               - String. The table name
       # * +entity_values+            - Hash. A hash of the name/value pairs for the entity.
-      # * +options+                  - Hash. Optional parameters. 
+      # * +options+                  - Hash. Optional parameters.
       #
       # ==== Options
       #
       # Accepted key/value pairs in options parameter are:
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
-      # 
+      #
       # See http://msdn.microsoft.com/en-us/library/azure/hh452242
       #
-      # Returns the ETag for the entity on success 
-      def insert_or_replace_entity(table_name, entity_values, options={})
+      # Returns the ETag for the entity on success
+      def insert_or_replace_entity(table_name, entity_values, options = {})
         options[:create_if_not_exists] = true
         update_entity(table_name, entity_values, options)
       end
@@ -456,19 +458,17 @@ module Azure::Storage
       # Accepted key/value pairs in options parameter are:
       # * +:if_match+                - String. A matching condition which is required for update (optional, Default="*")
       # * +:timeout+                 - Integer. A timeout in seconds.
-      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded 
+      # * +:request_id+              - String. Provides a client-generated, opaque value with a 1 KB character limit that is recorded
       #                                in the analytics logs when storage analytics logging is enabled.
       #
       # See http://msdn.microsoft.com/en-us/library/azure/dd135727
       #
       # Returns nil on success
-      def delete_entity(table_name, partition_key, row_key, options={})
+      def delete_entity(table_name, partition_key, row_key, options = {})
         if_match = "*"
         if_match = options[:if_match] if options[:if_match]
 
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
-        call(:delete, entities_uri(table_name, partition_key, row_key, query), nil, { "If-Match"=> if_match }, options)
+        call(:delete, entities_uri(table_name, partition_key, row_key, new_query(options)), nil, { "If-Match" => if_match }, options)
         nil
       end
 
@@ -491,16 +491,13 @@ module Azure::Storage
       # Returns an array of results, one for each operation in the batch
       def execute_batch(batch, options={})
         headers = {
-          'Content-Type' => "multipart/mixed; boundary=#{batch.batch_id}",
-          'Accept' => 'application/atom+xml,application/xml',
-          'Accept-Charset'=> 'UTF-8'
+          HeaderConstants::CONTENT_TYPE => "multipart/mixed; boundary=#{batch.batch_id}",
+          HeaderConstants::ACCEPT => Table::Serialization.get_accept_string(options[:accept]),
+          'Accept-Charset' => 'UTF-8'
         }
 
-        query = { }
-        query["timeout"] = options[:timeout].to_s if options[:timeout]
-
         body = batch.to_body
-        response = call(:post, generate_uri('/$batch', query), body, headers, options)
+        response = call(:post, generate_uri('/$batch', new_query(options)), body, headers, options, true)
         batch.parse_response(response)
       rescue => e
         raise_with_response(e, response)
@@ -523,7 +520,7 @@ module Azure::Storage
       #                                in the analytics logs when storage analytics logging is enabled.
       #
       # Returns an Azure::Storage::Table::Entity instance on success
-      def get_entity(table_name, partition_key, row_key, options={})
+      def get_entity(table_name, partition_key, row_key, options = {})
         options[:partition_key] = partition_key
         options[:row_key] = row_key
         results = query_entities(table_name, options)
@@ -563,7 +560,7 @@ module Azure::Storage
       #
       # Returns a URI
       public
-      def entities_uri(table_name, partition_key=nil, row_key=nil, query={})
+      def entities_uri(table_name, partition_key = nil, row_key = nil, query = {})
         return table_name if table_name.kind_of? ::URI
 
         path = if partition_key && row_key
@@ -618,6 +615,19 @@ module Azure::Storage
         raise e if response.nil?
         raise "Response header: #{response.headers.inspect}\nResponse body: #{response.body.inspect}\n#{e.inspect}\n#{e.backtrace.join("\n")}"
       end
+
+      protected
+      def call(method, uri, body = nil, headers = {}, options = {}, is_batch = false)
+        # Add JSON Content-Type header if is_batch is false because default is Atom.
+        headers[HeaderConstants::CONTENT_TYPE] = HeaderConstants::JSON_CONTENT_TYPE_VALUE unless is_batch
+        headers[HeaderConstants::DATA_SERVICE_VERSION] = TableConstants::DEFAULT_DATA_SERVICE_VERSION
+        super(method, uri, body, headers, options)
+      end
+
+      protected
+      def new_query(options = {})
+        options[:timeout].nil? ? {} : { QueryStringConstants::TIMEOUT => options[:timeout].to_s }
+      end
     end
   end
 end

data/lib/azure/storage/version.rb

@@ -27,8 +27,8 @@ module Azure
     class Version
       # Fields represent the parts defined in http://semver.org/
       MAJOR = 0 unless defined? MAJOR
-      MINOR = 12 unless defined? MINOR
-      UPDATE = 3 unless defined? UPDATE
+      MINOR = 13 unless defined? MINOR
+      UPDATE = 0 unless defined? UPDATE
       PRE = 'preview' unless defined? PRE
 
       class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: azure-storage
 version: !ruby/object:Gem::Version
-  version: 0.12.3.preview
+  version: 0.13.0.preview
 platform: ruby
 authors:
 - Microsoft Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-11 00:00:00.000000000 Z
+date: 2017-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: azure-core
@@ -52,6 +52,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.8
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement