tem_mr_search 0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1. Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009 Massachusetts Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Manifest

@@ -0,0 +1,25 @@
+CHANGELOG
+lib/tem_mr_search/client_query.rb
+lib/tem_mr_search/db.rb
+lib/tem_mr_search/map_reduce_executor.rb
+lib/tem_mr_search/map_reduce_job.rb
+lib/tem_mr_search/map_reduce_planner.rb
+lib/tem_mr_search/query_builder.rb
+lib/tem_mr_search.rb
+LICENSE
+Manifest
+Rakefile
+README
+tem_mr_search.gemspec
+test/mr_test_case.rb
+test/test_db.rb
+test/test_map_reduce_executor.rb
+test/test_map_reduce_job.rb
+test/test_map_reduce_planner.rb
+test/test_query_builder.rb
+testdata/fares.yml
+testdata/parallel_plan_431.yml
+testdata/parallel_plan_740.yml
+testdata/serial_plan_410.yml
+testdata/serial_plan_431.yml
+testdata/serial_plan_740.yml

data/README

@@ -0,0 +1,4 @@
+This is a concept proof of a Map-Reduce on a cluster of Trusted Execution
+Modules (TEMs). The Map-Reduce cluster performs queries consisting of finding
+the best item in a homogenous database using secret ranking criteria.
+ 

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+gem 'echoe'
+require 'echoe'
+
+Echoe.new('tem_mr_search') do |p|
+  p.project = 'tem' # rubyforge project
+  p.docs_host = "costan@rubyforge.org:/var/www/gforge-projects/tem/rdoc/"
+  
+  p.author = 'Victor Costan'
+  p.email = 'victor@costan.us'
+  p.summary = 'Tem Map-Reduce proof of concept: database search.'
+  p.url = 'http://tem.rubyforge.org'
+  p.dependencies = ['tem_ruby >=0.11.2', 'tem_multi_proxy >=0.2']
+  
+  p.need_tar_gz = !Platform.windows?
+  p.need_zip = !Platform.windows?
+  p.rdoc_pattern = /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/  
+end
+
+if $0 == __FILE__
+  Rake.application = Rake::Application.new
+  Rake.application.run
+end

data/lib/tem_mr_search/client_query.rb

@@ -0,0 +1,21 @@
+# :nodoc: namespace
+module Tem::Mr::Search
+
+class ClientQuery < MapReduceJob
+  def initialize(attributes)
+    super
+    @query_key = attributes[:key]
+  end
+
+  # Unpacks a reduce output into its components.
+  #
+  # This is expected to be called with the encrypted output returned by the
+  # search provider.
+  def unpack_output(output)
+    # TODO(costan): decrypt output once we enable encryption
+    decrypted_output = output
+    unpack_decrypted_output decrypted_output
+  end
+end
+  
+end  # namespace Tem::Mr::search

data/lib/tem_mr_search/db.rb

@@ -0,0 +1,19 @@
+# :nodoc: namespace
+module Tem::Mr::Search
+  
+class Db
+  attr_reader :data
+  def initialize(path)
+    @data = File.open(path, 'r') { |f| YAML.load f }
+  end
+  
+  def length
+    @data.length
+  end
+  
+  def item(item_index)
+    @data[item_index]
+  end
+end
+  
+end  # namespace Tem::Mr::search

data/lib/tem_mr_search/map_reduce_executor.rb

@@ -0,0 +1,114 @@
+require 'thread'
+
+
+# :nodoc: namespace
+module Tem::Mr::Search
+  
+class MapReduceExecutor
+  # Creates an executor for a Map-Reduce job.
+  #
+  # Arguments:
+  #   root_job:: the Map-Reduce job (see Tem::Mr::Search::MapReduceJob)
+  #   db:: the database to run Map-Reduce over
+  #   tems:: sessions to the available TEMs
+  #   root_tem:: the index of the TEM that has the root mapper and reducer
+  #   planner_class:: (optional) replacement for the default planner strategy
+  def initialize(root_job, db, tems, root_tem, planner_class = nil)
+    planner_class ||= MapReducePlanner
+    
+    @db = db  # Writable only in main thread.
+    @tems = tems  # Writable only in main thread.
+
+    # Writable only in main thread.
+    @planner = planner_class.new @job, db.length, tems.length, root_tem
+    
+    # Protected by @lock
+    @tem_jobs = { :mapper => { root_tem => root_job },
+                  :reducer => { root_tem => root_job },
+                  :finalizer => { root_tem => root_job } }
+    # Protected by @lock
+    @outputs = {}
+    
+    # Thread-safe.
+    @thread_queues = tems.map { |tem| Queue.new }
+    @main_queue = Queue.new
+    @lock = Mutex.new
+  end
+
+  # Executes the job.
+  def execute
+    # Spawn TEM threads.
+    @tems.each_index { |i| Thread.new(i) { |i| executor_thread i } }
+    
+    until @planner.done?
+      actions = @planner.next_actions!
+      @lock.synchronize do
+        actions.each { |action| @thread_queues[action[:with]] << action }
+      end
+      
+      action = @main_queue.pop
+      @planner.action_done action
+    end
+    
+    return @outputs[@planner.output_id]
+  end
+  
+  # Main method for thread in charge of a TEM.
+  def executor_thread(tem_index)
+    queue = @thread_queues[tem_index]    
+    while action = queue.pop
+      execute_action action, tem_index
+      @main_queue << action
+    end
+  end
+  
+  # Executes a Map-Reduce planner action.
+  #
+  # This method is called on the thread corresponding to the TEM that the action
+  # is supposed to execute on.
+  def execute_action(action, tem_index)
+    case action[:action]
+    when :migrate
+      in_job = @lock.synchronize { @tem_jobs[action[:secpack]][tem_index] }
+      out_job = in_job  # TODO(costan): actual migration
+      @lock.synchronize do
+        @tem_jobs[action[:secpack]][action[:to]] = out_job
+      end
+      
+    when :map
+      job, item = nil, nil
+      @lock.synchronize do
+        job = @tem_jobs[:mapper][tem_index]
+        item = @db.item(action[:item])
+      end
+      output = job.map_object item, @tems[tem_index]
+      @lock.synchronize do
+        @outputs[action[:output_id]] = output
+      end
+      
+    when :reduce
+      job, output1, output2 = nil, nil, nil
+      @lock.synchronize do
+        job = @tem_jobs[:reducer][tem_index]
+        output1 = @outputs[action[:output1_id]]
+        output2 = @outputs[action[:output2_id]]
+      end
+      output = job.reduce_outputs output1, output2, @tems[tem_index]
+      @lock.synchronize do
+        @outputs[action[:output_id]] = output
+      end
+
+    when :finalize
+      @lock.synchronize do
+        job = @tem_jobs[:finalizer][tem_index]
+        output = @outputs[action[:output_id]]
+      end
+      final_output = job.finalize_output output, @tems[tem_index]
+      @lock.synchronize do
+        @outputs[action[:final_id]] = final_output
+      end
+    end    
+  end
+end
+
+end  # namespace Tem::Mr::Search

data/lib/tem_mr_search/map_reduce_job.rb

@@ -0,0 +1,67 @@
+# :nodoc: namespace
+module Tem::Mr::Search
+  
+class MapReduceJob  
+  attr_reader :map_secpack, :reduce_secpack, :attributes, :id_attribute
+  
+  def initialize(attributes)
+    @map_secpack = attributes[:map]
+    @reduce_secpack = attributes[:reduce]
+    @finalize_secpack = attributes[:finalize]
+    @attributes = attributes[:attributes]
+    @id_attribute = attributes[:id_attribute]
+  end
+  
+  # Returns a SECpack for mapping the given object data into the query.
+  def map_for_object(object_data)
+    return nil unless @map_secpack
+    object_id = object_data[id_attribute.to_s]    
+    secpack = Tem::SecPack.new_from_array @map_secpack.to_array
+    secpack.set_bytes :_id, [object_id].pack('q').unpack('C*').reverse
+    attributes.each do |attribute|
+      name, type = attribute[:name], attribute[:type]
+      secpack.set_value name.to_sym, type, object_data[name.to_s]
+    end
+    secpack
+  end
+  
+  # Maps the given object into the query.
+  def map_object(object_data, tem)    
+    secpack = map_for_object object_data
+    secpack ? tem.execute(secpack) : object_data
+  end
+
+  # Returns a SECpack for reducing two inputs coming from maps or other reduces.
+  def reduce_for_outputs(output1, output2)
+    secpack = Tem::SecPack.new_from_array @reduce_secpack.to_array
+    
+    secpack.set_bytes :_output1, output1
+    secpack.set_bytes :_output2, output2
+    secpack
+  end
+  
+  # Reduces two inputs coming from maps or other reduces.
+  def reduce_outputs(output1, output2, tem)
+    secpack = reduce_for_outputs output1, output2
+    tem.execute secpack
+  end
+
+  # Converts a map/reduce output into the final result for the operation.
+  def finalize_output(output, tem)
+    return output unless @finalize_secpack
+    secpack = Tem::SecPack.new_from_array @finalize_secpack.to_array
+    secpack.set_bytes :_output, output
+    tem.execute secpack
+  end
+  
+  # Unpacks a decrypted output into its components.
+  def unpack_decrypted_output(output)
+    {
+      :id => output[0, 8].reverse.pack('C*').unpack('q').first,
+      :score => Tem::Abi.read_tem_short(output, 8),
+      :check => output[13, 3]
+    }
+  end
+end
+
+end  # namespace Tem::Mr::search

data/lib/tem_mr_search/map_reduce_planner.rb

@@ -0,0 +1,169 @@
+require 'rbtree'
+require 'set'
+
+# :nodoc: namespace
+module Tem::Mr::Search
+  
+class MapReducePlanner  
+  # Creates a planner for a Map-Reduce job.
+  #
+  # Arguments:
+  #   job:: the Map-Reduce job (see Tem::Mr::Search::MapReduceJob)
+  #   num_items: how many data items does the Map-Reduce run over
+  #   num_tems:: how many TEMs are available
+  #   root_tem:: the index of the TEM that has the root mapper and reducer
+  def initialize(job, num_items, num_tems, root_tem)
+    @job = job
+    @root_tem = root_tem
+    
+    @without = { :mapper => RBTree.new, :reducer => RBTree.new }
+    @with = { :mapper => Set.new([root_tem]),
+              :reducer => Set.new([root_tem]) }
+    @free_tems = RBTree.new
+    0.upto(num_tems - 1) do |tem|
+      @free_tems[tem] = true
+      next if tem == root_tem
+      @without.each { |k, v| v[tem] = true }
+    end
+    
+    @unmapped_items = (0...num_items).to_a.reverse
+    @reduce_queue = RBTree.new
+    @last_output_id = 0
+    @last_reduce_id = 2 * num_items - 2
+    @done_reducing, @output_id = false, nil
+  end
+
+  # Generates migrating actions for a SECpack type that are possible now.
+  def migrate_actions(sec_type)
+    actions = []
+    return actions if @without[sec_type].length == 0
+    free_tems = free_tems_with_sec sec_type
+    free_tems.each do |source_tem|
+      break if @without[sec_type].length == 0
+      target_tem = @without[sec_type].min.first
+      @without[sec_type].delete target_tem
+      @free_tems.delete source_tem
+      actions.push :action => :migrate, :secpack => sec_type,
+                   :with => source_tem, :to => target_tem
+    end
+    actions
+  end
+  private :migrate_actions
+  
+  # Informs the planner that a SECpack migration has completed.
+  def done_migrating(action)
+    @free_tems[action[:with]] = true
+    @with[action[:secpack]] << action[:to]
+  end
+  private :done_migrating
+  
+  # A sorted array of the free TEMs that have a SECpack type.
+  def free_tems_with_sec(sec_type)
+    tems = []
+    @free_tems.each do |tem, true_value|
+      tems << tem if @with[sec_type].include? tem
+    end
+    tems
+  end
+  
+  # A unique output_id.
+  def next_output_id
+    next_id = @last_output_id
+    @last_output_id += 1
+    next_id
+  end
+  
+  # Generates mapping actions possible right now.
+  def map_actions
+    actions = []
+    return actions if @unmapped_items.empty?
+    free_tems_with_sec(:mapper).each do |tem|
+      break unless item = @unmapped_items.pop
+      @free_tems.delete tem
+      actions.push :action => :map, :item => item, :with => tem,
+                   :output_id => next_output_id
+    end
+    actions
+  end
+  private :map_actions
+  
+  # Informs the planner that a data mapping has completed.
+  def done_mapping(action)
+    @free_tems[action[:with]] = true
+    @reduce_queue[action[:output_id]] = true
+  end
+  private :done_mapping
+  
+  # Generates reducing actions possible right now.
+  def reduce_actions
+    actions = []
+    return actions if @reduce_queue.length <= 1
+    free_tems_with_sec(:reducer).each do |tem|
+      break if @reduce_queue.length <= 1
+      output1_id, output2_id = *[0, 1].map do |i|
+        output_id = @reduce_queue.min.first
+        @reduce_queue.delete output_id
+        output_id
+      end
+      @free_tems.delete tem
+      actions.push :action => :reduce, :with => tem, :output1_id => output1_id,
+                   :output2_id => output2_id, :output_id => next_output_id
+    end
+    actions
+  end
+  private :reduce_actions
+  
+  # Informs the planner that a data reduction has completed.
+  def done_reducing(action)
+    @free_tems[action[:with]] = true
+    if action[:output_id] == @last_reduce_id
+      @done_reducing = true      
+      return
+    end
+    @reduce_queue[action[:output_id]] = true
+  end
+  private :done_reducing
+  
+  # Generates finalizing actions possible right now.
+  def finalize_actions
+    return [] unless @done_reducing and !@output_id and @free_tems[@root_tem]
+    @finalize_ready = false
+    return [ :action => :finalize, :with => @root_tem,
+             :output_id => @last_reduce_id, :final_id => next_output_id ]
+  end
+  private :finalize_actions
+  
+  # Informs the planner that an action issued by next_action was done.
+  def done_finalizing(action)
+    @free_tems[action[:with]] = true
+    @output_id = action[:final_id]    
+  end
+  private :done_finalizing
+
+  # True when the Map-Reduce job is complete.
+  def done?
+    !@output_id.nil?
+  end
+  
+  # The output ID of the Map-Reduce's final result.
+  attr_reader :output_id
+
+  # Informs the planner that an action issued by next_actions was completed.
+  def action_done(action)
+    dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>
+                 :done_reducing, :finalize => :done_finalizing } 
+    self.send dispatch[action[:action]], action
+  end
+
+  # Issues a set of actions that can be performed right now.
+  def next_actions!
+    actions = migrate_actions :mapper
+    actions += migrate_actions :reducer
+    actions += map_actions
+    actions += reduce_actions
+    actions += finalize_actions
+    actions
+  end  
+end
+
+end  # namespace Tem::Mr::search

data/lib/tem_mr_search/query_builder.rb

@@ -0,0 +1,167 @@
+# :nodoc: namespace
+module Tem::Mr::Search
+
+class QueryBuilder
+  # Build a Query.
+  def self.query
+    builder = self.new
+    yield builder
+    builder.query
+  end
+  
+  # Defines the object attributes imported into the map method.
+  def attributes(attributes)
+    @attributes = attributes.to_a.map do |k, v|
+      { :name => k,
+        :type => v,
+        :length => Tem::Abi.send(:"#{v}_length")        
+      }
+    end
+  end
+  
+  # Defines the object attribute that's used as an object ID.
+  def id_attribute(id_attribute)
+    @id_attribute = id_attribute.to_sym
+  end
+  
+  # Defines the query's map procedure.
+  def map
+    @map_secpack = Tem::Assembler.assemble do |s|
+      s.label :_secret
+      s.label :_key
+      s.zeros :tem_ubyte, 16
+      s.label :_check_bytes
+      s.data :tem_ubyte, @check_bytes
+      
+      # User-provided ranking procedure (secret).
+      s.label :_ranking
+      yield s
+      s.ret
+      
+      s.entry
+      s.ldbc 16
+      s.outnew
+      s.call :_ranking
+      s.ldbc 3
+      s.ldwc :_nonce
+      s.rnd
+      s.mcfxb :from => :_check_bytes, :to => :_check, :size => 3
+      # TODO(costan): encryption instead of plain dump
+      s.outfxb :from => :_id, :size => 16
+      s.halt
+      
+      s.label :_plain
+      
+      # Make room for query attributes.
+      @attributes.each do |attribute|
+        s.label attribute[:name]
+        s.zeros attribute[:type], 1
+      end
+      # Object ID.
+      s.label :_id
+      s.zeros :tem_ubyte, 8
+      # Object score.
+      s.label :score
+      s.zeros :tem_short, 1
+      # Random nonce to prevent matching map outputs.
+      s.label :_nonce
+      s.zeros :tem_ubyte, 3
+      # Check bytes to prevent malicious input corruption.
+      s.label :_check
+      s.zeros :tem_ubyte, 3
+      
+      s.stack 64
+    end    
+  end
+  
+  # Defines the query's reduce procedure.
+  def reduce
+    @reduce_secpack = Tem::Assembler.assemble do |s|
+      s.label :_secret
+      s.label :_key
+      s.zeros :tem_ubyte, 16
+      s.label :_check
+      s.data :tem_ubyte, @check_bytes
+      
+      s.label :_signed
+      # User-provided comparison procedure (signed).
+      s.label :_comparison_proc
+      yield s
+      s.ret
+      
+      s.entry
+      s.ldbc 16
+      s.outnew      
+      # Decode inputs.
+      [1, 2].each do |i|
+        # TODO(costan): decrypt instead of copying
+        s.mcfxb :from => :"_output#{i}", :to => :"_id#{i}", :size => 16
+        
+        # Compare the check bytes and abort if the inputs were tampered with.
+        s.mcmpfxb :op1 => :"_check#{i}", :op2 => :"_check", :size => 3
+        s.jz :"_check_#{i}_ok"
+        s.halt
+        s.label :"_check_#{i}_ok"
+      end
+      
+      # Compare and output.
+      s.call :_comparison_proc
+      s.ldw :comparison
+      s.jae :_output1_wins
+      s.mcfxb :from => :_id2, :to => :_id1, :size => 16
+      s.jmp :_output
+      s.label :_output1_wins
+      # Still do a memcpy, to prevent timing attacks.
+      s.mcfxb :from => :_id2, :to => :_id2, :size => 16
+      s.jmp :_output
+      # Refresh the nonce to prevent learning about the comparison criteria.
+      s.label :_output
+      s.ldbc 3
+      s.ldwc :_nonce1
+      s.rnd
+      # TODO(costan): encrypt instead of copying
+      s.outfxb :from => :_id1, :size => 16
+      s.halt
+      
+      s.label :_plain
+      # The comparison result produced by the user comparison procedure.
+      s.label :comparison
+      s.zeros :tem_short, 1
+      
+      # The two inputs to reduce.
+      [1, 2].each do |i|
+        # Encrypted map/reduce output.
+        s.label :"_output#{i}"        
+        s.zeros :tem_ubyte, 16
+        # Unencrypted input (decrypted inside TEM).
+        s.label :"_id#{i}"
+        s.zeros :tem_ubyte, 8
+        s.label :"score#{i}"
+        s.zeros :tem_short, 1
+        s.label :"_nonce#{i}"
+        s.zeros :tem_ubyte, 3        
+        s.label :"_check#{i}"
+        s.zeros :tem_ubyte, 3
+      end
+      s.stack 8
+    end
+  end
+  
+  def query
+    raise "Map procedure not specified" unless @map_secpack
+    raise "Reduce procedure not specified" unless @reduce_secpack
+    raise "ID attribute not specified" unless @id_attribute
+    
+    ClientQuery.new :key => @query_key, :attributes => @attributes,
+                    :map => @map_secpack, :reduce => @reduce_secpack,
+                    :id_attribute => @id_attribute
+  end
+
+  def initialize
+    @check_bytes = [1, 2, 3]
+    # TODO(costan): generate query key
+    @query_key = nil
+  end
+end  # class QueryBuilder
+
+end  # namespace Tem::Mr::Search

data/lib/tem_mr_search.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'tem_multi_proxy'
+require 'tem_ruby'
+
+# :nodoc: namespace
+module Tem::Mr
+end
+# :nodoc: namespace
+module Tem::Mr::Search
+end
+
+require 'tem_mr_search/db.rb'
+require 'tem_mr_search/map_reduce_executor.rb'
+require 'tem_mr_search/map_reduce_job.rb'
+require 'tem_mr_search/map_reduce_planner.rb'
+require 'tem_mr_search/query_builder.rb'
+require 'tem_mr_search/client_query.rb'

data/tem_mr_search.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tem_mr_search}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Victor Costan"]
+  s.date = %q{2009-06-02}
+  s.description = %q{Tem Map-Reduce proof of concept: database search.}
+  s.email = %q{victor@costan.us}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/tem_mr_search/client_query.rb", "lib/tem_mr_search/db.rb", "lib/tem_mr_search/map_reduce_executor.rb", "lib/tem_mr_search/map_reduce_job.rb", "lib/tem_mr_search/map_reduce_planner.rb", "lib/tem_mr_search/query_builder.rb", "lib/tem_mr_search.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "lib/tem_mr_search/client_query.rb", "lib/tem_mr_search/db.rb", "lib/tem_mr_search/map_reduce_executor.rb", "lib/tem_mr_search/map_reduce_job.rb", "lib/tem_mr_search/map_reduce_planner.rb", "lib/tem_mr_search/query_builder.rb", "lib/tem_mr_search.rb", "LICENSE", "Manifest", "Rakefile", "README", "tem_mr_search.gemspec", "test/mr_test_case.rb", "test/test_db.rb", "test/test_map_reduce_executor.rb", "test/test_map_reduce_job.rb", "test/test_map_reduce_planner.rb", "test/test_query_builder.rb", "testdata/fares.yml", "testdata/parallel_plan_431.yml", "testdata/parallel_plan_740.yml", "testdata/serial_plan_410.yml", "testdata/serial_plan_431.yml", "testdata/serial_plan_740.yml"]
+  s.homepage = %q{http://tem.rubyforge.org}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Tem_mr_search", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{tem}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Tem Map-Reduce proof of concept: database search.}
+  s.test_files = ["test/test_db.rb", "test/test_map_reduce_executor.rb", "test/test_map_reduce_job.rb", "test/test_map_reduce_planner.rb", "test/test_query_builder.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<tem_ruby>, [">= 0.11.2"])
+      s.add_runtime_dependency(%q<tem_multi_proxy>, [">= 0.2"])
+    else
+      s.add_dependency(%q<tem_ruby>, [">= 0.11.2"])
+      s.add_dependency(%q<tem_multi_proxy>, [">= 0.2"])
+    end
+  else
+    s.add_dependency(%q<tem_ruby>, [">= 0.11.2"])
+    s.add_dependency(%q<tem_multi_proxy>, [">= 0.2"])
+  end
+end