azure-plus 0.6.5

data/lib/azure/table/batch_response.rb

@@ -0,0 +1,118 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+module Azure
+  module Table
+    module BatchResponse
+      def self.parse(data)
+        context = { 
+          :lines => data.lines.to_a,
+          :index=> 0,
+          :responses => []
+        }
+
+        find(context) { |c| batch_boundary c }
+        find(context) { |c| batch_headers c }
+        
+        while(find(context){ |c| changeset_boundary_or_end c } == :boundary)
+          find(context) { |c| changeset_headers c }
+          find(context) { |c| response c }
+          find(context) { |c| response_headers c }
+          find(context) { |c| response_body c }
+        end
+
+        context[:responses]
+      end
+
+      def self.find(context, &block)
+        while(context[:index] < context[:lines].length)
+          result = block.call(context)
+          return result if result
+          context[:index] +=1
+        end
+      end
+
+      def self.response_body(context)
+        end_of_body = nil
+        end_of_body = changeset_boundary_or_end(context.dup.merge!({:index=>context[:index] + 1})) if context[:index] < (context[:lines].length - 1)
+
+        if end_of_body
+          context[:responses].last[:body] ||= ""
+          context[:responses].last[:body] << current_line(context)
+          return context[:responses].last[:body]
+        else 
+          context[:responses].last[:body] ||= ""
+          context[:responses].last[:body] << current_line(context)
+          return nil
+        end
+      end
+
+      def self.response_headers(context)
+        match = /(.*): (.*)/.match(current_line(context))
+
+        if context[:responses].last[:headers] and not match
+          context[:index] += 1
+          return context[:responses].last[:headers]
+        elsif match
+          context[:responses].last[:headers] ||= {}
+          context[:responses].last[:headers][match[1].downcase] = match[2].strip
+          return nil
+        else
+          return nil
+        end
+      end
+
+      def self.response(context)
+        match = /HTTP\/1.1 (\d*) (.*)/.match(current_line(context))
+        return nil unless match
+        response = {:status_code => match[1], :message => match[2] }
+        context[:responses].push response
+      end
+      
+      def self.changeset_headers(context)
+        current_line(context).strip ==  ''
+      end
+
+      def self.changeset_boundary_or_end(context)
+        match_boundary = /--changesetresponse_(.*)/.match(current_line(context))
+        match_end = /--changesetresponse_(.*)--/.match(current_line(context))
+
+        (match_boundary and not match_end) ? :boundary : (match_end ? :end : nil)
+      end
+
+      def self.batch_headers(context)
+        match = /(.*): (.*)/.match(current_line(context))
+
+        if context[:batch_headers] and not match
+          return context[:batch_headers]
+        elsif match
+          context[:batch_headers] ||= {}
+          context[:batch_headers][match[1].downcase] = match[2]
+          return nil
+        else
+          return nil
+        end
+      end
+
+      def self.batch_boundary(context)
+        match = /--batchresponse_(.*)/.match(current_line(context))
+        match ? match[1] : nil
+      end
+      
+      def self.current_line(context)
+        context[:lines][context[:index]]
+      end
+    end
+  end
+end

data/lib/azure/table/edmtype.rb

@@ -0,0 +1,127 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+
+require 'azure/table/guid'
+
+require "time"
+require "date"
+
+module Azure
+  module Table
+    module EdmType
+      # Public: Get the Edm type of an object
+      #
+      # value - Object. An typed instance
+      #
+      # Returns the Edm type as a String
+      def self.property_type(value)
+        case value
+        when Float
+          "Edm.Double"
+        when Date, Time, DateTime
+          "Edm.DateTime"
+        when Integer
+          value.abs < 2**31 ? "Edm.Int32" : "Edm.Int64"
+        when TrueClass, FalseClass
+          "Edm.Boolean"
+        when GUID
+          "Edm.Guid"
+        when IO, File
+          "Edm.Binary"
+        when String
+          value.encoding.names.include?("BINARY") ? "Edm.Binary" : ""
+        else
+          value.kind_of?(IO) ? "Edm.Binary" : ""
+        end
+      end
+
+      # Public: Get the value of a property in a serialized way
+      #
+      # value - Object. An typed instance
+      #
+      # Returns the Edm type as a String
+      def self.serialize_value(type, value)
+        case type
+        when "Edm.Double", "Edm.Int32", "Edm.Int64", "Edm.Guid", "Edm.String", nil
+          value.to_s
+        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
+        else
+          value.to_s
+        end
+      end
+
+      # Public: Serializes EDM value into proper value to be used in query.
+      # 
+      # value - String. The value to serialize.
+      #
+      # Returns the serialized value
+      def self.serialize_query_value(value)
+        case value
+        when Date, Time, DateTime
+          "datetime'#{value.iso8601}'"
+        when TrueClass, FalseClass
+          value ? "true" : "false"
+        when Float, Integer
+          value.abs < 2**31 ? value.to_s : value.to_s + "L"
+        when GUID
+          "guid'#{value.to_s}'"
+        when IO, File
+          "X'" + value.to_s.unpack("H*").join("") + "'"
+        else
+          if value != nil && value.encoding.names.include?("BINARY")
+            "X'" + value.to_s.unpack("H*").join("") + "'"
+          else
+            # NULL also is treated as EdmType::STRING
+            value.to_s.gsub("'","''");
+          end
+        end
+      end
+
+      # Public: Convert a serialized value into an typed object
+      #
+      # value - String. The Edm value
+      # type  - String. The Edm datatype
+      #
+      # Returns an typed object
+      def self.unserialize_query_value(value, type)
+        case type
+        when "Edm.DateTime"
+          Time.parse(value)
+        when "Edm.Double"
+          Float(value)
+        when "Edm.Int32", "Edm.Int64"
+          Integer(value)
+        when "Edm.Boolean"
+          /true/i === value
+        when "Edm.Guid"
+          GUID.new(value.to_s)
+        when "Edm.Binary"
+          Base64.decode64(value.to_s).force_encoding("BINARY")
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/azure/table/entity.rb

@@ -0,0 +1,31 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+
+module Azure
+  module Table
+    class Entity
+      
+      def initialize 
+        @properties = {}
+        yield self if block_given?
+      end
+
+      attr_accessor :table
+      attr_accessor :updated
+      attr_accessor :etag
+      attr_accessor :properties
+    end
+  end
+end

data/lib/azure/table/guid.rb

@@ -0,0 +1,24 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "delegate"
+
+module Azure
+  module Table
+    # Public: Wrapper around a string to represent a GUID
+    #
+    class GUID < SimpleDelegator
+    end
+  end
+end

data/lib/azure/table/query.rb

@@ -0,0 +1,112 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/table/table_service'
+require 'azure/table/edmtype'
+
+module Azure
+  module Table
+    class Query
+      def initialize(table="", partition=nil, row=nil, &block)
+        @table = table
+        @partition_key = partition
+        @row_key = row
+        @fields = []
+        @filters = []
+        @top_n = nil
+        @table_service = Azure::Table::TableService.new
+        self.instance_eval(&block) if block_given?
+      end
+        
+      attr_reader :table
+      attr_reader :partition_key
+      attr_reader :row_key
+
+      attr_reader :fields
+      attr_reader :filters
+      attr_reader :top_n
+
+      attr_reader :next_partition_key
+      attr_reader :next_row_key
+
+      attr_reader :table_service
+
+      def from(table_name)
+        @table = table_name
+        self
+      end
+
+      def partition(partition_key)
+        @partition_key = partition_key
+        self
+      end
+
+      def row(row_key)
+        @row_key = row_key
+        self
+      end
+
+      def select(*p)
+        @fields.concat(p)
+        self
+      end
+
+      def where(*p)
+        @filters.push(p)
+        self
+      end
+      
+      def top(n)
+        @top_n = n
+        self
+      end
+
+      def next_partition(next_partition_key)
+        @next_partition_key = next_partition_key
+        self
+      end
+
+      def next_row(next_row_key)
+        @next_row_key = next_row_key
+        self
+      end
+
+      def execute
+        @table_service.query_entities(@table, {
+          :partition_key => @partition_key,
+          :row_key => @row_key, 
+          :select => @fields.map{ |f| f.to_s },
+          :filter => _build_filter_string,
+          :top => (@top_n ? @top_n.to_i : @top_n),
+          :continuation_token => { 
+            :next_partition_key => @next_partition_key,
+            :next_row_key => @next_row_key
+          }
+        })
+      end
+
+      def _build_filter_string
+        result = ""
+        clauses = []
+        filters.each { |f|
+          clauses.push "#{f[0].to_s} #{f[1].to_s} #{Azure::Table::EdmType.serialize_query_value(f[2])}"
+        }
+        return nil if clauses.length == 0 
+        
+        result << clauses.join(" and ")
+        result
+      end
+    end
+  end
+end

data/lib/azure/table/serialization.rb

@@ -0,0 +1,108 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service/serialization'
+
+require 'azure/table/guid'
+require 'azure/table/edmtype'
+
+require "time"
+require "date"
+
+module Azure
+  module Table
+    module Serialization
+      include Azure::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)
+        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")
+
+              type = Azure::Table::EdmType.property_type(val)
+              attributes = {}
+              attributes["m:type"] = type unless type.nil? || type.empty?
+
+              if val.nil?
+                attributes["m:null"] = "true"
+                properties.send("d:#{key}", attributes)
+              else
+                properties.send("d:#{key}", Azure::Table::EdmType.serialize_value(type, val), attributes)
+              end
+            end
+          end
+        end
+
+        xml
+      end
+
+      def self.entries_from_feed_xml(xml)
+        xml = slopify(xml)
+        expect_node("feed", xml)
+
+        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
+        end
+
+        results
+      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::Table::EdmType.unserialize_query_value(prop.text, prop["m:type"]) : prop["null"] ? nil : ""
+          end
+        end
+        result[:properties] = properties
+        result
+      end
+    end
+  end
+end