nand 0.1.2

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nand"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/nand

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'nand'
+require 'nand/cli'
+
+def split_options( argv )
+  if argv.include? "--"
+    idx = argv.index("--")
+    [argv[0...idx], argv[idx+1..-1] ]
+  else
+    [argv, []]
+  end
+end
+
+wrap_exception{
+  argv, additional = split_options(ARGV)
+  Nand.additional_argv = additional
+  Cli.start(argv)
+}

data/lib/nand.rb

@@ -0,0 +1,47 @@
+require "nand/version"
+
+module Nand
+  def wrap_exception
+    yield
+  rescue => e
+    STDERR.puts e.message
+    #STDERR.puts "\n\t" + e.backtrace.join("\n\t")
+    exit -1
+  end
+  def self.additional_argv=(argv)
+    @@additional_argv ||= argv.freeze
+  end
+  def self.additional_argv
+    @@additional_argv
+  end
+  def string_to_stdio( str )
+    if str.to_s.upcase =~/^STD(OUT|ERR|IN)$/
+      eval(str)
+    else
+      str
+    end
+  end
+  def restore_options( options )
+    opts = options.dup
+    unless opts[:debug]
+      opts[:out] &&= string_to_stdio(opts[:out])
+      opts[:err] &&= string_to_stdio(opts[:err])
+      opts[:in]  &&= string_to_stdio(opts[:in] )
+
+      opts[:daemon_log] &&= string_to_stdio(opts[:daemon_log])
+      opts[:daemon_out] &&= string_to_stdio(opts[:daemon_out])
+      opts[:daemon_err] &&= string_to_stdio(opts[:daemon_err])
+
+    else
+      opts[:out] = STDOUT
+      opts[:err] = STDERR
+
+      opts[:daemon_out] = STDOUT
+      opts[:daemon_err] = STDERR
+      opts[:daemon_log] = STDOUT
+    end
+    opts
+  end
+end
+
+include Nand

data/lib/nand/cli.rb

@@ -0,0 +1,126 @@
+# -*-mode: ruby; coding: utf-8 -*-
+
+require 'pathname'
+require 'thor'
+
+require 'nand/daemon'
+require 'nand/logger'
+require 'nand/launcher'
+
+module Nand
+  class Cli < Thor
+    include Logging
+
+    class_option :run_dir, :desc => "Specify running dir, Default is a Current Directory"
+    class_option :debug, :type => :boolean, :default => false, :hide => true, :desc => "This is debug flag, Daemon process stdout/stderr pipes to this terminal"
+
+    desc "start EXEC_TARGET [OPTIONS] [-- EXEC OPTIONS]", "Start Daemon for EXEC with options"
+    option :out, :aliases => '-o', :default => "/dev/null", :desc => "Daemon process STDOUT pipes to output file"
+    option :err, :aliases => '-e', :default => "/dev/null", :desc => "Daemon process STDERR pipes to output error file"
+    option :in, :aliases => '-i', :default => "/dev/null", :desc => "Daemon process STDIN  pipes to input file"
+    option :name, :aliases => '-n', :desc => "Spcify Alias Name of Daemon process, default is first argument(EXEC_TARGET)"
+    option :plugin, :aliases => '-p', :desc => "Nand Plugin File Name or Gem Package Name"
+    option :sec, :aliases => '-s', :type => :numeric, :desc => "Running time limit [seconds] of Daemon process"
+    option :demon_out, :default => "/dev/null", :hide => true, :desc => "Daemon Process STDOUT pipes DEAMON_OUT"
+    option :demon_err, :default => "/dev/null", :hide => true, :desc => "Daemon Process STDERR pipes DEAMON_ERR"
+    option :demon_log, :default => "/dev/null", :desc => "Output Daemon Process Log file"
+    option :recovery, :aliases => '-r', :type => :boolean, :desc => "Auto Recovery"
+    option :recovery_sec, :type => :numeric, :desc => "Auto Recovery time span[seconds]"
+
+    def start(target, *argv)
+      opts = restore_options(options)
+      log_debug! if opts[:debug]
+      dir = run_dir(opts)
+      dir.mkpath unless dir.exist?
+      launcher = find_launcher(target, opts, *argv)
+      opts[:launcher] = launcher
+      daemon = Daemon.new(dir, launcher.execname, opts)
+      print "#{daemon.execname} is Start "
+      begin
+        daemon.run
+        sleep 0
+        if daemon.running?
+          puts "Success [#{daemon.pid}]"
+        end
+      rescue => e
+        puts "Failed [#{e.message}]"
+        log.debug "\t" + e.backtrace.join("\n\t")
+        exit -1
+      end
+    end
+
+    desc "status [EXEC_TARGET] [OPTIONS]", "Show Running Daemon Process Status w/wo EXEC_TARGET"
+    option :all, :aliases => '-a', :type => :boolean, :desc => "All running Daemons Status in this Server"
+    def status(target = nil)
+      ds = if options[:all]
+             Daemon.all_runnings
+           else
+             Daemon.running_in(run_dir(options), target)
+           end
+      ds.each do |d|
+        puts status_message(d.run_dir, d.execname, d.running?, d.pid, d.user)
+      end
+      puts status_message(run_dir(options), target, false) if ds.empty? and !target.nil?
+    end
+
+    desc "stop [EXEC_TARGET] [OPTIONS]", "Stop Daemon Process w/wo EXEC_TARGET"
+    option :all, :aliases => '-a', :type => :boolean, :desc => "Show All Running Daemon Status in this Server"
+    def stop(target = nil)
+      dir = run_dir(options)
+      log_debug! if options[:debug]
+      ds = if options[:all]
+             Daemon.all_runnings
+           else
+             Daemon.running_in(dir, target)
+           end
+      ds.each do |d|
+        pid = d.pid
+        if d.running?
+          begin
+            print "#{d.execname} is "
+            d.stop and puts "Stopped [#{pid}]"
+          rescue => e
+            puts "Failed [#{e.message}]"
+            log.debug "\t" + e.backtrace.join("\n\t")
+          end
+        else
+          puts "#{d.execname} is Not Running"
+        end
+      end
+      puts status_message(dir, target, false) if !target.nil? and ds.empty?
+    end
+
+    desc "version", ""
+    def version
+        puts File.basename($PROGRAM_NAME) + " " + VERSION
+    end
+
+    private
+    def find_launcher(target, opts, *argv, &block)
+      launcher = Nand::Launcher.find( target, opts, *(argv + Nand.additional_argv) )
+      if block_given?
+        block.call(launcher)
+      else
+        launcher
+      end
+    end
+    def run_dir(opts)
+      Pathname.new(opts[:run_dir] || Dir.pwd)
+    end
+    def status_message(dir, target, running, pid = nil, user = nil)
+      "#{target} is " + (running ? "Running [#{pid}] by #{user}" : "Not Running") + " in #{dir}"
+    end
+    no_tasks do
+      # デフォルトメソッドを上書きして -h をヘルプ
+      def invoke_task(task, *args)
+        if options[:help]
+          help(task.name)
+        elsif options[:version] or args.flatten.first == "-v"
+          version
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/nand/daemon.rb

@@ -0,0 +1,127 @@
+# -*-mode: ruby; coding: utf-8 -*-
+
+require 'pathname'
+require 'nand/proc_operation'
+require 'nand/logger'
+
+module Nand
+  class Daemon
+    extend ProcOperation
+    include Logging
+    def logger_output_params ; [@daemon_log]     end
+    def logger_progname      ; @execname         end
+    def logger_formatter     ; TimeFormatter.new end
+
+    attr_reader :execname, :run_dir
+    def initialize(run_dir, execname, opts = {} )
+      @run_dir = Pathname.new(run_dir)
+      @execname = execname.to_s
+      @launcher = opts[:launcher]
+      @arg_uid  = opts[:uid]
+      @pid_file = @run_dir.join(self.class.pid_filename(@execname))
+      @daemon_log = opts[:daemon_log] || "/dev/null"
+      @daemon_out = opts[:daemon_out] || "/dev/null"
+      @daemon_err = opts[:daemon_err] || "/dev/null"
+      @recovery   = opts[:recovery] || false
+      @recovery_sec = opts[:recovery_sec] || 1
+      @limit = opts[:sec]
+
+      log.level  = LOG_DEBUG if opts[:debug]
+    end
+    def user
+      Etc.getpwuid(uid).name
+    rescue => e
+      nil
+    end
+    def uid;  @arg_uid || Process.uid  end
+    def running?; @pid_file.exist? and self.class.running_with?(pid, @execname) end
+
+    def run
+      raise "Launcher is Not Specified for #{@execname}" if @launcher.nil?
+      raise "PID file exist #{@pid_file}" if @pid_file.exist?
+      daemonize
+    end
+    def stop; stop_with_signal(:TERM) end
+    def kill; stop_with_signal(:KILL) end
+    def pid;  @pid ||=self.class.pid_from_pidfile(@pid_file) end
+
+    private
+    def daemonize( &block )
+      if child = Process.fork
+        Process.waitpid(child) # wait until exit child process
+        return child
+      end
+      Process.setsid
+      exit(0) if Process.fork # double fork and exit child process
+      Process.setsid
+      Dir.chdir(@run_dir)
+      File.umask(0)
+      STDIN.reopen("/dev/null")
+      STDOUT.reopen(@daemon_out)
+      STDERR.reopen(@daemon_err)
+
+      begin
+        File.open(@pid_file, "w"){|fs| fs.puts Process.pid }
+
+        log.info "Daemonize [#{Process.pid}]"
+
+        Signal.trap(:INT)  {Thread.new{log.warn("RECEVIED Signal INT") ; send_signal_and_exit(:INT)}}
+        Signal.trap(:TERM) {Thread.new{log.warn("RECEVIED Signal TERM") ; send_signal_and_exit(:TERM)}}
+        begin
+          sleep 0.1
+
+          @child = @launcher.launch
+          raise "Failed Launch for #{@execname}" if @child.nil?
+          log.info "Launched Child Process [#{@child}]"
+
+          wait_untill_limit if !@limit.nil? and 0 < @limit
+
+          Process.waitpid2(@child) unless @child.nil?
+          log.warn "PID #{@child} down"
+          sleep @recovery_sec if @recovery
+        end while @recovery
+      rescue => e
+        log.fatal e.message
+        log.debug "\n\t" + e.backtrace.join("\n\t")
+      ensure
+        terminate
+      end
+    end
+    def terminate( code = 0 )
+      unless @child.nil?
+        log.info "terminate for #{@child} with exit code #{code}"
+        @child = nil
+      end
+      @pid_file.delete if @pid_file.exist?
+      exit code
+    end
+    def send_signal_and_exit(type)
+      Process.kill(type, -@child) unless @child.nil?
+      log.warn "Sent Signal #{type} to #{@child}"
+      terminate
+    rescue => e
+      log.fatal "Failed Send Signal to -#{@child}, since #{e.message}"
+      terminate -1
+    end
+    private
+    def stop_with_signal(signal)
+      raise "Can Not Send #{signal.to_s.capitalize} Signal to #{@execname}" unless uid == Process.uid or uid == 0
+      unless running?
+        @pid_file.delete if @pid_file.exist?
+        raise "#{@execname} is Not Running"
+      end
+      Process.kill(signal, pid)
+    end
+    def wait_untill_limit
+      Signal.trap(:SIGCHLD) {terminate}
+      pid, status = Process.waitpid2(@child, Process::WNOHANG)
+      if pid.nil?
+        log.info "Child[#{@child}] will be Stopped after #{@limit} sec"
+        sleep @limit
+        Signal.trap(:SIGCHLD, "IGNORE")
+        log.info "Send Signal TERM to Child[#{@child}] #{@limit} sec past"
+        Process.kill(:TERM, @child)
+      end
+    end
+  end
+end

data/lib/nand/launcher.rb

@@ -0,0 +1,55 @@
+# -*-mode: ruby; coding: utf-8 -*-
+
+require 'pathname'
+require 'stringio'
+
+module Nand
+  module Launcher
+    def self.find(target, opts = {}, *argv)
+      require 'nand/launcher/executable_file_launcher'
+      require 'nand/launcher/shell_launcher'
+      require 'nand/launcher/rb_file_launcher'
+      require 'nand/launcher/plugin_launcher'
+
+      err = StringIO.new("", "w")
+      launcher_klass = [ExecutableFileLauncher, RbFileLauncher, PluginLauncher, ShellLauncher].find do |klass|
+        klass.launchable? target, err, opts
+      end
+      raise "Not Found Executable #{target}:\n#{io.string}" if launcher_klass.nil?
+      launcher = launcher_klass.load(target, opts, *argv)
+      raise "Not be Ready for #{target} Launcher" unless launcher.ready?
+      launcher
+    end
+
+    class Base
+      def self.launchable?(target, io, *argv)
+        raise "Not Implemented #{__method__} in #{self.name}"
+      end
+      def self.load( target, opts, *argv)
+        raise "Not Implemented #{__method__} in #{self.name}"
+      end
+      attr_reader :execname
+      def initialize(target, opts, *argv)
+        @progname    = target
+        @execname    = opts[:name] || File.basename(target)
+        @exec_stdout = opts[:out]  || "/dev/null"
+        @exec_stderr = opts[:err]  || "/dev/null"
+        @exec_stdin  = opts[:in]   || "/dev/null"
+        @argv   = argv
+      end
+      def launch; end
+      def ready?
+        [@exec_stdout, @exec_stderr].each do |out|
+          next if out.is_a? IO
+          path = Pathname.new(out)
+          raise "Illegal Output File #{path.to_s}" unless (path.exist? and path.writable?) or
+            (!path.exist? and path.dirname.writable?)
+        end
+        return true if @exec_stdin.is_a? IO
+        path = Pathname.new(@exec_stdin)
+        raise "Illegal Input File #{@exec_stdin.to_s}" unless path.exist? and path.readable?
+        true
+      end
+    end
+  end
+end

data/lib/nand/launcher/executable_file_launcher.rb

@@ -0,0 +1,35 @@
+# -*-mode: ruby; coding: utf-8 -*-
+
+require 'nand/launcher/shell_launcher'
+
+module Nand
+  module Launcher
+    class ExecutableFileLauncher < ShellLauncher
+      def self.launchable?(target, io, opts)
+        file = exec_file(target)
+        raise "Not Found #{file.to_s}"  unless file.exist?
+        raise "Not Executable #{file.to_s}" unless file.executable?
+        true
+      rescue => e
+        io.puts "\t- " + e.message
+        false
+      end
+      def self.load(target, opts = {}, *argv)
+        file = exec_file(target)
+        new(target, opts, *argv)
+      end
+      def self.exec_file(target)
+        Pathname.new(target).expand_path
+      end
+      attr_reader :name
+      def initialize(target, opts, *argv)
+        super(target, opts, *argv)
+        @file = self.class.exec_file(target)
+        @name = opts[:name] || @file.basename.to_s
+      end
+      def cmd; "#{@file} #{@argv.join(" ")}" end
+    end
+  end
+end
+
+

data/lib/nand/launcher/plugin_launcher.rb

@@ -0,0 +1,29 @@
+# -*-mode: ruby; coding: utf-8 -*-
+
+require 'nand/plugin'
+require 'nand/launcher/rb_file_launcher'
+
+module Nand
+  module Launcher
+    class PluginLauncher < RbFileLauncher
+      def self.require_rb(target)
+        require "#{target}/nand/plugin"
+      end
+      def self.launchable?( target, io, opts )
+        specs = Gem::Specification.find_all do |s|
+          s.name =~/^(nand-)*#{target}$/ and s.dependencies.find{ |d| d.name == "nand" }
+        end
+        raise "Not Found #{target} in Installed gems" if specs.empty?
+        raise "Target name #{target} is Not Uniq for installed gem" if 1 < specs.size
+        require_rb(specs.first.name)
+        true
+      rescue LoadError => e
+        io.puts "\t- " + e.message
+        false
+      rescue => e
+        io.puts "\t- " + e.message
+        false
+      end
+    end
+  end
+end