rubber 1.1.7 → 1.2.0

data/VERSION

@@ -1 +1 @@
-1.1.7
+1.2.0

data/generators/vulcanize/templates/base/config/rubber/deploy-setup.rb

@@ -13,20 +13,20 @@ namespace :rubber do
       rubber_instances.filtered.each do |ic|
         env = rubber_cfg.environment.bind(ic.role_names, ic.name)
         if env.use_enterprise_ruby
-          ent_ruby_hosts << ic.full_name
+          ent_ruby_hosts << ic.full_name unless ic.windows?
         end
       end
 
       if ent_ruby_hosts.size > 0
         task :_install_enterprise_ruby, :hosts => ent_ruby_hosts do
-          ver = "1.8.7-2009.10"
+          ver = "1.8.7-2010.01"
           rubber.run_script "install_ruby-enterprise", <<-ENDSCRIPT
-            if [[ ! `ruby --version 2> /dev/null` =~ "Ruby Enterprise Edition 2009.10" ]]; then
+            if [[ ! `ruby --version 2> /dev/null` =~ "Ruby Enterprise Edition 2010.01" ]]; then
               arch=`uname -m`
               if [ "$arch" = "x86_64" ]; then
-                src="http://rubyforge.org/frs/download.php/66163/ruby-enterprise_#{ver}_amd64.deb"
+                src="http://rubyforge.org/frs/download.php/68720/ruby-enterprise_#{ver}_amd64.deb"
               else
-                src="http://rubyforge.org/frs/download.php/66164/ruby-enterprise_#{ver}_i386.deb"
+                src="http://rubyforge.org/frs/download.php/68718/ruby-enterprise_#{ver}_i386.deb"
               fi
               src_file="${src##*/}"
               wget -qP /tmp ${src}

data/generators/vulcanize/templates/base/config/rubber/rubber.yml

@@ -82,6 +82,19 @@ cloud_providers:
     # m1.small or m1.large or m1.xlarge
     image_type: m1.small
 
+    # OPTIONAL: EC2 spot instance request support.
+    #
+    # Enables the creation of spot instance requests.  Rubber will wait synchronously until the request is fulfilled,
+    # at which point it will begin initializing the instance, unless spot_instance_request_timeout is set.
+    # spot_instance: true
+    #
+    # The maximum price you would like to pay for your spot instance.
+    # spot_price: "0.085"
+    #
+    # If a spot instance request can't be fulfilled in 3 minutes, fallback to on-demand instance creation.  If not set,
+    # the default is infinite.
+    # spot_instance_request_timeout: 180
+
 # REQUIRED the cloud provider to use
 #
 cloud_provider: aws

data/generators/vulcanize/templates/jetty/config/rubber/role/jetty/jetty.sh

@@ -0,0 +1,589 @@
+<%-
+  @path = "#{rubber_env.jetty_dir}/bin/jetty.sh"
+  @perms = 0744
+%>
+
+#!/bin/bash  
+#
+# Startup script for jetty under *nix systems (it works under NT/cygwin too).
+
+# To get the service to restart correctly on reboot, uncomment below (3 lines):
+# ========================
+# chkconfig: 3 99 99
+# description: Jetty 7 webserver
+# processname: jetty
+# ========================
+
+# Configuration files
+#
+# /etc/default/jetty
+#   If it exists, this is read at the start of script. It may perform any 
+#   sequence of shell commands, like setting relevant environment variables.
+#
+# $HOME/.jettyrc
+#   If it exists, this is read at the start of script. It may perform any 
+#   sequence of shell commands, like setting relevant environment variables.
+#
+# /etc/jetty.conf
+#   If found, and no configurations were given on the command line,
+#   the file will be used as this script's configuration. 
+#   Each line in the file may contain:
+#     - A comment denoted by the pound (#) sign as first non-blank character.
+#     - The path to a regular file, which will be passed to jetty as a 
+#       config.xml file.
+#     - The path to a directory. Each *.xml file in the directory will be
+#       passed to jetty as a config.xml file.
+#
+#   The files will be checked for existence before being passed to jetty.
+#
+# $JETTY_HOME/etc/jetty.xml
+#   If found, used as this script's configuration file, but only if
+#   /etc/jetty.conf was not present. See above.
+#   
+# Configuration variables
+#
+# JAVA_HOME  
+#   Home of Java installation. 
+#
+# JAVA
+#   Command to invoke Java. If not set, $JAVA_HOME/bin/java will be
+#   used.
+#
+# JAVA_OPTIONS
+#   Extra options to pass to the JVM
+
+JAVA_OPTIONS="<%= rubber_env.jetty_jvm_options %>"
+
+#
+# JETTY_HOME
+#   Where Jetty is installed. If not set, the script will try go
+#   guess it by first looking at the invocation path for the script,
+#   and then by looking in standard locations as $HOME/opt/jetty
+#   and /opt/jetty. The java system property "jetty.home" will be
+#   set to this value for use by configure.xml files, f.e.:
+#
+#    <Arg><SystemProperty name="jetty.home" default="."/>/webapps/jetty.war</Arg>
+#
+# JETTY_PORT
+#   Override the default port for Jetty servers. If not set then the
+#   default value in the xml configuration file will be used. The java
+#   system property "jetty.port" will be set to this value for use in
+#   configure.xml files. For example, the following idiom is widely
+#   used in the demo config files to respect this property in Listener
+#   configuration elements:
+#
+#    <Set name="Port"><SystemProperty name="jetty.port" default="8080"/></Set>
+#
+#   Note: that the config file could ignore this property simply by saying:
+#
+#    <Set name="Port">8080</Set>
+#
+# JETTY_RUN
+#   Where the jetty.pid file should be stored. It defaults to the
+#   first available of /var/run, /usr/var/run, and /tmp if not set.
+#  
+# JETTY_PID
+#   The Jetty PID file, defaults to $JETTY_RUN/jetty.pid
+#   
+# JETTY_ARGS
+#   The default arguments to pass to jetty.
+#
+# JETTY_USER
+#   if set, then used as a username to run the server as
+#
+# Set to 0 if you do not want to use start-stop-daemon (especially on SUSE boxes)
+START_STOP_DAEMON=1
+
+usage()
+{
+    echo "Usage: $0 {start|stop|run|restart|check|supervise} [ CONFIGS ... ] "
+    exit 1
+}
+
+[ $# -gt 0 ] || usage
+
+
+##################################################
+# Some utility functions
+##################################################
+findDirectory()
+{
+    OP=$1
+    shift
+    for L in $* ; do
+        [ $OP $L ] || continue 
+        echo $L
+        break
+    done 
+}
+
+running()
+{
+    [ -f $1 ] || return 1
+    PID=$(cat $1)
+    ps -p $PID >/dev/null 2>/dev/null || return 1
+    return 0
+}
+
+##################################################
+# Get the action & configs
+##################################################
+
+ACTION=$1
+shift
+ARGS="$*"
+NO_START=0
+
+##################################################
+# See if there's a default configuration file
+##################################################
+if [ -f /etc/default/jetty7 ] ; then 
+  . /etc/default/jetty7
+elif [ -f /etc/default/jetty ] ; then 
+  . /etc/default/jetty
+fi
+
+
+##################################################
+# See if there's a user-specific configuration file
+##################################################
+if [ -f $HOME/.jettyrc ] ; then 
+  . $HOME/.jettyrc
+fi
+
+##################################################
+# Set tmp if not already set.
+##################################################
+
+if [ -z "$TMP" ] 
+then
+  TMP=/tmp
+fi
+
+##################################################
+# Jetty's hallmark
+##################################################
+JETTY_INSTALL_TRACE_FILE="etc/jetty.xml"
+TMPJ=$TMP/j$$
+
+
+##################################################
+# Try to determine JETTY_HOME if not set
+##################################################
+if [ -z "$JETTY_HOME" ] 
+then
+  JETTY_HOME_1=`dirname "$0"`
+  JETTY_HOME_1=`dirname "$JETTY_HOME_1"`
+  if [ -f "${JETTY_HOME_1}/${JETTY_INSTALL_TRACE_FILE}" ] ; 
+  then 
+     JETTY_HOME=${JETTY_HOME_1} 
+  fi
+fi
+
+
+##################################################
+# if no JETTY_HOME, search likely locations.
+##################################################
+if [ "$JETTY_HOME" = "" ] ; then
+  STANDARD_LOCATIONS="           \
+        /usr/share               \
+        /usr/share/java          \
+        $HOME                    \
+        $HOME/src                \
+        ${HOME}/opt/             \
+        /opt                     \
+        /java                    \
+        /usr/local               \
+        /usr/local/share         \
+        /usr/local/share/java    \
+        /home                    \
+        "
+  JETTY_DIR_NAMES="              \
+        jetty-7                  \
+        jetty7                   \
+        jetty-7.*                \
+        jetty                    \
+        Jetty-7                  \
+        Jetty7                   \
+        Jetty-7.*                \
+        Jetty                    \
+        "
+        
+  JETTY_HOME=
+  for L in $STANDARD_LOCATIONS 
+  do
+     for N in $JETTY_DIR_NAMES 
+     do
+         if [ -d $L/$N ] && [ -f "$L/${N}/${JETTY_INSTALL_TRACE_FILE}" ] ; 
+         then 
+            JETTY_HOME="$L/$N"
+         fi
+     done
+     [ ! -z "$JETTY_HOME" ] && break
+  done
+fi
+
+
+##################################################
+# No JETTY_HOME yet? We're out of luck!
+##################################################
+if [ -z "$JETTY_HOME" ] ; then
+    echo "** ERROR: JETTY_HOME not set, you need to set it or install in a standard location" 
+    exit 1
+fi
+
+cd $JETTY_HOME
+JETTY_HOME=`pwd`
+
+#####################################################
+# Check that jetty is where we think it is
+#####################################################
+if [ ! -r $JETTY_HOME/$JETTY_INSTALL_TRACE_FILE ] 
+then
+   echo "** ERROR: Oops! Jetty doesn't appear to be installed in $JETTY_HOME"
+   echo "** ERROR:  $JETTY_HOME/$JETTY_INSTALL_TRACE_FILE is not readable!"
+   exit 1
+fi
+
+##################################################
+# Try to find this script's configuration file,
+# but only if no configurations were given on the
+# command line.
+##################################################
+if [ -z "$JETTY_CONF" ] 
+then
+  if [ -f /etc/jetty.conf ]
+  then
+     JETTY_CONF=/etc/jetty.conf
+  elif [ -f "${JETTY_HOME}/etc/jetty.conf" ]
+  then
+     JETTY_CONF="${JETTY_HOME}/etc/jetty.conf"
+  fi
+fi
+
+##################################################
+# Read the configuration file if one exists
+##################################################
+CONFIG_LINES=
+if [ -f "$JETTY_CONF" ] && [ -r "$JETTY_CONF" ] 
+then
+  CONFIG_LINES=`cat $JETTY_CONF | grep -v "^[:space:]*#" | tr "\n" " "` 
+fi
+
+#####################################################
+# Find a location for the pid file
+#####################################################
+if [  -z "$JETTY_RUN" ] 
+then
+  JETTY_RUN=`findDirectory -w /var/run /usr/var/run /tmp`
+fi
+
+#####################################################
+# Find a PID for the pid file
+#####################################################
+if [  -z "$JETTY_PID" ] 
+then
+  JETTY_PID="$JETTY_RUN/jetty.pid"
+fi
+
+
+##################################################
+# Check for JAVA_HOME
+##################################################
+if [ -z "$JAVA_HOME" ]
+then
+    # If a java runtime is not defined, search the following
+    # directories for a JVM and sort by version. Use the highest
+    # version number.
+
+    # Java search path
+    JAVA_LOCATIONS="\
+        /usr/java \
+        /usr/bin \
+        /usr/local/bin \
+        /usr/local/java \
+        /usr/local/jdk \
+        /usr/local/jre \
+        /usr/lib/jvm \
+        /opt/java \
+        /opt/jdk \
+        /opt/jre \
+    " 
+    JAVA_NAMES="java jdk jre"
+    for N in $JAVA_NAMES ; do
+        for L in $JAVA_LOCATIONS ; do
+            [ -d $L ] || continue 
+            find $L -name "$N" ! -type d | grep -v threads | while read J ; do
+                [ -x $J ] || continue
+                VERSION=`eval $J -version 2>&1`       
+                [ $? = 0 ] || continue
+                VERSION=`expr "$VERSION" : '.*"\(1.[0-9\.]*\)["_]'`
+                [ "$VERSION" = "" ] && continue
+                expr $VERSION \< 1.2 >/dev/null && continue
+                echo $VERSION:$J
+            done
+        done
+    done | sort | tail -1 > $TMPJ
+    JAVA=`cat $TMPJ | cut -d: -f2`
+    JVERSION=`cat $TMPJ | cut -d: -f1`
+
+    JAVA_HOME=`dirname $JAVA`
+    while [ ! -z "$JAVA_HOME" -a "$JAVA_HOME" != "/" -a ! -f "$JAVA_HOME/lib/tools.jar" ] ; do
+        JAVA_HOME=`dirname $JAVA_HOME`
+    done
+    [ "$JAVA_HOME" = "" ] && JAVA_HOME=
+
+    echo "Found JAVA=$JAVA in JAVA_HOME=$JAVA_HOME"
+fi
+
+
+##################################################
+# Determine which JVM of version >1.2
+# Try to use JAVA_HOME
+##################################################
+if [ "$JAVA" = "" -a "$JAVA_HOME" != "" ]
+then
+  if [ ! -z "$JAVACMD" ] 
+  then
+     JAVA="$JAVACMD" 
+  else
+    [ -x $JAVA_HOME/bin/jre -a ! -d $JAVA_HOME/bin/jre ] && JAVA=$JAVA_HOME/bin/jre
+    [ -x $JAVA_HOME/bin/java -a ! -d $JAVA_HOME/bin/java ] && JAVA=$JAVA_HOME/bin/java
+  fi
+fi
+
+if [ "$JAVA" = "" ]
+then
+    echo "Cannot find a JRE or JDK. Please set JAVA_HOME to a >=1.2 JRE" 2>&2
+    exit 1
+fi
+
+JAVA_VERSION=`expr "$($JAVA -version 2>&1 | head -1)" : '.*1\.\([0-9]\)'`
+
+#####################################################
+# See if JETTY_PORT is defined
+#####################################################
+if [ "$JETTY_PORT" != "" ] 
+then
+  JAVA_OPTIONS="$JAVA_OPTIONS -Djetty.port=$JETTY_PORT"
+fi
+
+#####################################################
+# See if JETTY_LOGS is defined
+#####################################################
+if [ "$JETTY_LOGS" != "" ]
+then
+  JAVA_OPTIONS="$JAVA_OPTIONS -Djetty.logs=$JETTY_LOGS"
+fi
+
+#####################################################
+# Are we running on Windows? Could be, with Cygwin/NT.
+#####################################################
+case "`uname`" in
+CYGWIN*) PATH_SEPARATOR=";";;
+*) PATH_SEPARATOR=":";;
+esac
+
+
+#####################################################
+# Add jetty properties to Java VM options.
+#####################################################
+JAVA_OPTIONS="$JAVA_OPTIONS -Djetty.home=$JETTY_HOME -Djava.io.tmpdir=$TMP"
+
+[ -f $JETTY_HOME/etc/start.config ] && JAVA_OPTIONS="-DSTART=$JETTY_HOME/etc/start.config $JAVA_OPTIONS"
+
+#####################################################
+# This is how the Jetty server will be started
+#####################################################
+
+JETTY_START=$JETTY_HOME/start.jar
+[ ! -f $JETTY_START ] && JETTY_START=$JETTY_HOME/lib/start.jar
+
+RUN_ARGS="$JAVA_OPTIONS -jar $JETTY_START --fromDaemon $JETTY_ARGS $ARGS"
+RUN_CMD="$JAVA $RUN_ARGS"
+
+#####################################################
+# Comment these out after you're happy with what 
+# the script is doing.
+#####################################################
+#echo "JETTY_HOME     =  $JETTY_HOME"
+#echo "JETTY_CONF     =  $JETTY_CONF"
+#echo "JETTY_RUN      =  $JETTY_RUN"
+#echo "JETTY_PID      =  $JETTY_PID"
+#echo "JETTY_ARGS     =  $JETTY_ARGS"
+#echo "ARGS           =  $ARGS"
+#echo "JAVA_OPTIONS   =  $JAVA_OPTIONS"
+#echo "JAVA           =  $JAVA"
+
+
+##################################################
+# Do the action
+##################################################
+case "$ACTION" in
+  start)
+        echo -n "Starting Jetty: "
+
+        if [ "$NO_START" = "1" ]; then 
+	  echo "Not starting jetty - NO_START=1 in /etc/default/jetty7";
+          exit 0;
+	fi
+
+
+	if [ "$START_STOP_DAEMON" = "1" ] && type start-stop-daemon > /dev/null 2>&1
+	then
+          [ x$JETTY_USER = x ] && JETTY_USER=$(whoami)
+	  [ $UID = 0 ] && CH_USER="-c $JETTY_USER"
+	  if start-stop-daemon -S -p$JETTY_PID $CH_USER -d $JETTY_HOME -b -m -a $JAVA -- $RUN_ARGS 
+	  then
+	      sleep 1
+	      if running $JETTY_PID
+	      then
+                  echo OK
+              else
+                  echo FAILED
+              fi
+	  fi
+
+	else
+
+          if [ -f $JETTY_PID ]
+          then
+            if running $JETTY_PID
+            then
+              echo "Already Running!!"
+              exit 1
+            else
+              # dead pid file - remove
+              rm -f $JETTY_PID
+            fi
+          fi
+
+          if [ x$JETTY_USER != x ] 
+          then
+              touch $JETTY_PID
+              chown $JETTY_USER $JETTY_PID
+              su - $JETTY_USER -c "
+                $RUN_CMD &
+                PID=\$!
+                disown \$PID
+                echo \$PID > $JETTY_PID"
+          else
+              $RUN_CMD &
+              PID=$!
+              disown $PID
+              echo $PID > $JETTY_PID
+          fi
+
+          echo "STARTED Jetty `date`" 
+        fi
+
+        ;;
+
+  stop)
+        echo -n "Stopping Jetty: "
+	if [ "$START_STOP_DAEMON" = "1" ] && type start-stop-daemon > /dev/null 2>&1; then
+	  start-stop-daemon -K -p $JETTY_PID -d $JETTY_HOME -a $JAVA -s HUP 
+	  sleep 1
+	  if running $JETTY_PID
+	  then
+	      sleep 3
+	      if running $JETTY_PID
+	      then
+		  sleep 30
+	          if running $JETTY_PID
+	          then
+	             start-stop-daemon -K -p $JETTY_PID -d $JETTY_HOME -a $JAVA -s KILL
+		  fi
+              fi
+	  fi
+
+	  rm -f $JETTY_PID
+          echo OK
+	else
+	  PID=`cat $JETTY_PID 2>/dev/null`
+          TIMEOUT=30
+          while running $JETTY_PID && [ $TIMEOUT -gt 0 ]
+          do
+            kill $PID 2>/dev/null
+            sleep 1
+            let TIMEOUT=$TIMEOUT-1
+          done
+          
+          [ $TIMEOUT -gt 0 ] || kill -9 $PID 2>/dev/null
+
+	  rm -f $JETTY_PID
+          echo OK
+	fi
+        ;;
+
+  restart)
+        JETTY_SH=$0
+        if [ ! -f $JETTY_SH ]; then
+          if [ ! -f $JETTY_HOME/bin/jetty.sh ]; then
+            echo "$JETTY_HOME/bin/jetty.sh does not exist."
+            exit 1
+          fi
+          JETTY_SH=$JETTY_HOME/bin/jetty.sh
+        fi
+        $JETTY_SH stop $*
+        sleep 5
+        $JETTY_SH start $*
+        ;;
+
+  supervise)
+       #
+       # Under control of daemontools supervise monitor which
+       # handles restarts and shutdowns via the svc program.
+       #
+         exec $RUN_CMD
+         ;;
+
+  run|demo)
+        echo "Running Jetty: "
+
+        if [ -f $JETTY_PID ]
+        then
+            if running $JETTY_PID
+            then
+              echo "Already Running!!"
+              exit 1
+            else
+              # dead pid file - remove
+              rm -f $JETTY_PID
+            fi
+        fi
+
+        exec $RUN_CMD
+        ;;
+
+  check)
+        echo "Checking arguments to Jetty: "
+        echo "JETTY_HOME     =  $JETTY_HOME"
+        echo "JETTY_CONF     =  $JETTY_CONF"
+        echo "JETTY_RUN      =  $JETTY_RUN"
+        echo "JETTY_PID      =  $JETTY_PID"
+        echo "JETTY_PORT     =  $JETTY_PORT"
+        echo "JETTY_LOGS     =  $JETTY_LOGS"
+        echo "JAVA_OPTIONS   =  $JAVA_OPTIONS"
+        echo "JAVA           =  $JAVA"
+        echo "CLASSPATH      =  $CLASSPATH"
+        echo "RUN_CMD        =  $RUN_CMD"
+        echo
+        
+        if [ -f $JETTY_RUN/jetty.pid ]
+        then
+            echo "Jetty running pid="`cat $JETTY_RUN/jetty.pid`
+            exit 0
+        fi
+        exit 1
+        ;;
+
+*)
+        usage
+	;;
+esac
+
+exit 0
+
+
+

data/generators/vulcanize/templates/jetty/config/rubber/rubber-jetty.yml

@@ -3,6 +3,8 @@ jetty_prefix: /opt
 jetty_dir: "#{jetty_prefix}/jetty"
 jetty_port: 8080
 
+jetty_jvm_options: -XX:MaxPermSize=128m
+
 roles:
   jetty:
     packages: [openjdk-6-jdk]

data/generators/vulcanize/templates/mysql/config/rubber/rubber-mysql.yml

@@ -32,6 +32,7 @@ role_dependencies:
   db: [mysql_slave]
 
 packages: [mysql-client, libmysql-ruby]
+gems: [mysql]
 
 roles:
   mysql_master:

data/generators/vulcanize/templates/passenger/config/rubber/rubber-passenger.yml

@@ -1,4 +1,4 @@
-passenger_version: 2.2.8
+passenger_version: 2.2.9
 passenger_root: "#{ruby_prefix}/lib/ruby/gems/1.8/gems/passenger-#{passenger_version}"
 passenger_ruby: "#{ruby_prefix}/bin/ruby"
 passenger_lib: "#{passenger_root}/ext/apache2/mod_passenger.so"

data/generators/vulcanize/templates/redis/config/rubber/deploy-redis.rb

@@ -8,7 +8,7 @@ namespace :rubber do
     after "rubber:install_packages", "rubber:redis:custom_install"
 
     task :custom_install, :roles => :redis do
-      custom_package('http://ftp.us.debian.org/debian/pool/main/r/redis/', 'redis-server', '1.02-1', '! -x /usr/bin/redis-server')
+      custom_package('http://ftp.us.debian.org/debian/pool/main/r/redis/', 'redis-server', '1.2.0-1', '! -x /usr/bin/redis-server')
     end
 
     desc "Stops the redis server"

data/lib/rubber/cloud/aws.rb

@@ -15,13 +15,18 @@ module Rubber
         AWS::S3::Base.establish_connection!(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
       end
 
-
       def create_instance(ami, ami_type, security_groups, availability_zone)
         response = @ec2.run_instances(:image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
         instance_id = response.instancesSet.item[0].instanceId
         return instance_id
       end
 
+      def create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
+        response = @ec2.request_spot_instances(:spot_price => spot_price, :image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
+        request_id = response.spotInstanceRequestSet.item[0].spotInstanceRequestId
+        return request_id
+      end
+
       def describe_instances(instance_id=nil)
         instances = []
         opts = {}
@@ -37,6 +42,7 @@ module Rubber
             instance[:internal_host] = item.privateDnsName
             instance[:state] = item.instanceState.name
             instance[:zone] = item.placement.availabilityZone
+            instance[:platform] = item.platform || 'linux'
             instances << instance
           end
         end if response.reservationSet
@@ -271,6 +277,10 @@ module Rubber
         end
       end
 
+      def destroy_spot_instance_request(request_id)
+        @ec2.cancel_spot_instance_requests :spot_instance_request_id => request_id
+      end
+
       def describe_load_balancers(name=nil)
         lbs = []
         opts = {}
@@ -300,6 +310,25 @@ module Rubber
         return lbs
       end
 
+      def describe_spot_instance_requests(request_id=nil)
+        requests = []
+        opts = {}
+        opts[:spot_instance_request_id] = request_id if request_id
+        response = @ec2.describe_spot_instance_requests(opts)
+        response.spotInstanceRequestSet.item.each do |item|
+          request = {}
+          request[:id] = item.spotInstanceRequestId
+          request[:spot_price] = item.spotPrice
+          request[:state] = item.state
+          request[:created_at] = item.createTime
+          request[:type] = item.launchSpecification.instanceType
+          request[:image_id] = item.launchSpecification.imageId
+          request[:instance_id] = item.instanceId
+          requests << request
+        end if response.spotInstanceRequestSet
+        return requests
+      end
+
     end
 
   end

data/lib/rubber/instance.rb

@@ -81,6 +81,8 @@ module Rubber
       attr_accessor :external_host, :external_ip
       attr_accessor :internal_host, :internal_ip
       attr_accessor :static_ip, :volumes, :partitions
+      attr_accessor :spot_instance_request_id
+      attr_accessor :platform
 
       def initialize(name, domain, roles, instance_id, security_group_list=[])
         @name = name
@@ -97,6 +99,15 @@ module Rubber
       def role_names()
         roles.collect {|r| r.name}
       end
+
+      def platform
+        # Deal with old instance configurations that don't have a platform value persisted.
+        @platform || 'linux'
+      end
+
+      def windows?
+        platform == 'windows'
+      end
     end
 
     # The configuration for a single role contained in the list

data/lib/rubber/recipes/rubber.rb

@@ -10,7 +10,13 @@ require 'rubber'
 
 namespace :rubber do
 
-  # advise capistrano's task method so that tasks for non-existant roles don't
+  # Disable connecting to any Windows instance.
+  alias :original_task :task
+  def task(name, options={}, &block)
+    original_task(name, options.merge(:except => { :platform => 'windows' }), &block)
+  end
+
+  # advise capistrano's task method so that tasks for non-existent roles don't
   # fail when roles isn't defined due to using a FILTER for load_roles
   # If you have a task you need to execute even when there are no
   # roles, you have to use required_task instead of task - see rubber:create
@@ -19,7 +25,8 @@ namespace :rubber do
     class << ns
       alias :required_task :task
       def task(name, options={}, &block)
-        required_task(name, options) do
+        # Disable connecting to any Windows instance.
+        required_task(name, options.merge(:except => { :platform => 'windows' })) do
           # define empty roles for the case when a task has a role that we don't define anywhere
           [*options[:roles]].each do |r|
             roles[r] ||= []
@@ -73,7 +80,7 @@ namespace :rubber do
     # define capistrano host => role mapping for all instances
     rubber_instances.filtered.each do |ic|
       ic.roles.each do |role|
-        opts = Rubber::Util::symbolize_keys(role.options)
+        opts = Rubber::Util::symbolize_keys(role.options).merge(:platform => ic.platform)
         msg = "Auto role: #{role.name.to_sym} => #{ic.full_name}"
         msg << ", #{opts.inspect}" if opts.inspect.size > 0
         logger.info msg

data/lib/rubber/recipes/rubber/instances.rb

@@ -10,6 +10,8 @@ namespace :rubber do
     default_roles = env.instance_roles
     r = get_env("ROLES", "Instance roles (e.g. web,app,db:primary=true)", true, default_roles)
 
+    create_spot_instance = ENV.delete("SPOT_INSTANCE") || env.cloud_providers[env.cloud_provider].spot_instance
+
     if r == '*'
       instance_roles = rubber_cfg.environment.known_roles
       instance_roles = instance_roles.collect {|role| role == "db" ? "db:primary=true" : role }
@@ -33,7 +35,7 @@ namespace :rubber do
     # Add in roles that the given set of roles depends on
     ir = Rubber::Configuration::RoleItem.expand_role_dependencies(ir, get_role_dependencies)
 
-    create_instance(instance_alias, ir)
+    create_instance(instance_alias, ir, create_spot_instance)
   end
 
   desc <<-DESC
@@ -154,7 +156,7 @@ namespace :rubber do
 
   # Creates a new ec2 instance with the given alias and roles
   # Configures aliases (/etc/hosts) on local and remote machines
-  def create_instance(instance_alias, instance_roles)
+  def create_instance(instance_alias, instance_roles, create_spot_instance=false)
     fatal "Instance already exists: #{instance_alias}" if rubber_instances[instance_alias]
 
     role_names = instance_roles.collect{|x| x.name}
@@ -167,12 +169,45 @@ namespace :rubber do
     ami = env.cloud_providers[env.cloud_provider].image_id
     ami_type = env.cloud_providers[env.cloud_provider].image_type
     availability_zone = env.availability_zone
-    logger.info "Creating instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
-    instance_id = cloud.create_instance(ami, ami_type, security_groups, availability_zone)
+
+    if create_spot_instance
+      spot_price = env.cloud_providers[env.cloud_provider].spot_price.to_s
+
+      logger.info "Creating spot instance request for instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      request_id = cloud.create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
+
+      print "Waiting for spot instance request to be fulfilled"
+      max_wait_time = env.cloud_providers[env.cloud_provider].spot_instance_request_timeout || (1.0 / 0) # Use the specified timeout value or default to infinite.
+      instance_id = nil
+      while instance_id.nil? do
+        print "."
+        sleep 2
+        max_wait_time -= 2
+
+        request = cloud.describe_spot_instance_requests(request_id).first
+        instance_id = request[:instance_id]
+
+        if max_wait_time < 0 && instance_id.nil?
+          cloud.destroy_spot_instance_request(request[:id])
+
+          print "\n"
+          print "Failed to fulfill spot instance in the time specified. Falling back to on-demand instance creation."
+          break
+        end
+      end
+
+      print "\n"
+    end
+
+    if !create_spot_instance || (create_spot_instance && max_wait_time < 0)
+      logger.info "Creating instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      instance_id = cloud.create_instance(ami, ami_type, security_groups, availability_zone)
+    end
 
     logger.info "Instance #{instance_id} created"
 
     instance_item = Rubber::Configuration::InstanceItem.new(instance_alias, env.domain, instance_roles, instance_id, security_groups)
+    instance_item.spot_instance_request_id = request_id if create_spot_instance
     rubber_instances.add(instance_item)
     rubber_instances.save()
 
@@ -190,6 +225,7 @@ namespace :rubber do
         instance_item.external_ip = instance[:external_ip]
         instance_item.internal_host = instance[:internal_host]
         instance_item.zone = instance[:zone]
+        instance_item.platform = instance[:platform]
         rubber_instances.save()
 
         # setup amazon elastic ips if configured to do so
@@ -206,7 +242,14 @@ namespace :rubber do
         # so that we can update all aliases
 
         task :_get_ip, :hosts => instance_item.external_ip do
-          instance_item.internal_ip = capture(print_ip_command).strip
+          # There's no good way to get the internal IP for a Windows host, so just set it to the external
+          # and let the router handle mapping to the internal network.
+          if instance_item.windows?
+            instance_item.internal_ip = instance_item.external_ip
+          else
+            instance_item.internal_ip = capture(print_ip_command).strip
+          end
+
           rubber_instances.save()
         end
 

data/lib/rubber/recipes/rubber/setup.rb

@@ -1,5 +1,8 @@
 namespace :rubber do
 
+  # Disable connecting to any Windows instance.
+  set :default_run_options, :except => { :platform => 'windows' }
+
   desc <<-DESC
     Bootstraps instances by setting timezone, installing packages and gems
   DESC

data/lib/rubber/recipes/rubber/spot_requests.rb

@@ -0,0 +1,23 @@
+namespace :rubber do
+
+  desc "Describes all your spot instance requests"
+  required_task :describe_spot_instance_requests do
+    requests = cloud.describe_spot_instance_requests()
+    requests.each do |request|
+      logger.info "======================"
+      logger.info "ID: #{request[:id]}"
+      logger.info "Created at: #{request[:created_at]}"
+      logger.info "Max. price: $#{request[:spot_price]}"
+      logger.info "State: #{request[:state]}"
+      logger.info "Instance type: #{request[:type]}"
+      logger.info "AMI: #{request[:image_id]}"
+    end
+  end
+
+  desc "Cancel the spot instances request for the given id"
+  required_task :cancel_spot_instances_request do
+    request_id = get_env('SPOT_INSTANCE_REQUEST_ID', 'The id of the spot instances request to cancel', true)
+    cloud.destroy_spot_instance_request(request_id)
+  end
+
+end

data/lib/rubber/recipes/rubber/static_ips.rb

@@ -80,6 +80,89 @@ namespace :rubber do
     destroy_static_ip(ip)
   end
 
+  desc 'Move a static IP address from DONOR machine to RECEIVER machine.'
+  task :move_static_ip do
+    donor_alias = get_env 'DONOR', 'Instance alias to get the IP from (e.g., web01)', true
+    receiver_alias = get_env 'RECEIVER', 'Instance alias to assign the IP to (e.g., web02)', true
+
+    # Sanity checks
+    donor = rubber_instances[donor_alias]
+    fatal "Instance does not exist: #{donor_alias}" unless donor
+
+    static_ip = donor.static_ip
+    fatal 'No static IP address to move exists' unless static_ip && static_ip != ''
+
+    receiver = rubber_instances[receiver_alias]
+    fatal "Instance does not exist: #{receiver_alias}" unless receiver
+
+    # Temporary removal of the instances.
+    old_donor = rubber_instances.remove(donor_alias)
+    old_receiver = rubber_instances.remove(receiver_alias)
+
+    rubber_instances.save
+
+    # Getting rid of alias->IP mappings and SSH's known_hosts records.
+    load_roles
+    setup_aliases
+    cleanup_known_hosts(old_donor)
+    cleanup_known_hosts(old_receiver)
+
+    # Detachment of EIPA.
+    success = cloud.detach_static_ip(static_ip)
+    fatal "Failed to detach static IP address #{static_ip}" unless success
+    rubber_instances.artifacts['static_ips'].delete(old_donor.name)
+
+    rubber_instances.save
+
+    # Attachment of EIPA.
+    success = cloud.attach_static_ip(static_ip, old_receiver.instance_id)
+    fatal "Failed to associate static IP address #{static_ip}" unless success
+
+    print "Waiting for #{receiver_alias} to get the address"
+    while true do
+      print '.'
+      sleep 3
+      instance = cloud.describe_instances(old_receiver.instance_id).first
+      break if instance[:external_ip] == static_ip
+    end
+
+    # Partial cleanup of static IP records.
+    rubber_instances.artifacts['static_ips'][old_receiver.name] = static_ip
+
+    rubber_instances.save
+
+    # First half of the sync.
+    new_receiver = Rubber::Configuration::InstanceItem.new(old_receiver.name,
+      old_receiver.domain, old_receiver.roles, old_receiver.instance_id,
+      old_receiver.security_groups)
+    new_receiver.static_ip = static_ip
+    rubber_instances.add(new_receiver)
+
+    rubber_instances.save
+
+    refresh_instance(receiver_alias)
+
+    print "Waiting for #{donor_alias} to get a new address"
+    while true do
+      print '.'
+      sleep 3
+      instance = cloud.describe_instances(old_donor.instance_id).first
+      break if instance[:external_ip] && instance[:external_ip] != ''
+    end
+
+    # Second half of the sync.
+    new_donor = Rubber::Configuration::InstanceItem.new(old_donor.name,
+      old_donor.domain, old_donor.roles, old_donor.instance_id,
+      old_donor.security_groups)
+    rubber_instances.add(new_donor)
+
+    rubber_instances.save
+
+    refresh_instance(donor_alias)
+
+    logger.info "Run 'cap rubber:describe_static_ips' to check the allocated ones"
+  end
+
   def allocate_static_ip()
     ip = cloud.create_static_ip()
     fatal "Failed to allocate static ip" if ip.nil?

data/test/environment_test.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'tempfile'
 require 'test_helper'

data/test/generator_test.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'tempfile'
 require 'test_helper'

data/test/instance_test.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'tempfile'
 require 'test_helper'

data/test/util_test.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'test_helper'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubber
 version: !ruby/object:Gem::Version 
-  version: 1.1.7
+  version: 1.2.0
 platform: ruby
 authors: 
 - Matt Conway
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 -05:00
+date: 2010-01-22 00:00:00 -05:00
 default_executable: vulcanize
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.8
+        version: 0.9.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: aws-s3
@@ -80,6 +80,7 @@ extensions: []
 
 extra_rdoc_files: 
 - README
+- TODO
 files: 
 - CHANGELOG
 - COPYING
@@ -138,6 +139,7 @@ files:
 - generators/vulcanize/templates/haproxy/config/rubber/rubber-haproxy.yml
 - generators/vulcanize/templates/haproxy/templates.yml
 - generators/vulcanize/templates/jetty/config/rubber/deploy-jetty.rb
+- generators/vulcanize/templates/jetty/config/rubber/role/jetty/jetty.sh
 - generators/vulcanize/templates/jetty/config/rubber/role/jetty/jetty.xml
 - generators/vulcanize/templates/jetty/config/rubber/role/jetty/monit-jetty.conf
 - generators/vulcanize/templates/jetty/config/rubber/rubber-jetty.yml
@@ -253,6 +255,7 @@ files:
 - lib/rubber/recipes/rubber/load_balancers.rb
 - lib/rubber/recipes/rubber/security_groups.rb
 - lib/rubber/recipes/rubber/setup.rb
+- lib/rubber/recipes/rubber/spot_requests.rb
 - lib/rubber/recipes/rubber/static_ips.rb
 - lib/rubber/recipes/rubber/utils.rb
 - lib/rubber/recipes/rubber/volumes.rb