opener-daemons 1.3.0 → 2.0

data/lib/opener/daemons/opt_parser.rb

@@ -1,177 +0,0 @@
-require 'optparse'
-
-module Opener
-  module Daemons
-    class OptParser
-      attr_accessor :option_parser, :options
-
-      def initialize(&block)
-        @options = {}
-        @option_parser = construct_option_parser(options, &block)
-      end
-
-      def parse(args)
-        process(:parse, args)
-      end
-
-      def parse!(args)
-        process(:parse!, args)
-      end
-
-      def pre_parse!(args)
-        delete_double_dash = false
-        process(:parse!, args, delete_double_dash)
-      end
-
-      def pre_parse(args)
-        delete_double_dash = false
-        process(:parse, args, delete_double_dash)
-      end
-
-      def self.parse(args)
-        new.parse(args)
-      end
-
-      def self.parse!(args)
-        new.parse!(args)
-      end
-
-      def self.pre_parse!(args)
-        new.pre_parse!(args)
-      end
-
-      def self.pre_parse(args)
-        new.pre_parse(args)
-      end
-
-      private
-
-      def process(call, args, delete_double_dash=true)
-        args.delete("--") if delete_double_dash
-        option_parser.send(call, args)
-        return options
-      end
-
-      def construct_option_parser(options, &block)
-        script_name = File.basename($0, ".rb")
-        unless script_name.include?("-daemon")
-          script_name = "#{script_name}-daemon"
-        end
-
-        OptionParser.new do |opts|
-          if block_given?
-            opts.banner = "Usage: #{script_name} <start|stop|restart> [daemon_options] -- [component_options]"
-          else
-            opts.banner = "Usage: #{script_name} <start|stop|restart> [options]"
-          end
-
-          opts.separator ""
-          opts.separator "When calling #{script_name} without <start|stop|restart> the daemon will start as a foreground process"
-          opts.separator ""
-
-          opts.separator "Environment Variables:"
-          opts.separator ""
-
-          opts.separator "These daemons make use of Amazon SQS queues and other Amazon services."
-          opts.separator "The access to these services and other environment variables can be configured"
-          opts.separator "using a .opener-daemons-env file in the home directory of the current user."
-          opts.separator ""
-          opts.separator "It is also possible to provide the environment variables directly to the deamon."
-          opts.separator ""
-          opts.separator "For example:"
-          opts.separator "AWS_REGION='eu-west-1' #{script_name} start [other options]"
-          opts.separator ""
-          opts.separator "We advise to have the following environment variables available: "
-          opts.separator "* AWS_ACCESS_KEY_ID"
-          opts.separator "* AWS_SECRET_ACCESS_KEY"
-          opts.separator "* AWS_REGION"
-          opts.separator ""
-
-          if block_given?
-            opts.separator "Component Specific options:"
-            opts.separator ""
-            yield opts, options
-            opts.separator ""
-          end
-
-          opts.separator "Daemon options:"
-
-          opts.on("-i", "--input QUEUE_NAME", "Input queue name") do |v|
-            options[:input_queue] = v
-          end
-
-          opts.on("-o", "--output QUEUE_NAME", "Output queue name") do |v|
-            options[:output_queue] = v
-          end
-
-          opts.on("--batch-size COUNT", Integer, "Request x messages at once where x is between 1 and 10") do |v|
-            options[:batch_size] = v
-          end
-
-          opts.on("--buffer-size COUNT", Integer, "Size of input and output buffer. Defaults to 4 * batch-size") do |v|
-            options[:buffer_size] = v
-          end
-
-          opts.on("--sleep-interval SECONDS", Integer, "The interval to sleep when the queue is empty (seconds)") do |v|
-            options[:sleep_interval] = v
-          end
-
-          opts.on("-r", "--readers COUNT", Integer, "number of reader threads") do |v|
-            options[:readers] = v
-          end
-
-          opts.on("-w", "--workers COUNT", Integer, "number of worker thread") do |v|
-            options[:workers] = v
-          end
-
-          opts.on("-p", "--writers COUNT", Integer, "number of writer / pusher threads") do |v|
-            options[:writers] = v
-          end
-
-          opts.on("-l", "--logfile FILENAME", "--log FILENAME", "Filename and path of logfile. Defaults to STDOUT") do |v|
-            options[:log] = v
-          end
-
-          opts.on("-P", "--pidfile FILENAME", "--pid FILENAME", "Filename and path of pidfile. Defaults to /var/run/#{script_name}.pid") do |v|
-            options[:pid] = v
-          end
-
-          opts.on("--pidpath DIRNAME", "Directory where to put the PID file. Is Overwritten by --pid if that option is present") do |v|
-            options[:pidpath] = v
-          end
-
-          opts.on("--debug", "Turn on debug log level") do |v|
-            options[:debug] = true
-          end
-
-          opts.on("--relentless", "Be relentless, fail fast, fail hard, do not continue processing when encountering component errors") do |v|
-            options[:relentless] = true
-          end
-          
-          opts.on("--bucket-name BUCKET_NAME", "The name of the bucket where the output should be stored.") do |v|
-            options[:bucket_name] = v
-          end
-          
-          opts.on("--bucket-dir BUCKET_DIR", "The directory that the output should be stored in. Requires --bucket-name option.") do |v|
-            options[:bucket_dir] = v
-          end
-          
-          opts.on("--file-suffix FILE_SUFFIX", "The suffix of the filename. Requires --bucket-name option.") do |v|
-            options[:bucket_name] = v
-          end
-
-          opts.separator ""
-
-          opts.separator "Common options:"
-
-          # No argument, shows at tail.  This will print an options summary.
-          # Try it and see!
-          opts.on_tail("-h", "--help", "Show this message. Usage: #{script_name} -h") do
-            puts opts
-            exit
-          end
-        end
-      end
-    end
-  end
-end

data/lib/opener/daemons/s3.rb

@@ -1,34 +0,0 @@
-require 'aws-sdk'
-
-module Opener
-  module Daemons
-    class S3
-      attr_reader :s3_client, :bucket_name, :content, :filename, :directory, :url
-
-      def initialize(bucket_name, content, filename, directory = nil, filename_suffix = nil)
-        @s3_client   = AWS::S3.new
-        @bucket_name = bucket_name
-        @filename    = [filename, filename_suffix].compact.reject{|e| e.empty?}.join("-")
-        @content     = content
-        @directory   = directory
-      end
-      
-      def upload
-        @filename = File.join(directory, filename) if directory
-        bucket = s3_client.buckets[bucket_name]
-        object = bucket.objects["#{filename}.kaf"]
-
-        object.write(content)
-        
-        @url = object.url_for(
-          :read,
-          :secure                       => false,
-          :force_path_style             => false,
-          :response_content_type        => "application/xml",
-          :response_content_disposition => "attachment",
-          :expires                      => 7 * 24 * 60 * 60 # 7 days
-        )
-      end
-    end
-  end
-end

data/lib/opener/daemons/sqs.rb

@@ -1,54 +0,0 @@
-require 'aws-sdk-core'
-
-module Opener
-  module Daemons
-    class SQS
-      attr_reader :sqs, :name, :url
-
-      def self.find(name)
-        new(name)
-      end
-
-      def initialize(name)
-        @sqs = Aws::SQS::Client.new
-        @name = name
-        begin
-          @url = sqs.get_queue_url(:queue_name=>name)[:queue_url]
-        rescue Aws::SQS::Errors::NonExistentQueue => e
-          sqs.create_queue(:queue_name=>name)
-          retry
-        end
-      end
-
-      def send_message(message)
-        sqs.send_message(:queue_url=>url, :message_body=>message)
-      end
-
-      def delete_message(handle)
-        sqs.delete_message(:queue_url=>url, :receipt_handle=>handle)
-      end
-
-      def receive_messages(limit)
-        result = sqs.receive_message(:queue_url=>url,
-                                     :max_number_of_messages=>limit)[:messages] rescue []
-                                            
-        result ? to_hash(result) : []                       
-                                     
-      end
-      
-      def to_hash(messages)
-        messages.map do |m| 
-          hash = m.to_hash
-          json_body = JSON.parse(hash.delete(:body))
-          hash[:body] = json_body["body"] ? json_body["body"] : json_body
-          hash
-        end
-      end
-      
-      def queue_url
-        url
-      end
-
-    end
-  end
-end