rexec 1.1.10

data/README.rdoc

@@ -0,0 +1,14 @@
+= RExec
+
+Author::    Samuel Williams (http://www.oriontransfer.co.nz/)
+Copyright:: Copyright (C) 2009, 2010 Samuel Williams
+License::   GPLv3
+
+RExec stands for Ruby Execute or Remote Execute (depending on how you use it). It provides a number of different things to assist with running Ruby code:
+
+* A framework to send Ruby code to a remote server for execution
+* A framework for writing command line daemons (i.e. <tt>start</tt>, <tt>restart</tt>, <tt>stop</tt>, <tt>status</tt>)
+* A comprehensive <tt>Task</tt> class for launching tasks, managing input and output, exit status, etc
+* Basic privilege management code for changing the processes owner
+* A bunch of helpers for various different things (such as reading a file backwards)
+* <tt>daemon-exec</tt> executable for running regular shell tasks in the background

data/bin/daemon-exec

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubygems'
+
+require 'rexec'
+require 'optparse'
+
+OPTIONS = {
+	:out => "/tmp/daemon-exec.log",
+	:err => "/tmp/daemon-exec-error.log",
+	:in => "/dev/null",
+	:print_pid => false,
+	:root => "/",
+	:verbose => false,
+	:relocate => true,
+	:read_stdin => false,
+}
+
+ARGV.options do |o|
+	script_name = File.basename($0)
+
+	o.set_summary_indent("\t")
+	o.banner = "Usage: #{script_name} [-I stdin] [-O stdout] [-E stderr] [script/stdin]"
+	o.define_head "Copyright (c) 2010 Samuel Williams <http://www.oriontransfer.co.nz/>."
+
+	o.on("-d [dir]", String, "Daemons working path, default /") do |dir|
+		OPTIONS[:root] = dir
+	end
+	
+	o.on("-s", "Don't attempt to relocate arguments to absolute paths") do
+		OPTIONS[:relocate] = false
+	end
+
+	o.define "File / Pipe Options:"
+
+	o.on("-I [path]", String, "File for STDIN, defaults to #{OPTIONS[:in]}; Note: Use -I - to send data from current STDIN") do |path|
+		OPTIONS[:in] = path
+	end
+	
+	o.on("-O [path]", String, "File for STDOUT, defaults to #{OPTIONS[:out]}") do |path|
+		OPTIONS[:in] = path
+	end
+	
+	o.on("-E [path]", String, "File for STDERR, defaults to #{OPTIONS[:err]}") do |path|
+		OPTIONS[:err] = path
+	end
+	
+	o.define "Misc Options:"
+	
+	o.on("-p", "Print out the PID of the forked process") do
+		OPTIONS[:print_pid] = true
+	end
+	
+	o.on("-V", "Print verbose information about what is going on") do
+		OPTIONS[:verbose] = true
+	end
+	
+	o.on("-h", "Show this help/version information and exit") do
+		puts o
+		exit 0
+	end
+end.parse!
+
+if OPTIONS[:relocate]
+	ARGV.collect! do |value|
+		if File.exist?(value)
+			File.expand_path(value)
+		else
+			value
+		end
+	end
+
+	[:in, :out, :err].each do |path|
+		OPTIONS[path] = File.expand_path(OPTIONS[path]) unless OPTIONS[path] == "-"
+	end
+end
+
+if OPTIONS[:verbose]
+	puts "Running #{ARGV.inspect}"
+end
+
+task_options = {
+	:daemonize => true,
+	:out => File.open(OPTIONS[:out], "a"),
+	:err => File.open(OPTIONS[:err], "a")
+}
+
+if OPTIONS[:in] == '-'
+	task_options[:passthrough] = [:in]
+end
+
+daemon = lambda do
+	Dir.chdir(OPTIONS[:root])
+	system("env", *ARGV)
+end
+
+task = RExec::Task.open(daemon, task_options)
+
+if OPTIONS[:print_pid]
+	puts task.pid
+end

data/lib/rexec.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2007 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# = Summary =
+# This gem provides a very simple connection based API for communicating 
+# with remote instances of ruby. These can either be local, or remote, such
+# as over SSH.
+#
+# The API is very simple and deals with sending and receiving objects using 
+# Marshal. One of the primary goals was to impose as little structure as
+# possible on the end user of this library, while still maintaining a level
+# of convenience.
+#
+# Author::    Samuel Williams (samuel AT oriontransfer DOT org)
+# Copyright:: Copyright (c) 2009 Samuel Williams.
+# License::   Released under the GNU GPLv3.
+
+require 'rexec/version'
+require 'rexec/connection'
+require 'rexec/server'
+require 'rexec/priviledges'

data/lib/rexec/client.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2007 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This code is executed in a remote ruby process.
+
+$stdout.sync = true
+$stderr.sync = true
+
+# We don't connect to $stderr here as this is a client. Clients write to regular $stderr.
+$connection = RExec::Connection.new($stdin, $stdout)
+

data/lib/rexec/connection.rb

@@ -0,0 +1,153 @@
+# Copyright (c) 2007 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This class is as small and independant as possible as it will get sent to clients for execution.
+
+require 'thread'
+
+module RExec
+  
+  # This class represents an abstract connection to another ruby process. The interface does not impose
+  # any structure on the way this communication link works, except for the fact you can send and receive
+  # objects. You can implement whatever kind of idiom you need for communication on top of this library.
+  #
+  # Depending on how you set things up, this can connect to a local ruby process, or a remote ruby process
+  # via SSH (for example).
+  class Connection
+    public
+
+    def self.build(process, options, &block)
+      cin = process.input
+      cout = process.output
+      cerr = process.error
+      
+      # We require both cin and cout to be connected in order for connection to work
+      raise InvalidConnectionError.new("Input (#{cin}) or Output (#{cout}) is not connected!") unless cin and cout
+      
+      yield cin
+      
+      cin.puts("\004")
+      
+      return self.new(cout, cin, cerr)
+    end
+
+    # Create a new connection. You need to supply a pipe for reading input, a pipe for sending output,
+    # and optionally a pipe for errors to be read from.
+    def initialize(input, output, error = nil)
+      @input = input
+      @output = output
+      @running = true
+
+      @error = error
+
+      @receive_mutex = Mutex.new
+      @send_mutex = Mutex.new
+    end
+
+    # The pipe used for reading data
+    def input
+      @input
+    end
+
+    # The pipe used for writing data
+    def output
+      @output
+    end
+
+    # The pipe used for receiving errors. On the client side this pipe is writable, on the server 
+    # side this pipe is readable. You should avoid using it on the client side and simply use $stderr.
+    def error
+      @error
+    end
+
+    # Stop the connection, and close the output pipe.
+    def stop
+      @running = false
+      @output.close
+    end
+    
+    # Return whether or not the connection is running.
+    def running?
+      @running
+    end
+
+    # This is a very simple runloop. It provides an object when it is received.
+    def run(&block)
+      while @running
+        pipes = IO.select([@input])
+
+        if pipes[0].size > 0
+          object = receive_object
+          
+          if object == nil
+            @running = false
+            return
+          end
+          
+          begin
+            yield object
+          rescue Exception => ex
+            send_object(ex)
+          end
+        end
+      end
+    end
+
+    # Dump any text which has been written to $stderr in the child process.
+    def dump_errors(to = $stderr)
+      if @error and !@error.closed?
+        while true
+          result = IO.select([@error], [], [], 0)
+
+          break if result == nil
+
+          to.puts @error.readline.chomp
+        end
+      end
+    end
+    
+    # Receive an object from the connection. This function is thread-safe. This function may block.
+    def receive_object
+      object = nil
+
+      @receive_mutex.synchronize do
+        begin
+          object = Marshal.load(@input)
+        rescue EOFError
+          object = nil
+          @running = false
+        end
+      end
+      
+      if object and object.kind_of?(Exception)
+        raise object
+      end
+      
+      return object
+    end
+
+    # Send object(s). This function is thread-safe.
+    def send_object(*objects)
+      @send_mutex.synchronize do
+        objects.each do |o|
+          data = Marshal.dump(o)
+          @output.write(data)
+        end
+        
+        @output.flush
+      end
+    end
+  end
+end

data/lib/rexec/daemon.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2007, 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rexec/daemon/base'
+
+module RExec
+  module Daemon
+    
+    # Would this kind of API be useful?
+    #def run_daemon(options = {}, &block)
+    #  
+    #end
+    
+  end
+end

data/lib/rexec/daemon/base.rb

@@ -0,0 +1,151 @@
+# Copyright (c) 2007, 2009 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'fileutils'
+require 'rexec/daemon/controller'
+require 'rexec/reverse_io'
+
+module RExec
+  module Daemon
+    # This class is the base daemon class. If you are writing a daemon, you should inherit from this class.
+    class Base
+      @@var_directory = nil
+      @@log_directory = nil
+      @@pid_directory = nil
+      
+      # Return the name of the daemon
+      def self.daemon_name
+        return name.gsub(/[^a-zA-Z0-9]+/, '-')
+      end
+
+      # Base directory for daemon log files / run files
+      def self.var_directory
+        @@var_directory || File.join("", "var")
+      end
+      
+      # The directory the daemon will run in (Dir.chdir)
+      def self.working_directory
+        var_directory
+      end
+
+      # Return the directory to store log files in
+      def self.log_directory
+        @@log_directory || File.join(var_directory, "log", daemon_name)
+      end
+
+      # Standard log file for errors
+      def self.err_fn
+        File.join(log_directory, "stderr.log")
+      end
+
+      # Standard log file for normal output
+      def self.log_fn
+        File.join(log_directory, "stdout.log")
+      end
+
+      # Standard location of pid file
+      def self.pid_directory
+        @@pid_directory || File.join(var_directory, "run", daemon_name)
+      end
+
+      # Standard pid file
+      def self.pid_fn
+        File.join(pid_directory, "#{daemon_name}.pid")
+      end
+
+      # Mark the error log
+      def self.mark_err_log
+        fp = File.open(err_fn, "a")
+        fp.puts "=== Error Log Opened @ #{Time.now.to_s} ==="
+        fp.close
+      end
+
+      # Prints some information relating to daemon startup problems
+      def self.tail_err_log(outp)
+        lines = []
+        
+        File.open(err_fn, "r") do |fp|
+          fp.seek_end
+
+          fp.reverse_each_line do |line|
+            lines << line
+            break if line.match("=== Error Log") || line.match("=== Daemon Exception Backtrace")
+          end
+        end
+        
+        lines.reverse_each do |line|
+          outp.puts line
+        end
+      end
+
+      # Check the last few lines of the log file to find out if
+      # the daemon crashed.
+      def self.crashed?
+        File.open(err_fn, "r") do |fp|
+          fp.seek_end
+          
+          count = 2
+          fp.reverse_each_line do |line|
+            return true if line.match("=== Daemon Crashed")
+            
+            count -= 1
+            
+            break if count == 0
+          end
+        end
+        
+        return false
+      end
+
+      # Corresponds to controller method of the same name
+      def self.daemonize
+        Controller.daemonize(self)
+      end
+
+      # Corresponds to controller method of the same name
+      def self.start
+        Controller.start(self)
+      end
+
+      # Corresponds to controller method of the same name
+      def self.stop
+        Controller.stop(self)
+      end
+
+      # Corresponds to controller method of the same name
+      def self.status
+        Controller.status(self)
+      end
+
+      # The main function to setup any environment required by the daemon
+      def self.prefork
+        @@var_directory = File.expand_path(@@var_directory) if @@var_directory
+        @@log_directory = File.expand_path(@@log_directory) if @@log_directory
+        @@pid_directory = File.expand_path(@@pid_directory) if @@pid_directory
+        
+        FileUtils.mkdir_p(log_directory)
+        FileUtils.mkdir_p(pid_directory)
+      end
+      
+      # The main function to start the daemon
+      def self.run
+      end
+
+      # The main function to stop the daemon
+      def self.shutdown
+      end
+    end
+  end
+end