daioikachan 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c10cbfb0cfbfbc731033be5a02a9f8ea843f4f5
+  data.tar.gz: fe2a499b9da5d66a57458234d5de4f475034b734
+SHA512:
+  metadata.gz: 585730388e9aff3c91ef30e36060957d3363be9cc6b376d9f23c843d1b617112383466a5166d212d4319be2083529989c9bff9d706a29ee4fd72d85f1d3d7f89
+  data.tar.gz: 4910660d2dbd34642730b438362b7b9b799efb8946f3cd5abb7bbbd3a6beebce1589e83a61d2029fb50bd21b5763ff5ca69ac3da70f2c3e13fbdebdca2d33f7b

data/.gitignore

@@ -0,0 +1,17 @@
+/*.gem
+~*
+#*
+*~
+.bundle
+Gemfile.lock
+.rbenv-version
+vendor
+doc/*
+tmp/*
+coverage
+.yardoc
+.ruby-version
+pkg/*
+.tags
+.env
+daioikachan.conf

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+
+rvm:
+  - 2.0.0
+  - 2.1
+  - 2.2
+
+branches:
+  only:
+    - master
+
+script: bundle exec rake test

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.0.1 (2015/03/22)
+
+Initial version

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Naotoshi Seo
+
+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,141 @@
+# Daioikachan
+
+[Ikachan](https://github.com/yappo/p5-App-Ikachan) compatible interface with multiple backends (IRC, Slack, etc).
+
+## Requirements
+
+* Ruby
+
+## Installation
+
+Write Gemfile:
+
+```
+source "https://rubygems.org"
+
+gem 'daioikachan'
+```
+
+Run:
+
+```
+$ bundle
+```
+
+IRC, Slack backends are bundled as default.
+
+Daioikachan supports plugin architecture. You may add your favirite backends as gems. See Plugin section for details.
+
+## How to Run
+
+This is an example to post messages for both IRC and Slack.
+
+### Start
+
+Generate a sample [daioikachan.conf](./examples/example.conf):
+
+```
+$ bundle exec daioikachan -g daioikachan.conf
+```
+
+Create `.env` and configure your IRC server and Slack token:
+
+```
+IRC_SERVER=XX.XX.XX.XX
+SLACK_API_TOKEN=XXX-XXXXX-XXXXXX-XXXXX
+````
+
+Start `daioikachan` as
+
+```
+$ bundle exec daioikachan
+```
+
+### Test
+
+Test to post a message to `#daioikachan` channel of both IRC and Slack via `daioikachan` like:
+
+```
+$ curl -d "channel=#daioikachan&message=test daioikachan" http://localhost:4979/notice
+```
+
+Look whether posting to IRC, and Slack succeeds.
+
+## Configuration
+
+See [example.conf](./example.conf) or [multi_slack.conf](./examples/multi_slack.conf) as examples.
+
+You might've noticed that the config file is similar with Fluentd.
+Yes, `daioikachan` is created based on Fluentd.
+So, you can use `routing` functions which Fluentd has (`tag` and `label`).
+
+See [config-file](http://docs.fluentd.org/articles/config-file) documentation of Fluentd for details.
+
+See following pages for built-in plugins.
+
+* [in_daioikachan](./README/in_daioikachan.md)
+* [fluent-plugin-irc](./README/out_irc.md)
+* [fluent-plugin-slack](https://github.com/sowawa/fluent-plugin-slack)
+
+If you need other backends, search other fluentd output plugins and add them. Enjoy!
+
+## Plugin
+
+You can create and add your own backends for daioikachan as a Fluentd Plugin.
+
+See http://www.fluentd.org/plugins#notifications for available plugins.
+
+## API
+
+### /notice
+
+Send `notice` message.
+
+```
+$ curl -d "channel=#channel&message=test message" http://localhost:4979/notice
+```
+
+### /privmsg
+
+Send `privmsg` message.
+
+```
+$ curl -d "channel=#channel&message=test message" http://localhost:4979/privmsg
+```
+
+### /join
+
+The server always returns 200, and ignore.
+
+IRC client (`fluent-plugin-irc`) automatically joins to a channel on sending message.
+Slack client does not require to join to a channel.
+
+### /leave
+
+The server always returns 200, and ignores.
+
+## ChangeLog
+
+See [CHANGELOG.md](CHANGELOG.md) for details.
+
+## Contributing
+
+1. Fork it
+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 new [Pull Request](../../pull/new/master)
+
+## Copyright
+
+### daioikachan, and fluent-plugin-daioikachan
+
+Copyright (c) 2015 Naotoshi Seo. See [LICENSE](LICENSE) for details.
+
+### fluent-plugin-irc
+
+See https://github.com/choplin/fluent-plugin-irc
+
+### fluent-plugin-slack
+
+See https://github.com/sowawa/fluent-plugin-slack

data/README/in_daioikachan.md

@@ -0,0 +1,63 @@
+# Daioikachan plugin for Fluentd
+
+This plugin provides [ikachan](https://github.com/yappo/p5-App-Ikachan) compatible interface by Fluentd.
+
+## Installation
+
+Bundled with `daioikachan` gem.
+
+## Configuration
+
+```apache
+<source>
+  type daioikachan
+  bind 127.0.0.1
+  port 4979
+  backlog 2048
+
+  # optional Puma parameters
+  min_threads 0
+  max_threads 4
+</source>
+```
+
+Receiving API post like below,
+
+```
+$ curl -d "channel=#channel&message=test message" http://localhost:4979/notice
+```
+
+emits an event as
+
+```
+notice.channel {"command":"notice","channel":"channel","message":"test message"}
+```
+
+## API
+
+### /notice
+
+Send `notice` message.
+
+```
+$ curl -d "channel=#channel&message=test message" http://localhost:4979/notice
+```
+
+### /privmsg
+
+Send `privmsg` message.
+
+```
+$ curl -d "channel=#channel&message=test message" http://localhost:4979/privmsg
+```
+
+### /join
+
+The server always returns 200, and ignored.
+
+IRC client should automatically join to a channel on sending message.
+Slack client does not require to join to a channel.
+
+### /leave
+
+The server always returns 200, and ignored.

data/README/out_irc.md

@@ -0,0 +1,58 @@
+# Fluent::Plugin::Irc, a plugin for [Fluentd](http://fluentd.org)
+
+[![Build Status](https://travis-ci.org/choplin/fluent-plugin-irc.svg)](https://travis-ci.org/choplin/fluent-plugin-irc)
+
+Fluent plugin to send messages to IRC server
+
+## Installation
+
+`$ fluent-gem install fluent-plugin-irc`
+
+## Configuration
+
+### Example
+
+```
+<match **>
+  type irc
+  host localhost
+  port 6667
+  channel fluentd
+  nick fluentd
+  user fluentd
+  real fluentd
+  message notice: %s [%s] %s
+  out_keys tag,time,message
+  time_key time
+  time_format %Y/%m/%d %H:%M:%S
+  tag_key tag
+</match>
+```
+
+### Parameter
+
+|parameter|description|default|
+|---|---|---|
+|host|IRC server host|localhost|
+|port|IRC server port number|6667|
+|channel|channel to send messages (without first '#')||
+|channel_keys|keys used to format channel. %s will be replaced with value specified by channel_keys if this option is used|nil|
+|nick|nickname registerd of IRC|fluentd|
+|user|user name registerd of IRC|fluentd|
+|real|real name registerd of IRC|fluentd|
+|message|message format. %s will be replaced with value specified by out_keys||
+|out_keys|keys used to format messages||
+|time_key|key name for time|time|
+|time_format|time format. This will be formatted with Time#strftime.|%Y/%m/%d %H:%M:%S|
+|tag_key|key name for tag|tag|
+|command|irc command. `privmsg` or `notice`|privmsg|
+|command_keys|keys used to format command. %s will be replaced with value specified by command_keys if this option is used|nil|
+|send_interval|interval (sec) to send message. defence Excess Flood|2|
+|max_send_queue|maximum size of send message queue|100|
+
+## Copyright
+
+<table>
+<tr><td>Copyright</td><td>Copyright (c) 2015 OKUNO Akihiro</td></tr>
+<tr><td>License</td><td>Apache License, Version 2.0</td></tr>
+</table>

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = (Dir["test/plugin/test_*.rb"] - ["helper.rb"]).sort
+  test.verbose = true
+end
+
+task :default => [:test]

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/daioikachan

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require 'rubygems' unless defined?(gem)
+ROOT = File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path(File.join(ROOT, 'lib'))
+
+require 'dotenv'
+Dotenv.load
+
+# tweak default_options
+require 'fluent/supervisor'
+class Fluent::Supervisor
+  class << self
+    alias :fluentd_default_options :default_options
+  end
+  def self.default_options
+    fluentd_default_options.merge({
+      :config_path => 'daioikachan.conf',
+      :plugin_dirs => [File.join(ROOT, 'lib/fluent/plugin')],
+    })
+  end
+end
+
+# handle argv to generate conf
+require 'optparse'
+opts = {}
+opt = OptionParser.new
+opt.on('-g', "--generate PATH", "generate a sample configuration file") {|s|
+  opts[:generate_path] = s
+}
+begin
+  opt.parse!(ARGV)
+rescue OptionParser::InvalidOption => e
+  argv = ARGV # suppress warning to constant
+  argv.unshift(*(e.args)) # restore and ignore unknown options to pass to Fluentd
+end
+
+if generate_path = opts[:generate_path]
+  require 'fileutils'
+  FileUtils.mkdir_p File.dirname(generate_path)
+  if File.exist?(generate_path)
+    puts "#{generate_path} already exists."
+  else
+    File.open(generate_path, "w") {|f|
+      conf = File.read File.join(ROOT, 'examples/example.conf')
+      f.write conf
+    }
+    puts "Installed #{generate_path}."
+  end
+  exit 0
+end
+
+require 'fluent/command/fluentd'

data/daioikachan.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "daioikachan"
+  gem.description = "Ikachan compatible interface with multiple backends (IRC, Slack, etc)"
+  gem.homepage    = "https://github.com/sonots/daioikachan"
+  gem.summary     = gem.description
+  gem.version     = File.read("VERSION").strip
+  gem.authors     = ["Naotoshi Seo"]
+  gem.email       = "sonots@gmail.com"
+  gem.has_rdoc    = false
+  gem.license     = 'MIT License'
+  gem.files       = `git ls-files`.split("\n")
+  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ['lib']
+
+  gem.add_dependency "fluentd", "~> 0.12.0"
+  gem.add_dependency "dotenv"
+  gem.add_dependency "puma"
+  # gem.add_dependency "fluent-plugin-irc"
+  gem.add_dependency "irc_parser"
+  gem.add_dependency "fluent-plugin-slack", ">= 0.5.0"
+  gem.add_development_dependency "rake"
+end

data/examples/example.conf

@@ -0,0 +1,57 @@
+<source>
+  type daioikachan
+  bind 0.0.0.0
+  port 4979
+  min_threads 0
+  max_threads 4
+  backlog 1024
+  @label @raw
+</source>
+
+<label @raw>
+  <match **>
+    type copy
+    <store>
+      type stdout
+    </store>
+    <store>
+      type relabel
+      @label @slack
+    </store>
+    <store>
+      type relabel
+      @label @irc
+    </store>
+  </match>
+</label>
+
+<label @irc>
+  <match **>
+    type irc
+    host "#{ENV['IRC_SERVER']}"
+    port 6667
+    nick daioikachan
+    user daioikachan
+    real daioikachan
+    command %s
+    command_keys command
+    channel %s
+    channel_keys channel
+    message %s
+    out_keys message
+    send_interval 2s # IRC has Excess Flood limit, this is the default value taken from ikachan
+  </match>
+</label>
+
+<label @slack>
+  <match **>
+    type slack
+    token "#{ENV['SLACK_API_TOKEN']}"
+    username daioikachan
+    channel %s
+    channel_keys channel
+    color good
+    icon_emoji :ghost:
+    flush_interval 1s # slack API has limit as a post / sec
+  </match>
+</label>

data/examples/multi_slack.conf

@@ -0,0 +1,46 @@
+<source>
+  type daioikachan
+  bind 0.0.0.0
+  port 4979
+  min_threads 0
+  max_threads 4
+  backlog 1024
+  @label @raw
+</source>
+
+<label @raw>
+  <match **>
+    type copy
+    <store>
+      type stdout
+    </store>
+    <store>
+      type relabel
+      @label @slack
+    </store>
+  </match>
+</label>
+
+<label @slack>
+  # #fluentd_warn => team1.slack.com#general
+  <match *.fluentd_warn>
+    type slack
+    token "#{ENV['TEAM1_TOKEN']}"
+    username daioikachan
+    channel general
+    color bad
+    icon_emoji :ghost:
+    flush_interval 1s # slack API has limit as a post / sec
+  </match>
+  # other channels => default_team.slack.com#${channel}
+  <match **>
+    type slack
+    token "#{ENV['DEFAULT_TEAM_TOKEN']}"
+    username daioikachan
+    channel %s
+    channel_keys channel
+    color bad
+    icon_emoji :ghost:
+    flush_interval 1s # slack API has limit as a post / sec
+  </match>
+</label>

data/lib/fluent/plugin/in_daioikachan.rb

@@ -0,0 +1,160 @@
+module Fluent
+  class DaioikachanInput < Input
+    Plugin.register_input('daioikachan', self)
+
+    def initialize
+      require 'puma'
+      require 'uri'
+      super
+    end
+
+    config_param :port, :integer, :default => 4979
+    config_param :bind, :string, :default => '0.0.0.0'
+    config_param :min_threads, :integer, :default => 0
+    config_param :max_threads, :integer, :default => 4
+    config_param :backlog, :integer, :default => nil
+
+    def configure(conf)
+      super
+    end
+
+    def start
+      super
+
+      # Refer puma's Runner and Rack handler for puma server setup
+      @server = ::Puma::Server.new(method(:on_request))
+      @server.min_threads = @min_threads
+      @server.max_threads = @max_threads
+      @server.leak_stack_on_error = false
+      setup_http
+
+      @app = App.new(self)
+
+      @thread = Thread.new(&method(:run))
+    end
+
+    def shutdown
+      @server.stop(true)
+      @thread.join
+    end
+
+    def run
+      @server.run(false)
+    rescue => e
+      log.error "unexpected error", :error => e.to_s
+      log.error_backtrace e.backtrace
+    end
+
+    def on_request(env)
+      @app.run(env)
+    end
+
+    def setup_http
+      log.info "listening http on #{@bind}:#{@port}"
+
+      opts = [@bind, @port, true]
+      opts << @backlog if @backlog
+      @server.add_tcp_listener(*opts)
+    end
+
+    class App
+      class BadRequest < StandardError; end
+      class InternalServerError < StandardError; end
+      class NotFound < StandardError; end
+
+      attr_reader :router, :log
+
+      def initialize(plugin)
+        @router = plugin.router
+        @log    = plugin.log
+      end
+
+      def run(env)
+        # req = Rack::Request.new(env)
+        method = env['REQUEST_METHOD'.freeze] # req.method
+        path   = URI.parse(env['REQUEST_URI'.freeze]).path # req.path
+        body   = env['rack.input'].read # req.body.read
+        params = Rack::Utils.parse_query(body)
+
+        begin
+          if method == 'POST'
+            case path
+            when '/notice'
+              notice(params)
+            when '/privmsg'
+              privmsg(params)
+            when '/join'
+              return ok
+            when '/leave'
+              return ok
+            else
+              return not_found
+            end
+          else
+            return not_found
+          end
+        rescue BadRequest => e
+          bad_request(e.message)
+        rescue NotFound => e
+          not_found(e.message)
+        rescue InternalServerError => e
+          internal_server_error(e.message)
+        rescue => e
+          internal_server_error("#{e.class} #{e.message} #{e.backtrace.first}")
+        else
+          ok
+        end
+      end
+
+      def notice(params)
+        channel, message = build_channel(params), build_message(params)
+        tag    = "notice.#{channel}"
+        record = params.merge('command' => 'notice', 'channel' => channel, 'message' => message)
+        router.emit(tag, Fluent::Engine.now, record)
+      end
+
+      def privmsg(params)
+        channel, message = build_channel(params), build_message(params)
+        tag    = "privmsg.#{channel}"
+        record = params.merge('command' => 'privmsg', 'channel' => channel, 'message' => message)
+        router.emit(tag, Fluent::Engine.now, record)
+      end
+
+      private
+
+      def build_channel(params)
+        unless channel = params.delete('channel')
+          raise BadRequest.new('`channel` parameter is mandatory')
+        end
+        if channel.start_with?('#')
+          channel[1..-1] # remove starting #
+        else
+          channel
+        end
+      end
+
+      def build_message(params)
+        unless message = params.delete('message')
+          raise BadRequest.new('`message` parameter is mandatory')
+        end
+        message # should I truncate message to max_length?
+      end
+
+      def ok(msg = nil)
+        [200, {'Content-type'=>'text/plain'}, ["OK\n#{msg}"]]
+      end
+
+      def bad_request(msg = nil)
+        [400, {'Content-type'=>'text/plain'}, ["Bad Request\n#{msg}"]]
+      end
+
+      def not_found(msg = nil)
+        [404, {'Content-type'=>'text/plain'}, ["Not Found\n#{msg}"]]
+      end
+
+      def internal_server_error(msg = nil)
+        [500, {'Content-type'=>'text/plain'}, ["Internal Server Error\n#{msg}"]]
+      end
+    end
+  end
+end

data/lib/fluent/plugin/out_irc.rb

@@ -0,0 +1,283 @@
+module Fluent
+  class IRCOutput < Fluent::Output
+    Fluent::Plugin.register_output('irc', self)
+
+    include SetTimeKeyMixin
+    include SetTagKeyMixin
+
+    config_set_default :include_time_key, true
+    config_set_default :include_tag_key, true
+
+    config_param :host        , :string  , :default => 'localhost'
+    config_param :port        , :integer , :default => 6667
+    config_param :channel     , :string
+    config_param :channel_keys, :default => nil do |val|
+      val.split(',')
+    end
+    config_param :nick        , :string  , :default => 'fluentd'
+    config_param :user        , :string  , :default => 'fluentd'
+    config_param :real        , :string  , :default => 'fluentd'
+    config_param :password    , :string  , :default => nil
+    config_param :message     , :string
+    config_param :out_keys do |val|
+      val.split(',')
+    end
+    config_param :time_key    , :string  , :default => 'time'
+    config_param :time_format , :string  , :default => '%Y/%m/%d %H:%M:%S'
+    config_param :tag_key     , :string  , :default => 'tag'
+    config_param :command     , :string  , :default => 'privmsg'
+    config_param :command_keys, :default => nil do |val|
+      val.split(',')
+    end
+
+    config_param :blocking_timeout, :time,    :default => 0.5
+    config_param :max_send_queue,   :integer, :default => 100
+    config_param :send_interval,    :time,    :default => 2
+
+    COMMAND_MAP = {
+      'priv_msg' => :priv_msg,
+      'privmsg'  => :priv_msg,
+      'notice'   => :notice,
+    }
+
+    # To support log_level option implemented by Fluentd v0.10.43
+    unless method_defined?(:log)
+      define_method("log") { $log }
+    end
+
+    attr_reader :conn # for test
+
+    def initialize
+      super
+      require 'irc_parser'
+    end
+
+    def configure(conf)
+      super
+
+      begin
+        @message % (['1'] * @out_keys.length)
+      rescue ArgumentError
+        raise Fluent::ConfigError, "string specifier '%s' and out_keys specification mismatch"
+      end
+
+      if @channel_keys
+        begin
+          @channel % (['1'] * @channel_keys.length)
+        rescue ArgumentError
+          raise Fluent::ConfigError, "string specifier '%s' and channel_keys specification mismatch"
+        end
+      end
+      @channel = '#'+@channel
+
+      if @command_keys
+        begin
+          @command % (['1'] * @command_keys.length)
+        rescue ArgumentError
+          raise Fluent::ConfigError, "string specifier '%s' and command_keys specification mismatch"
+        end
+      else
+        unless @command = COMMAND_MAP[@command]
+          raise Fluent::ConfigError, "command must be one of #{COMMAND_MAP.keys.join(', ')}"
+        end
+      end
+
+      @send_queue = []
+    end
+
+    def start
+      super
+
+      begin
+        @loop = Coolio::Loop.new
+        @conn = create_connection
+        @timer = TimerWatcher.new(@send_interval, true, log, &method(:on_timer))
+        @loop.attach(@timer)
+        @thread = Thread.new(&method(:run))
+      rescue => e
+        puts e
+        raise Fluent::ConfigError, "failed to connect IRC server #{@host}:#{@port}"
+      end
+    end
+
+    def shutdown
+      super
+      @loop.watchers.each { |w| w.detach }
+      @loop.stop
+      @conn.close
+      @thread.join
+    end
+
+    def run
+      @loop.run(@blocking_timeout)
+    rescue => e
+      log.error "unexpected error", :error => e, :error_class => e.class
+      log.error_backtrace
+    end
+
+    def emit(tag, es, chain)
+      chain.next
+
+      if @conn.closed?
+        log.warn "out_irc: connection is closed. try to reconnect"
+        @conn = create_connection
+      end
+
+      es.each do |time,record|
+        if @send_queue.size >= @max_send_queue
+          log.warn "out_irc: send queue size exceeded max_send_queue(#{@max_send_queue}), discards"
+          break
+        end
+
+        filter_record(tag, time, record)
+        command, channel, message = build_command(record), build_channel(record), build_message(record)
+        log.debug { "out_irc: push {command:\"#{command}\", channel:\"#{channel}\", message:\"#{message}\"}" }
+        @send_queue.push([command, channel, message])
+      end
+    end
+
+    def on_timer
+      return if @send_queue.empty?
+      command, channel, message = @send_queue.shift
+      log.info { "out_irc: send {command:\"#{command}\", channel:\"#{channel}\", message:\"#{message}\"}" }
+      @conn.send_message(command, channel, message)
+    end
+
+    private
+
+    def create_connection
+      conn = IRCConnection.connect(@host, @port)
+      conn.log  = log
+      conn.nick = @nick
+      conn.user = @user
+      conn.real = @real
+      conn.password = @password
+      conn.attach(@loop)
+      conn
+    end
+
+    def build_message(record)
+      values = fetch_keys(record, @out_keys)
+      @message % values
+    end
+
+    def build_channel(record)
+      return @channel unless @channel_keys
+
+      values = fetch_keys(record, @channel_keys)
+      @channel % values
+    end
+
+    def build_command(record)
+      return @command unless @command_keys
+
+      values = fetch_keys(record, @command_keys)
+      unless command = COMMAND_MAP[@command % values]
+        log.warn "out_irc: command is not one of #{COMMAND_MAP.keys.join(', ')}, use privmsg"
+      end
+      command || :priv_msg
+    end
+
+    def fetch_keys(record, keys)
+      Array(keys).map do |key|
+        begin
+          record.fetch(key).to_s
+        rescue KeyError
+          log.warn "out_irc: the specified key '#{key}' not found in record. [#{record}]"
+          ''
+        end
+      end
+    end
+
+    class TimerWatcher < Coolio::TimerWatcher
+      def initialize(interval, repeat, log, &callback)
+        @callback = callback
+        @log = log
+        super(interval, repeat)
+      end
+
+      def on_timer
+        @callback.call
+      rescue
+        @log.error $!.to_s
+        @log.error_backtrace
+      end
+    end
+
+    class IRCConnection < Cool.io::TCPSocket
+      attr_reader :joined # for test
+      attr_accessor :log, :nick, :user, :real, :password
+
+      def initialize(*args)
+        super
+        @joined = {}
+      end
+
+      def on_connect
+        if @password
+          IRCParser.message(:pass) do |m|
+            m.password = @password
+            write m
+          end
+        end
+        IRCParser.message(:nick) do |m|
+          m.nick   = @nick
+          write m
+        end
+        IRCParser.message(:user) do |m|
+          m.user = @user
+          m.postfix = @real
+          write m
+        end
+      end
+
+      def on_read(data)
+        data.each_line do |line|
+          begin
+            msg = IRCParser.parse(line)
+            log.debug { "out_irc: on_read :#{msg.class.to_sym}" }
+            case msg.class.to_sym
+            when :ping
+              IRCParser.message(:pong) do |m|
+                m.target = msg.target
+                m.body = msg.body
+                write m
+              end
+            when :join
+              log.info { "out_irc: joined to #{msg.channels.join(', ')}" }
+              msg.channels.each {|channel| @joined[channel] = true }
+            when :err_nick_name_in_use
+              log.warn "out_irc: nickname \"#{msg.error_nick}\" is already in use."
+            when :error
+              log.warn "out_irc: an error occured. \"#{msg.error_message}\""
+            end
+          rescue
+            #TODO
+          end
+        end
+      end
+
+      def joined?(channel)
+        @joined[channel]
+      end
+
+      def join(channel)
+        IRCParser.message(:join) do |m|
+          m.channels = channel
+          write m
+        end
+        log.debug { "out_irc: join to #{channel}" }
+      end
+
+      def send_message(command, channel, message)
+        join(channel) unless joined?(channel)
+        IRCParser.message(command) do |m|
+          m.target = channel
+          m.body = message
+          write m
+        end
+        channel # return channel for test
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'fileutils'
+require 'fluent/log'
+require 'fluent/test'
+
+unless defined?(Test::Unit::AssertionFailedError)
+  class Test::Unit::AssertionFailedError < StandardError
+  end
+end
+
+def unused_port
+  s = TCPServer.open(0)
+  port = s.addr[1]
+  s.close
+  port
+end
+
+def ipv6_enabled?
+  require 'socket'
+
+  begin
+    TCPServer.open("::1", 0)
+    true
+  rescue
+    false
+  end
+end
+
+$log = Fluent::Log.new(Fluent::Test::DummyLogDevice.new, Fluent::Log::LEVEL_WARN)

data/test/plugin/test_in_daioikachan.rb

@@ -0,0 +1,105 @@
+require_relative '../helper'
+require 'fluent/plugin/in_daioikachan'
+require 'net/https'
+
+class DaioikachanInputTest < Test::Unit::TestCase
+  def post(path, params, header = {}, ssl = false)
+    http = Net::HTTP.new("127.0.0.1", PORT)
+    if ssl
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    req = Net::HTTP::Post.new(path, header)
+    if params.is_a?(String)
+      req.body = params
+    else
+      req.set_form_data(params)
+    end
+    http.request(req)
+  end
+
+  def setup
+    Fluent::Test.setup
+  end
+
+  PORT = unused_port
+  CONFIG = %[
+    port #{PORT}
+  ]
+
+  def create_driver(conf = CONFIG)
+    Fluent::Test::InputTestDriver.new(Fluent::DaioikachanInput).configure(conf, true)
+  end
+
+  def test_default_configure
+    d = create_driver(%[])
+    assert_equal 4979,      d.instance.port
+    assert_equal '0.0.0.0', d.instance.bind
+    assert_equal 0,         d.instance.min_threads
+    assert_equal 4,         d.instance.max_threads
+    assert_equal nil,       d.instance.backlog
+  end
+
+  def test_configure
+    d = create_driver(%[
+      port #{PORT}
+      bind 127.0.0.1
+      min_threads 0
+      max_threads 4
+      backlog 1024
+    ])
+    assert_equal PORT,        d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+    assert_equal 0,           d.instance.min_threads
+    assert_equal 4,           d.instance.max_threads
+    assert_equal 1024,        d.instance.backlog
+  end
+
+  def test_notice
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    Fluent::Engine.now = time
+
+    d.expect_emit "notice.channel", time, {"command" => "notice", "channel" => "channel", "message" => "message"}
+
+    d.run do
+      d.expected_emits.each {|tag, time, record|
+        res = post("/notice", {command: "notice", channel: "channel", message: "message"})
+        assert_equal "200", res.code
+      }
+    end
+  end
+
+  def test_privmsg
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    Fluent::Engine.now = time
+
+    d.expect_emit "privmsg.channel", time, {"command" => "privmsg", "channel" => "channel", "message" => "message"}
+
+    d.run do
+      d.expected_emits.each {|tag, time, record|
+        res = post("/privmsg", {command: "privmsg", channel: "channel", message: "message"})
+        assert_equal "200", res.code
+      }
+    end
+  end
+
+  def test_join
+    d = create_driver
+    d.run do
+      res = post("/join", {})
+      assert_equal "200", res.code
+    end
+  end
+
+  def test_leave
+    d = create_driver
+    d.run do
+      res = post("/leave", {})
+      assert_equal "200", res.code
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: daioikachan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Naotoshi Seo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: irc_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fluent-plugin-slack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !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'
+description: Ikachan compatible interface with multiple backends (IRC, Slack, etc)
+email: sonots@gmail.com
+executables:
+- daioikachan
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- README/in_daioikachan.md
+- README/out_irc.md
+- Rakefile
+- VERSION
+- bin/daioikachan
+- daioikachan.gemspec
+- examples/example.conf
+- examples/multi_slack.conf
+- lib/fluent/plugin/in_daioikachan.rb
+- lib/fluent/plugin/out_irc.rb
+- test/helper.rb
+- test/plugin/test_in_daioikachan.rb
+homepage: https://github.com/sonots/daioikachan
+licenses:
+- MIT License
+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: Ikachan compatible interface with multiple backends (IRC, Slack, etc)
+test_files:
+- test/helper.rb
+- test/plugin/test_in_daioikachan.rb