automan 2.1.2

data/spec/beanstalk/uploader_spec.rb

@@ -0,0 +1,53 @@
+require 'automan'
+
+describe Automan::Beanstalk::Uploader do
+  subject(:u) do
+    AWS.stub!
+    u = Automan::Beanstalk::Uploader.new
+    u.logger = Logger.new('/dev/null')
+    u.template_files = 'foo'
+    u.stub(:config_templates).and_return(['foo'])
+    u
+  end
+
+  it { should respond_to :template_files }
+  it { should respond_to :s3_path }
+  it { should respond_to :upload_config_templates }
+  it { should respond_to :config_templates_valid? }
+
+  describe '#config_templates_valid?' do
+
+    it 'raises error if config templates do not exist' do
+      u.stub(:config_templates).and_return([])
+      expect {
+        u.config_templates_valid?
+      }.to raise_error(Automan::Beanstalk::NoConfigurationTemplatesError)
+    end
+
+    it 'returns true if config templates are valid json' do
+      u.stub(:read_config_template).and_return('[{}]')
+      u.config_templates_valid?.should be_true
+    end
+
+    it 'returns false if config templates are invalid json' do
+      u.stub(:read_config_template).and_return('@#$%#')
+      u.config_templates_valid?.should be_false
+    end
+  end
+
+  describe '#upload_config_templates' do
+    it 'raises error if any config template fails validation' do
+      u.stub(:config_templates_valid?).and_return(false)
+      expect {
+        u.upload_config_templates
+      }.to raise_error(Automan::Beanstalk::InvalidConfigurationTemplateError)
+    end
+
+    it 'uploads files if they are valid' do
+      u.stub(:config_templates).and_return(%w[a b c])
+      u.stub(:config_templates_valid?).and_return(true)
+      u.should_receive(:upload_file).exactly(3).times
+      u.upload_config_templates
+    end
+  end
+end

data/spec/beanstalk/version_spec.rb

@@ -0,0 +1,60 @@
+require "automan"
+
+describe Automan::Beanstalk::Version do
+
+  it { should respond_to :application }
+  it { should respond_to :label }
+  it { should respond_to :create }
+  it { should respond_to :delete }
+  it { should respond_to :cull_versions }
+  it { should respond_to :delete_by_label }
+
+  describe '#exists?' do
+    subject(:v) do
+      AWS.stub!
+      v = Automan::Beanstalk::Version.new
+      v.eb = AWS::ElasticBeanstalk::Client.new
+      v.application = 'foo'
+      v.label = 'v4'
+      v.log_aws_calls = false
+      v.logger = Logger.new('/dev/null')
+      v
+    end
+
+    it "is true when version exists in response" do
+      resp = v.eb.stub_for :describe_application_versions
+      resp.data[:application_versions] = [
+        {application_name: v.application, version_label: v.label}
+      ]
+      v.exists?.should be_true
+    end
+
+    it "is false when version is not in response" do
+      resp = v.eb.stub_for :describe_application_versions
+      resp.data[:application_versions] = [
+        {application_name: '', version_label: ''}
+      ]
+      v.exists?.should be_false
+    end
+  end
+
+  describe '#delete_by_label' do
+    subject(:v) do
+      AWS.stub!
+      v = Automan::Beanstalk::Version.new
+      v.logger = Logger.new('/dev/null')
+      v
+    end
+
+    it 'ignores AWS::ElasticBeanstalk::Errors::SourceBundleDeletionFailure' do
+      eb = double(:eb)
+      eb.stub(:delete_application_version).and_raise(AWS::ElasticBeanstalk::Errors::SourceBundleDeletionFailure)
+      v.eb = eb
+      expect {
+        v.delete_by_label('foo')
+      }.not_to raise_error
+    end
+
+  end
+
+end

data/spec/chef/uploader_spec.rb

@@ -0,0 +1,9 @@
+require "automan"
+
+describe Automan::Chef::Uploader do
+  it { should respond_to :repopath }
+  it { should respond_to :s3path }
+  it { should respond_to :chefver }
+  it { should respond_to :tempdir }
+  it { should respond_to :upload }
+end

data/spec/cloudformation/launcher_spec.rb

@@ -0,0 +1,240 @@
+require 'automan'
+
+describe Automan::Cloudformation::Launcher do
+  it { should respond_to :name }
+  it { should respond_to :template }
+  it { should respond_to :parameters }
+  it { should respond_to :disable_rollback }
+  it { should respond_to :enable_iam }
+  it { should respond_to :enable_update }
+  it { should respond_to :parse_template_parameters }
+  it { should respond_to :launch_or_update }
+  it { should respond_to :launch }
+  it { should respond_to :update }
+  it { should respond_to :read_manifest }
+  it { should respond_to :wait_for_completion }
+  it { should respond_to :stack_launch_complete? }
+  it { should respond_to :stack_update_complete? }
+
+  describe '#read_manifest' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s
+    end
+
+    it 'raises MissingManifestError if manifest does not exist' do
+      s.stub(:manifest_exists?).and_return(false)
+      expect {
+        s.read_manifest
+      }.to raise_error(Automan::Cloudformation::MissingManifestError)
+    end
+
+    it 'merges manifest contents into parameters hash' do
+      s.stub(:manifest_exists?).and_return(true)
+      s.stub(:s3_read).and_return('{"foo": "bar", "big": "poppa"}')
+      s.parameters = {'foo'=> 'baz', 'fo'=> 'shizzle'}
+      s.read_manifest
+      s.parameters.should eq({'foo' => 'bar', 'fo' => 'shizzle', 'big' => 'poppa'})
+    end
+  end
+
+  describe '#parse_template_parameters' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.cfn = AWS::CloudFormation.new
+      s.cfn.client.stub_for :validate_template
+      s
+    end
+
+    it "returns a hash" do
+      s.template = File.join(File.dirname(__FILE__), 'templates', 'worker_role.json')
+      result = s.parse_template_parameters
+      result.class.should eq(Hash)
+    end
+
+  end
+
+  describe '#template_handle' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s
+    end
+
+    it "returns an s3 key if it is an s3 path" do
+      s.template_handle("s3://foo/bar/baz").should be_a AWS::S3::S3Object
+    end
+
+    it "returns a string if it is a local file" do
+      s.template_handle(__FILE__).should be_a String
+    end
+  end
+
+  describe '#validate_parameters' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.logger = Logger.new('/dev/null')
+      s.parameters = {}
+      s
+    end
+
+    it "raises error if no parameters were specified" do
+      s.parameters = nil
+      expect {
+        s.validate_parameters
+      }.to raise_error Automan::Cloudformation::MissingParametersError
+    end
+
+    it "raises error if the template doesn't validate" do
+      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return({code: 'foo', message: 'bar'})
+      expect {
+        s.validate_parameters
+      }.to raise_error Automan::Cloudformation::BadTemplateError
+    end
+
+    it "raises error if a required parameter isn't present" do
+      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
+      expect {
+        s.validate_parameters
+      }.to raise_error Automan::Cloudformation::MissingParametersError
+    end
+
+    it "raises no error if all required parameters are present" do
+      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
+      s.parameters = {'foo' => 'bar'}
+      expect {
+        s.validate_parameters
+      }.not_to raise_error
+    end
+
+    it "raises no error if there are no required parameters" do
+      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo', default_value: 'bar'}])
+      expect {
+        s.validate_parameters
+      }.not_to raise_error
+    end
+  end
+
+  describe '#update' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:template_handle).and_return('foo')
+      s
+    end
+
+    it "ignores AWS::CloudFormation::Errors::ValidationError when no updates are to be performed" do
+      s.stub(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("No updates are to be performed.")
+      expect {
+        s.update
+      }.to_not raise_error
+    end
+
+    it 're-raises any other ValidationError' do
+      s.stub(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("foo")
+      expect {
+        s.update
+      }.to raise_error AWS::CloudFormation::Errors::ValidationError
+    end
+  end
+
+  describe '#launch_or_update' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:validate_parameters)
+      s
+    end
+
+    it "launches a new stack if it does not exist" do
+      s.stub(:stack_exists?).and_return(false)
+      s.should_receive(:launch)
+      s.launch_or_update
+    end
+
+    it "updates an existing stack if update is enabled" do
+      s.stub(:stack_exists?).and_return(true)
+      s.stub(:enable_update).and_return(true)
+      s.should_receive(:update)
+      s.launch_or_update
+    end
+
+    it "raises an error when updating an existing stack w/o update enabled" do
+      s.stub(:stack_exists?).and_return(true)
+      s.stub(:enable_update).and_return(false)
+      expect {
+        s.launch_or_update
+      }.to raise_error Automan::Cloudformation::StackExistsError
+    end
+  end
+
+  describe '#stack_launch_complete?' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'returns true when the stack completes' do
+      s.stub(:stack_status).and_return('CREATE_COMPLETE')
+      s.stack_launch_complete?.should be_true
+    end
+
+    it 'raises an error when the stack fails' do
+      s.stub(:stack_status).and_return('CREATE_FAILED')
+      expect {
+        s.stack_launch_complete?
+      }.to raise_error Automan::Cloudformation::StackCreationError
+    end
+
+    rollback_states = %w[ROLLBACK_COMPLETE ROLLBACK_FAILED ROLLBACK_IN_PROGRESS]
+    rollback_states.each do |state|
+      it "raises an error when the stack goes into #{state} state" do
+        s.stub(:stack_status).and_return(state)
+        expect {
+          s.stack_launch_complete?
+        }.to raise_error Automan::Cloudformation::StackCreationError
+      end
+    end
+
+    it 'returns false for any other state' do
+      s.stub(:stack_status).and_return('foo')
+      s.stack_launch_complete?.should be_false
+    end
+  end
+
+  describe '#stack_update_complete?' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Cloudformation::Launcher.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'returns true when the stack completes' do
+      s.stub(:stack_status).and_return('UPDATE_COMPLETE')
+      s.stack_update_complete?.should be_true
+    end
+
+    rollback_states = %w[UPDATE_ROLLBACK_COMPLETE UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_ROLLBACK_FAILED UPDATE_ROLLBACK_IN_PROGRESS]
+    rollback_states.each do |state|
+      it "raises an error when the stack enters #{state} state" do
+        s.stub(:stack_status).and_return(state)
+        expect {
+          s.stack_update_complete?
+        }.to raise_error Automan::Cloudformation::StackUpdateError
+      end
+    end
+
+    it 'returns false for any other state' do
+      s.stub(:stack_status).and_return('foo')
+      s.stack_update_complete?.should be_false
+    end
+  end
+end

data/spec/cloudformation/replacer_spec.rb

@@ -0,0 +1,58 @@
+require 'automan'
+
+describe Automan::Cloudformation::Replacer do
+  it { should respond_to :name }
+  it { should respond_to :replace_instances }
+  it { should respond_to :ok_to_replace_instances? }
+  it { should respond_to :stack_exists? }
+
+  describe '#ok_to_replace_instances?' do
+    subject(:r) do
+      AWS.stub!
+      r = Automan::Cloudformation::Replacer.new
+    end
+
+    good_states = %w[UPDATE_COMPLETE]
+
+    bad_states =
+      %w[
+        CREATE_FAILED ROLLBACK_IN_PROGRESS ROLLBACK_FAILED
+        ROLLBACK_COMPLETE DELETE_IN_PROGRESS DELETE_FAILED
+        DELETE_COMPLETE UPDATE_ROLLBACK_IN_PROGRESS
+        UPDATE_ROLLBACK_FAILED UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS
+        UPDATE_ROLLBACK_COMPLETE
+        ]
+
+    wait_states =
+      %w[CREATE_COMPLETE CREATE_IN_PROGRESS
+         UPDATE_IN_PROGRESS UPDATE_COMPLETE_CLEANUP_IN_PROGRESS
+        ]
+
+    good_states.each do |state|
+      it "returns true when stack is in the right state (state: #{state})" do
+        r.ok_to_replace_instances?(state, Time.now).should be_true
+      end
+    end
+
+    good_states.each do |state|
+      it "returns false when stack is in the right state but has not been updated in the last 5m" do
+        last_updated = Time.now - (5 * 60 + 1)
+        r.ok_to_replace_instances?(state, last_updated).should be_false
+      end
+    end
+
+    bad_states.each do |state|
+      it "raises error when stack is borked (state: #{state})" do
+        expect {
+          r.ok_to_replace_instances?(state, Time.now)
+        }.to raise_error Automan::Cloudformation::StackBrokenError
+      end
+    end
+
+    wait_states.each do |state|
+      it "returns false when it is not yet ok to replace (state: #{state})" do
+        r.ok_to_replace_instances?(state, Time.now).should be_false
+      end
+    end
+  end
+end

data/spec/cloudformation/templates/worker_role.json

@@ -0,0 +1,337 @@
+{
+  "AWSTemplateFormatVersion" : "2010-09-09",
+
+  "Description" : "AWS CloudFormation Sample Template WorkerRole: Create a multi-az, Auto Scaled worker that pulls command messages from a queue and execs the command. Each message contains a command/script to run, an input file location and an output location for the results. The application is Auto-Scaled based on the amount of work in the queue. **WARNING** This template creates one or more Amazon EC2 instances and an Amazon SQS queue. You will be billed for the AWS resources used if you create a stack from this template.",
+
+  "Parameters" : {
+    "InstanceType" : {
+      "Description" : "Worker EC2 instance type",
+      "Type" : "String",
+      "Default" : "m1.small",
+      "AllowedValues" : [ "t1.micro","m1.small","m1.medium","m1.large","m1.xlarge","m2.xlarge","m2.2xlarge","m2.4xlarge","c1.medium","c1.xlarge","cc1.4xlarge","cc2.8xlarge","cg1.4xlarge"],
+      "ConstraintDescription" : "must be a valid EC2 instance type."
+    },
+
+    "KeyName" : {
+      "Description" : "The EC2 Key Pair to allow SSH access to the instances",
+      "Type" : "String"
+    },
+
+    "MinInstances" : {
+      "Description" : "The minimum number of Workers",
+      "Type" : "Number",
+      "MinValue" : "0",
+      "Default"  : "0",
+      "ConstraintDescription" : "Enter a number >=0"
+    },
+
+    "MaxInstances" : {
+      "Description" : "The maximum number of Workers",
+      "Type" : "Number",
+      "MinValue" : "1",
+      "Default"  : "1",
+      "ConstraintDescription" : "Enter a number >1"
+    }
+  },
+
+  "Mappings" : {
+    "AWSInstanceType2Arch" : {
+      "t1.micro"    : { "Arch" : "64" },
+      "m1.small"    : { "Arch" : "64" },
+      "m1.medium"   : { "Arch" : "64" },
+      "m1.large"    : { "Arch" : "64" },
+      "m1.xlarge"   : { "Arch" : "64" },
+      "m2.xlarge"   : { "Arch" : "64" },
+      "m2.2xlarge"  : { "Arch" : "64" },
+      "m2.4xlarge"  : { "Arch" : "64" },
+      "c1.medium"   : { "Arch" : "64" },
+      "c1.xlarge"   : { "Arch" : "64" },
+      "cc1.4xlarge" : { "Arch" : "64HVM" },
+      "cc2.8xlarge" : { "Arch" : "64HVM" },
+      "cg1.4xlarge" : { "Arch" : "64HVM" }
+    },
+
+    "AWSRegionArch2AMI" : {
+      "us-east-1"      : { "32" : "ami-31814f58", "64" : "ami-1b814f72", "64HVM" : "ami-0da96764" },
+      "us-west-2"      : { "32" : "ami-38fe7308", "64" : "ami-30fe7300", "64HVM" : "NOT_YET_SUPPORTED" },
+      "us-west-1"      : { "32" : "ami-11d68a54", "64" : "ami-1bd68a5e", "64HVM" : "NOT_YET_SUPPORTED" },
+      "eu-west-1"      : { "32" : "ami-973b06e3", "64" : "ami-953b06e1", "64HVM" : "NOT_YET_SUPPORTED" },
+      "ap-southeast-1" : { "32" : "ami-b4b0cae6", "64" : "ami-beb0caec", "64HVM" : "NOT_YET_SUPPORTED" },
+      "ap-northeast-1" : { "32" : "ami-0644f007", "64" : "ami-0a44f00b", "64HVM" : "NOT_YET_SUPPORTED" },
+      "sa-east-1"      : { "32" : "ami-3e3be423", "64" : "ami-3c3be421", "64HVM" : "NOT_YET_SUPPORTED" }
+    }
+  },
+
+  "Resources" : {
+
+    "WorkerUser" : {
+      "Type" : "AWS::IAM::User",
+      "Properties" : {
+        "Path": "/",
+        "Policies": [{
+          "PolicyName": "root",
+          "PolicyDocument": {
+            "Version": "2012-10-17",
+            "Statement":[{
+              "Effect": "Allow",
+              "Action": [
+                "cloudformation:DescribeStackResource",
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sns:Publish"
+              ],
+              "Resource": "*"
+            }]
+          }
+        }]
+      }
+    },
+
+    "WorkerKeys" : {
+      "Type" : "AWS::IAM::AccessKey",
+      "Properties" : {
+        "UserName" : {"Ref": "WorkerUser"}
+      }
+    },
+
+    "InputQueue" : {
+      "Type" : "AWS::SQS::Queue"
+    },
+
+    "InputQueuePolicy" : {
+      "Type" : "AWS::SQS::QueuePolicy",
+      "DependsOn" : "LaunchConfig",
+      "Properties" : {
+        "Queues" : [ { "Ref" : "InputQueue" } ],
+        "PolicyDocument":  {
+          "Version": "2012-10-17",
+          "Id": "ReadFromQueuePolicy",
+          "Statement" : [ {
+            "Sid": "ConsumeMessages",
+            "Effect": "Allow",
+            "Principal" : { "AWS": {"Fn::GetAtt" : ["WorkerUser", "Arn"]} },
+            "Action": ["sqs:ReceiveMessage", "sqs:DeleteMessage"],
+            "Resource": { "Fn::GetAtt" : [ "InputQueue", "Arn" ] }
+          } ]
+        }
+      }
+    },
+
+    "InstanceSecurityGroup" : {
+      "Type" : "AWS::EC2::SecurityGroup",
+      "Properties" : {
+        "GroupDescription" : "Enable SSH access",
+        "SecurityGroupIngress" : [ { "IpProtocol" : "tcp", "FromPort" : "22", "ToPort" : "22", "CidrIp" : "0.0.0.0/0" } ]
+      }
+    },
+
+    "LaunchConfig" : {
+      "Type" : "AWS::AutoScaling::LaunchConfiguration",
+      "Metadata" : {
+        "Comment" : "Install a simple PHP application",
+        "AWS::CloudFormation::Init" : {
+          "configSets" : {
+            "ALL" : ["XML", "Time", "LWP", "AmazonLibraries", "WorkerRole"]
+          },
+          "XML" : {
+            "packages" : {
+              "yum" : {
+                "perl-XML-Simple"         : []
+              }
+            }
+          },
+          "Time" : {
+            "packages" : {
+              "yum" : {
+                "perl-LWP-Protocol-https" : []
+              }
+            }
+          },
+          "LWP" : {
+            "packages" : {
+              "yum" : {
+                "perl-Time-HiRes"         : []
+              }
+            }
+          },
+          "AmazonLibraries" : {
+            "sources" : {
+              "/home/ec2-user/sqs" : "http://s3.amazonaws.com/awscode/amazon-queue/2009-02-01/perl/library/amazon-queue-2009-02-01-perl-library.zip"
+            }
+          },
+          "WorkerRole" : {
+            "files" : {
+              "/etc/cron.d/worker.cron" : {
+                "content" : "*/1 * * * * ec2-user /home/ec2-user/worker.pl &> /home/ec2-user/worker.log\n",
+                "mode"    : "000644",
+                "owner"   : "root",
+                "group"   : "root"
+              },
+
+              "/home/ec2-user/worker.pl" : {
+                "content" : { "Fn::Join" : ["", [
+                  "#!/usr/bin/perl -w\n",
+                  "#\n",
+                  "use strict;\n",
+                  "use Carp qw( croak );\n",
+                  "use lib qw(/home/ec2-user/sqs/amazon-queue-2009-02-01-perl-library/src);  \n",
+                  "use LWP::Simple qw( getstore );\n",
+                  "\n",
+                  "my $AWS_ACCESS_KEY_ID     = \"", { "Ref" : "WorkerKeys" }, "\";\n",
+                  "my $AWS_SECRET_ACCESS_KEY = \"", { "Fn::GetAtt": ["WorkerKeys", "SecretAccessKey"]}, "\";\n",
+                  "my $QUEUE_NAME            = \"", { "Ref" : "InputQueue" }, "\";\n",
+                  "my $COMMAND_FILE          = \"/home/ec2-user/command\";\n",
+                  "\n",
+                  "eval {\n",
+                  "\n",
+                  "  use Amazon::SQS::Client; \n",
+                  "  my $service = Amazon::SQS::Client->new($AWS_ACCESS_KEY_ID, $AWS_SECRET_ACCESS_KEY);\n",
+                  " \n",
+                  "  my $response = $service->receiveMessage({QueueUrl=>$QUEUE_NAME, MaxNumberOfMessages=>1});\n",
+                  "  if ($response->isSetReceiveMessageResult) {\n",
+                  "    my $result = $response->getReceiveMessageResult();\n",
+                  "    if ($result->isSetMessage) {\n",
+                  "      my $messageList = $response->getReceiveMessageResult()->getMessage();\n",
+                  "      foreach(@$messageList) {\n",
+                  "        my $message = $_;\n",
+                  "        my $messageHandle = 0;\n",
+                  "        if ($message->isSetReceiptHandle()) {\n",
+                  "          $messageHandle = $message->getReceiptHandle();\n",
+                  "        } else {\n",
+                  "          croak \"Couldn't get message Id from message\";\n",
+                  "        }\n",
+                  "        if ($message->isSetBody()) {\n",
+                  "          my %parameters = split(/[=;]/, $message->getBody());\n",
+                  "          if (defined($parameters{\"Input\"}) && defined($parameters{\"Output\"}) && defined($parameters{\"Command\"})) {\n",
+                  "            getstore($parameters{\"Command\"}, $COMMAND_FILE);\n",
+                  "            chmod(0755, $COMMAND_FILE);\n",
+                  "            my $command = $COMMAND_FILE . \" \" . $parameters{\"Input\"} . \" \" . $parameters{\"Output\"};\n",
+                  "            my $result = `$command`;\n",
+                  "            print \"Result = \" . $result . \"\\n\";\n",
+                  "          } else {\n",
+                  "            croak \"Invalid message\";\n",
+                  "          }\n",
+                  "        } else {\n",
+                  "          croak \"Couldn't get message body from message\";\n",
+                  "        }\n",
+                  "        my $response = $service->deleteMessage({QueueUrl=>$QUEUE_NAME, ReceiptHandle=>$messageHandle});\n",
+                  "      }\n",
+                  "    } else {\n",
+                  "      printf \"Empty Poll\\n\";\n",
+                  "    }\n",
+                  "  } else {\n",
+                  "    croak \"Call failed\";\n",
+                  "  }\n",
+                  "}; \n",
+                  "\n",
+                  "my $ex = $@;\n",
+                  "if ($ex) {\n",
+                  "  require Amazon::SQS::Exception;\n",
+                  "  if (ref $ex eq \"Amazon::SQS::Exception\") {\n",
+                  "    print(\"Caught Exception: \" . $ex->getMessage() . \"\\n\");\n",
+                  "  } else {\n",
+                  "    croak $@;\n",
+                  "  }\n",
+                  "}\n"
+                ]]},
+                "mode"    : "000755",
+                "owner"   : "ec2-user",
+                "group"   : "ec2-user"
+              }
+            }
+          }
+        }
+      },
+      "Properties" : {
+        "KeyName" : { "Ref" : "KeyName" },
+        "SpotPrice" : "0.05",
+        "ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" },
+                                          { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" },
+                                          "Arch" ] } ] },
+        "SecurityGroups" : [ { "Ref" : "InstanceSecurityGroup" } ],
+        "InstanceType" : { "Ref" : "InstanceType" },
+        "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
+          "#!/bin/bash\n",
+          "yum update -y aws-cfn-bootstrap\n",
+          "# Install the Worker application\n",
+          "/opt/aws/bin/cfn-init ",
+          "         --stack ", { "Ref" : "AWS::StackName" },
+          "         --resource LaunchConfig ",
+          "         --configset ALL",
+          "         --access-key ", { "Ref" : "WorkerKeys" },
+          "         --secret-key ", {"Fn::GetAtt": ["WorkerKeys", "SecretAccessKey"]},
+          "         --region ", { "Ref" : "AWS::Region" }, "\n"
+        ]]}}
+      }
+    },
+
+    "WorkerGroup" : {
+      "Type" : "AWS::AutoScaling::AutoScalingGroup",
+      "Properties" : {
+        "AvailabilityZones" : { "Fn::GetAZs" : ""},
+        "LaunchConfigurationName" : { "Ref" : "LaunchConfig" },
+        "MinSize" : { "Ref" : "MinInstances" },
+        "MaxSize" : { "Ref" : "MaxInstances" }
+      }
+    },
+
+    "WorkerScaleUpPolicy" : {
+      "Type" : "AWS::AutoScaling::ScalingPolicy",
+      "Properties" : {
+        "AdjustmentType" : "ChangeInCapacity",
+        "AutoScalingGroupName" : { "Ref" : "WorkerGroup" },
+        "Cooldown" : "60",
+        "ScalingAdjustment" : "1"
+      }
+    },
+
+    "WorkerScaleDownPolicy" : {
+      "Type" : "AWS::AutoScaling::ScalingPolicy",
+      "Properties" : {
+        "AdjustmentType" : "ChangeInCapacity",
+        "AutoScalingGroupName" : { "Ref" : "WorkerGroup" },
+        "Cooldown" : "60",
+        "ScalingAdjustment" : "-1"
+      }
+    },
+
+    "TooManyMessagesAlarm": {
+     "Type": "AWS::CloudWatch::Alarm",
+      "Properties": {
+        "AlarmDescription": "Scale-Up if queue depth grows beyond 10 messages",
+        "Namespace": "AWS/SQS",
+        "MetricName": "ApproximateNumberOfMessagesVisible",
+        "Dimensions": [{ "Name": "QueueName", "Value" : { "Fn::GetAtt" : ["InputQueue", "QueueName"] } }],
+        "Statistic": "Sum",
+        "Period": "60",
+        "EvaluationPeriods": "3",
+        "Threshold": "1",
+        "ComparisonOperator": "GreaterThanThreshold",
+        "AlarmActions": [ { "Ref": "WorkerScaleUpPolicy" } ]
+      }
+    },
+
+    "NotEnoughMessagesAlarm": {
+     "Type": "AWS::CloudWatch::Alarm",
+     "Properties": {
+        "AlarmDescription": "Scale-down if there are too many empty polls, indicating there is not enough work",
+        "Namespace": "AWS/SQS",
+        "MetricName": "NumberOfEmptyReceives",
+        "Dimensions": [{ "Name": "QueueName", "Value" : { "Fn::GetAtt" : ["InputQueue", "QueueName"] } }],
+        "Statistic": "Sum",
+        "Period": "60",
+        "EvaluationPeriods": "10",
+        "Threshold": "3",
+        "ComparisonOperator": "GreaterThanThreshold",
+        "AlarmActions": [ { "Ref": "WorkerScaleDownPolicy" } ]
+      }
+    }
+  },
+
+  "Outputs" : {
+    "QueueURL" : {
+      "Description" : "URL of input queue",
+      "Value" : { "Ref" : "InputQueue" }
+    }
+  }
+}