villein 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b6d36799ad957920fbb7b42d62b6e1bf148c70b
+  data.tar.gz: 375feb1e4a3da4b2febac8f08e3980a86916be03
+SHA512:
+  metadata.gz: c24bfe7a7a228c061a27d2beb0d2a9ad7b218a0e63d0d28d21cd2a57a00a60b39932976898ee962e690bdf554c656140131aaddd75016c923e711dafdefe990a
+  data.tar.gz: c85805cc00f7f680fc75c674bf537a2b35552301c5bc631bd26058e0d39458dd096b5b83c9879ad379fbbd5241112292f4dace6f706f80cc1b595d9d298d16ca

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+cache: bundler
+rvm:
+  - "2.1.1"
+  - "2.0.0"
+  - "2.1.0"
+  - "ruby-head"
+
+matrix:
+  allow_failures:
+    - rvm:
+      - "2.1.0"
+      - "ruby-head"
+  fast_finish: true
+notifications:
+  email:
+    - travis-ci@sorah.jp
+before_script:
+  - mkdir -p vendor/serf
+  - curl -o vendor/serf/serf.zip https://dl.bintray.com/mitchellh/serf/0.5.0_linux_amd64.zip
+  - unzip -d vendor/serf vendor/serf/serf.zip
+  - export PATH=$PWD/vendor/serf:$PATH
+script: bundle exec rspec -fd ./spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in villein.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Shota Fukumori (sora_h)
+
+MIT License
+
+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.md

@@ -0,0 +1,149 @@
+# Villein - Use `serf` from Ruby
+
+Use [serf](https://www.serfdom.io/) from Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'villein'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install villein
+
+## Requirements
+
+- Ruby 2.0.0+
+
+## Usage
+
+### Use for existing `serf agent`
+
+``` ruby
+require 'villein'
+
+# You have to tell RPC address and node name.
+client = Villein::Client.new('localhost:7373', name: 'testnode')
+```
+
+### Start new `serf agent` then use
+
+``` ruby
+require 'villein'
+
+client = Villein::Agent.new
+
+# Start the agent
+client.start!
+
+# Stop the agent
+client.stop!
+
+# Inspect the status
+p client.running?
+p client.stopped?
+
+# You can specify many options to Agent.new...
+# :node, :rpc_addr, :bind, :iface, :advertise, :discover,
+# :config_file, :config_dir, :discover, :join, :snapshot, :encrypt, :profile,
+# :protocol, :event_handlers, :replay, :tags, :tags_file, :log_level
+```
+
+### join and leave
+
+``` ruby
+client.join('x.x.x.x')
+client.join('x.x.x.x', replay: true)
+client.leave()
+client.force_leave('other-node')
+```
+
+### Sending user events
+
+``` ruby
+# Send user event
+client.event('my-event', 'payload')
+client.event('my-event', 'payload', coalesce: true)
+```
+
+### Retrieve member list
+
+``` ruby
+# Retrieve member list
+client.members
+# =>
+#   [
+#     {
+#      "name"=>"testnode", "addr"=>"192.168.101.157:7946", "port"=>7946,
+#      "tags"=>{}, "status"=>"alive",
+#      "protocol"=>{"max"=>4, "min"=>2, "version"=>4}
+#     }
+#   ]
+
+# You can use some filters.
+# The filters will be passed `serf members` command directly, so be careful
+# to escape regexp-like strings!
+client.members(name: 'foo')
+client.members(status: 'alive')
+client.members(tags: {foo: 'bar'})
+```
+
+### (Agent only) hook events
+
+``` ruby
+agent = Villein::Agent.new
+agent.start!
+
+agent.on_member_join do |event|
+  p event # => #<Villein::Event>
+  p event.type # => 'member-join'
+  p event.self_name
+  p event.self_tags # => {"TAG1" => 'value1'}
+  p event.members # => [{name: "the-node", address:, tags: {tag1: 'value1'}}]
+  p event.user_event # => 'user'
+  p event.query_name
+  p event.ltime
+  p event.payload #=> "..."
+end
+
+agent.on_member_leave { |event| ... }
+agent.on_member_failed { |event| ... }
+agent.on_member_update { |event| ... }
+agent.on_member_reap { |event| ... }
+agent.on_user_event { |event| ... }
+agent.on_query { |event| ... }
+
+# Catch any events
+agent.on_event { |event| p event }
+
+# Catch the agent stop
+agent.on_event { |status|
+  # `status` will be a Process::Status, on unexpectedly exits.
+  p status
+}
+```
+
+## Advanced
+
+TBD
+
+### Specifying location of `serf` command
+
+### Logging `serf agent`
+
+## FAQ
+
+### Why I have to tell node name?
+
+## Contributing
+
+1. Fork it ( https://github.com/sorah/villein/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+  rdoc.rdoc_dir = "#{__dir__}/doc"
+end

data/lib/villein/agent.rb

@@ -0,0 +1,256 @@
+require 'socket'
+require 'timeout'
+require 'thread'
+require 'villein/client'
+require 'villein/event'
+
+module Villein
+  ##
+  # Villein::Agent allows you to start new serf agent.
+  # Use this when you need to start and manage the serf agents from ruby process.
+  class Agent < Client
+    class AlreadyStarted < Exception; end
+    class NotRunning < Exception; end
+
+    EVENT_HANDLER_SH = File.expand_path(File.join(__dir__, '..', '..', 'misc', 'villein-event-handler'))
+
+    def initialize(serf: 'serf',
+                   node: Socket.gethostname,
+                   rpc_addr: '127.0.0.1:7373', bind: nil, iface: nil, advertise: nil,
+                   config_file: nil, config_dir: nil,
+                   discover: false, join: nil, snapshot: nil,
+                   encrypt: nil, profile: nil, protocol: nil,
+                   event_handlers: [], replay: nil,
+                   tags: {}, tags_file: nil,
+                   log_level: :info, log: File::NULL)
+      @serf = serf
+      @name = node
+      @rpc_addr = rpc_addr
+      @bind, @iface, @advertise = bind, iface, advertise
+      @config_file, @config_dir = config_file, config_dir
+      @discover, @join, @snapshot = discover, join, snapshot
+      @encrypt, @profile, @protocol = encrypt, profile, protocol
+      @custom_event_handlers, @replay = event_handlers, replay
+      @initial_tags, @tags_file = tags, tags_file
+      @log_level, @log = log_level, log
+      @hooks = {}
+
+      @pid, @exitstatus = nil, nil
+      @pid_lock = Mutex.new
+    end
+
+    attr_reader :pid, :exitstatus
+
+    ##
+    # Returns true when the serf agent has started
+    def started?
+      !!@pid
+    end
+
+    ##
+    # Returns true when the serf agent has started, but stopped for some reason.
+    # Use Agent#exitstatus to get <code>Process::Status</code> object.
+    def dead?
+      !!@exitstatus
+    end
+
+    ##
+    # Returns true when the serf agent is running (it has started and not dead yet).
+    def running?
+      started? && !dead?
+    end
+
+    # Start the serf agent.
+    def start!
+      raise AlreadyStarted if running?
+
+      @pid_lock.synchronize do
+        start_listening_events
+        start_process
+        start_watchdog
+      end
+    end
+
+    ##
+    # Stop the serf agent.
+    # After +timeout_sec+ seconds elapsed, it will attempt to KILL if the agent is still running.
+    def stop!(timeout_sec = 10)
+      raise NotRunning unless running?
+
+      @pid_lock.synchronize do
+        Process.kill(:INT, @pid)
+
+        stop_watchdog
+        call_hooks 'stop', nil
+
+        kill_process(timeout_sec)
+
+        stop_listening_events
+
+        @pid = nil
+      end
+    end
+
+    ##
+    # Add +at_exit+ hook to safely stop at exit of current ruby process.
+    # Note that +Kernel#.at_exit+ hook won't run when Ruby has crashed.
+    def auto_stop
+      at_exit { self.stop! }
+    end
+
+    %w(member_join member_leave member_failed member_update member_reap
+       user_event query stop event).each do |event|
+
+      define_method(:"on_#{event}") do |&block|
+        add_hook(event, block)
+      end
+    end
+
+    ##
+    # Command line arguments to start serf-agent.
+    def command
+      cmd = [@serf, 'agent']
+
+      cmd << ['-node', @name] if @name
+      cmd << '-replay' if @replay
+      cmd << '-discover' if @discover
+
+      @initial_tags.each do |key, val|
+        cmd << ['-tag', "#{key}=#{val}"]
+      end
+
+      cmd << [
+        '-event-handler',
+        [EVENT_HANDLER_SH, *event_listener_addr].join(' ')
+      ]
+
+      @custom_event_handlers.each do |handler|
+        cmd << ['-event-handler', handler]
+      end
+
+      %w(bind iface advertise config-file config-dir
+         encrypt join log-level profile protocol rpc-addr
+         snapshot tags-file).each do |key|
+
+        val = instance_variable_get("@#{key.gsub(/-/,'_')}")
+        cmd << ["-#{key}", val] if val
+      end
+
+      cmd.flatten.map(&:to_s)
+    end
+
+    private
+
+    def start_process
+      @exitstatus = nil
+
+      actual = -> { @pid = spawn(*command, out: @log, err: @log) }
+
+      if defined? Bundler
+        Bundler.with_clean_env(&actual)
+      else
+        actual.call
+      end
+    end
+
+    def kill_process(timeout_sec = 10)
+      begin
+        begin
+          timeout(timeout_sec) { Process.waitpid(@pid) }
+        rescue Timeout::Error
+          Process.kill(:KILL, @pid)
+        end
+      rescue Errno::ECHILD
+      end
+    end
+
+    def start_watchdog
+      return if @watchdog && @watchdog.alive?
+
+      @watchdog = Thread.new do
+        pid, @exitstatus = Process.waitpid2(@pid)
+        call_hooks(:stop, @exitstatus)
+      end
+    end
+
+    def stop_watchdog
+      @watchdog.kill if @watchdog && @watchdog.alive?
+    end
+
+    def event_listener_addr
+      raise "event listener not started [BUG]" unless @event_listener_server
+
+      addr = @event_listener_server.addr
+      [addr[-1], addr[1]]
+    end
+
+    def start_listening_events
+      return if @event_listener_thread
+
+      @event_listener_server = TCPServer.new('localhost', 0)
+      @event_listener_thread = Thread.new do
+        event_listener_loop
+      end
+    end
+
+    def stop_listening_events
+      if @event_listener_thread && @event_listener_thread.alive?
+        @event_listener_thread.kill
+      end
+
+      if @event_listener_server && !@event_listener_server.closed?
+        @event_listener_server.close
+      end
+
+      @event_listener_thread = nil
+      @event_listener_server = nil
+    end
+
+    def event_listener_loop
+      while sock = @event_listener_server.accept
+        Thread.new do
+          begin
+            buf = ""
+            loop do
+              socks, _, _ = IO.select([sock], nil, nil, 5)
+              break unless socks
+
+              socks[0].read_nonblock(1024, buf)
+              break if socks[0].eof?
+            end
+
+            handle_event buf
+          ensure
+            sock.close unless sock.closed?
+          end
+        end
+      end
+    end
+
+    def handle_event(json)
+      event_payload = JSON.parse(json)
+      event = Event.new(event_payload['env'], payload: event_payload['input'])
+
+      call_hooks event.type.gsub(/-/, '_'), event
+      call_hooks 'event', event
+    rescue JSON::ParserError
+      # do nothing
+    end
+
+    def hooks_for(name)
+      @hooks[name.to_s] ||= []
+    end
+
+    def call_hooks(name, *args)
+      hooks_for(name).each do |hook|
+        hook.call(*args)
+      end
+      nil
+    end
+
+    def add_hook(name, block)
+      hooks_for(name) << block
+    end
+  end
+end
+

data/lib/villein/client.rb

@@ -0,0 +1,107 @@
+require 'json'
+require 'villein/tags'
+
+module Villein
+  ##
+  # Villein::Client allows you to order existing serf agent.
+  # You will need RPC address and agent name to command.
+  class Client
+    def initialize(rpc_addr, name: nil, serf: 'serf', silence: true)
+      @rpc_addr = rpc_addr
+      @name = name
+      @serf = serf
+      @silence = true
+    end
+
+    def silence?() !!@silence; end
+    attr_writer :silence
+
+    attr_reader :name, :rpc_addr, :serf
+
+    def event(name, payload, coalesce: true)
+      options = []
+
+      unless coalesce
+        options << '-coalesce=false'
+      end
+
+      call_serf 'event', *options, name, payload
+    end
+
+    def join(addr, replay: false)
+      options = []
+
+      if replay
+        options << '-replay'
+      end
+
+      call_serf 'join', *options, addr
+    end
+
+    def leave
+      call_serf 'leave'
+    end
+
+    def force_leave(node)
+      call_serf 'force-leave', node
+    end
+
+    def members(status: nil, name: nil, tags: {})
+      options = ['-format', 'json']
+
+      options.push('-status', status.to_s) if status
+      options.push('-name', name.to_s) if name
+
+      tags.each do |tag, val|
+        options.push('-tag', "#{tag}=#{val}")
+      end
+
+      json = IO.popen(['serf', 'members', "-rpc-addr=#{rpc_addr}", *options], 'r', &:read)
+      response = JSON.parse(json)
+
+      response["members"]
+    end
+
+    ##
+    # Returns Villein::Tags object for the current agent.
+    # Villein::Tags provides high-level API for tagging agents.
+    def tags
+      @tags ||= Tags.new(self)
+    end
+
+    ##
+    # Get tag from the agent.
+    # Using Villein::Client#tags method is recommended. It provides high-level API via +Villein::Tags+.
+    def get_tags
+      me = members(name: self.name)[0]
+      me["tags"]
+    end
+
+    ##
+    # Remove tag from the agent.
+    # Using Villein::Client#tags method is recommended. It provides high-level API via +Villein::Tags+.
+    def delete_tag(key)
+      call_serf 'tags', '-delete', key
+    end
+
+    ##
+    # Set tag to the agent.
+    # Using Villein::Client#tags method is recommended. It provides high-level API via +Villein::Tags+.
+    def set_tag(key, val)
+      call_serf 'tags', '-set', "#{key}=#{val}"
+    end
+
+    private 
+
+    def call_serf(cmd, *args)
+      options = {}
+
+      if silence?
+        options[:out] = File::NULL
+        options[:err] = File::NULL
+      end
+
+      system @serf, cmd, "-rpc-addr=#{rpc_addr}", *args, options
+    end
+  end
+end

data/lib/villein/event.rb

@@ -0,0 +1,73 @@
+module Villein
+  class Event
+    MEMBERS_EVENT = %w(member-join member-leave member-failed member-update member-reap)
+
+    def initialize(env={}, payload: nil)
+      @type = env['SERF_EVENT']
+      @self_name = env['SERF_SELF_NAME']
+      @self_tags = Hash[env.select{ |k, v| /^SERF_TAG_/ =~ k }.map { |k, v| [k.sub(/^SERF_TAG_/, ''), v] }]
+      @user_event = env['SERF_USER_EVENT']
+      @query_name = env['SERF_QUERY_NAME']
+      @user_ltime = env['SERF_USER_LTIME']
+      @query_ltime = env['SERF_QUERY_LTIME']
+      @payload = payload
+    end
+
+    attr_reader :type, :self_name, :self_tags, :user_event, :query_name, :user_ltime, :query_ltime, :payload
+
+    def ltime
+      user_ltime || query_ltime
+    end
+
+    ##
+    # Parse and returns member list in Array<Hash> when available.
+    # Always return +nil+ if the event type is not +member-*+.
+    def members
+      return nil unless MEMBERS_EVENT.include?(type)
+      @members ||= begin
+        payload.each_line.map do |line|
+          name, address, _, tags_str = line.chomp.split(/\t/)
+          {name: name, address: address, tags: parse_tags(tags_str || '')}
+        end
+      end
+    end
+
+    private
+
+    def parse_tags(str)
+      # "aa=b=,,c=d,e=f,g,h,i=j" => {"aa"=>"b=,", "c"=>"d", "e"=>"f,g,h", "i"=>"j"}
+      tokens = str.scan(/(.+?)([,=]|\z)/).flatten
+
+      pairs = []
+      stack = []
+
+      while token = tokens.shift
+        case token
+        when "="
+          stack << token
+        when ","
+          stack << token
+
+          if tokens.first != ',' && 2 <= stack.size
+            pairs << stack.dup
+            stack.clear
+          end
+        else
+          stack << token
+        end
+      end
+      pairs << stack.dup unless stack.empty?
+
+      pairs = pairs.inject([]) { |r, pair|
+        if !pair.find{ |_| _ == '='.freeze } && r.last
+          r.last.push(*pair) 
+          r
+        else
+          r << pair
+        end
+      }
+      pairs.each(&:pop)
+      Hash[pairs.map{ |_| _.join.split(/=/,2) }]
+    end
+  end
+end

data/lib/villein/tags.rb

@@ -0,0 +1,57 @@
+module Villein
+  class Tags
+    def initialize(client) # :nodoc:
+      @client = client
+      reload
+    end
+
+    ##
+    # Set tag of the agent.
+    def []=(key, value)
+      if value
+        key = key.to_s
+        value = value.to_s
+        @client.set_tag(key, value)
+        @tags[key] = value
+      else
+        self.delete key.to_s
+      end
+    end
+
+    ##
+    # Returns tag of the agent.
+    # Note that this method is cached, you have to call +reload+ method to flush them.
+    def [](key)
+      @tags[key.to_s]
+    end
+
+    ##
+    # Remove tag from the agent.
+    def delete(key)
+      key = key.to_s
+
+      @client.delete_tag key
+      @tags.delete key
+
+      nil
+    end
+
+    def inspect
+      "#<Villein::Tags #{@tags.inspect}>"
+    end
+
+    ##
+    # Returns +Hash+ of tags.
+    def to_h
+      # duping
+      Hash[@tags.map{ |k,v| [k,v] }]
+    end
+
+    ##
+    # Reload tags of the agent.
+    def reload
+      @tags = @client.get_tags
+      self
+    end
+  end
+end

data/lib/villein/version.rb

@@ -0,0 +1,3 @@
+module Villein
+  VERSION = "0.0.1"
+end

data/lib/villein.rb

@@ -0,0 +1,8 @@
+require "villein/version"
+
+module Villein
+  # Your code goes here...
+end
+
+require 'villein/client'
+require 'villein/agent'

data/misc/villein-event-handler

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec ruby -rsocket -rjson -e'TCPSocket.new(ARGV[0], ARGV[1].to_i).puts({env: Hash[ENV.select{|k,v|/SERF/ =~ k}], input: $stdin.read}.to_json)' -- $*

data/spec/agent_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'villein/client'
+
+require 'villein/agent'
+
+describe Villein::Agent do
+  it "inherits Villein::Client" do
+    expect(described_class.ancestors).to include(Villein::Client)
+  end
+
+  let(:bind)     { ENV["VILLEIN_TEST_BIND"]     || "127.0.0.1:17946" }
+  let(:rpc_addr) { ENV["VILLEIN_TEST_RPC_ADDR"] || "127.0.0.1:17373" }
+
+  subject(:agent) { described_class.new(rpc_addr: rpc_addr, bind: bind) }
+
+  before do
+    @pids = []
+    allow(agent).to(receive(:spawn) { |*args|
+      pid = Kernel.spawn(*args)
+      @pids << pid
+      pid
+    })
+  end
+
+  after do
+    @pids.each do |pid|
+      begin
+        begin
+          timeout(5) { Process.waitpid(pid) }
+        rescue Timeout::Error
+          Process.kill(:KILL, pid)
+        end
+      rescue Errno::ECHILD, Errno::ESRCH
+      end
+    end
+  end
+
+  it "can start and stop workers" do
+    received = nil
+    agent.on_stop { |arg| received = [true, arg] }
+
+    agent.start!
+
+    expect(agent.dead?).to be_false
+    expect(agent.running?).to be_true
+    expect(agent.started?).to be_true
+    expect(agent.pid).to be_a(Fixnum)
+
+    agent.stop!
+
+    expect(agent.dead?).to be_false
+    expect(agent.running?).to be_false
+    expect(agent.started?).to be_false
+    expect(agent.pid).to be_nil
+
+    expect(received).to eq [true, nil]
+  end
+
+  it "can receive events" do
+    received1, received2 = nil, nil
+
+    agent.on_event { |e| received1 = e }
+    agent.on_member_join { |e| received2 = e }
+
+    agent.start!
+    20.times { break if received1; sleep 0.1 }
+    agent.stop!
+
+    expect(received1).to be_a(Villein::Event)
+    expect(received2).to be_a(Villein::Event)
+    expect(received1.type).to eq 'member-join'
+    expect(received2.type).to eq 'member-join'
+  end
+
+  it "can handle unexpected stop" do
+    received = nil
+    agent.on_stop { |status| received = status }
+
+    agent.start!
+    Process.kill(:KILL, agent.pid)
+
+    20.times { break if received; sleep 0.1 }
+    expect(agent.dead?).to be_true
+    expect(agent.running?).to be_false
+    expect(agent.started?).to be_true
+    expect(received).to be_a_kind_of(Process::Status)
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'villein/client'
+
+describe Villein::Client do
+  let(:name) { 'the-node' }
+  subject(:client) { described_class.new('x.x.x.x:nnnn', name: name) }
+
+  def expect_serf(cmd, *args, retval: true, out: File::NULL)
+    expect(subject).to receive(:system) \
+      .with('serf', cmd, '-rpc-addr=x.x.x.x:nnnn', *args, out: out, err: out) \
+      .and_return(retval)
+  end
+
+  describe "#event" do
+    it "sends user event" do
+      expect_serf('event', 'test', 'payload')
+
+      client.event('test', 'payload')
+    end
+
+    context "with coalesce=false" do
+      it "sends user event with the option" do
+        expect_serf('event', '-coalesce=false', 'test', 'payload')
+
+        client.event('test', 'payload', coalesce: false)
+      end
+    end
+  end
+
+  describe "#join" do
+    it "attempts to join another node" do
+      expect_serf('join', 'y.y.y.y:nnnn')
+
+      client.join('y.y.y.y:nnnn')
+    end
+
+    context "with replay=true" do
+      it "attempts to join another node with replaying" do
+        expect_serf('join', '-replay', 'y.y.y.y:nnnn')
+
+        client.join('y.y.y.y:nnnn', replay: true)
+      end
+    end
+  end
+
+  describe "#leave" do
+    it "attempts to leave from cluster" do
+      expect_serf('leave')
+
+      client.leave
+    end
+  end
+
+  describe "#force_leave" do
+    it "attempts to remove member forcely" do
+      expect_serf('force-leave', 'the-node')
+
+      client.force_leave('the-node')
+    end
+  end
+
+  describe "#members" do
+    let(:json) { (<<-EOJ).gsub(/\n|\s+/,'') }
+    {"members":[{"name":"the-node","addr":"a.a.a.a:mmmm","port": 7948,
+    "tags":{"key":"val"},"status":"alive","protocol":{"max":4,"min":2,"version":4}}]}
+    EOJ
+
+    it "returns member list" do
+      allow(IO).to receive(:popen).with(%w(serf members -rpc-addr=x.x.x.x:nnnn -format json), 'r') \
+        .and_yield(double('io', read: json))
+
+      expect(client.members).to be_a_kind_of(Array)
+      expect(client.members[0]["name"]).to eq "the-node"
+    end
+
+    context "with status filter" do
+      it "returns member list" do
+        allow(IO).to receive(:popen).with(%w(serf members -rpc-addr=x.x.x.x:nnnn -format json -status alive), 'r') \
+          .and_yield(double('io', read: json))
+
+        client.members(status: :alive)
+      end
+    end
+
+    context "with name filter" do
+      it "returns member list" do
+        allow(IO).to receive(:popen).with(%w(serf members -rpc-addr=x.x.x.x:nnnn -format json -name node), 'r') \
+          .and_yield(double('io', read: json))
+
+        client.members(name: 'node')
+      end
+    end
+
+    context "with tag filter" do
+      it "returns member list" do
+        allow(IO).to receive(:popen).with(%w(serf members -rpc-addr=x.x.x.x:nnnn -format json -tag a=1 -tag b=2), 'r') \
+          .and_yield(double('io', read: json))
+
+        client.members(tags: {a: '1', b: '2'})
+      end
+    end
+  end
+
+  describe "#tags" do
+    before do
+      allow(client).to receive(:get_tags).and_return('a' => 'b')
+    end
+
+    it "returns Villein::Tags" do
+      expect(client.tags).to be_a(Villein::Tags)
+      expect(client.tags['a']).to eq 'b'
+    end
+
+    it "memoizes" do
+      expect(client.tags.__id__ == client.tags.__id__).to be_true
+    end
+  end
+
+  describe "#set_tag" do
+    it "sets tag" do
+      expect_serf('tags', '-set', 'newkey=newval')
+
+      client.set_tag('newkey', 'newval')
+    end
+  end
+
+  describe "#delete_tag" do
+    it "deletes tag" do
+      expect_serf('tags', '-delete', 'newkey')
+
+      client.delete_tag('newkey')
+    end
+  end
+
+  describe "#get_tags" do
+    subject(:tags) { client.get_tags }
+
+    it "retrieves using #member(name: )" do
+      json = (<<-EOJ).gsub(/\n|\s+/,'')
+        {"members":[{"name":"the-node","addr":"a.a.a.a:mmmm","port": 7948,
+        "tags":{"key":"val"},"status":"alive","protocol":{"max":4,"min":2,"version":4}}]}
+      EOJ
+
+      allow(IO).to receive(:popen).with(%w(serf members -rpc-addr=x.x.x.x:nnnn -format json -name the-node), 'r') \
+        .and_yield(double('io', read: json))
+
+      expect(tags).to be_a_kind_of(Hash)
+      expect(tags['key']).to eq 'val'
+    end
+
+    context "without name" do
+      let(:name) { nil }
+
+      it "raises error" do
+        expect { tags }.to raise_error
+      end
+    end
+  end
+end
+

data/spec/event_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'villein/event'
+
+describe Villein::Event do
+  it "holds event variables" do
+    event = Villein::Event.new(
+      'SERF_EVENT'       => 'type',
+      'SERF_SELF_NAME'   => 'self_name',
+      'SERF_TAG_key'     => 'val',
+      'SERF_TAG_key2'    => 'val2',
+      'SERF_USER_EVENT'  => 'user_event',
+      'SERF_QUERY_NAME'  => 'query_name',
+      'SERF_USER_LTIME'  => 'user_ltime',
+      'SERF_QUERY_LTIME' => 'query_ltime',
+      payload: 'payload',
+    )
+
+    expect(event.type).to eq 'type'
+    expect(event.self_name).to eq 'self_name'
+    expect(event.self_tags).to eq('key' => 'val', 'key2' => 'val2')
+    expect(event.user_event).to eq 'user_event'
+    expect(event.query_name).to eq 'query_name'
+    expect(event.user_ltime).to eq 'user_ltime'
+    expect(event.query_ltime).to eq 'query_ltime'
+    expect(event.payload).to eq 'payload'
+  end
+
+  describe "#ltime" do
+    it "returns user_ltime or query_ltime" do
+      expect(described_class.new('SERF_USER_LTIME' => nil, 'SERF_QUERY_LTIME' => '2').ltime).to eq '2'
+      expect(described_class.new('SERF_USER_LTIME' => '1', 'SERF_QUERY_LTIME' => nil).ltime).to eq '1'
+      expect(described_class.new('SERF_USER_LTIME' => '1', 'SERF_QUERY_LTIME' => '2').ltime).to eq '1'
+    end
+  end
+
+  describe "#members" do
+    context "when event is member-*" do
+      let(:payload) {  "the-node\tX.X.X.X\t\tkey=val,a=b\nanother-node\tY.Y.Y.Y\t\tkey=val,a=b\n" }
+      subject(:event) { Villein::Event.new('SERF_EVENT' => 'member-join', payload: payload) }
+
+      it "parses member list" do
+        expect(event.members).to be_a_kind_of(Array)
+        expect(event.members.size).to eq 2
+        expect(event.members[0]).to eq(name: 'the-node', address: 'X.X.X.X', tags: {'key' => 'val', 'a' => 'b'})
+        expect(event.members[1]).to eq(name: 'another-node', address: 'Y.Y.Y.Y', tags: {'key' => 'val', 'a' => 'b'})
+      end
+
+      context "with confused tags" do
+        let(:payload) { "the-node\tX.X.X.X\t\taa=b=,,c=d,e=f,g,h,i=j\n" }
+
+        it "parses greedily" do
+          expect(event.members[0][:tags]).to eq("aa"=>"b=,", "c"=>"d", "e"=>"f,g,h", "i"=>"j")
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/tags_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'villein/tags'
+
+describe Villein::Tags do
+  let(:parent) { double('parent', get_tags: {'a' => '1'}) }
+  subject(:tags) { described_class.new(parent) }
+
+  describe "#[]" do
+    it "returns value for key in Symbol" do
+      expect(tags[:a]).to eq '1'
+    end
+
+    it "returns value for key in String" do
+      expect(tags['a']).to eq '1'
+    end
+  end
+
+  describe "#[]=" do
+    it "sets value for key in Symbol, using parent#set_tag" do
+      expect(parent).to receive(:set_tag).with('b', "1").and_return('1')
+
+      tags['b'] = 1
+
+      expect(tags['b']).to eq '1'
+    end
+
+    it "sets value for key in String, using parent#set_tag" do
+      expect(parent).to receive(:set_tag).with('b', "1").and_return('1')
+
+      tags[:b] = 1
+
+      expect(tags[:b]).to eq '1'
+    end
+
+    context "with nil" do
+      it "deletes key" do
+        expect(tags).to receive(:delete).with('b')
+        tags[:b] = nil
+      end
+    end
+  end
+
+  describe "#delete" do
+    it "deletes key, using parent#delete_tag" do
+      expect(parent).to receive(:delete_tag).with('a')
+      tags.delete :a
+      expect(tags[:a]).to be_nil
+    end
+  end
+
+  describe "#to_h" do
+    it "returns hash" do
+      expect(tags.to_h).to eq('a' => '1')
+    end
+  end
+
+  describe "#reload" do
+    it "retrieves latest tag using parent#get_tags" do
+      tags # init
+      allow(parent).to receive(:get_tags).and_return('new' => 'tag')
+
+      expect {
+        tags.reload
+      }.to change { tags['new'] } \
+       .from(nil).to('tag')
+    end
+  end
+end

data/villein.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'villein/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "villein"
+  spec.version       = Villein::VERSION
+  spec.authors       = ["Shota Fukumori (sora_h)"]
+  spec.email         = ["sorah@cookpad.com", "her@sorah.jp"]
+  spec.summary       = %q{Use `serf` (serfdom.io) from Ruby.}
+  spec.description   = %q{Use serf (http://www.serfdom.io/) from Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec", "2.14.1"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rdoc"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: villein
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shota Fukumori (sora_h)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use serf (http://www.serfdom.io/) from Ruby.
+email:
+- sorah@cookpad.com
+- her@sorah.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/villein.rb
+- lib/villein/agent.rb
+- lib/villein/client.rb
+- lib/villein/event.rb
+- lib/villein/tags.rb
+- lib/villein/version.rb
+- misc/villein-event-handler
+- spec/agent_spec.rb
+- spec/client_spec.rb
+- spec/event_spec.rb
+- spec/spec_helper.rb
+- spec/tags_spec.rb
+- villein.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Use `serf` (serfdom.io) from Ruby.
+test_files:
+- spec/agent_spec.rb
+- spec/client_spec.rb
+- spec/event_spec.rb
+- spec/spec_helper.rb
+- spec/tags_spec.rb