rolo 1.0.2 → 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85800c263104b5c8d064668bc6794ad5f8473a76
+  data.tar.gz: 8b5519137d8d035ed43a288512be8117b631d2d4
+SHA512:
+  metadata.gz: c6eef30e55754f6f12806fe1ae57bc348fcb93bdb0f6f43a8db4bef66feb9808d727d464406b0cf3f868f56a97e5b18e33d9e4d2789f63d0acbf512f178c90d2
+  data.tar.gz: bd64784e67ef5eb6501abc32316cad8eab5edadb1702ef2aa33eacaedf1ab1d852df2722bfc5cd338107cdf99d9c91a91258862bd29eacd27d080f9adcad0716

data/README.md

@@ -4,39 +4,42 @@
 
 ## SYNOPSIS
 
-<pre>
-  $0 [-v] [--test] [-a address] -p port command [arguments]
-</pre>
+    $0 [options] command [arguments]
 
 ## DESCRIPTION
 
+  Start an application and/or prevent it from running twice by simply
+  checking if there is a network socket that is open by the application
+  and/or by `rolo`.
+
   `rolo.rb` prevents a program from running more than one copy at a time;
-   it is useful with cron to make sure that a job doesn't run before a
-   previous one has finished. `robo.rb` is a ruby version of Timothy
-   program `solo` with more options.
+  it is useful with cron to make sure that a job doesn't run before a
+  previous one has finished. `robo.rb` is a ruby version of Timothy
+  program <https://github.com/timkay/solo> with some more options.
 
 ## OPTIONS
 
-  * `-v` (`--verbose`)
-      Print verbose message
-  * `-t` (`--test`)
-      Test of program is running. Don't execute command.
-  * `-a` (`--address`)
-      Address to check / listen on. By default, this address is
-      `127.x.y.1:<port>` where `x.y` is translated from process's user
-      identity number and this allows two different users on the system
-      can use the same port with `rolo.rb`
-  * `-p` (`--port`)
-      Port to check / on which rolo will listen
-
-In `<command>` and `<arguments>`, you can use `%address`, `%port` which
-are replaced by the socket address and port that the problem uses to
-check for status of your command. This is very useful if your command
-closes all file descriptors at the time it runs, but it has some ways
-to listen on `%address:%port`. See EXAMPLE for details.
+  Please run the command `rolo` without any arguments for more details.
+
+## INSTALLATION
+
+  This program can be installed by using RubyGems
+
+    gem install --remote rolo
+
+  You can build and install it locally
+
+    git clone git://github.com/icy/rolo.git
+    cd rolo
+    gem build rolo.gemspec
+    gem install --local rolo-VERSION.gem
 
 ## HOW IT WORKS
 
+  If the `--no-bind` option is used, the program will simply assume that
+  the port is open by another program and it will only check if that port
+  is open or not. Otherwise, see below.
+
   Before starting your `<command>` (using `exec`), `rolo.rb` will open a
   socket on a local address (or address specified by option `--address`.)
   This socket will be closed after your command exits, and as long as
@@ -52,11 +55,13 @@ to listen on `%address:%port`. See EXAMPLE for details.
 
 ## EXAMPLE
 
+  Here are some simple examples and applications. Feel free to contribute.
+
+### Create SSH tunnels
+
   To create tunnel to a remote server, you can use this ssh command
 
-<pre>
-ssh -fN remote -L localhost:1234:localhost:10000
-</pre>
+    ssh -fN remote -L localhost:1234:localhost:10000
 
   This allows you to connect to the local port 1234 on your mahince
   as same as conneting to address `localhost:10000` on remote server.
@@ -65,15 +70,15 @@ ssh -fN remote -L localhost:1234:localhost:10000
 
   To keep this tunnel persistent, you can add this to your crontab
 
-<pre>
-rolo.rb -p 4567 \
-  ssh remote -fNL localhost:1234:localhost:10000
-</pre>
+    rolo.rb -p 4567 \
+      ssh remote -fNL localhost:1234:localhost:10000
 
   and allows this line to be executed once every 5 minutes. `rolo.rb`
   will check if your ssh command is still running. If 'yes', it will
   simply exit; if 'no', `rolo.rb` will start the ssh command.
 
+### With OpenSSH 5.6p1 or later
+
   However, if you use *OpenSSH 5.6p1* (or later), `ssh` will close all file
   descriptors from the parent (except for `STDIN`, `STDOUT` and `STDERR`).
   As the socket opened by `rolo.rb` is closed, `rolo.rb` will always
@@ -83,12 +88,11 @@ rolo.rb -p 4567 \
 
   Fortunately, `ssh` has option to bind on the local address.
   Using this option we can trick `rolo.rb` as below
-<pre>
-rolo.rb -p 4567 \
-  ssh remote -fN \
-    -L localhost:1234:localhost:10000 \
-    -L %address:%port:localhost:12345
-</pre>
+
+    rolo.rb -p 4567 \
+      ssh remote -fN \
+        -L localhost:1234:localhost:10000 \
+        -L %address:%port:localhost:12345
 
   The last use of option `-L` will ask `ssh` to open a socket on
   `%address:%port` (the real values will be provided by `rolo.rb`),
@@ -98,14 +102,21 @@ rolo.rb -p 4567 \
 
   Another way is to use option `--address`
 
-<pre>
-rolo.rb -p 1234 -a 127.0.0.1 \
-  ssh remote -fNL localhost:1234:localhost:10000
-</pre>
+    rolo.rb -p 1234 -a 127.0.0.1 \
+      ssh remote -fNL localhost:1234:localhost:10000
 
   And this is another way
 
-<pre>
-rolo.rb -p 1234 -a 127.0.0.1 \
-  ssh remote -fNL %address:%port:localhost:10000
-</pre>
+    rolo.rb -p 1234 -a 127.0.0.1 \
+      ssh remote -fNL %address:%port:localhost:10000
+
+### Start VirtualBox guests
+
+  To make sure that your VirtualBox Windows guest is always running,
+  you can use:
+
+    rolo -a 1.2.3.4 -p 3389 --no-bind \
+      VBoxManage startvm foobar --type headless
+
+  Here `1.2.3.4` is the guest's address, and `3389` is the port
+  that is used by `rdesktop` service on the guest.

data/bin/rolo

@@ -53,6 +53,7 @@
 #
 
 require 'socket'
+require 'timeout'
 
 class String
   def die(ret = 1, dev = STDERR, prefix = ":: ")
@@ -79,9 +80,60 @@ def close_on_exec(att = true)
   end
 end
 
-OPTIONS = {:verbose => false, :port => 0}
+# See also
+# http://stackoverflow.com/questions/517219/ruby-see-if-a-port-is-open
+def port_open?(ip, port, timeout = 1)
+  Timeout::timeout(timeout) do
+    begin
+      TCPSocket.new(ip, port).close
+      true
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
+      false
+    end
+  end
+rescue Timeout::Error
+  false
+end
+
+OPTIONS = {:verbose => false,
+           :port => 0,
+           :timeout => 3,
+           :no_bind => false,
+           :address => "",
+           :message => ":: Address is in use. Is your application running?"}
+
+"Start an application and/or prevent it from running twice by simply
+checking if there is a network socket that is open by the application
+and/or by `rolo`.
+
+Syntax: rolo [options] <command> [<command arguments>]
+
+Option may be
+
+      --verbose   Show some verbose message (not very useful, though)
+  -t, --test      Test if application is running or if there's any error
+                  and return, without executing the command
+  -a, --address * Specify the address to listen on / to check
+  -p, --port    * To port to bind on / to check
+  -m, --message * The error message to use when application is running
+      --timeout * Time to wait for check if port `address:port` is open
+      --no-bind   Don't bind on any `address:port`, just use a simple
+                  TCP connection to check if `address:port` is open.
+                  This option should be used with `--address` option.
+                  This option is useful if your application binds on
+                  another interface (e.g, an remote command), and/or
+                  the port is too low to bind on (e.g, 22, 80).
 
-"Syntax: rolo [--verbose] [--test] [--address <address>] --port <port_number> <command> [<arguments>]".die if ARGV.empty?
+(Any star `*` indicates the option requires a valid value.)
+
+In `<command>` and `<arguments>`, you can use `%address`, `%port` which
+are replaced by the socket address and port that the problem uses to
+check for status of your command. This is very useful if your command
+closes all file descriptors at the time it runs, but it has some ways
+to listen on `%address:%port`. See EXAMPLE for details.
+
+To get support please use https://github.com/icy/rolo/issues.
+".die(1, STDERR, "") if ARGV.empty?
 
 while true
   f = ARGV.first
@@ -100,6 +152,12 @@ while true
   elsif %w{-m --message}.include?(f)
     ARGV.shift
     OPTIONS[:message] = ARGV.shift
+  elsif %w{--no-bind}.include?(f)
+    ARGV.shift
+    OPTIONS[:no_bind] = true
+  elsif %w{--timeout}.include?(f)
+    ARGV.shift
+    OPTIONS[:timeout] = ARGV.shift.to_i
   elsif %w{-t --test}.include?(f)
     OPTIONS[:test] = true
     ARGV.shift
@@ -121,24 +179,38 @@ address = OPTIONS[:address] || [127, Process.uid, 1].pack("CnC").unpack("C4").jo
 
 cmd = cmd.gsub("%port", OPTIONS[:port].to_s).gsub("%address", address)
 
-("Will bind on %s:%d, command = '%s'" \
-  % [address, OPTIONS[:port], cmd]).verbose(OPTIONS[:verbose])
-
-# Taken from example in the source code documetation
-# Link: http://ruby-doc.org/stdlib-1.8.7/
-#         libdoc/socket/rdoc/Socket.html#method-i-bind
-begin
-  include Socket::Constants
-  socket = Socket.new(AF_INET, SOCK_STREAM, 0)
-  socket.bind(Socket.pack_sockaddr_in(OPTIONS[:port], address))
-  socket.close if OPTIONS[:address]
-rescue Errno::EADDRINUSE
-  (OPTIONS[:message] || ":: Address is in use. Is your application running?").die(0, STDOUT, "")
-rescue => e
-  e.to_s.die(1)
+("Would bind on %s:%d, command = '%s'" \
+  % [address, OPTIONS[:port], cmd]).verbose(OPTIONS[:verbose]) \
+    unless OPTIONS[:no_bind]
+
+if OPTIONS[:no_bind]
+  "The '--no-bind' option must be used with '--address' option".die \
+    if OPTIONS[:address].empty?
+
+  begin
+    OPTIONS[:message].die(0, STDOUT, "") \
+      if port_open?(OPTIONS[:address], OPTIONS[:port], OPTIONS[:timeout])
+  rescue => e
+    e.to_s.die(1)
+  end
+else
+  # Taken from example in the source code documetation
+  # Link: http://ruby-doc.org/stdlib-1.8.7/
+  #         libdoc/socket/rdoc/Socket.html#method-i-bind
+  begin
+    include Socket::Constants
+    socket = Socket.new(AF_INET, SOCK_STREAM, 0)
+    socket.bind(Socket.pack_sockaddr_in(OPTIONS[:port], address))
+    # Bind on the address if specified
+    socket.close unless OPTIONS[:address].empty?
+  rescue Errno::EADDRINUSE
+    OPTIONS[:message].die(0, STDOUT, "") unless OPTIONS[:message].empty?
+  rescue => e
+    e.to_s.die(1)
+  end
 end
 
 unless OPTIONS[:test]
-  close_on_exec(false)
+  close_on_exec(false) unless OPTIONS[:no_bind]
   exec cmd
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rolo
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 1.1.1
 platform: ruby
 authors:
 - Anh K. Huynh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2013-06-21 00:00:00.000000000 Z
 dependencies: []
-description: Prevents a program from running more than one copy at a time
+description: Start an application and/or prevent it from running twice by simply checking
+  if there is a network socket that is open by the application and/or by `rolo`
 email: kyanh@viettug.org
 executables:
 - rolo
@@ -21,27 +21,27 @@ files:
 - README.md
 - bin/rolo
 homepage: https://github.com/icy/rolo
-licenses: []
+licenses:
+- GPL v2
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.16
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: ! '`rolo` prevents a program from running more than one copy at a time'
+specification_version: 4
+summary: '`rolo` prevents a program from running more than one copy at a time'
 test_files: []