pokan-cluster 0.1

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec"
+  gem "guard-rspec"
+  gem "bundler"
+  gem "jeweler"
+  gem "pry"
+end
+
+gem "pokan", "~> 0.1.0rc2"
+gem "host"
+gem "yagni", "~> 1.2"
+gem "logging"
+
+#TODO: remove this group
+group :local do
+  gem "redis"
+  gem "eventmachine" 
+end

data/Gemfile.lock

@@ -0,0 +1,65 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (0.9.8)
+    diff-lcs (1.1.3)
+    eventmachine (0.12.10)
+    git (1.2.5)
+    guard (0.8.4)
+      thor (~> 0.14.6)
+    guard-rspec (0.4.5)
+      guard (>= 0.4.0)
+    host (0.1)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    json (1.6.1)
+    little-plugger (1.1.2)
+    logging (1.6.1)
+      little-plugger (>= 1.1.2)
+    method_source (0.6.7)
+      ruby_parser (>= 2.3.1)
+    pokan (0.1.0rc2)
+      eventmachine
+      eventmachine
+      json
+      redis
+      redis
+    pry (0.9.7.3)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.7)
+      ruby_parser (>= 2.3.1)
+      slop (~> 2.1.0)
+    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)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.7)
+    slop (2.1.0)
+    thor (0.14.6)
+    yagni (1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  eventmachine
+  guard-rspec
+  host
+  jeweler
+  logging
+  pokan (~> 0.1.0rc2)
+  pry
+  redis
+  rspec
+  yagni (~> 1.2)

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :cli => '--color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/pokan-cluster.rb}) { |m| "spec/pokan-cluster_spec.rb" }
+  watch(%r{^lib/pokan-cluster/(.+)\.rb$}) { |m| "spec/pokan-cluster/#{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-cluster
+
+Description goes here.
+
+== Contributing to pokan-cluster
+ 
+* 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 rmascarenhas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require File.expand_path('lib/pokan-cluster/version')
+
+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-cluster"
+  gem.version = Pokan::Cluster::VERSION
+
+  gem.homepage = "http://github.com/rmascarenhas/pokan-cluster"
+  gem.license = "MIT"
+
+  gem.summary = %Q{pokan-cluster is a set of neat, handy functionalities built
+                   on top of pokan.}
+
+  gem.description = <<-END
+    pokan-cluster adds a handy set of functionalities on top of pokan, everyone's
+    favorite Ruby Gossip protocol implementation. Logging, easy YAML configuration
+    file, workload information of peers in your network (so that you can write a
+    simple load balancer) are among the features pokan-cluster has to offer!
+    Take a look at it and contribute! (see our Github page).
+  END
+  gem.email = "renato.mascosta@gmail.com"
+  gem.authors = ["Fabio Lima Pereira", "Rafael Regis do Prado", "Renato Mascarenhas"]
+  
+  gem.add_dependency 'pokan'
+  gem.add_dependency 'yagni'
+  gem.add_dependency 'host'
+
+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'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = Pokan::Cluster::VERSION 
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pokan-cluster #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/pokan-cluster.rb

@@ -0,0 +1,247 @@
+require 'pokan'
+require 'yell/hash'
+require 'logging'
+
+module Pokan
+
+  require_relative 'pokan-cluster/configuration'
+  require_relative 'pokan-cluster/prepared_string'
+  require_relative 'pokan-cluster/autorunner'
+  require_relative 'pokan-cluster/log_messages'
+  require_relative 'pokan-cluster/config_defaults'
+  require_relative 'pokan-cluster/version'
+
+  # Cluster module, to be included on all classes that want to implement
+  # a custom Gossip server. Including this module enables the developer to
+  # customize the configuration file location (and format, as long as she
+  # provided a parser for that format). The user can also pass manually
+  # the values for the configuration options. However, this is not the
+  # recommended way, of course.
+  #
+  # Example
+  #
+  #   class MyCustomGossiper
+  #     include Pokan::Cluster
+  #
+  #     config { JSON.parse(CONFIG_PATH) }
+  #
+  #   end
+  #
+  # The `config` method expects a hash containing values for network connection,
+  # seed address, log information, and others. If you want to see an example of a 
+  # valid configuration hash, you can parse the following YAML (recommened config
+  # format for pokan-cluster):
+  #
+  #   pokan:
+  #     address: "10.10.10.8" # your IP address
+  #
+  #     connect:
+  #       tcp: 4444
+  #       udp: 8787 # ports that will be binded
+  #       epoll: true # Linux machine?
+  #
+  #     gossip:
+  #       every: 2 # seconds
+  #       share: "cpu,memory,load" # these are the valid options (separated by comma).
+  #
+  #     seed: "10.10.10.2" # will be contacted on startup
+  #
+  #     log:
+  #       enabled: true # always good!
+  #       level: "info"
+  #       file: "/path/to/my/log" # default is STDOUT
+  #
+  # Optionally, you can directly pass a file, using the `config_file` method. However,
+  # only the YAML format is currently supported
+  #
+  #   class MyCustomGossiper
+  #     include Pokan::Cluster
+  #
+  #     config_file = '/path/to/my/config.yml'
+  #   end
+  module Cluster
+
+
+    # When a server includes the Pokan::Cluster module, it gains access to its
+    # class methods, allowing the user to set configuration and behavior of the
+    # server. It is also configured to automatically run when the server class
+    # is loaded.
+    def self.included(klass)
+      klass.extend ClassMethods
+      Autorunner.register_server(klass)
+    end
+
+    # Automatically starts registered servers.
+    at_exit { 
+      unless $! || Pokan::Cluster::Autorunner.run?
+        Pokan::Cluster::Autorunner.run
+      end
+    }
+
+    module ClassMethods
+
+      attr_accessor :address, :tcp_port, :udp_port, :epoll, :gossip_interval,
+                    :seed, :logging, :log_level, :log_file
+
+      # Pretty names
+      alias_method :epoll?, :epoll
+      alias_method :logging?, :logging
+
+      # Loads the server configuration, expecting a valid config hash in a block.
+      # This allows you to use whatever configuration format, as long as you can 
+      # transform it to a valid pokan hash.
+      def config(&block)
+        @server || load!(block.call)
+        initialize_log
+        delegate
+      end
+
+      # Convenience method, allowing the user to set the file containing the
+      # configuration in the YAML format. In the future, maybe add builtin support
+      # for other different formats.
+      def config_file(path, options={})
+        config { YAML.load(File.read path) }
+      end
+
+      # Disables log for the gossip server
+      def disable_log
+        @logging = false
+      end
+
+      # Sets the seed address and redis port, if specified
+      #
+      #   class Server
+      #     include Pokan::Cluster
+      #
+      #     gossip_with '10.10.10.3', :redis => 6549
+      #   end
+      #
+      # If no Redis port is specified, +6379+ is assumed (as it is the default
+      # Redis port).
+      def gossip_with(address, options)
+        update_autorunner_option(:gossip_with, address)
+        update_autorunner_option(:redis, options[:redis] || DEFAULTS[:redis])
+      end
+
+      def method_missing(meth, *args, &block)
+        @delegator.send(meth, *args, &block)
+      end
+
+    private
+
+      # Sets variables according to the hash passed.
+      def load!(config_hash)
+        config = Configuration.new(config_hash)
+        @address = config.get('pokan.address')
+        @server = Pokan::Server.new(@address)
+
+        update_ivs(config)
+        config_autorunner
+      end
+
+      def update_ivs(config)
+        @tcp_port         = config.get('pokan.connect.tcp')      || DEFAULTS[:tcp_port]
+        @udp_port         = config.get('pokan.connect.udp')      || DEFAULTS[:udp_port]
+        @epoll            = config.get('pokan.connect.epoll')    || DEFAULTS[:epoll]
+        @gossip_interval  = config.get('pokan.gossip.every')     || DEFAULTS[:gossip_interval]
+        @seed             = config.get('pokan.seed.address')
+        @redis            = config.get('pokan.seed.redis')       || DEFAULTS[:redis]
+        @logging          = config.get('pokan.log.enabled')      || DEFAULTS[:logging]
+        @log_level        = config.get('pokan.log.level').to_sym || DEFAULTS[:level]
+        @log_file         = config.get('pokan.log.file')
+      end
+
+      def config_autorunner
+        options = {}
+        options.merge!({ :gossip_with => @seed }) unless @seed.nil?
+        options.merge!({ :redis => @redis }) unless @redis.nil?
+
+        Autorunner.options = options
+      end
+
+      def update_autorunner_option(key, value)
+        opt = Autorunner.options
+        opt[key] = value
+
+        Autorunner.options = opt 
+      end
+
+      # Adds callbacks for logging on the happening of certain events, such
+      # as new keys being defined, changed, gossip messages, etc.
+      def initialize_log
+        @log_initialized ||= false
+        
+        if logging? && !@log_initialized
+          setup_logging
+          add_log_callbacks
+        end
+
+        @log_initialized = true
+      end
+
+      # requires and sets up the `logging` library.
+      def setup_logging
+        @logger = Logging.logger['pokan-cluster']
+        appenders = [Logging.appenders.stdout]
+        appenders << Logging.appenders.file(@log_file) if @log_file
+
+        @logger.add_appenders *appenders
+        @logger.level = @log_level
+      end
+
+      # adds callbacks on the server instance so that some events are logged
+      def add_log_callbacks
+        @server.on(:start) do |address, tcp_port, udp_port, epoll, gossip_interval, seed_address, seed_port|
+          @logger.debug LOG_MESSAGES[:start][:debug].with(address, tcp_port, udp_port, epoll,
+                                                 gossip_interval, seed_address, @log_level.to_s, @log_file).string
+
+          @logger.info LOG_MESSAGES[:start][:info].with(address).string
+        end
+
+        @server.before(:sync) do |address, port|
+          @logger.debug LOG_MESSAGES[:before_sync][:debug].with(address, port).string
+          @logger.info LOG_MESSAGES[:before_sync][:info].string
+        end
+
+        @server.after(:sync) do |time_elapsed|
+          @logger.debug LOG_MESSAGES[:after_sync][:debug].with(time_elapsed).string
+          @logger.info LOG_MESSAGES[:after_sync][:info].string
+        end
+
+        @server.on(:new_key) do |key, value|
+          @logger.debug LOG_MESSAGES[:new_key][:debug].with(key.to_s, value).string
+        end
+
+        @server.before(:gossip) do |address, port, digest_length|
+          @logger.debug LOG_MESSAGES[:before_gossip][:debug].with(address, digest_length).string
+          @logger.info LOG_MESSAGES[:before_gossip][:info].with(address).string
+        end
+
+        @server.after(:gossip) do
+          @logger.debug LOG_MESSAGES[:after_gossip][:debug].string
+        end
+
+        @server.on(:shutdown) do
+          @logger.info LOG_MESSAGES[:shutdown]
+        end
+
+
+      end
+
+      # Initializes the delegator instance so that unknown methods will
+      # be delegated to the server instance, providing a better API for
+      # developers who want to customize their server behavior.
+      def delegate
+        require 'delegate'
+        @delegator = DelegateClass(Pokan::Server).new(@server)
+      end
+
+      def prepend(a_string, to_string)
+       (a_string.to_s + to_string.to_s).to_sym
+      end
+
+    end
+
+  end
+
+end

data/lib/pokan-cluster/autorunner.rb

@@ -0,0 +1,34 @@
+module Pokan
+  
+  module Cluster
+
+    # Class used for automatically run a server that include Pokan::Cluster
+    # module.
+    class Autorunner
+
+      class << self
+        attr_accessor :server
+        attr_accessor :options
+      end
+
+      # Registers a new server, that will be started when the method
+      # Pokan::Cluster::Autorunner.run gets called.
+      def self.register_server(server_class)
+        @server = server_class
+      end
+
+      # Checks if we have any server to start
+      def self.run?
+        @server.respond_to? :start
+      end
+
+      # Calls the method `start` on every registered server
+      def self.run
+        @server.start(@options)
+      end
+
+    end
+
+  end
+  
+end

data/lib/pokan-cluster/config_defaults.rb

@@ -0,0 +1,21 @@
+module Pokan
+  module Cluster
+
+    # Default values for configuration, specifying:
+    # * TCP and UDP ports
+    # * epoll set to false
+    # * logging enabled to `STDOUT`
+    # * gossip interval: 1 second
+
+    DEFAULTS = {
+      :tcp_port         => 5555,
+      :udp_port         => 5555,
+      :epoll            => false,
+      :gossip_interval  => 1,
+      :redis            => 6379,
+      :logging          => true,
+      :level            => :info
+    }.freeze
+
+  end
+end

data/lib/pokan-cluster/configuration.rb

@@ -0,0 +1,77 @@
+# lib/pokan-cluster/configuration.rb
+
+module Pokan
+  module Cluster
+
+    # Class used to hold configuration options for anything.
+    # It inherits from Yell::Hash, so that the options are can be passed
+    # in a usual Ruby hash. Optionally, you can pass it a string containing
+    # your data and an object which responds to the method +parse+,
+    # which will take the data string and build the corresponding hash.
+    #
+    # The options passed can be accessed later via the +get+ method, used in the
+    # example above (see further details in Pokan::Cluster::Configuration#get)
+    #
+    # Usage
+    #
+    #   # If we wanted to use a YAML configuration file...
+    #   # and our file was the following:
+    #   # pokan:
+    #   #   cluster: "configuration"
+    #
+    #   class YAMLParser
+    #     def self.parse(data)
+    #       YAML.load(data)
+    #     end
+    #   end
+    #
+    #   c = Pokan::Cluster::Configuration.new(File.read('config.yaml'), YAMLParser)
+    #   c.get('pokan.cluster') #=> "configuration"
+    class Configuration < Yell::Hash
+
+      # Creates a new Pokan::Cluster::Configuration object, containing the
+      # data passed. It can be either a usual Ruby hash or a String with your
+      # data, as long as you provide a parser which responds to the method
+      # +parse+ taking the string as parameter and returning the corresponding
+      # hash.
+      def initialize(data, parser=nil)
+        case data
+        when Object::Hash
+          @data = data
+        when String
+          @data = load_data(data, parser)
+        end
+
+        super(@data)
+      end
+
+      # Loads the data in case a string was passed in the initialization.
+      # It actually just calls the method +parse+ on the parser object
+      def load_data(data, parser)
+        parser.parse(data)
+      end
+
+      # Main method, used to query values from your configuration. It accepts
+      # as a parameter a string containing the "path" to reach the data you
+      # want.
+      #
+      #   h = { :max_connections => "10", :proto => { :tcp => true } }
+      #   c = Pokan::Cluster::Configuration.new(h)
+      #   c.get('max_connections') #=> "10"
+      #   c.get('proto.tcp')       #=> "true"
+      def get(query)
+        step = nil  # contains consequent results of our query
+        path = query.split '.'
+
+        path.each { |param| step = send(param.to_sym) }
+
+        step
+      rescue NoMethodError
+        nil
+      ensure
+        reload
+      end
+
+    end
+  end
+end

data/lib/pokan-cluster/log_messages.rb

@@ -0,0 +1,48 @@
+module Pokan
+  module Cluster
+
+    def self.m(string)
+      PreparedString.new(string)
+    end
+
+    LOG_MESSAGES = {
+      :start => { :debug => m("Address: %p\nTCP port: %p\nUDP port: %p\n
+                               Using epoll: %p\nGossip interval: %p seconds\n
+                               Seed address: %p\n\n
+                               Log level is %p\n. Logging to %p\n"),
+
+                  :info  => m('Server is starting at %p...')
+      },
+
+      :before_sync => { :debug => m("Starting Redis sync with seed on address %p, port %p"),
+                        :info  => m("Syncing databases...")
+      },
+
+      :after_sync => { :debug => m("Databases synced in %p seconds"),
+                       :info  => m("Done.")
+      },
+
+      :new_key => { :debug => m("Saving new key-value pair: %p:%p") },
+
+      :new_peer => { :debug => m("New peer detected at address %p:%p"), 
+                     :info  => m("New peer: %p") },
+
+      :key_changed => { :debug => m("Key %p changing from %p to %p") },
+
+      :key_removed => { :debug => m("Key %p was removed"),
+                        :info  => m("Peer at addres %p just left")
+      },
+
+      :before_gossip => { :debug => m("Preparing digest message for gossiping with %p (length: %p bytes)"),
+                          :info  => m("Sending gossip message to randomly selected peer (%p)")
+      },
+
+      :after_gossip => { :debug  => m("Gossip message sent") },
+
+      :shutdown     => m('Server is finishing...')
+
+    }.freeze
+  
+
+  end
+end

data/lib/pokan-cluster/prepared_string.rb

@@ -0,0 +1,59 @@
+module Pokan
+
+  module Cluster
+
+    # PreparedString is a class representing strings with marks, to be
+    # substituted later with specific values.
+    #
+    # Example
+    #
+    #   p = PreparedString.new('Hi %p, my name is %p')
+    #   p.with('John', 'James').string #=> "Hi John, my name is James"
+    #   p.string                       #=> "Hi %p, my name is %p"
+    #   p.with('John').string          #=> "Hi John, my name is %p"
+    #
+    # Useful for log messages.
+    class PreparedString
+
+      # Creates a new instance of your prepared string as the first argument.
+      # You can specify the token to be substituted when using PreparedString#with
+      # as the second argument. Default is `%p`
+      def initialize(string, token='%p')
+        @original, @token = string, token
+        @current  = copy @original
+        @changed  = false
+      end
+
+      # Retrieves the string content for the prepared string. If a substitution had
+      # already been done (using PreparedString#with), then the substitued string
+      # will be returned. Otherwise, the original string is returned.
+      def string
+        r_string = @changed ? @current : @original
+        @changed = false
+        @current = copy @original
+
+        r_string
+      end
+
+      # Allows you to specify the strings to be placed in the tokens
+      def with(*args)
+        @changed = true
+
+        args.each { |token|
+          @current.sub!(@token, token.to_s)
+        }
+
+        self
+      end
+
+    private
+
+      def copy(obj)
+        obj.dup
+      end
+
+    end
+
+  end
+
+end

data/lib/pokan-cluster/version.rb

@@ -0,0 +1,7 @@
+# lib/pokan-cluster/version.rb
+
+module Pokan
+  module Cluster
+    VERSION = "0.1"
+  end
+end

data/lib/server_configuration.rb

@@ -0,0 +1,119 @@
+# lib/pokan-cluster/server_configuration.rb
+module Pokan
+
+  ##
+  # Class used to store and manage server configuration.
+  # Should not be used by user code, just by the Pokan::Cluster
+  # class. It loads a YAML configuration file located in the user
+  # home directory or in the +.config+ directory or in +/etc/pokan.yml+. 
+  # Optionally, a different config file can be passed.
+  #
+  # === Usage
+  #   s = Pokan::ServerConfiguration.new("pokan.yml")
+  #   s.tcp_port #=> 8888 (depending on your configuration options)
+  #
+  # A general configuration file has the following skeleton:
+  #
+  #   pokan:
+  #     connection:
+  #       udp: 88885
+  #       tcp: 7777
+  #
+  #     seed: "10.10.10.8"
+  #
+  #     log:
+  #       enabled: true
+  #       log_file: "/var/log/pokan.log"
+  class ServerConfiguration
+
+    YAML_ROOT = 'pokan'
+
+    # Creates a new instance of Pokan::ServerConfiguration. 
+    # You can pass an optional parameter indicating the location
+    # of the configuration file (must be a valid YAML file)
+    #
+    # If no config file is passed, we first look if there is a +.pokan.yml+
+    # file in the user's home directory. If there isn't, then we search
+    # for a +.config/pokan/pokan.yml+. If none of these are found, then
+    # we set the default values (see Pokan::ServerConfiguration#set_defaults
+    # for further details) 
+    def initialize(config_file=nil)
+      @config_file = config_file || search_config
+
+      @config_file.nil? ? set_defaults : load_config(@config_file)
+    end
+
+    # Searches for a valid YAML configuration file in +.pokan.yml+
+    # located in the user's home directory or in +.config/pokan/pokan.yml'+,
+    # or in +/etc/pokan.yml+.
+    # Returns the file name, if found, or +nil+ if no configuration file was 
+    # found.
+    def search_config
+      home_file   = File.absolute_path '~/.pokan.yml'
+      config_file = File.absolute_path '~/.config/pokan/pokan.yml'
+      etc_file    = '/etc/pokan.yml'
+
+      [home_file, config_file, etc_file].each do |config|
+        return config if File.exists? config
+      end
+
+      nil
+    end
+    
+    # Returns +true+ if a configuration file was found, or if the user
+    # explicitly passed a file.
+    def has_config_file?
+      !@config_file.nil?
+    end
+
+    # Returns the absolute path of the configuration file, if any.
+    def file_path
+      @config_file
+    end
+
+    # Returns +true+ if we are logging activities on the server
+    def logging?
+      @logging
+    end
+
+    def load_config(config_file)
+      raise "YAML file not found: #{config_file}" unless File.exists? config_file
+
+      @data = YAML.load_file(config_file)
+      define_methods_for(@data[YAML_ROOT].keys)
+    end
+
+    # Sets the default values for all the attributes that can be set
+    # with the configuration file. These are:
+    # * TCP port: 5555
+    # * UDP port: 5555
+    # * no seeds information
+    # * logger enabled
+    # * log_file ./pokan.log
+    def set_defaults
+      @tcp_port   = 5555
+      @udp_port   = 5555
+      @seeds      = []
+      @logging    = true
+      @log_file   = './pokan.log'
+    end
+
+  private
+
+    # Defines methods in the singleton class for every key in the +keys+
+    # parameter
+    def define_methods_for(keys)
+      keys.each do |k|
+        singleton_class.send(:define_method, k) do
+          @data[YAML_ROOT][k]
+        end
+      end
+    end
+
+    def singleton_class
+      class << self; self; end
+    end
+
+  end
+
+end

data/pokan.log

@@ -0,0 +1,10 @@
+ INFO  pokan-cluster : New peer detected at address role
+ INFO  pokan-cluster : Sending gossip message to randomly selected peer ()
+ INFO  pokan-cluster : New peer detected at address role
+ INFO  pokan-cluster : Server is starting at 192.168.229.197...
+ INFO  pokan-cluster : New peer detected at address role
+ INFO  pokan-cluster : Server is starting at 192.168.229.197...
+ INFO  pokan-cluster : New peer detected at address role
+ INFO  pokan-cluster : Server is starting at 192.168.229.197...
+ INFO  pokan-cluster : Sending gossip message to randomly selected peer (10.10.10.8)
+ INFO  pokan-cluster : Server is starting at 192.168.229.197...

data/spec/pokan-cluster/autorunner_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../spec_helper'
+
+describe Pokan::Cluster::Autorunner do
+
+  subject { Pokan::Cluster::Autorunner }
+
+  it 'should register classes that include Pokan::Cluster' do
+    class DummyServer
+      include Pokan::Cluster
+    end
+
+    subject.server.should eq DummyServer
+  end
+end

data/spec/pokan-cluster/configuration_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper'
+
+describe Pokan::Cluster::Configuration do
+
+  let(:yaml) {
+    <<-END
+      connection:
+        udp: 8888
+        tcp: 8888
+
+      seed:
+        address: "10.10.10.8"
+        redis: 6379
+
+      log:
+        enabled: true
+        log_file: "/var/log/pokan" 
+    END
+  }
+
+  subject { 
+    parser = double('parser')
+    parser.stub! :parse => YAML.load(yaml)
+    Pokan::Cluster::Configuration.new(yaml, parser) 
+  }
+
+  it 'should retrieve all data' do
+    subject.get('connection.udp').should eq 8888
+    subject.get('connection.tcp').should eq 8888
+
+    subject.get('seed.address').should eq "10.10.10.8"
+    subject.get('seed.redis').should eq 6379
+
+    subject.get('log.enabled').should be_true
+    subject.get('log.log_file').should eq "/var/log/pokan"
+  end
+
+  it 'should return nil on non existent configuration' do
+    subject.get('log.levell').should be_nil
+  end
+
+
+
+end

data/spec/pokan-cluster/prepared_string_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe Pokan::Cluster::PreparedString do
+
+  let(:string) {
+    'A: %p, B: %p C:%p'
+  }
+
+  let(:prepared_string) {
+    Pokan::Cluster::PreparedString.new(string)
+  }
+
+  it 'should return the given string when no substitution is made' do
+    prepared_string.string.should eq string
+  end
+
+  it 'should return semi substituted string' do
+    prepared_string.with('dummy').string.should eq 'A: dummy, B: %p C:%p'
+  end
+
+  it 'should return fully substituted string' do
+    prepared_string.with('dummy', 'yummy', 'mummy').string.should eq 'A: dummy, B: yummy C:mummy'
+  end
+
+  it 'should return correctly substituted string when more arguments are passed' do
+    prepared_string.with('dummy', 'yummy', 'mummy', 'a', 'b', 'c').string.should eq 'A: dummy, B: yummy C:mummy'
+  end
+
+  it 'should return initial string after changes' do
+    prepared_string.with('dummy').string.should eq 'A: dummy, B: %p C:%p'
+    prepared_string.string.should eq string
+  end
+
+end

data/spec/pokan-cluster_spec.rb

@@ -0,0 +1,64 @@
+require_relative 'spec_helper'
+
+describe Pokan::Cluster do
+
+  subject { 
+    class MyPokan
+      include Pokan::Cluster
+
+      config {
+        YAML.parse(<<-END
+          pokan:
+
+            address: "10.10.10.7" 
+
+            connect:
+              tcp: 8888
+              udp: 8888
+              epoll: true
+
+            seed:
+              address: "10.10.10.1"
+              redis: 6379
+            
+            gossip:
+              every: 2
+
+            log:
+              enabled: true
+              level: "info"
+              file: "pokan.log"
+        END
+        ).to_ruby
+      }
+
+      self
+    end
+  }
+
+  context 'when all options are passed' do
+
+    it 'should properly initialize instance variables' do
+      subject.address.should eq '10.10.10.7'
+      
+      subject.tcp_port.should eq 8888
+      subject.udp_port.should eq 8888
+      subject.epoll.should be_true
+
+      subject.seed.should eq '10.10.10.1'
+
+      subject.gossip_interval.should eq 2
+
+      subject.logging.should be_true
+      subject.log_level.should eq :info
+      subject.log_file.should eq 'pokan.log'
+
+    end
+
+    it 'should delegate to the server instance' do
+      subject.use_epoll.should be_true
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'pokan-cluster'

data/test_server.rb

@@ -0,0 +1,17 @@
+require 'pokan-cluster'
+require 'yaml'
+
+class TestServer
+  include Pokan::Cluster
+
+  config { YAML.parse_file('/home/renato/pokan.yml').to_ruby }
+
+  after :sync do
+    puts "Synced!"
+  end
+
+  after :gossip do |addr, port|
+    puts "Gossiped with #{addr}:#{port}"
+  end
+
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: pokan-cluster
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Fabio Lima Pereira
+- Rafael Regis do Prado
+- Renato Mascarenhas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pokan
+  requirement: &4783360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *4783360
+- !ruby/object:Gem::Dependency
+  name: yagni
+  requirement: &4782660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *4782660
+- !ruby/object:Gem::Dependency
+  name: host
+  requirement: &4781960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *4781960
+description: ! "    pokan-cluster adds a handy set of functionalities on top of pokan,
+  everyone's\n    favorite Ruby Gossip protocol implementation. Logging, easy YAML
+  configuration\n    file, workload information of peers in your network (so that
+  you can write a\n    simple load balancer) are among the features pokan-cluster
+  has to offer!\n    Take a look at it and contribute! (see our Github page).\n"
+email: renato.mascosta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/pokan-cluster.rb
+- lib/pokan-cluster/autorunner.rb
+- lib/pokan-cluster/config_defaults.rb
+- lib/pokan-cluster/configuration.rb
+- lib/pokan-cluster/log_messages.rb
+- lib/pokan-cluster/prepared_string.rb
+- lib/pokan-cluster/version.rb
+- lib/server_configuration.rb
+- pokan.log
+- spec/pokan-cluster/autorunner_spec.rb
+- spec/pokan-cluster/configuration_spec.rb
+- spec/pokan-cluster/prepared_string_spec.rb
+- spec/pokan-cluster_spec.rb
+- spec/spec_helper.rb
+- test_server.rb
+homepage: http://github.com/rmascarenhas/pokan-cluster
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1258949825256661048
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: pokan-cluster is a set of neat, handy functionalities built on top of pokan.
+test_files: []