mamiya 0.0.1.alpha2

data/lib/mamiya/logger.rb

@@ -0,0 +1,190 @@
+require 'logger'
+require 'forwardable'
+require 'thread'
+require 'term/ansicolor'
+require 'time'
+
+module Mamiya
+  class Logger
+    include ::Logger::Severity
+    extend Forwardable
+
+    def self.defaults
+      return @defaults if @defaults
+      if ENV["MAMIYA_LOG_LEVEL"]
+        level = ::Logger::Severity.const_get(ENV["MAMIYA_LOG_LEVEL"].upcase) rescue INFO
+      else
+        level = INFO
+      end
+      @defaults = {color: nil, outputs: [STDOUT], level: level}
+    end
+
+    def initialize(color: self.class.defaults[:color], outputs: self.class.defaults[:outputs], level: self.class.defaults[:level])
+      @logdev = LogDev.new(outputs)
+      @logger = ::Logger.new(@logdev)
+      @logger.level = level
+      @logger.formatter = method(:format)
+
+      @color = color.nil? ? @logdev.tty? : color
+    end
+
+    attr_accessor :color
+    def_delegators :@logger,
+      :<<, :add, :log,
+      :fatal, :error, :warn, :info, :debug,
+      :fatal?, :error?, :warn?, :info?, :debug?,
+      :level, :level=, :progname, :progname=,
+      :close
+
+    def_delegators :@logdev, :reopen
+
+    def add_output(*outputs)
+      @logdev.add(*outputs)
+    end
+
+    def remove_output(*outputs)
+      @logdev.remove(*outputs)
+    end
+
+    def with_additional_file(*outputs)
+      @logdev.add_output(*outputs)
+
+      yield
+
+    ensure
+      @logdev.remove_output(*outputs)
+    end
+
+    def [](progname)
+      self.dup.tap do |new_logger|
+        new_logger.instance_eval do
+          @logger = @logger.dup
+          @logger.progname = progname
+        end
+      end
+    end
+
+    private
+
+    def format(severity, time, progname, msg)
+      rseverity = " #{severity.rjust(5)} "
+      if @color
+        colored_severity = case severity
+          when 'ANY'.freeze
+            rseverity
+          when 'DEBUG'.freeze
+            Term::ANSIColor.on_black(rseverity)
+          when 'INFO'.freeze
+            Term::ANSIColor.on_blue(rseverity)
+          when 'WARN'.freeze
+            Term::ANSIColor.on_yellow(Term::ANSIColor.black(rseverity))
+          when 'ERROR'.freeze
+            Term::ANSIColor.on_magenta(rseverity)
+          when 'FATAL'.freeze
+            Term::ANSIColor.on_red(Term::ANSIColor.white(Term::ANSIColor.bold(rseverity)))
+          else
+            rseverity
+          end
+      else
+        colored_severity = "#{rseverity}|"
+      end
+
+      msg = "#{(progname && "[#{progname}] ")}#{msg}"
+      if @color
+        colored_msg = case severity
+          when 'DEBUG'.freeze
+            Term::ANSIColor.bright_black(msg)
+          when 'FATAL'.freeze
+            Term::ANSIColor.bold(msg)
+          else
+            msg
+          end
+      else
+        colored_msg = msg
+      end
+
+      formatted_time = time.strftime('%m/%d %H:%M:%S')
+      colored_time = @color ? Term::ANSIColor.bright_black(formatted_time) : formatted_time
+
+      "#{colored_time} " \
+      "#{colored_severity} " \
+      "#{colored_msg}" \
+      "\n"
+    end
+
+    class LogDev
+      def initialize(outputs)
+        @outputs = normalize_outputs(outputs)
+        @mutex = Mutex.new
+      end
+
+      def tty?
+        @outputs.all?(&:tty?)
+      end
+
+      def write(*args)
+        @outputs.each do |output|
+          output.write(*args) unless output.respond_to?(:closed?) && output.closed?
+        end
+        self
+      end
+
+      def close
+        @outputs.each do |output|
+          output.close unless output.respond_to?(:closed?) && output.closed?
+        end
+        self
+      end
+
+      def reopen
+        @outputs.select { |io| io.respond_to?(:path) }.each do |io|
+          sync = io.sync
+          io.reopen(io.path, 'a')
+          io.sync = sync
+        end
+      end
+
+      def add(*outputs)
+        @mutex.synchronize do
+          @outputs.push(*normalize_outputs(outputs))
+        end
+        self
+      end
+
+      def remove(*removing_outputs)
+        @mutex.synchronize do
+          removing_outputs.each do |removing|
+            case removing
+            when File
+              @outputs.reject! { |out| out.kind_of?(File) && out.path == removing.path }
+            when IO
+              @outputs.reject! { |out| out.kind_of?(IO) && out.fileno == removing.fileno }
+            when String
+              @outputs.reject! { |out| out.kind_of?(File) && out.path == removing }
+            when Integer
+              @outputs.reject! { |out| out.kind_of?(IO) && out.fileno == removing }
+            else
+              @outputs.reject! { |out| out == removing }
+            end
+          end
+        end
+        self
+      end
+
+      private
+
+      def normalize_outputs(ary)
+        ary.map do |out|
+          case
+          when out.respond_to?(:write)
+            out
+          when out.kind_of?(String)
+            File.open(out, 'a').tap{ |_| _.sync = true }
+          else
+            raise ArgumentError, 'output should able to respond to :write or be String'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mamiya/master.rb

@@ -0,0 +1,118 @@
+require 'mamiya/agent'
+require 'mamiya/master/web'
+require 'mamiya/master/agent_monitor'
+
+module Mamiya
+  class Master < Agent
+    MASTER_EVENTS = []
+
+    def initialize(*)
+      super
+
+      @agent_monitor = AgentMonitor.new(self)
+      @events_only ||= []
+      @events_only << MASTER_EVENTS
+    end
+
+    attr_reader :agent_monitor
+
+    def web
+      logger = self.logger
+      this = self
+
+      @web ||= Rack::Builder.new do
+        use AppBridge, logger, this
+        run Web
+      end
+    end
+
+    def start
+      # Override and stop starting fetcher
+      web_start
+      serf_start
+      monitor_start
+    end
+
+    def distribute(application, package)
+      trigger(:fetch, application: application, package: package)
+    end
+
+    def storage(app)
+      config.storage_class.new(
+        config[:storage].merge(
+          application: app
+        )
+      )
+    end
+
+    def applications
+      config.storage_class.find(
+        config[:storage]
+      ).keys
+    end
+
+    def status
+      {name: serf.name, master: true}
+    end
+
+    private
+
+    def init_serf
+      super.tap do |serf|
+        serf.on_user_event do |event|
+          monitor_commit_event(event)
+        end
+
+        serf.on_member_join do |event|
+          @agent_monitor.refresh(node: event.members.map { |_| _[:name] })
+        end
+      end
+    end
+
+    def monitor_commit_event(event)
+      @agent_monitor.commit_event(event)
+    rescue Exception => e
+      logger.fatal("Error during commiting event: #{e.inspect}")
+      e.backtrace.each do |line|
+        logger.fatal "\t#{line}"
+      end
+    end
+
+    def web_start
+      @web_thread = Thread.new do
+        options = config[:web] || {}
+        rack_options = {
+          app: self.web,
+          Port: options[:port].to_i,
+          Host: options[:bind],
+          environment: options[:environment],
+          server: options[:server],
+          Logger: logger['web']
+        }
+        server = Rack::Server.new(rack_options)
+        # To disable trap(:INT) and trap(:TERM)
+        server.define_singleton_method(:trap) { |*args| }
+        server.start
+      end
+      @web_thread.abort_on_exception = true
+    end
+
+    def monitor_start
+      logger.debug "Starting agent_monitor..."
+      @agent_monitor.start!
+      logger.debug "agent_monitor became ready"
+    end
+
+    class AppBridge
+      def initialize(app, log, this)
+        @app, @logger, @this = app, log['web'], this
+      end
+
+      def call(env)
+        env['rack.logger'] = @logger
+        env['mamiya.master'] = @this
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/mamiya/master/agent_monitor.rb

@@ -0,0 +1,146 @@
+require 'json'
+require 'set'
+require 'thread'
+
+require 'mamiya/master'
+require 'mamiya/master/agent_monitor_handlers'
+
+module Mamiya
+  class Master
+    ##
+    # Class to monitor agent's status. This collects all agents' status.
+    # Statuses are updated by event from agent, and running serf query `mamiya:status` periodically.
+    class AgentMonitor
+      include AgentMonitorHandlers
+
+      STATUS_QUERY = 'mamiya:status'.freeze
+      DEFAULT_INTERVAL = 60
+
+      def initialize(master, raise_exception: false)
+        @master = master
+        @interval = (master.config[:master] && 
+                    master.config[:master][:monitor] &&
+                    master.config[:master][:monitor][:refresh_interval]) ||
+                    DEFAULT_INTERVAL
+ 
+        @raise_exception = raise_exception
+
+        @agents = {}.freeze
+        @failed_agents = [].freeze
+        @statuses = {}
+        @commit_lock = Mutex.new
+      end
+
+      attr_reader :statuses, :agents, :failed_agents
+
+      def start!
+        @thread ||= Thread.new do
+          loop do
+            self.work_loop
+            sleep @interval
+          end
+        end
+      end
+
+      def stop!
+        @thread.kill if running?
+        @thread = nil
+      end
+
+      def running?
+        @thread && @thread.alive?
+      end
+
+      def work_loop
+        self.refresh
+      rescue Exception => e
+        raise e if @raise_exception
+
+        logger.fatal "Periodical refreshing failed: #{e.class}: #{e.message}"
+        e.backtrace.each do |line|
+          logger.fatal "\t#{line}"
+        end
+      end
+
+      def commit_event(event)
+        @commit_lock.synchronize { commit_event_without_lock(event) }
+      end
+
+      def commit_event_without_lock(event)
+        return unless /\Amamiya:/ === event.user_event
+
+        method_name = event.user_event[7..-1].gsub(/:/, '__').gsub(/-/,'_')
+        return unless self.respond_to?(method_name, true)
+
+        payload = JSON.parse(event.payload)
+        agent = @statuses[payload["name"]]
+        return unless agent
+
+        logger.debug "Commiting #{event.user_event}"
+        logger.debug "- #{agent.inspect}"
+        __send__ method_name, agent, payload, event
+        logger.debug "+ #{agent.inspect}"
+
+      rescue JSON::ParserError => e
+        logger.warn "Failed to parse payload in event #{event.user_event}: #{e.message}"
+      end
+
+      def refresh(**kwargs)
+        # TODO: lock
+        logger.debug "Refreshing..."
+
+        new_agents = {}
+        new_failed_agents = Set.new
+        new_statuses = {}
+
+        @master.serf.members.each do |member|
+          new_agents[member["name"]] = member
+          new_failed_agents.add(member["name"]) unless member["status"] == 'alive'
+        end
+
+        @commit_lock.synchronize { 
+          response = @master.serf.query(STATUS_QUERY, '', **kwargs)
+          response["Responses"].each do |name, json|
+            begin
+              new_statuses[name] = JSON.parse(json)
+            rescue JSON::ParserError => e
+              logger.warn "Failed to parse status from #{name}: #{e.message}"
+              new_failed_agents << name
+              next
+            end
+          end
+
+          new_failed_agents = new_failed_agents.to_a
+
+          (new_agents.keys - @agents.keys).join(", ").tap do |agents|
+            logger.info "Added agents: #{agents}" unless agents.empty?
+          end
+
+          (@agents.keys - new_agents.keys).join(", ").tap do |agents|
+            logger.info "Removed agents: #{agents}" unless agents.empty?
+          end
+
+          (failed_agents - new_failed_agents).join(", ").tap do |agents|
+            logger.info "Recovered agents: #{agents}" unless agents.empty?
+          end
+
+          (new_failed_agents - failed_agents).join(", ").tap do |agents|
+            logger.info "Newly failed agents: #{agents}" unless agents.empty?
+          end
+
+          @agents = new_agents.freeze
+          @failed_agents = new_failed_agents.freeze
+          @statuses = new_statuses
+        }
+
+        self
+      end
+
+      private
+
+      def logger
+        @logger ||= @master.logger['agent-monitor']
+      end
+    end
+  end
+end