ruboty-exec_command 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c22adae587104ba29fd27dea7c0f6d391f5d4db6
-  data.tar.gz: b4ab84f740da52a7bc08f6e8974295409ac195bb
+  metadata.gz: 6f31fbeb824f00f5843ea7a7168363a33539b82f
+  data.tar.gz: d7fabdad9e511f00165e8096e828e83f1af70023
 SHA512:
-  metadata.gz: 761fa8ddc718ed11e1c0f8effee917c663a3b2e43f7bf9faede6a7f654532e1b154e7c6bbeadf01540500ab7ede514ba1a761dd5adce574ea33463c28bba4768
-  data.tar.gz: 9d03859456db4d1124f6a472ae811f4d0dd32f9956e2a6dae0f5cbf88016d8bfa3acdc21ef357cd445d1dbfcae083cb175e7341529dbdb9009891c60f2901d23
+  metadata.gz: 45bc5f831cdc072533200b0ce52c2a4dadc83cb9808c7620c407de2fbf4e64a30b7de6660c5c5b651b0c03693d32c9abab394577d1967b53891b30a3a186b3ce
+  data.tar.gz: 6c91c79b5694c3017427aeea2f804395f662ff8bc949aa51a72fc1bf99436faa9fb43f3495162eeba4fc76cd174211d57466420764a83f6de57584360ea0cc6a

data/.gitignore

@@ -12,3 +12,6 @@
 *.o
 *.a
 mkmf.log
+
+# exec_command log files
+/logs

data/README.md

@@ -12,6 +12,16 @@ if RUBOTY_ROOT is defined.
 For your convinience, please implement -h option into the
 command. The usage will be used for help message of ruboty.
 
+## Command Controll
+
+List running commands:
+
+    > ruboty command list
+
+Kill running command, you can specify command index in the result of ```command list``` or PID
+
+    > ruboty command kill <index|PID>
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -28,6 +38,12 @@ Or install it yourself as:
 
     $ gem install ruboty-exec_command
 
+## History
+
+- 0.0.4:
+ - command runs as a back ground thread
+ - command accepts option arguments
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/ruboty-exec_command/fork )

data/commands/example/hello

@@ -1,3 +1,5 @@
 #!/bin/bash
 
-echo hello!
+[ "$1" == "-h" ] && echo "say hello!" && exit
+
+echo hello $*!

data/commands/example/sleep

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+if [ "$1" == "-h" ]; then
+  echo "sleep"
+else
+  echo "Have a good sleep." 1>&2
+  sleep $*
+fi

data/lib/ruboty/exec_command/actions/command.rb

@@ -4,8 +4,53 @@ module Ruboty
       class Command < Ruboty::Actions::Base
         def call
           # TODO: add timeout
-          extension = Ruboty::ExecCommand::Command.new(command_args: command_body)
-          message.reply(extension.run.chomp)
+          c = Ruboty::ExecCommand::Command.new(command_args: command_body)
+          run_and_monitor(c)
+        end
+
+        def command_slot
+          message.robot.brain.data[:command_slot] ||= Ruboty::ExecCommand::CommandSlot.new
+        end
+
+        def list_commands
+          message.reply(command_slot.list_commands)
+        end
+
+        def kill_command
+          # TODO: command list lock
+          # kill running process, command is "kill command <index>"
+          killed = command_slot.kill(message.body.split.last.to_i)
+
+          if killed.nil?
+            message.reply("Command [#{message.body.split.last}] not found.")
+          end
+        end
+
+        def run_and_monitor(comm)
+          pid = command_slot.run(comm)
+          message.reply("[#{comm.command_name}] invoked.")
+
+          # Waiter thread
+          thread = Thread.new do
+            ignore_pid, status = Process.wait2(pid)
+            command_slot.forget(pid)
+
+            if status.exitstatus == 0
+              message.reply("[#{comm.command_name}] completed successfully.")
+              message.reply(comm.stdout_log.chomp)
+            elsif status.signaled?
+              message.reply("[#{comm.command_name}] killed by signal #{status.termsig}")
+            else
+              message.reply("[#{comm.command_name}] exit status with #{status}\n" +
+                          comm.stdout_log +
+                          "stderr: " + comm.stderr_log.chomp
+                        )
+            end
+          end
+
+          if ENV['RUBOTY_ENV'] == 'blocked_test'
+            thread.join
+          end
         end
 
         def robot_prefix_pattern

data/lib/ruboty/exec_command/command.rb

@@ -3,8 +3,16 @@ module Ruboty
     class Command
 
       class << self
+        def ruboty_root
+          "#{ENV['RUBOTY_ROOT'] || Dir.pwd}"
+        end
+
         def command_root
-          "#{ENV['RUBOTY_ROOT'] || Dir.pwd}/commands"
+          "#{ruboty_root}/commands"
+        end
+
+        def log_root
+          "#{ruboty_root}/logs/exec_command"
         end
 
         def command?(path)
@@ -27,34 +35,93 @@ module Ruboty
       def initialize(args={})
         args = { absolute_path: nil, command_args: nil }.merge(args)
         @absolute_path = args[:absolute_path]
-        @command_args = args[:command_args]
+        @command_args = args[:command_args].split if not args[:command_args].nil?
+        @pid = nil
+        @start_at = nil
       end
 
+      attr_reader :pid
+      attr_reader :start_at
+
       def absolute_path
-        @absolute_path ||= command2path
+        @absolute_path ||= command2path[0]
       end
 
       def relative_path
         @relative_path ||= absolute_path.sub(/^#{self.class.command_root}\//,"")
       end
 
-      def command_args
-        @command_args ||= relative_path.gsub('/', ' ')
+      def command_name
+        @command_name ||= relative_path.gsub('/', ' ')
+      end
+
+      def __command2path(path, args)
+        if self.class.command?(path)
+          [path, args]
+        else
+          if args == []
+            # command not found
+            return ["", ""]
+          else
+            __command2path("#{path}/#{args[0]}", args.slice(1, args.length))
+          end
+        end
       end
 
       def command2path
         path = self.class.command_root
-        @command_args.split(" ").each do |arg|
-          path = "#{path}/#{arg}"
-          return path if self.class.command?(path)
-        end
-        ""
+        __command2path "#{path}/#{@command_args[0]}",
+                      @command_args.slice(1, @command_args.length)
+      end
+
+      def opt_args
+        @opt_args ||= command2path[1]
+      end
+
+      def this_month
+        Time.now.strftime "%Y-%m"
+      end
+
+      def this_time
+        Time.now.strftime "%Y-%m-%d_%H:%M:%S"
+      end
+
+      def log_dir
+        d = "#{self.class.log_root}/#{this_month}"
+        FileUtils.mkdir_p(d) if not Dir.exists?(d)
+        d
+      end
+
+      def output_file_name
+        %Q(#{log_dir}/#{command_name.gsub(" ", "_")}-#{this_time})
+      end
+
+      def output_files
+        # return temporary output file IO objects [stdout, stderr]
+        ["#{output_file_name}.out", "#{output_file_name}.err"]
+      end
+
+      def stdout_log
+        # return contents of stdout
+        File.open(output_files[0]).read
+      end
+
+      def stderr_log
+        # return contents of stderr
+        File.open(output_files[1]).read
       end
 
       def run(args=[])
         `#{absolute_path} #{args.join(" ")}`
       end
 
+      def run_bg(args=[])
+        stdout, stderr = output_files
+        @start_at = this_time
+        @pid = Process.spawn(%Q(#{absolute_path} #{args.join(" ")}),
+                        pgroup: true, out: stdout, err: stderr)
+      end
+
       def help
         run(args=['-h']).chomp
       end

data/lib/ruboty/exec_command/command_slot.rb

@@ -0,0 +1,70 @@
+module Ruboty
+  module ExecCommand
+    class CommandSlot
+
+      def initialize
+        @commands = []
+      end
+
+      def running_commands
+        @commands
+      end
+
+      def remember(comm)
+        # remember
+        #     comm: command object
+        # TODO: add owner info
+        @commands << comm
+      end
+
+      def forget(pid)
+        # remove thread object
+        @commands.delete_if do |c|
+          c.pid == pid
+        end
+      end
+
+      def command_in_list(idx_or_pid)
+        found = @commands.index { |c| c.pid == idx_or_pid }
+
+        if found.nil?
+          i = idx_or_pid.to_i
+          num_commands = @commands.size
+          if i <= 0 or i > num_commands
+            nil
+          else
+            @commands[i-1]
+          end
+        else
+          @commands[found]
+        end
+      end
+
+      def run(command)
+        remember(command)
+        command.run_bg(command.opt_args)
+      end
+
+      def list_commands
+        if @commands.size == 0
+          "No command running."
+        else
+          number = 0
+          @commands.map do |c|
+            number += 1
+            "#{number}: #{c.command_name} (PID[#{c.pid}], started at #{c.start_at})\n"
+          end.join.chomp
+        end
+      end
+
+      def kill(idx_or_pid)
+        command = command_in_list(idx_or_pid)
+        unless command.nil?
+          Process.kill(-9, command.pid) # kill process group
+          forget(command.pid)
+        end
+        command
+      end
+    end
+  end
+end

data/lib/ruboty/exec_command/version.rb

@@ -1,5 +1,5 @@
 module Ruboty
   module ExecCommand
-    VERSION = "0.0.2"
+    VERSION = "0.1.0"
   end
 end

data/lib/ruboty/exec_command.rb

@@ -1,3 +1,4 @@
 require "ruboty/exec_command/command"
+require "ruboty/exec_command/command_slot"
 require "ruboty/exec_command/version"
 require "ruboty/handlers/command"

data/lib/ruboty/handlers/command.rb

@@ -3,20 +3,35 @@ require "ruboty/exec_command/actions/command"
 module Ruboty
   module Handlers
     class Command < Base
+
+      on(/command list/i, name: "list_commands",
+          description: "List running commands in background")
+
+      on(/command kill/i, name: "kill_command",
+          description: "command kill <index|PID>  ")
+
       # Registering commands. Each command is located
       # under "commands" directory. The path name to the
       # executable command is gonna be a command name.
-      #  i.e. commands/server/monitor => /^server monitor.*/
+      #  i.e. commands/server/monitor => /server monitor/
       # The command should return a usage with -h option
       def self.register_commands
         Ruboty::ExecCommand::Command.all.each do |e|
-          on /#{e.command_args}/i, name: "command_handler", description: e.help
+          on /#{e.command_name}/i, name: "command_handler", description: e.help
         end
       end
 
       def command_handler(message)
         Ruboty::ExecCommand::Actions::Command.new(message).call
       end
+
+      def list_commands(message)
+        Ruboty::ExecCommand::Actions::Command.new(message).list_commands
+      end
+
+      def kill_command(message)
+        Ruboty::ExecCommand::Actions::Command.new(message).kill_command
+      end
     end
   end
 end

data/ruboty-exec_command.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "ruboty"
-  spec.add_runtime_dependency "systemu"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "2.14.1"

data/spec/lib/ruboty/exec_command/command_slot_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Ruboty::ExecCommand::CommandSlot do
+
+  before do
+    @slot = Ruboty::ExecCommand::CommandSlot.new
+    @command = Ruboty::ExecCommand::Command.new(command_args: "example sleep")
+  end
+
+  describe "#run" do
+    it "should count up number of commands" do
+      expect { @slot.run(@command) }.to change {
+          @slot.running_commands.count
+        }.from(0).to(1)
+    end
+
+    it "should return pid" do
+      expect(@slot.run(@command)).to be > 0
+    end
+  end
+end
+
+
+describe Ruboty::ExecCommand::CommandSlot do
+
+  before(:each) do
+    @slot = Ruboty::ExecCommand::CommandSlot.new
+    @command = Ruboty::ExecCommand::Command.new(command_args: "example sleep")
+    @slot.remember(@command)
+    @command.run_bg(["1"])
+  end
+
+  describe "#forget" do
+    it "should count down number of commnads" do
+      expect { @command.pid }.not_to be_nil
+      expect { @slot.forget(@command.pid) }.to change {@slot.running_commands.count}.from(1).to(0)
+    end
+  end
+
+  describe "#command_in_list" do
+    it "should return command with pid" do
+      expect(@slot.command_in_list(@command.pid).pid).to eq(@command.pid)
+    end
+
+    it "should return command with index" do
+      expect(@slot.command_in_list(1).pid).to eq(@command.pid)
+    end
+  end
+
+end

data/spec/lib/ruboty/{exec-command → exec_command}/command_spec.rb

@@ -34,15 +34,16 @@ describe Ruboty::ExecCommand::Command do
 
   describe "#command" do
     it "should return command name" do
-      expect(@e.command_args).to eq("a b")
+      expect(@e.command_name).to eq("a b")
     end
   end
 end
 
+# convert command args -> absolute path, so this is a test for ruboty action
 describe Ruboty::ExecCommand::Command do
-  before do
+  before(:each) do
     ENV['RUBOTY_ROOT'] = Dir.pwd
-    @c = Ruboty::ExecCommand::Command.new(command_args: "example hello hoge")
+    @c = Ruboty::ExecCommand::Command.new(command_args: "example hello hoge -l fuga")
   end
 
   describe "#absolute_path" do
@@ -50,4 +51,10 @@ describe Ruboty::ExecCommand::Command do
       expect(@c.absolute_path).to eq("#{ENV['RUBOTY_ROOT']}/commands/example/hello")
     end
   end
+
+  describe "#opt_args" do
+    it "should return only command options" do
+      expect(@c.opt_args).to eq(["hoge", "-l", "fuga"])
+    end
+  end
 end

data/spec/lib/ruboty/handlers/command_spec.rb

@@ -15,32 +15,117 @@ describe Ruboty::Handlers::Command do
   end
 
   let(:said) do
-    "@ruboty example hello"
+    "@ruboty example hello world"
+  end
+
+  let(:said_to_sleep) do
+    "@ruboty example sleep 1"
+  end
+
+  let(:said_to_kill) do
+    "@ruboty command kill 1"
+  end
+
+  let(:said_to_list) do
+    "@ruboty command list"
   end
 
   let(:replied) do
-    "hello!"
+    "[example hello] invoked."
   end
 
-  before do
-    ENV['RUBOTY_ROOT'] = Dir.pwd
+  let(:replied_sleep) do
+    "[example sleep] invoked."
   end
 
-  describe "#command_handler" do
-    it "run example command" do
-      robot.should_receive(:say).with(
-      body: replied,
+  let(:replied_success) do
+    "[example hello] completed successfully."
+  end
+
+  let(:replied_stdout) do
+    "hello world!"
+  end
+
+  let(:replied_after_kill) do
+    "[example sleep] killed by signal 9"
+  end
+
+  def reply_data(body, original_body)
+    {
+      body: body,
       from: to,
       to: from,
       original: {
-        body: said,
+        body: original_body,
         from: from,
         robot: robot,
         to: to,
-      },
-      )
+      }
+    }
+  end
+
+  before do
+    ENV['RUBOTY_ROOT'] = Dir.pwd
+  end
+
+  describe "#command_handler" do
+    before do
+      # block waiter thread in Ruboty::ExecCommand::Actions::Command.run_and_monitor
+      ENV['RUBOTY_ENV'] = "blocked_test"
+    end
+
+    it "run example command" do
+      robot.should_receive(:say).with(reply_data(replied, said))
+      robot.should_receive(:say).with(reply_data(replied_success, said))
+      robot.should_receive(:say).with(reply_data(replied_stdout, said))
       robot.receive(body: said, from: from, to: to)
     end
+
+    after do
+      ENV['RUBOTY_ENV'] = "test"
+    end
+  end
+
+  describe "#kill_command" do
+    it "run kill command" do
+      thread = Thread.new do
+        ENV['RUBOTY_ENV'] = "blocked_test"
+        robot.should_receive(:say).with(reply_data(replied_sleep, said_to_sleep))
+        robot.should_receive(:say).with(reply_data(replied_after_kill, said_to_sleep))
+        robot.receive(body: said_to_sleep, from: from, to: to)
+      end
+
+
+      # Test command invoked
+      expect { robot.receive(body: said_to_kill, from: from, to: to) }.to change {
+        robot.brain.data[:command_slot].running_commands.count}.from(1).to(0)
+
+        # Wait killed message
+      thread.join
+    end
+    
+    after do
+      ENV['RUBOTY_ENV'] = "test"
+    end
+  end
+
+  describe "#list_command" do
+    it "list running commands" do
+      robot.receive(body: said_to_sleep, from: from, to: to)
+      robot.receive(body: said_to_sleep, from: from, to: to)
+
+      comm1 = robot.brain.data[:command_slot].running_commands[0]
+      comm2 = robot.brain.data[:command_slot].running_commands[1]
+      body1="1: example sleep (PID[#{comm1.pid}], started at #{comm1.start_at})\n"
+      body2="2: example sleep (PID[#{comm2.pid}], started at #{comm2.start_at})"
+
+      robot.should_receive(:say).with(reply_data(body1+body2, said_to_list))
+      robot.receive(body: said_to_list, from: from, to: to)
+    end
+
+    after do
+      ENV['RUBOTY_ENV'] = "test"
+    end
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruboty-exec_command
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Nakai Tooru
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-25 00:00:00.000000000 Z
+date: 2015-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruboty
@@ -24,20 +24,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: systemu
-  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -136,13 +122,16 @@ files:
 - README.md
 - Rakefile
 - commands/example/hello
+- commands/example/sleep
 - lib/ruboty/exec_command.rb
 - lib/ruboty/exec_command/actions/command.rb
 - lib/ruboty/exec_command/command.rb
+- lib/ruboty/exec_command/command_slot.rb
 - lib/ruboty/exec_command/version.rb
 - lib/ruboty/handlers/command.rb
 - ruboty-exec_command.gemspec
-- spec/lib/ruboty/exec-command/command_spec.rb
+- spec/lib/ruboty/exec_command/command_slot_spec.rb
+- spec/lib/ruboty/exec_command/command_spec.rb
 - spec/lib/ruboty/handlers/command_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -170,6 +159,7 @@ signing_key:
 specification_version: 4
 summary: Add command to ruboty as a handler
 test_files:
-- spec/lib/ruboty/exec-command/command_spec.rb
+- spec/lib/ruboty/exec_command/command_slot_spec.rb
+- spec/lib/ruboty/exec_command/command_spec.rb
 - spec/lib/ruboty/handlers/command_spec.rb
 - spec/spec_helper.rb