wakame-dolphin 0.0.2

data/lib/dolphin/request_handler.rb

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+
+require 'reel/app'
+require 'extlib/blank'
+
+module Dolphin
+  class RequestHandler
+    include Reel::App
+    include Dolphin::Util
+    include Dolphin::Helpers::RequestHelper
+
+    GET_EVENT_LIMIT = 30.freeze
+
+    def initialize(host, port)
+
+      # TODO: Fix Celluloid.logger loading order.
+      logger :info, "Load settings in #{Dolphin.config}"
+
+      @server = Reel::Server.supervise_as(:reques_handler, host, port) do |connection|
+
+        while request = connection.request
+          begin
+            logger :info, {
+              :host => request.headers["Host"],
+              :user_agent => request.headers["User-Agent"]
+            }
+            options = {
+              :method => request.method,
+              :input => request.body
+            }
+            options.merge!(request.headers)
+            status, headers_or_body, body = call Rack::MockRequest.env_for(request.url, options)
+            connection.respond status_symbol(status), headers_or_body, body.to_s
+          rescue => e
+            logger :error, e
+            break
+          end
+        end
+      end
+      logger :info, "Running on ruby #{RUBY_VERSION} with selected #{Celluloid::task_class}"
+      logger :info, "Listening on http://#{host}:#{port}"
+      @server
+    end
+
+    post '/events' do |request|
+      run(request) do
+
+        raise 'Nothing parameters.' if @params.blank?
+
+        event = {}
+        event[:notification_id] = @notification_id
+        event[:message_type] = @message_type
+        event[:messages] = @params
+
+        events = worker.future.put_event(event)
+
+        # always success because put_event is async action.
+        response_params = {
+          :message => 'OK'
+        }
+        respond_with response_params
+      end
+    end
+
+    get '/events' do |request|
+      run(request) do
+
+        limit = @params['limit'].blank? ? GET_EVENT_LIMIT : @params['limit'].to_i
+        raise "Requested over the limit. Limited to #{GET_EVENT_LIMIT}" if limit > GET_EVENT_LIMIT
+
+        params = {}
+        params[:count] = limit
+        params[:start_time] = parse_time(@params['start_time']) unless @params['start_time'].blank?
+        params[:start_id] = @params['start_id'] unless @params['start_id'].blank?
+
+        events = worker.get_event(params)
+        raise events.message if events.fail?
+
+        response_params = {
+          :results => events.message,
+          :message => 'OK'
+        }
+        response_params[:start_time] = @params['start_time'] unless @params['start_time'].blank?
+        respond_with response_params
+      end
+    end
+
+    get '/notifications' do |request|
+      run(request) do
+        required 'notification_id'
+
+        notification = {}
+        notification[:id] = @notification_id
+
+        result = worker.get_notification(notification)
+        raise result.message if result.fail?
+        raise "Not found notification id" if result.message.nil?
+
+        response_params = {
+          :results => result.message,
+          :message => 'OK'
+        }
+        respond_with response_params
+      end
+    end
+
+    post '/notifications' do |request|
+      run(request) do
+        required 'notification_id'
+        raise 'Nothing parameters.' if @params.blank?
+
+        unsupported_sender_types = @params.keys - Sender::TYPES
+        raise "Unsuppoted sender types: #{unsupported_sender_types.join(',')}" unless unsupported_sender_types.blank?
+
+        notification = {}
+        notification[:id] = @notification_id
+        notification[:methods] = @params
+        result = worker.put_notification(notification)
+        raise result.message if result.fail?
+
+        response_params = {
+          :message => 'OK'
+        }
+        respond_with response_params
+      end
+    end
+
+    delete '/notifications' do |request|
+      run(request) do
+        required 'notification_id'
+
+        notification = {}
+        notification[:id] = @notification_id
+
+        result = worker.delete_notification(notification)
+        raise result.message if result.fail?
+
+        response_params = {
+          :message => 'OK'
+        }
+        respond_with response_params
+      end
+    end
+
+    private
+    def worker
+      Celluloid::Actor[:workers]
+    end
+  end
+end

data/lib/dolphin/sender.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+require 'celluloid'
+require 'extlib/blank'
+require 'time'
+
+module Dolphin
+  module Sender
+    TYPES = ['email'].freeze
+
+    TYPE = [:mail_senders].freeze
+
+    class Mail
+      include Celluloid
+      include Dolphin::Util
+
+      def notify(notification_object)
+        time_now = DateTime.now.strftime('%a, %d %b %Y %H:%M:%S %z')
+        send_params = {
+          :from => notification_object.from,
+          :to => notification_object.to,
+          :subject => notification_object.subject,
+          :body => notification_object.body,
+          :date => time_now,
+          :event_id => notification_object.event_id
+        }
+
+        unless notification_object.to.blank?
+          send_params[:cc] = notification_object.cc
+        end
+
+        unless notification_object.bcc.blank?
+          send_params[:bcc] = notification_object.bcc
+        end
+
+        logger :info, send_params
+        begin
+          Mailer.notify(send_params)
+          logger :info, "Success Sent message"
+        rescue => e
+          logger :error, e.message
+        end
+
+      end
+    end
+  end
+end

data/lib/dolphin/util.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+require 'celluloid'
+
+module Dolphin
+  module Util
+    include Celluloid::Logger
+
+    def logger(type, message)
+      message = {
+        :message => message,
+        :classname => self.class.name,
+        :thread_id => Thread.current.object_id
+      }
+      Celluloid.logger.__send__(type, message)
+    end
+  end
+end

data/lib/dolphin/version.rb

@@ -0,0 +1,3 @@
+module Dolphin
+  VERSION = '0.0.1'
+end

data/lib/dolphin/worker.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+require 'extlib/blank'
+
+module Dolphin
+  class Worker
+    include Celluloid
+    include Dolphin::Util
+
+    def put_event(event_object)
+      logger :info, "Worker put events #{event_object}"
+
+      notification_id = event_object[:notification_id]
+      message_template_id = event_object[:message_type]
+
+      future_event = query_processor.future.put_event(event_object)
+
+      # if notification_id not exists, doesn't send notification.
+      unless notification_id
+        return SuccessObject.new
+      end
+
+      future_notification = query_processor.future.get_notification(notification_id)
+
+      # synchronized
+      notifications = future_notification.value
+      event_id = future_event.value
+      if notifications.nil?
+        log_message = "Not found notification: #{event_object[:notification_id]}"
+        logger :error, log_message
+        return FailureObject.new(log_message)
+      end
+
+      if query_processor_failed?(notifications)
+        return FailureObject.new('Failed to get notifications')
+      end
+
+      notifications.each do |sender_type, values|
+        if values.blank?
+          logger :info, "Skip to notify message because notifications was blank."
+          next
+        end
+
+        unless Sender::TYPES.include? sender_type
+          log_message = "Not found sender #{sender_type}"
+          logger :error, log_message
+          # Does not do response to Request Handler.
+          next
+        end
+
+        build_params = {}
+        # TODO: Plugin
+        case sender_type
+          when 'email'
+            build_params["to"] = values['to']
+            build_params["cc"] = values['cc']
+            build_params["bcc"] = values['bcc']
+            build_params["messages"] = event_object[:messages]
+        end
+
+        message = build_message(sender_type, message_template_id, build_params)
+        message.event_id = event_id
+
+        if message.nil?
+          log_message = "Failed to build message: #{message}"
+          logger :error, log_message
+          # Does not do response to Request Handler.
+          next
+        end
+
+        logger :info, "Send notification from Worker #{message}"
+
+        begin
+          send_notification(sender_type, message)
+        rescue => e
+          logger :error, e
+          # Does not do response to Request Handler.
+          next
+        end
+      end
+
+      SuccessObject.new
+    end
+
+    def get_event(params)
+      event = query_processor.get_event(params)
+      if query_processor_failed?(event)
+       return FailureObject.new('Failed to get events')
+     end
+      SuccessObject.new(event)
+    end
+
+    def get_notification(notification)
+      notification_id = notification[:id]
+      notification = query_processor.get_notification(notification_id)
+      if query_processor_failed?(notification)
+        return FailureObject.new('Failed to get notification')
+      end
+      SuccessObject.new(notification)
+    end
+
+    def put_notification(notification)
+      notification = query_processor.put_notification(notification)
+      if query_processor_failed?(notification)
+        return FailureObject.new('Failed to put notification')
+      end
+      SuccessObject.new(notification)
+    end
+
+    def delete_notification(notification)
+      notification = query_processor.delete_notification(notification)
+      if query_processor_failed?(notification)
+        return FailureObject.new('Failed to delete notification')
+      end
+      SuccessObject.new(notification)
+    end
+
+    private
+    def query_processor_failed?(response_data)
+      response_data === FALSE
+    end
+
+    def query_processor
+      Celluloid::Actor[:query_processors]
+    end
+
+    def sender(type)
+      Celluloid::Actor[type]
+    end
+
+    def send_notification(type, log_message)
+      case type
+        when 'email'
+          sender(:mail_senders).notify(log_message)
+        else
+          raise "Unsuppoted sender type: #{type}"
+      end
+    end
+
+    def build_message(type, template_id, params)
+      case type
+        when 'email'
+          MessageBuilder::Mail.new.build(template_id, params)
+        else
+          nil
+      end
+    end
+  end
+end

data/script/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+begin
+  require "rubygems"
+  require "bundler/setup"
+rescue LoadError => e
+end
+
+require File.join(File.expand_path('../../', __FILE__), 'lib/dolphin')
+
+require 'irb'
+IRB.start

data/spec/files/cassandra_models_spec.rb

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+
+describe 'Test Dolphin::Models for Cassandra' do
+  before(:all) do
+    @connection = Dolphin::DataStore::Cassandra.new(
+      :keyspace => 'dolphin_test',
+      :hosts => Dolphin.settings['database']['hosts'],
+      :port => Dolphin.settings['database']['port']
+    )
+    @connection.connect
+  end
+
+  describe Dolphin::Models::Cassandra::Event do
+    before(:all) do
+      if @connection.closed?
+        pending "Cassandra doens't exist"
+      else
+        @event_values = []
+        @event_values << {
+          'notification_id' => "system",
+          'message_type' => "alert_port",
+          'messages' => {
+            "message"=>"Alert!!!!"
+          }
+        }
+
+        @column_name = SimpleUUID::UUID.new(Time.now).to_guid
+        @connection.connect.insert(
+          Dolphin::Models::Cassandra::Event::COLUMN_FAMILY,
+          Dolphin::Models::Cassandra::Event::ROW_KEY,
+          {@column_name => MultiJson.dump(@event_values)}
+        )
+      end
+    end
+
+    describe ".get" do
+      let(:message) {
+        res = @connection.get_event({:count=>1})
+        message = res[0]
+      }
+
+      it "expect to get message id" do
+        expect(message['id']).to eql SimpleUUID::UUID.new(message['id']).to_guid
+      end
+
+      it "expect to get message values" do
+        expect(message['event']).to eql @event_values
+      end
+
+      it "expect to get message created_at formated by ISO8601" do
+        expect(Time.iso8601(message['created_at'])).to be_instance_of Time
+      end
+    end
+
+    describe '.put' do
+      it "expect to put success" do
+        event_id = @connection.put_event(@event_values[0])
+        expect(SimpleUUID::UUID.new(event_id)).to be_a SimpleUUID::UUID
+        event_data = @connection.get_event({
+          :count => 1,
+          :start_id => SimpleUUID::UUID.new(event_id)
+        })[0]
+        expect(event_id).to eql event_data['id']
+      end
+    end
+  end
+
+  context Dolphin::Models::Cassandra::Notification do
+
+    before(:all) do
+      if @connection.closed?
+        pending "Cassandra doens't exist"
+      else
+        @notification_values = {
+          "email"=> {
+            "to" => "foo@example.com,bar@example.com",
+            "cc" => "foo@example.com,bar@example.com",
+            "bcc" =>"foofoo@example.com,barbar@example.com"
+          }
+        }
+        @row_key = 'system'
+        @connection.connect.insert('notifications', @row_key, {
+          'methods' => MultiJson.dump(@notification_values)
+        })
+      end
+    end
+
+    let(:notification_data) do
+      @connection.get_notification(@row_key)
+    end
+
+    describe '.get' do
+      it "expect to the same values before created" do
+        expect(notification_data).to eql @notification_values
+      end
+    end
+
+    describe '.put' do
+      let(:notification_new_data) do
+        @connection.put_notification(@row_key, @notification_values)
+      end
+
+      it "expect to put success" do
+        expect(notification_new_data).to be_nil
+
+        notification_data = @connection.get_notification(@row_key)
+        expect(notification_data).to eql @notification_values
+      end
+    end
+
+    describe '.delete' do
+      it "expect to delete success" do
+        @connection.put_notification(@row_key, @notification_values)
+        notification_new_data = @connection.get_notification(@row_key)
+        expect(notification_new_data).to eql @notification_values
+
+        deleted_notification = @connection.delete_notification(@row_key)
+        expect(deleted_notification).to be_nil
+
+        notification_data = @connection.get_notification(@row_key)
+        expect(notification_data).to be_nil
+      end
+    end
+  end
+end