pokan 0.1.0rc1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color --format doc

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec"
+  gem "bundler"
+  gem "jeweler"
+  gem "guard"
+  gem "guard-rspec"
+end
+
+gem "eventmachine"
+gem "redis"

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    eventmachine (0.12.10)
+    git (1.2.5)
+    guard (0.6.3)
+      thor (~> 0.14.6)
+    guard-rspec (0.4.4)
+      guard (>= 0.4.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    redis (2.2.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  eventmachine
+  guard
+  guard-rspec
+  jeweler
+  redis
+  rspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :cli => '--color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/pokan/(.+)\.rb$}) { |m| "spec/pokan/#{m[1]}_spec.rb" } 
+  watch("spec/spec_helper.rb") { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Renato Mascarenhas
+
+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/README.rdoc

@@ -0,0 +1,19 @@
+= pokan
+
+Description goes here.
+
+== Contributing to pokan
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Renato Mascarenhas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/pokan/version.rb', __FILE__)
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "pokan"
+  gem.version = Pokan::VERSION
+  
+  gem.homepage = "http://github.com/haze/pokan"
+  gem.license = "MIT"
+  
+  gem.summary = %Q{Gossip-protocol implementation with an event based API}
+  
+  gem.description = %Q{pokan is an implementation of the Gossip protocol 
+    (best described in http://www.cs.cornell.edu/home/rvr/papers/flowgossip.pdf),
+    which aims to have a simple, event based API capable of being used in large,
+    not previously known networks.}
+  
+    gem.email = "haze-gem@googlegroups.com"
+  gem.authors = ["Renato Mascarenhas", "Rafael Regis do Prado", "Fabio Lima Pereira"]
+  
+  gem.add_dependency 'json'
+  gem.add_dependency 'eventmachine'
+  gem.add_dependency 'redis'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = Pokan::VERSION 
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pokan #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/pokan.rb

@@ -0,0 +1,19 @@
+module Pokan
+  require_relative 'pokan/connection'
+  require_relative 'pokan/entity'
+  require_relative 'pokan/peer'
+  require_relative 'pokan/query'
+  require_relative 'pokan/event_handler'
+  require_relative 'pokan/collective_peer_operations'
+  require_relative 'pokan/request_handler'
+  require_relative 'pokan/network'
+  require_relative 'pokan/version'
+  require_relative 'pokan/server_messages'
+  require_relative 'pokan/server'
+
+  class << self
+    def root
+      @@root = File.expand_path File.dirname(__FILE__) + '/..'
+    end
+  end
+end

data/lib/pokan/collective_peer_operations.rb

@@ -0,0 +1,88 @@
+# lib/pokan/collective_peer_operations.rb
+
+module Pokan
+  ##
+  # The CollectivePeerOperations should be used when it is necessary to apply a
+  # operation over a undefined amount of peers
+  module CollectivePeerOperations
+
+    ##
+    # Stores the keys-values-timestamps with timestamp greater than the
+    # peers' timestamp
+    # === Usage
+    #   class Collective; include CollectivePeerOperations; end
+    #   col = Collective.new
+    #   col.merge({ id1: { key: { value: 'FAIL', timestamp: => 223412 } } }) # pair stored
+    def merge(peers)
+      query = Query.new(Peer)
+      peers.each do |id, key_set|
+        peer = query.where(id: id.to_s)[0]
+        unless peer
+          peer = Peer.new
+          peer.id = id
+        end
+        key_set.keys.each do |key|
+          value = key_set[key]
+          value.keys.each { |k| value[k.to_sym] = value.delete(k) }
+          key_set[key.to_sym] = key_set.delete(key)
+        end
+        peer.merge(key_set)
+        peer.save
+      end
+    end
+
+    ##
+    # Returns all peers' updated keys-values-timestamps in relation
+    # to a given digest in a Complete Structure
+    #
+    # Given structure +{'id1' => {'status' => 3234124325.234323}}+
+    #
+    # Return structure +{ peer_id => { key => {"value" => value, "timestamp" => timestamp}, ...},...}+
+    def newer(digest)
+      query = Query.new(Peer)
+      newer_keys = Hash.new
+      digest.each do |id, keys|
+        peer = query.where(id: id.to_s)[0]
+        newer_keys[id] = peer ? peer.newer(keys) : {}
+      end
+
+      newer_keys
+    end
+
+    ##
+    # Returns all peers' outdated keys in relation to a given digest in a Old Key Structure
+    #
+    # Given structure +{'id1' => {'status' => 3234124325.234323}}+
+    #
+    # Return structure: +{peer_id => [old_key, ...], ...}+
+    def older(data)
+      query = Query.new(Peer)
+      older_keys = Hash.new
+
+      data.each do |id, dig|
+        peer = query.where(id: id.to_s)[0]
+        older_keys[id] = peer ? peer.older(dig) : dig.keys
+      end
+
+      older_keys
+    end
+
+    ##
+    # Returns all the ids' keys/values/timestamps for the keys in the given hash
+    #
+    # Given structure +{id1: [:k1, :k2, :foo]}+
+    #
+    # Return structure +{peer_id => { key => {"value" => value, "timestamp" => timestamp}, ...},...}+
+    def retrieve(req)
+      query = Query.new(Peer)
+      data = Hash.new
+
+      req.each do |id, keys|
+        peer = query.where(id: id.to_s, status:'alive')[0]
+        data[id] = peer.values(keys)  if peer
+      end
+
+      data
+    end
+  end
+end

data/lib/pokan/connection.rb

@@ -0,0 +1,27 @@
+# lib/pokan/connection.rb
+require 'singleton'
+require 'redis'
+
+module Pokan
+
+  # Connection is a singleton for redis connection
+  class Connection
+    ##
+    # Redis connection
+    attr_reader :redis
+    include Singleton
+
+    # creates a new instance of Redis
+    def initialize
+      @redis = Redis.new
+    end
+
+    # Get the instance of the class Redis
+    # === Usage
+    #   redis = Pokan::Connection.redis
+    #   redis.flushall
+    def self.redis
+      instance.redis
+    end
+  end
+end

data/lib/pokan/entity.rb

@@ -0,0 +1,165 @@
+# lib/pokan/entity.rb
+
+module Pokan
+
+  ##
+  # Entity is the class that takes care of data management, including versioning
+  # and persistence.
+  # == Basic Usage
+  #   e = Entity.new
+  #   e.id = 'my_id'
+  #   e.store(:my_key, 'my_value')
+  #   e.value(:my_key) # => 'my_value'
+  #   e.save # persists the data
+  class Entity
+
+    attr_accessor :id
+
+    def initialize
+      @key_set = Hash.new
+    end
+
+    ##
+    # Stores the value and the timestamp for a given key. 
+    # If the key, which must be a symbol, already exists, it will be updated if
+    # the timestamp is greater.
+    # The timestamp defaults to Time.now.
+    def store(key, value, timestamp = Time.now)
+      if !@key_set.has_key?(key) || @key_set[key][:timestamp] < timestamp.to_f
+        @key_set[key] = { value: value, timestamp: timestamp.to_f }
+      end
+    end
+
+    ##
+    # Gets the value of the requested key.
+    # The given key must be a symbol.
+    def value(key)
+      @key_set[key][:value] if @key_set.has_key?(key)
+    end
+
+    ##
+    # Gets the current timestamp of the requested key
+    # The given key must be a symbol and the returned timestamp will be a Time object.
+    def timestamp(key)
+      if @key_set.has_key?(key)
+        Time.at(@key_set[key][:timestamp])
+      else
+        Time.at(0)
+      end
+    end
+
+    ##
+    # Returns all keys of the peer in an array
+    def keys
+      @key_set.keys
+    end
+
+    ##
+    # Returns all the values/timestamps for each given key in \'keys\' Array in
+    # the following structure: { key: { value: 'value', timestamp: <Time obj> },
+    # key2:... }
+    def values(keys)
+      key_values = Hash.new
+      keys.each do |k|
+        key_values[k] = @key_set[k.to_sym] || {}
+      end
+      key_values
+    end
+
+    ##
+    # Gets a digest containing all entity's key/timestamp
+    # It returns a hash with all the pairs in the following structure: { key: timestamp, ... }
+    def digest
+      digest = Hash.new
+      @key_set.each {|k, v| digest[k] = v[:timestamp]}
+      digest
+    end
+
+    ##
+    # Persists all the entity's data
+    def save
+      db = Connection.redis
+
+      raise "Could not save the data, id not defined"  unless @id
+      @key_set.each do |k, v|
+        db.hset("entity:#{@id}:value", k.to_s, v[:value])
+        db.hset("entity:#{@id}:timestamp", k.to_s, v[:timestamp])
+        db.sadd("entity:#{@id}:keys", k.to_s)
+      end
+      db.sadd("entities", @id)
+    end
+
+    ##
+    # Deletes all persisted data related to the entity
+    def destroy
+      db = Connection.redis
+      db.del("entity:#{@id}:key")
+      db.del("entity:#{@id}:timestamp")
+      db.del("entity:#{@id}:value")
+      db.srem('entities', @id)
+    end
+
+    ##
+    # Gets all the data related to the peer from database.
+    # Newer keys that wasn\'t saved in any momentwill also be substituted.
+    def reload
+      db = Connection.redis
+      values = db.hgetall("entity:#{@id}:value")
+      timestamps = db.hgetall("entity:#{@id}:timestamp")
+      @key_set = Hash.new
+      values.each do |k, v|
+        @key_set[k.to_sym] = { value: v, timestamp: timestamps[k].to_f }
+      end
+    end
+
+    ##
+    # Stores the keys-values-timestamps with timestamp greater than the
+    # entity's timestamp.
+    # The 'keys' parameter must have the following structure:
+    # { key: {value: 'value', timestamp: <Time obj> }, key1:.... }
+    def merge(keys)
+     keys.each do |key, data|
+       if data[:timestamp].to_f > timestamp(key).to_f
+         store(key, data[:value], Time.at(data[:timestamp].to_f))
+       end
+     end
+    end
+
+    ##
+    # Returns all entity's outdated keys in relation to a given digest.
+    #
+    # Return Structure:  [:old_key, ...]
+    def older(digest)
+      digest.select { |key, tmsp| Time.at(tmsp.to_f) > timestamp(key) }.keys
+    end
+
+    ##
+    # Returns all peer's updated keys-values-timestamps in relation
+    # to a given digest.
+    #
+    # Return structure: { key: { value: 'value', timestamp: <Time obj> }, ... }
+    def newer(digest)
+     newer = digest.select { |key, tmsp| Time.at(tmsp.to_f) < timestamp(key) }
+     newer.each_key do |key|
+       newer[key] = { value: value(key), timestamp: timestamp(key).to_f }
+     end
+    end
+
+    ##
+    # Verifies if the entity have the given keys with the same values.
+    # The query structure must be similar to: { key1: 'v', key2: ['1', '2'] }
+    def match?(query)
+      accepted = true
+      query.each do |key, value|
+        value = [value]  unless value.is_a?(Array) || value.is_a?(Hash)
+        if value.is_a?(Array)
+          accepted = false  unless value.include?(value(key))
+        else
+          accepted = false  if value[:min] && value[:min] >= value(key)
+          accepted = false  if value[:max] && value[:max] <= value(key)
+        end
+      end
+      accepted
+    end
+  end
+end