staugaard-cloudmaster 0.1.1

data/lib/RetryAWS/S3.rb

@@ -0,0 +1,77 @@
+require 'AWS/S3'
+
+module RetryAWS
+  class S3
+    def initialize(access_key, secret_key)
+      @s3 = AWS::S3.new(access_key, secret_key)
+      @@log = STDOUT
+      @retry_limit = 16
+     end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private 
+
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    def retry?(err, retry_time)
+      if err.response.code >= 500 && retry_time < @retry_limit
+        sleep retry_time
+	return retry_time * 2
+      end
+      nil
+    end
+
+    public
+
+    # Create an S3 object.
+    # Catch errors, but if one occurs, return false.
+    def create_object(bucket_name, object_key, opts={})
+      retry_time = 1
+      begin
+        @s3.create_object(bucket_name, object_key, opts)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def get_object(bucket_name, object_key, headers={})
+      retry_time = 1
+      begin
+        if block_given?
+          @s3.get_object(bucket_name, object_key, headers) do |segment|
+            yield(segment)
+	  end
+        else
+          @s3.get_object(bucket_name, object_key, headers)
+	end
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error nil
+      rescue
+        report_error nil
+      end
+    end
+
+    def set_canned_acl(canned_acl, bucket_name, object_key='')
+      retry_time = 1
+      begin
+        @s3.set_canned_acl(canned_acl, bucket_name, object_key)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+  end
+end

data/lib/RetryAWS/SQS.rb

@@ -0,0 +1,109 @@
+require 'AWS/SQS'
+
+module RetryAWS
+  # Wrap SQS routines that we use.
+  # Catch exceptions and return something reasonable.
+  class SQS
+    def initialize(*params)
+      @sqs = AWS::SQS.new(*params)
+      @@log = STDOUT
+      @retry_limit = 16
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private
+
+    # report error and return result
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    def retry?(err, retry_time)
+pp err
+      if err.response.code.to_i >= 500 && retry_time < @retry_limit
+        sleep retry_time
+	return retry_time * 2
+      end
+      nil
+    end
+
+    public
+
+    def list_queues(queue_name_prefix = nil)
+      retry_time = 1
+      begin
+        @sqs.list_queues(queue_name_prefix)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error []
+      rescue
+        report_error []
+      end
+    end
+
+    def create_queue(queue_name, visibility_timeout_secs = nil)
+      retry_time = 1
+      begin
+        @sqs.create_queue(queue_name, visibility_timeout_secs)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error nil
+      rescue
+        report_error nil
+      end
+    end
+
+    def receive_messages(queue_url, maximum=1, visibility_timeout=nil)
+      retry_time = 1
+      begin
+        @sqs.receive_messages(queue_url, maximum, visibility_timeout)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error []
+      rescue
+        report_error []
+      end
+    end
+
+    def send_message(queue_url, message_body, encode=false)
+      retry_time = 1
+      begin
+        @sqs.send_message(queue_url, message_body, encode)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error ''
+      rescue
+        report_error ''
+      end
+    end
+
+    def delete_message(queue_url, receipt_handle)
+      retry_time = 1
+      begin
+        @sqs.delete_message(queue_url, receipt_handle)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def get_queue_attributes(queue_url, attribute='All')
+      retry_time = 1
+      begin
+        @sqs.get_queue_attributes(queue_url, attribute)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error({})
+      rescue
+        report_error({})
+      end
+    end
+  end
+end

data/lib/RetryAWS/SimpleDB.rb

@@ -0,0 +1,118 @@
+require 'AWS/SimpleDB'
+
+# RetryAWS wraps the AWS module in code that retries it if it fails.
+#
+module RetryAWS
+  class SimpleDB
+    def initialize(access_key, secret_key)
+      @simple_db = AWS::SimpleDB.new(access_key, secret_key)
+      @@log = STDOUT
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private
+
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    def retry?(err, retry_time)
+      if err.response.code >= 500 && retry_time < @retry_limit
+        sleep retry_time
+	return retry_time * 2
+      end
+      nil
+    end
+
+    public
+
+    def list_domains(max_domains = 100)
+      retry_time = 1
+      begin
+        @simple_db.list_domains(max_domains)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error []
+      rescue
+        report_error []
+      end
+    end
+    
+    def create_domain(domain_name)
+      retry_time = 1
+      begin
+        @simple_db.create_domain(domain_name)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def delete_domain(domain_name)
+      retry_time = 1
+      begin
+        @simple_db.delete_domain(domain_name)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def put_attributes(domain_name, item_name, attributes, replace=false)
+      retry_time = 1
+      begin
+        @simple_db.put_attributes(domain_name, item_name, attributes, replace)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def delete_attributes(domain_name, item_name, attributes = {})
+      retry_time = 1
+      begin
+        @simple_db.delete_attributes(domain_name, item_name, attributes)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error false
+      rescue
+        report_error false
+      end
+    end
+
+    def get_attributes(domain_name, item_name, attribute_name = nil)
+      retry_time = 1
+      begin
+        @simple_db.get_attributes(domain_name, item_name, attribute_name)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error {}
+      rescue
+        report_error {}
+      end
+    end
+
+     def query(domain_name, query_expression=nil, options={:fetch_all=>true})
+      retry_time = 1
+      begin
+        @simple_db.query(domain_name, query_expression, options)
+      rescue AWS::ServiceError => err
+        retry if retry_time = retry?(err, retry_time)
+        report_error {}
+      rescue
+        report_error {}
+      end
+    end
+  end
+end

data/lib/SafeAWS/EC2.rb

@@ -0,0 +1,63 @@
+require 'AWS/EC2'
+
+# SafeAWS wraps the AWS module in exception catcher blocks, so that any
+# exceptions that are thrown do not affect the caller.
+#
+# The SafeEC2, SafeSQS, SafeSimpleDB and SafeS3 log any errors that they encounter, so
+# that they can be examined later.
+module SafeAWS
+  # Wrap EC2 functions that we use.
+  # Catch errors and do something reasonable.
+  class EC2
+    def initialize(access_key, secret_key)
+      @ec2 = AWS::EC2.new(access_key, secret_key)
+      @@log = STDOUT
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private
+
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    public
+
+    def describe_images(options={})
+      begin
+        @ec2.describe_images(options)
+      rescue
+        report_error []
+      end
+    end
+    
+    def describe_instances(instance_ids=[])
+      begin
+        @ec2.describe_instances(instance_ids)
+      rescue
+        report_error []
+      end
+    end
+
+    def run_instances(image_id, min_count=1, max_count=min_count, options={})
+      begin
+        @ec2.run_instances(image_id, min_count, max_count, options)
+      rescue
+        report_error []
+      end
+    end
+
+    def terminate_instances(instance_ids = [])
+      begin
+        @ec2.terminate_instances(instance_ids)
+      rescue
+        report_error []
+      end
+    end
+  end
+end

data/lib/SafeAWS/S3.rb

@@ -0,0 +1,56 @@
+require 'AWS/S3'
+
+module SafeAWS
+  class S3
+    def initialize(access_key, secret_key)
+      @s3 = AWS::S3.new(access_key, secret_key)
+      @@log = STDOUT
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private 
+
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    public
+
+    # Create an S3 object.
+    # Catch errors, but if one occurs, return false.
+    def create_object(bucket_name, object_key, opts={})
+      begin
+        @s3.create_object(bucket_name, object_key, opts)
+      rescue
+        report_error false
+      end
+    end
+
+    def get_object(bucket_name, object_key, headers={})
+      begin
+        if block_given?
+          @s3.get_object(bucket_name, object_key, headers) do |segment|
+            yield(segment)
+	  end
+        else
+          @s3.get_object(bucket_name, object_key, headers)
+	end
+      rescue
+        report_error nil
+      end
+    end
+
+    def set_canned_acl(canned_acl, bucket_name, object_key='')
+      begin
+        @s3.set_canned_acl(canned_acl, bucket_name, object_key)
+      rescue
+        report_error false
+      end
+    end
+  end
+end

data/lib/SafeAWS/SQS.rb

@@ -0,0 +1,75 @@
+require 'AWS/SQS'
+
+module SafeAWS
+  # Wrap SQS routines that we use.
+  # Catch exceptions and return something reasonable.
+  class SQS
+    def initialize(*params)
+      @sqs = AWS::SQS.new(*params)
+      @@log = STDOUT
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private 
+
+    # report error and return result
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    public
+
+    def create_queue(queue_name, visibility_timeout_secs = nil)
+      begin
+        @sqs.create_queue(queue_name, visibility_tmeout_secs)
+      rescue
+        report_error nil
+      end
+    end
+
+    def list_queues(queue_name_prefix = nil)
+      begin
+        @sqs.list_queues(queue_name_prefix)
+      rescue
+        report_error []
+      end
+    end
+
+    def receive_messages(queue_url, maximum=1, visibility_timeout=nil)
+      begin
+        @sqs.receive_messages(queue_url, maximum, visibility_timeout)
+      rescue
+        report_error []
+      end
+    end
+
+    def send_message(queue_url, message_body, encode=false)
+      begin
+        @sqs.send_message(queue_url, message_body, encode)
+      rescue
+        report_error ''
+      end
+    end
+
+    def delete_message(queue_url, receipt_handle)
+      begin
+        @sqs.delete_message(queue_url, receipt_handle)
+      rescue
+        report_error false
+      end
+    end
+
+    def get_queue_attributes(queue_url, attribute='All')
+      begin
+        @sqs.get_queue_attributes(queue_url, attribute)
+      rescue
+        report_error {}
+      end
+    end
+  end
+end

data/lib/SafeAWS/SimpleDB.rb

@@ -0,0 +1,88 @@
+require 'AWS/SimpleDB'
+
+# SafeAWS wraps the AWS module in exception catcher blocks, so that any
+# exceptions that are thrown do not affect the caller.
+#
+# The SafeEC2, SafeSQS, SafeSimpleDB, and SafeS3 log any errors that they encounter, so
+# that they can be examined later.
+module SafeAWS
+  # Wrap SimpleDB functions that we use.
+  # Catch errors and do something reasonable.
+  class SimpleDB
+    def initialize(access_key, secret_key)
+      @simple_db = AWS::SimpleDB.new(access_key, secret_key)
+      @@log = STDOUT
+    end
+
+    def logger=(logger)
+      @@log = logger
+    end
+
+    private
+
+    def report_error(res)
+      @@log.puts "error #{$!}"
+      $@.each {|line| @@log.puts "  #{line}"}
+      res
+    end
+
+    public
+
+    def list_domains(max_domains = 100)
+      begin
+        @simple_db.list_domains(max_domains)
+      rescue
+        report_error []
+      end
+    end
+    
+    def create_domain(domain_name)
+      begin
+        @simple_db.create_domain(domain_name)
+      rescue
+        report_error false
+      end
+    end
+
+    def delete_domain(domain_name)
+      begin
+        @simple_db.delete_domain(domain_name)
+      rescue
+        report_error false
+      end
+    end
+
+    def put_attributes(domain_name, item_name, attributes, replace=false)
+      begin
+        @simple_db.put_attributes(domain_name, item_name, attributes, replace)
+      rescue
+        report_error false
+      end
+    end
+
+    def delete_attributes(domain_name, item_name, attributes = {})
+      begin
+        @simple_db.delete_attributes(domain_name, item_name, attributes)
+      rescue
+        report_error false
+      end
+    end
+
+    def get_attributes(domain_name, item_name, attribute_name = nil)
+      begin
+        @simple_db.get_attributes(domain_name, item_name, attribute_name)
+      rescue
+        report_error {}
+      end
+    end
+
+     def query(domain_name, query_expression=nil, options={:fetch_all=>true})
+      begin
+        @simple_db.query(domain_name, query_expression, options)
+      rescue
+        report_error {}
+      end
+    end
+
+  end
+end