serfx 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3bb17715c2ea3ee4ecb6de764132ba68b69c1c8
-  data.tar.gz: 53c8a46a3907a5218a2a8fe9d7eb66807ae39bb2
+  metadata.gz: 8fc4921d5134cf839d21cf4ad57a23cb55147359
+  data.tar.gz: cb1047f5ff43db315934db351ee08aa7b1518820
 SHA512:
-  metadata.gz: 5dcf2af95c0d178c401604c93954d10772ae769e068f64d1647721c6bda12714de7c39b2398a777396f1e30635563525f22ad27878349a1dcfd34fe0cc412f1b
-  data.tar.gz: 61466ce03edfecc3697c8650841695bd58d7c32f36d48f33884d7fe98a0d2326c78d6ab6b0a78f011f32bc86fc4c61cb6501dfe53b34b0d96a94d3848a4ac39f
+  metadata.gz: b4146f8211e7c20e55a1f12ca2ada7a94b1a615221ae7e83a4563c8c380ef2c54002293ecb1993df2b5064512a2ba1ba3adf403f25e5594f00525e114aebe4fd
+  data.tar.gz: e123d303f6af8433a93f8c65ced93d5c5241c5958edd1046fec63fbda950f4c383683241ade956ad1f3fb1eae69a98866b8e720096f966f45fabc9530e19c5d7

data/.travis.yml

@@ -9,7 +9,7 @@ rvm:
 branches:
   only:
     - master
-script: "CODE_COVERAGE=1 bundle exec rake spec"
+script: "bundle exec rake spec"
 addons:
   code_climate:
     repo_token: 894a7a896e5ac4a4e7e497051fbc68152f348989a5b930cc3a037c713cf63df0 

data/Gemfile

@@ -4,5 +4,4 @@ gemspec
 group :development do
   gem 'irbtools'
   gem 'pry'
-  gem 'codeclimate-test-reporter', group: :test, require: nil
 end

data/lib/serfx/commands.rb

@@ -167,5 +167,36 @@ module Serfx
     def respond(id, payload)
       request(:respond, 'ID' => id, 'Payload' => payload)
     end
+
+    # install a new encryption key onto the cluster's keyring
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def install_key(key)
+      request(:install_key, 'Key' => key)
+    end
+
+    # change the primary key, which is used to encrypt messages
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def use_key(key)
+      request(:use_key, 'Key' => key)
+    end
+
+    # remove a key from the cluster's keyring
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def remove_key(key)
+      request(:remove_key, 'Key' => key)
+    end
+
+    # return a list of all encryption keys currently in use on the cluster
+    #
+    # @return  [Response]
+    def list_keys
+      request(:list_keys)
+    end
   end
 end

data/lib/serfx/connection.rb

@@ -27,7 +27,11 @@ module Serfx
       stop:             [:header],
       leave:            [:header],
       query:            [:header],
-      respond:          [:header]
+      respond:          [:header],
+      install_key:      [:header, :body],
+      use_key:          [:header, :body],
+      remove_key:       [:header, :body],
+      list_keys:        [:header, :body]
       }
 
     include Serfx::Commands

data/lib/serfx/utils/async_job.rb

@@ -0,0 +1,171 @@
+# encoding: UTF-8
+
+require 'json'
+module Serfx
+  module Utils
+
+    # serf event handler invocations are blocking calls. i.e. serf
+    # will not process any other event when a handler invocation is
+    # in progress. due to this limitations long running tasks can not be
+    # orchestrated or invoked as serf handler directly.
+    # [AsynchJob] address this by spawning the task as a background job,
+    # allowing the handler code to return immediately. It does double fork
+    # where the first child process is detached (attached to init as parent
+    # process) and spawn the second child process with the target,
+    # long running task. This allows the parent process to wait and reap the
+    # output of target task and save it in disk so that it can be exposed
+    # via other serf events
+    #
+    # @example
+    #   require 'serfx/utils/async_job'
+    #   require 'serfx/utils/handler'
+    #
+    #   job = Serfx::Utils::AsyncJob.new(
+    #     name: "bash_test"
+    #     command: "bash -c 'for i in `seq 1 3`; do echo $i; sleep 1; done'",
+    #     state: '/opt/serf/states/long_task'
+    #     )
+    #
+    #   on :query, 'task_fire' do |event|
+    #     puts job.run
+    #   end
+    #
+    #   on :query, 'task_check' do |event|
+    #     puts job.state_info.inspect
+    #   end
+    #
+    #   on :query, 'task_kill' do |event|
+    #     puts job.kill
+    #   end
+    #
+    #   on :query, 'task_reap' do |event|
+    #     puts job.reap
+    #   end
+    #
+    #   run
+    class AsyncJob
+
+      attr_reader :command, :state_file, :stdout_file, :stderr_file
+
+      # @param opts [Hash] specify the job details
+      # @option opts [Symbol] :state file path which will be used to store
+      #   task state locally
+      # @option opts [Symbol] :command actual command which will be invoked
+      #   in the background
+      # @option opts [Symbol] :stdout standard output file for the task
+      # @option opts [Symbol] :stderr standard error file for the task
+      def initialize(opts = {})
+        @state_file = opts[:state] || fail(ArgumentError, 'Specify state file')
+        @command = opts[:command]
+        @stdout_file = opts[:stdout] || File::NULL
+        @stderr_file = opts[:stderr] || File::NULL
+      end
+
+      # kill an already running task
+      #
+      # @param sig [String] kill signal that will sent to the backgroun process
+      # @return [TrueClass,FalseClass] true on success, false on failure
+      def kill(sig = 'KILL')
+        if running?
+          begin
+            Process.kill(sig, state_info['pid'].to_i)
+            'success'
+          rescue Exception => e
+            'failed'
+          end
+        else
+          'failed'
+        end
+      end
+
+      # obtain current state information about the task
+      #
+      # @return [Hash]
+      def state_info
+        if exists?
+          JSON.parse(File.read(state_file))
+        else
+          {'status' => 'absent' }
+        end
+      end
+
+      # delete the statefile of a finished task
+      #
+      # @return [String] 'success' if the task is reaped, 'failed' otherwise
+      def reap
+        if state_info['status'] == 'finished'
+          File.unlink(state_file)
+          'success'
+        else
+          'failed'
+        end
+      end
+
+
+      # start a background daemon and spawn another process to run specified
+      # command. writes back state information in the state file
+      # after spawning daemon process (state=invoking), after spawning the
+      # child process (state=running) and after reaping the child process
+      # (sate=finished).
+      #
+      # @return [String] 'success' if task is started
+      def start
+        if exists? or command.nil?
+          return 'failed'
+        end
+        pid = fork do
+          Process.daemon
+          state = {
+            ppid: Process.pid,
+            status: 'invoking',
+            pid: -1,
+            time: Time.now.to_i
+          }
+          write_state(state)
+          begin
+            child_pid = Process.spawn(command, out: stdout_file, err: stderr_file)
+            state[:pid] = child_pid
+            state[:status] = 'running'
+            write_state(state)
+            _ , status = Process.wait2(child_pid)
+            state[:exitstatus] = status.exitstatus
+            state[:status] = 'finished'
+          rescue Errno::ENOENT => e
+            state[:error] = e.class.name
+            state[:status] = 'failed'
+          end
+          write_state(state)
+          exit 0
+        end
+        Process.detach(pid)
+        'success'
+      end
+
+      private
+
+      # check if a task already running
+      #
+      # @return [TrueClass, FalseClass] true if the task running, else false
+      def running?
+        if exists?
+          File.exist?(File.join('/proc', state_info['pid'].to_s))
+        else
+          false
+        end
+      end
+
+      # check if a task already exist
+      #
+      # @return [TrueClass, FalseClass] true if the task exists, else false
+      def exists?
+        File.exists?(state_file)
+      end
+
+      # writes a hash as json in the state_file
+      # @param [Hash] state represented as a hash, to be written
+      def write_state(state)
+        File.open(state_file, 'w'){|f| f.write(JSON.generate(state))}
+      end
+    end
+  end
+end

data/lib/serfx/utils/handler.rb

@@ -0,0 +1,91 @@
+module Serfx
+  module Utils
+
+    # helper module to for serf custom handlers
+    #
+    # serf agents can be configured to invoke an executable
+    # script when an user event is received.
+    #
+    # [Serfx::Utils::Handler] module provides a set of helper methods to ease
+    # writing ruby based serf event handlers
+    #
+    # For example, following script will respond to any qury event named
+    # 'upcase' and return the uppercase version of the original query event's
+    # payload
+    # @example
+    #   require 'serfx/utils/handler'
+    #   include Serfx::Utils::Handler
+    #   on :query, 'upcase' do |event|
+    #     unless event.payload.nil?
+    #       STDOUT.write(event.payload.upcase)
+    #     end
+    #   end
+    #   run
+    module Handler
+
+      # when serf agent invokes a handler it passes the event payload
+      # through STDIN. while event metadata such as event type, name etc
+      # is passed as a set of environment variables.
+      # [SerfEvent] encapsulates such event.
+      class SerfEvent
+
+        attr_reader :environment, :payload, :type, :name
+
+        # @param env [Hash] environment
+        # @param stdin [IO] stadard input stream for the event
+        def initialize(env = ENV, stdin = STDIN)
+          @environment ={}
+          @payload = nil
+          @name = nil
+          env.keys.select{|k|k=~/^SERF/}.each do | k|
+            @environment[k] = env[k].strip
+          end
+          @type = @environment['SERF_EVENT']
+          case @type
+          when 'query'
+            @name = @environment['SERF_QUERY_NAME']
+            begin
+              @payload = stdin.read_nonblock(4096).strip
+            rescue Errno::EAGAIN => e
+            end
+          when 'user'
+            @name = @environment['SERF_USER_EVENT']
+            begin
+              @payload = stdin.read_nonblock(4096).strip
+            rescue Errno::EAGAIN => e
+            end
+          end
+        end
+      end
+
+      # register a callback against an event
+      #
+      # @param type [Symbol] event type for which this handler will be invoked
+      # @param name [String, Regex] match against name of the event
+      def on(type, name = nil,  &block)
+        callbacks[type] << SerfCallback.new(name, block)
+        nil
+      end
+
+      # execute callbacks registerd using `on`
+      def run
+        event = SerfEvent.new
+        callbacks[event.type.downcase.to_sym].each do |cbk|
+          if cbk.name
+            cbk.block.call(event) if (event.name === cbk.name)
+          else
+            cbk.block.call(event)
+          end
+        end
+      end
+
+      private
+
+      SerfCallback = Struct.new(:name, :block)
+
+      def callbacks
+        @_callbacks ||= Hash.new{|h,k| h[k] = []}
+      end
+    end
+  end
+end

data/lib/serfx/version.rb

@@ -2,5 +2,5 @@
 #
 # Provides version as a contsant for the serf gem
 module Serfx
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/data/config.json

@@ -1,3 +1,4 @@
 {
-  "rpc_auth" : "awesomesecret"
+  "rpc_auth" : "awesomesecret",
+  "encrypt_key": "QHOYjmYlxSCBhdfiolhtDQ=="
 }

data/spec/data/handler.rb

@@ -0,0 +1,11 @@
+require 'serfx/utils/handler'
+
+include Serfx::Utils::Handler
+
+on :query, 'upcase' do |event|
+  unless event.payload.nil?
+    STDOUT.write(event.payload.upcase)
+  end
+end
+
+run

data/spec/data/long_handler.rb

@@ -0,0 +1,24 @@
+require 'serfx/utils/async_job'
+require 'serfx/utils/handler'
+
+include Serfx::Utils::Handler
+
+command = "bash -c 'for i in `seq 1 300`; do echo $i; sleep 1; done'"
+job = Serfx::Utils::AsyncJob.new(command: command, state: '/tmp/long_task')
+
+on :query, 'task' do |event|
+  case event.payload
+  when 'start'
+    puts job.start
+  when 'check'
+    puts job.state_info.inspect
+  when 'reap'
+    puts job.reap
+  when 'kill'
+    puts job.kill
+  else
+    puts "unknown: #{event.payload}"
+  end
+end
+
+run

data/spec/serfx/client_spec.rb

@@ -2,7 +2,6 @@
 #
 require 'spec_helper'
 require 'timeout'
-require 'thread'
 
 describe Serfx do
 
@@ -129,4 +128,18 @@ describe Serfx do
       t.kill
     end
   end
+
+  it '#list, install, use and remove keys' do
+    keys = @conn.list_keys.body['Keys'].keys
+    expect(keys).to include('QHOYjmYlxSCBhdfiolhtDQ==')
+    @conn.install_key('Ih6cZqutM33tMdoFo1iNyw==')
+    keys = @conn.list_keys.body['Keys'].keys
+    expect(keys).to include('Ih6cZqutM33tMdoFo1iNyw==')
+    @conn.use_key('Ih6cZqutM33tMdoFo1iNyw==')
+    new_keys = @conn.list_keys.body['Keys'].keys
+    expect(new_keys.first).to eq('Ih6cZqutM33tMdoFo1iNyw==')
+    @conn.remove_key('QHOYjmYlxSCBhdfiolhtDQ==')
+    final_keys = @conn.list_keys.body['Keys'].keys
+    expect(final_keys.first).to_not include('QHOYjmYlxSCBhdfiolhtDQ==')
+  end
 end

data/spec/serfx/handler_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'serfx/utils/handler'
+
+describe Serfx::Utils::Handler do
+  it 'should invoke all the call backs' do
+    class CustomHandler
+      extend Serfx::Utils::Handler
+      @@state = {}
+      def self.state
+        @@state
+      end
+      on :query, 'foo' do |event|
+        @@state[:payload] = event.payload
+      end
+    end
+    ENV['SERF_EVENT'] = 'query'
+    ENV['SERF_QUERY_NAME'] = 'foo'
+    STDIN.should_receive(:read_nonblock).and_return('yeah')
+    CustomHandler.run
+    expect(CustomHandler.state[:payload]).to eq('yeah')
+  end
+end

data/spec/spec_helper.rb

@@ -6,8 +6,6 @@ require 'rspec'
 require 'serfx'
 require 'singleton'
 require 'tmpdir'
-require 'codeclimate-test-reporter'
-CodeClimate::TestReporter.start if ENV['CODE_COVERAGE']
 
 module Serfx
   # adds helper method for unit testing
@@ -40,7 +38,7 @@ module Serfx
 
       def daemonize(dir, join = false)
         command = serf_command(join)
-        pid = spawn(command, out: '/dev/null', chdir: dir)
+        pid = spawn(command, out: "#{dir}/stdout", chdir: dir)
         Process.detach(pid)
         pid
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serfx
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Rnjib Dey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -161,10 +161,15 @@ files:
 - lib/serfx/log.rb
 - lib/serfx/response.rb
 - lib/serfx/utils.rb
+- lib/serfx/utils/async_job.rb
+- lib/serfx/utils/handler.rb
 - lib/serfx/version.rb
 - serfx.gemspec
 - spec/data/config.json
+- spec/data/handler.rb
+- spec/data/long_handler.rb
 - spec/serfx/client_spec.rb
+- spec/serfx/handler_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ranjib/serfx
 licenses:
@@ -192,6 +197,9 @@ specification_version: 4
 summary: A barebone ruby client for serf
 test_files:
 - spec/data/config.json
+- spec/data/handler.rb
+- spec/data/long_handler.rb
 - spec/serfx/client_spec.rb
+- spec/serfx/handler_spec.rb
 - spec/spec_helper.rb
 has_rdoc: