slnky 0.8.3 → 0.9.0

data/lib/slnky/service/subscriber.rb

@@ -0,0 +1,57 @@
+module Slnky
+  module Service
+    class << self
+      def subscriber
+        Slnky::Service::Subscriber.instance
+      end
+    end
+
+    class Subscriber
+      class << self
+        def instance
+          @instance ||= self.new
+        end
+      end
+
+      def initialize
+        @subscriptions = []
+      end
+
+      def handle(name, data)
+
+      end
+
+      def add(name, method)
+        @subscriptions << Slnky::Service::Subscription.new(name, method)
+      end
+
+      def list
+        @subscriptions
+      end
+
+      def each
+        @subscriptions.each do |sub|
+          yield sub.name, sub.method
+        end
+      end
+
+      def for(name)
+        @subscriptions.each do |sub|
+          if sub.name == name || File.fnmatch(sub.name, name)
+            yield sub.name, sub.method if block_given?
+          end
+        end
+      end
+    end
+
+    class Subscription
+      attr_reader :name
+      attr_reader :method
+
+      def initialize(name, method)
+        @name = name
+        @method = method
+      end
+    end
+  end
+end

data/lib/slnky/service/timer.rb

@@ -0,0 +1,45 @@
+module Slnky
+  module Service
+    class << self
+      def timers
+        Slnky::Service::Timer.instance
+      end
+    end
+
+    class Timer
+      class << self
+        def instance
+          @instance ||= self.new
+        end
+      end
+
+      def initialize
+        @timers = []
+      end
+
+      def add(seconds, method)
+        @timers << Slnky::Service::Periodic.new(seconds, method)
+      end
+
+      def list
+        @timers
+      end
+
+      def each
+        @timers.each do |t|
+          yield t.seconds, t.method
+        end
+      end
+    end
+
+    class Periodic
+      attr_reader :seconds
+      attr_reader :method
+
+      def initialize(seconds, method)
+        @seconds = seconds
+        @method = method
+      end
+    end
+  end
+end

data/lib/slnky/service.rb

@@ -1,82 +1,70 @@
-require 'amqp'
-require 'open-uri'
-require 'json'
-require 'socket'
-
 require 'slnky/version'
 require 'slnky/message'
-require 'slnky/service/subscriptions'
-require 'slnky/service/periodics'
-require 'slnky/service/queues'
-require 'slnky/service/exchanges'
+require 'slnky/service/subscriber'
+require 'slnky/service/timer'
 
 module Slnky
   module Service
     class Base
       attr_reader :config
-
-      def initialize(url, options={})
-        @server = url
-        @name = self.class.name.split('::').last.downcase
-        @environment = options.delete(:env) || options.delete(:environment) || 'development'
-        @config = load_config(options)
-
-        @subscriptions = self.class.subscriptions || Slnky::Service::Subscriptions.new
-        @periodics = self.class.periodics || Slnky::Service::Periodics.new
-        @hostname = Socket.gethostname
-        @ipaddress = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }.ip_address
+      attr_reader :subscriber
+      attr_reader :timers
+      attr_reader :name
+
+      def initialize
+        config.service = name
+        @environment = config.environment
+        @server_down = false
       end
 
       def start
-        AMQP.start("amqp://#{config.rabbit.host}:#{config.rabbit.port}") do |connection|
-          @channel = AMQP::Channel.new(connection)
-          @channel.on_error do |ch, channel_close|
-            raise "Channel-level exception: #{channel_close.reply_text}"
-          end
-
-          @exchanges = Slnky::Service::Exchanges.new(@channel)
-          @exchanges.create('events')
-          @exchanges.create('logs')
+        transport.start!(self) do |_|
+          log.info "running"
+          run
 
-          @queues = Slnky::Service::Queues.new(@channel)
-          @queues.create(@name, @exchanges['events'])
+          subscriber.add "slnky.#{name}.command", :handle_command
+          subscriber.add "slnky.help.command", :handle_command
+          subscriber.add "slnky.service.restart", :handle_restart
+          timers.add 5.seconds, :handle_heartbeat unless config.development?
 
-          stopper = Proc.new do
-            puts "#{Time.now}: stopping"
-            connection.close { EventMachine.stop }
+          subscriber.each do |name, method|
+            log.info "subscribed to: #{name} -> #{self.class.name}.#{method}"
           end
+        end
+      end
 
-          Signal.trap("INT", stopper)
-          Signal.trap("TERM", stopper)
+      def handle_command(event, data)
+        if command
+          command.handle(event, data)
+        else
+          log.error "no comamnd support for #{name}"
+        end
+      end
 
-          log :info, "running"
+      def handle_restart(name, data)
+        # if we get this event, just stop. upstart will start us again.
+        log.warn "received restart event"
+        transport.stop!('Restarted')
+      end
 
-          run
+      def handle_heartbeat
+        return if @server_down
+        Slnky.heartbeat(name)
+      rescue => e
+        log.info "could not post heartbeat, server down? #{e.message}"
+        @server_down = true
+      end
 
-          @subscriptions.each do |name, method|
-            log :info, "subscribed to: #{name} -> #{self.class.name}.#{method}"
-          end
+      def subscriber
+        @subscriber ||= Slnky::Service.subscriber
+      end
 
-          @queues[@name].subscribe do |raw|
-            message = parse(raw)
-            event = message.name
-            data = message.payload
-            @subscriptions.for(event) do |name, method|
-              self.send(method.to_sym, event, data)
-            end
-            if event == 'slnky.service.restart'
-              # if we get this event, just stop. upstart will start us again.
-              log :warn, "received restart event"
-              stopper.call
-            end
-          end
+      def timers
+        @timers ||= Slnky::Service.timers
+      end
 
-          @periodics.each do |seconds, method|
-            EventMachine.add_periodic_timer(seconds) do
-              self.send(method.to_sym)
-            end
-          end
-        end
+      def name
+        @name ||= self.class.name.split('::')[1].downcase
       end
 
       protected
@@ -93,55 +81,29 @@ module Slnky
         Slnky::Message.parse(data)
       end
 
-      def subscribe(name, method)
-        raise "move this to class level, use methods instead of blocks"
-        # @subscriptions.add(name, method)
+      def log
+        Slnky::Log.instance
       end
 
-      def periodic(seconds, method)
-        raise "move this to class level, use methods instead of blocks"
-        # @periodics.add(seconds, method)
+      def config
+        Slnky.config
       end
 
-      def log(level, message)
-        data = {
-            service: "#{@name}-#{$$}",
-            level: level,
-            hostname: @hostname,
-            ipaddress: @ipaddress,
-            message: "slnky.service.#{@name}: #{message}"
-        }
-        @exchanges['logs'].publish(msg(data)) if @exchanges && @exchanges['logs'] # only log to the exchange if it's created
-        puts "%s [%6s] %s" % [Time.now, data[:level], data[:message]] if development? # log to the console if in development
+      def transport
+        @transport ||= Slnky::Transport.instance
       end
 
-      def development?
-        @environment == 'development'
-      end
-
-      def load_config(config)
-        # if you specify config, it will not load from server
-        # this is useful for testing, so you won't need to be running
-        # a server locally or configure your development service to
-        # talk to production server
-        if !config || config.count == 0
-          config = JSON.parse(open("#{@server}/configs/#{@name}") {|f| f.read })
-        end
-        DeepStruct.new(config)
+      def command
+        @command ||= "Slnky::#{name.capitalize}::Command".constantize.new rescue nil
       end
 
       class << self
-        attr_reader :subscriptions
-        attr_reader :periodics
-
         def subscribe(name, method)
-          @subscriptions ||= Slnky::Service::Subscriptions.new
-          @subscriptions.add(name, method)
+          Slnky::Service.subscriber.add(name, method)
         end
 
         def periodic(seconds, method)
-          @periodics ||= Slnky::Service::Periodics.new
-          @periodics.add(seconds, method)
+          Slnky::Service.timers.add(seconds, method)
         end
         alias_method :timer, :periodic
       end

data/lib/slnky/system.rb

@@ -0,0 +1,19 @@
+require 'socket'
+
+module Slnky
+  class System
+    class << self
+      def pid(service)
+        "#{ipaddress}/#{service}-#{$$}"
+      end
+
+      def hostname
+        @hostname ||= Socket.gethostname
+      end
+
+      def ipaddress
+        @ipaddress ||= Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }.ip_address
+      end
+    end
+  end
+end

data/lib/slnky/template/service/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/lib/slnky/template/service/config/deploy.rb.erb

@@ -1,17 +1,14 @@
 # config valid only for current version of Capistrano
 lock '3.4.0'
 
-set :application, '<%= dir %>'
-set :repo_url, 'git@github.com:something/<%= dir %>.git'
-
-rubyversion = File.read('.ruby-version').chomp
-rubygemset = File.read('.ruby-gemset').chomp
+set :application, '<%= service %>'
+set :repo_url, 'git@github.com:something/<%= service %>.git'
 
 set :deploy_to, "#{ENV['DEPLOY_DIR']}/#{fetch(:application)}#{fetch(:stage) == 'staging' ? '-stg' : ''}"
 
 set :keep_releases, 5
 
-set :rvm_ruby_version, "#{rubyversion}@#{rubygemset}"      # Defaults to: 'default'
+set :rvm_ruby_version, File.read('.ruby-version').chomp     # Defaults to: 'default'
 
 # Default branch is :master
 # ask :branch, `git rev-parse --abbrev-ref HEAD`.chomp

data/lib/slnky/template/service/lib/slnky/NAME/client.rb.erb

@@ -0,0 +1,11 @@
+module Slnky
+  module <%= cap %>
+    class Client
+      def initialize(config)
+
+      end
+
+
+    end
+  end
+end

data/lib/slnky/template/service/lib/slnky/NAME/command.rb.erb

@@ -0,0 +1,15 @@
+module Slnky
+  module <%= cap %>
+    class Command < Slnky::Command::Base
+      attr_writer :client
+      def client
+        @client ||= Slnky::<%= cap %>::Client.new(config)
+      end
+
+      def echo(request, response)
+        args = request.arguments||[]
+        response.output = args.join(" ")
+      end
+    end
+  end
+end

data/lib/slnky/template/service/lib/slnky/NAME/mock.rb.erb

@@ -0,0 +1,11 @@
+module Slnky
+  module <%= cap %>
+    class Mock
+      def initialize(config)
+
+      end
+
+      
+    end
+  end
+end

data/lib/slnky/template/service/lib/slnky/{service/NAME.rb.erb → NAME/service.rb.erb}

@@ -1,8 +1,11 @@
-require 'slnky'
-
 module Slnky
-  module Service
-    class <%= name.capitalize %> < Base
+  module <%= cap %>
+    class Service < Slnky::Service::Base
+      attr_writer :client
+      def client
+        @client ||= Slnky::<%= cap %>::Client.new(config)
+      end
+
       subscribe 'slnky.service.test', :handler
       # you can also subscribe to heirarchies, this gets
       # all events under something.happened

data/lib/slnky/template/service/lib/slnky/NAME.rb.erb

@@ -0,0 +1,6 @@
+require 'slnky'
+
+require 'slnky/<%= name %>/client'
+require 'slnky/<%= name %>/mock'
+require 'slnky/<%= name %>/service'
+require 'slnky/<%= name %>/command'

data/lib/slnky/template/service/service-slnky-NAME.erb

@@ -7,7 +7,7 @@ require 'rubygems'
 require 'bundler/setup'
 require 'dotenv'
 require 'daemons'
-require 'slnky/service/<%= name %>'
+require 'slnky/<%= name %>'
 Dotenv.load
 
 env = ARGV[0]
@@ -15,4 +15,4 @@ env = ARGV[0]
 # Become a daemon
 # Daemons.daemonize if env == 'production'
 
-Slnky::Service::<%= name.capitalize %>.new(ENV['SLNKY_URL'], env: env).start
+Slnky::<%= cap %>::Service.new(ENV['SLNKY_URL'], environment: env).start

data/lib/slnky/template/service/spec/slnky/NAME/command_spec.rb.erb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Slnky::<%= cap %>::Command do
+  subject do
+    s = described_class.new("http://localhost:3000", test_config)
+    s.client = Slnky::<%= cap %>::Mock.new(test_config)
+    s
+  end
+  let(:echo) { command('echo').payload }
+  let(:response) { Slnky::Command::Response.new() }
+
+  it 'handles echo' do
+    resp = response
+    expect(subject.echo(echo, resp)).not_to raise_error
+    expect(resp.output).to eq("test echo")
+  end
+end

data/lib/slnky/template/service/spec/slnky/NAME/service_spec.rb.erb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Slnky::<%= cap %>::Service do
+  subject do
+    s = described_class.new("http://localhost:3000", test_config)
+    s.client = Slnky::<%= cap %>::Mock.new(test_config)
+    s
+  end
+  let(:test_event) { event_load('test')}
+
+  it 'handles event' do
+    expect(subject.handler(test_event.name, test_event.payload)).to eq(true)
+  end
+end

data/lib/slnky/template/service/spec/spec_helper.rb.erb

@@ -1,6 +1,6 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'slnky'
-require 'slnky/service/<%= name %>'
+require 'slnky/<%= name %>'
 require 'yaml'
 require 'erb'
 require 'tilt'
@@ -8,12 +8,21 @@ require 'tilt'
 require 'dotenv'
 @dotenv = Dotenv.load
 
-def event_load(name)
+def event(name)
   @events ||= {}
   @events[name] ||= begin
     file = File.expand_path("../../test/events/#{name}.json", __FILE__)
     raise "file #{file} not found" unless File.exists?(file)
-    Slnky::Message.new(JSON.parse(File.read(file)))
+    Slnky::Data.new(JSON.parse(File.read(file)))
+  end
+end
+
+def command(name)
+  @commands ||= {}
+  @commands[name] ||= begin
+    file = File.expand_path("../../test/commands/#{name}.json", __FILE__)
+    raise "file #{file} not found" unless File.exists?(file)
+    Slnky::Command::Request.new(JSON.parse(File.read(file)))
   end
 end
 
@@ -22,6 +31,8 @@ def test_config
     file = File.expand_path("../../test/config.yaml", __FILE__)
     template = Tilt::ERBTemplate.new(file)
     output = template.render(self, @dotenv)
-    YAML.load(output)
+    cfg = Slnky::Data.new(YAML.load(output))
+    cfg.environment = 'test'
+    cfg
   end
 end

data/lib/slnky/template/service/test/commands/echo.json.erb

@@ -0,0 +1,11 @@
+{
+  "name": "slnky.<%= name %>.command",
+  "payload": {
+    "command": "echo",
+    "args": [
+      "test",
+      "echo"
+    ],
+    "responder": "STDOUT"
+  }
+}

data/lib/slnky/template/service/test/config.yaml.erb

@@ -1,5 +1,5 @@
 ---
-# config.yaml for Slnky::Service::<%= name.capitalize %>
+# config.yaml for Slnky::<%= cap %>::Service
 # this file is processed through ERB, you can inject
 # values into the config from the environment, by specifying them
 # in the .env file

data/lib/slnky/transport.rb

@@ -0,0 +1,98 @@
+require 'amqp'
+
+module Slnky
+  module Transport
+    class << self
+      def instance
+        @instance ||= begin
+          Slnky::Transport::Rabbit.new
+        end
+      end
+    end
+
+    class Rabbit
+      attr_reader :channel
+      attr_reader :exchanges
+      attr_reader :queues
+      attr_reader :stopper
+
+      def initialize
+        @config = Slnky.config
+        @host = @config.rabbit.host
+        @port = @config.rabbit.port
+        @url = "amqp://#{@host}:#{@port}"
+        @channel = nil
+        @exchanges = {}
+        @queues = {}
+      end
+
+      def start!(service, &block)
+        AMQP.start(@url) do |connection|
+          @connection = connection
+          @channel = AMQP::Channel.new(@connection)
+          @channel.on_error do |ch, channel_close|
+            raise "Channel-level exception: #{channel_close.reply_text}"
+          end
+
+          Signal.trap("INT", proc { self.stop!('Interrupted') })
+          Signal.trap("TERM", proc { self.stop!('Terminated') })
+
+          exchange('events', :fanout)
+          exchange('logs', :fanout)
+          exchange('response', :direct)
+          queue(service.name, 'events')
+
+          yield self if block_given?
+
+          if service.is_a?(Slnky::Service::Base)
+            queues.each do |name, queue|
+              queue.subscribe do |raw|
+                event = Slnky::Message.parse(raw)
+                service.subscriber.for(event.name) do |name, method|
+                  service.send(method.to_sym, event.name, event.payload)
+                end
+              end
+            end
+
+            service.timers.each do |seconds, method|
+              EventMachine.add_periodic_timer(seconds) do
+                service.send(method.to_sym)
+              end
+            end
+          end
+        end
+      end
+
+      def stop!(msg=nil)
+        return unless @connection
+        puts "#{Time.now}: stopping (#{msg})" if msg
+        @connection.close { EventMachine.stop { exit } }
+      end
+
+      def exchange(desc, type)
+        raise 'attempting to create exchange without channel' unless @channel
+        name = "slnky.#{desc}"
+        @exchanges[desc] ||=
+            case type
+              when :fanout
+                @channel.fanout(name)
+              when :direct
+                @channel.direct(name)
+              else
+                raise "unknown exchange type: #{ex.type}"
+            end
+      end
+
+      def queue(desc, exchange, options={})
+        raise 'attempting to create queue without channel' unless @channel
+        name = "service.#{desc}.#{exchange}"
+        options = {
+            durable: true
+        }.merge(options)
+        routing = options.delete(:routing_key)
+        bindoptions = routing ? {routing_key: routing} : {}
+        @queues[desc] ||= @channel.queue(name, options).bind(@exchanges[exchange], bindoptions)
+      end
+    end
+  end
+end

data/lib/slnky/version.rb

@@ -1,3 +1,3 @@
 module Slnky
-  VERSION = "0.8.3"
+  VERSION = "0.9.0"
 end

data/lib/slnky.rb

@@ -1,11 +1,17 @@
+require 'rest_client'
+require 'active_support/all'
+require 'open-uri'
+require 'json'
+
 require 'slnky/version'
 require 'slnky/data'
+require 'slnky/config'
+require 'slnky/log'
+require 'slnky/system'
 require 'slnky/message'
 require 'slnky/service'
-require 'slnky/generator'
-
-require 'rest_client'
-require 'active_support/all'
+require 'slnky/transport'
+require 'slnky/command'
 
 module Slnky
   class << self
@@ -13,18 +19,13 @@ module Slnky
       Slnky::VERSION
     end
 
-    def config
-      load_config unless @config
-      @config
-    end
-
-    def load_config(file='~/.slnky/config.yaml')
-      path = File.expand_path(file)
-      @config = Slnky::Data.new(YAML.load_file(path))
+    def heartbeat(name)
+      server = ENV['SLNKY_URL'] || Slnky.config.url
+      RestClient.post "#{server}/hooks/heartbeat", {name: name}, content_type: :json, accept: :json
     end
 
-    def notify(msg, server=nil)
-      server ||= config.slnky.url
+    def notify(msg)
+      server = self.config.url
       params = {name: msg.name, event: msg.to_h}
       RestClient.post "#{server}/hooks/notify", params.to_json, content_type: :json, accept: :json
     end

data/slnky.gemspec

@@ -38,4 +38,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'tilt', '~> 2.0.2'
   spec.add_dependency 'eventmachine', '~> 1.0.9.1'
   spec.add_dependency 'rest-client', '~> 1.8.0'
+  spec.add_dependency 'docopt', '~> 0.5.0'
+  spec.add_dependency 'highline', '~> 1.7.8'
 end