fum 0.1.0

data/lib/fum/command_manager.rb

@@ -0,0 +1,44 @@
+module Fum
+  module CommandManager
+
+    module ClassMethods
+
+      @@commands_map = Hash.new
+
+      def command(name, opts={})
+        require "fum/commands/#{name}"
+        class_name = name.to_s.capitalize
+        @@commands_map[name] = Fum::Commands::const_get(class_name)
+      end
+
+      def create_commands(*args)
+        map = {}
+        @@commands_map.each { |key, value|
+          map[key] = value.new(*args)
+        }
+        map
+      end
+    end
+
+    def self.included(includer)
+      includer.extend ClassMethods
+    end
+
+    def initialize
+      @commands = self.class.create_commands(self)
+    end
+
+    def commands
+      @commands
+    end
+
+    def parse_command_options(name)
+      @commands[name].parse_options
+    end
+
+    def run_command(name, options = {})
+      @commands[name].execute(options)
+    end
+
+  end
+end

data/lib/fum/commands/events.rb

@@ -0,0 +1,58 @@
+module Fum
+  module Commands
+    class Events < Fum::Command
+
+      def parse_options
+        Trollop::options do
+          banner "usage: events [options], where options are:"
+          opt :number, "Number of events to show", :type => :integer, :default => 100
+          opt :application, "Show events only for the specified application", :type => :string
+          opt :environment, "Show events associated with the specified environment name or id", :type => :string
+          opt :severity, "Limit events to severity or higher", :type => :string
+          opt :version_label, "Version label", :type => :string, :long => "version"
+        end
+      end
+
+      def execute(options)
+        beanstalk = Fog::AWS[:beanstalk]
+
+        filters = {
+            'MaxRecords' => options[:number],
+            'ApplicationName' => options[:application],
+            'VersionLabel' => options[:version_label]
+        }
+        filters['Severity'] = options[:severity].upcase unless options[:severity].nil?
+
+        if options[:environment] && options[:environment].match(/e-[a-zA-Z0-9]{10}/)
+          filters['EnvironmentId'] = options[:environment]
+        else
+          filters['EnvironmentName'] = options[:environment]
+        end
+
+        filters = filters.delete_if { |key, value| value.nil? }
+
+        events = beanstalk.events.all(filters).reverse
+
+        # Beanstalk seems to return an extra item
+        events.shift
+
+        events.each { |event|
+          app = event.application_name
+          if event.environment_name
+            app += "(#{event.environment_name})"
+          elsif event.version_label
+            app += "(#{event.version_label})"
+          elsif event.template_name
+            app += "(#{event.template_name})"
+          end
+
+          puts "#{event.date.strftime('%b %d %H:%M:%S')} #{app} #{event.severity} \"#{event.message}\""
+        }
+
+      end
+
+    end
+
+
+  end
+end

data/lib/fum/commands/launch.rb

@@ -0,0 +1,110 @@
+module Fum
+  module Commands
+    class Launch < Fum::Command
+      include Fum::DNS
+
+      def parse_options
+        options = Trollop::options do
+          banner "usage launch [options] <environment-id>, where options are:"
+          opt :version_label, "Launch the specified version", :long => "version", :type => :string
+          opt :create, "Create application if it does not exist"
+          opt :no_dns, "Do not change any DNS records", :default => false
+          opt :no_wait, "Launch environment, but do not wait for ready", :default => false, :short => 'w'
+        end
+        if ARGV.empty?
+          die "Stage not specified.  Please specify a stage to launch"
+        end
+        options[:stage_name] = ARGV.shift
+        options
+      end
+
+      def execute(options)
+        app = @application.main_decl
+
+        stage_name = options[:stage_name]
+        stage_decl = stage(@application.main_decl, stage_name)
+
+        if options[:verbose]
+          puts "Verifying application '#{app.name}' exists in AWS."
+        end
+
+        beanstalk = Fog::AWS[:beanstalk]
+
+        beanstalk_app = beanstalk.applications.get(app.name)
+
+        if beanstalk_app.nil?
+          if options[:create]
+            beanstalk_app = beanstalk.applications.create(:name => app.name)
+            beanstalk.versions.create({
+                :application_name => app.name,
+                :label => 'Sample'
+                                      })
+          else
+            die "Could not find app '#{app.name}' in AWS account."
+          end
+
+        end
+
+        env_opt = {
+            :application_name => app.name,
+            :name => stage_decl.environment_name
+        }
+        env_opt[:template_name] = stage_decl.template_name unless stage_decl.template_name.nil?
+        env_opt[:solution_stack_name] = stage_decl.solution_stack_name unless stage_decl.solution_stack_name.nil?
+        env_opt[:description] = stage_decl.env_description unless stage_decl.env_description.nil?
+
+        set_version(stage_decl, env_opt, options)
+
+        if options[:verbose] || options[:noop]
+          puts "Launching an environment named '#{stage_decl.environment_name}'"
+        end
+
+        begin
+          new_env = beanstalk.environments.create(env_opt) unless options[:noop]
+        rescue Exception => e
+          die "Problem creating environment: #{e.to_s}"
+        end
+
+        puts "Launched environment '#{stage_decl.environment_name}'."
+
+        puts "Waiting for environment to become ready..."
+
+        new_env.wait_for { ready? } unless options[:noop]
+
+        puts "New environment is ready."
+
+        puts "Waiting for environment to become healthy..."
+
+        new_env.wait_for { healthy? } unless options[:noop]
+
+        puts "New environment is healthy."
+
+        update_zones(stage_decl, new_env, options) unless options[:no_dns]
+
+      end
+
+      def set_version(stage_decl, env_opt, options)
+        version_label = stage_decl.version_label
+        return nil if version_label.nil?
+
+        if version_label.is_a?(String)
+          env_opt[:version_label] = version_label
+          puts "Using verison label #{version_label}"
+        elsif version_label.is_a?(Hash) && version_label.has_key?(:from_stage)
+          from_stage = version_label[:from_stage]
+          from_stage_decl = stage(@application.main_decl, from_stage)
+          analyzer = StageAnalyzer.new(from_stage_decl)
+          analyzer.analyze(options)
+          active = analyzer.active
+          die "Cannot determine version to launch. No active environment for stage '#{from_stage}' specified." if active.nil?
+          env_opt[:version_label] = active.version_label
+          puts "Using version #{active.version_label} from stage #{from_stage}."
+        else
+          "Unknown version label #{version_label.inspect}"
+        end
+
+
+      end
+    end
+  end
+end

data/lib/fum/commands/list.rb

@@ -0,0 +1,83 @@
+module Fum
+  module Commands
+    class List < Fum::Command
+      include Fum::DNS
+
+      def parse_options
+        opts = Trollop::options do
+          banner "usage: list [options] <environment-id>, where options are:"
+        end
+        if ARGV.empty?
+          die "Please specify a beanstalk type to list!"
+        end
+
+        object = ARGV.shift
+
+        opts[:type] = case object
+                        when "stacks"
+                          :stacks
+                        when "app", "apps", "applications"
+                          :applications
+                        when "env", "envs", "environments"
+                          :environments
+                        when "stages"
+                          :stages
+                        when "templates"
+                          :templates
+                        when "versions"
+                          :versions
+                        else
+                          die "Unknown object to list #{object}."
+                      end
+
+        opts
+      end
+
+      #
+      #
+      # * :type
+      def execute(options)
+        beanstalk = Fog::AWS[:beanstalk]
+
+        case options[:type]
+          when :stacks
+            beanstalk.solution_stacks.each { |stack|
+              puts stack["SolutionStackName"]
+            }
+          when :applications
+            beanstalk.applications.each { |app|
+              puts app.name
+            }
+          when :environments
+            list_environments(options)
+          when :stages
+            @application.main_decl.stages.each_value { |stage|
+              puts stage.id
+            }
+          when :templates
+            beanstalk.templates.each { |template|
+              puts template.name
+            }
+          when :versions
+            beanstalk.versions.each { |version|
+              puts version.label
+            }
+          else
+            die "Unknown object to list #{object}."
+        end
+
+      end
+
+      def list_environments(options)
+        beanstalk = Fog::AWS[:beanstalk]
+        environments = beanstalk.environments
+
+        environments.each { |env|
+          puts env.name
+        }
+
+      end
+
+    end
+  end
+end

data/lib/fum/commands/repair.rb

@@ -0,0 +1,45 @@
+module Fum
+  module Commands
+    class Repair < Fum::Command
+      include Fum::DNS
+
+      def parse_options
+        opts = Trollop::options do
+          banner "usage: repair [options] <stage-id>, where options are:"
+          opt :environment, "Environment name to repair", :type => :string
+        end
+        if ARGV.empty?
+          die "Please specify a stage name type to repair."
+        end
+        opts[:stage_name] = ARGV.shift
+
+        opts
+      end
+
+      #
+      #
+      # * :type
+      def execute(options)
+        stage_name = options[:stage_name]
+        stage_decl = stage(@application.main_decl, stage_name)
+
+        analyzer = StageAnalyzer.new(stage_decl)
+
+        analyzer.analyze(options)
+
+        degraded = analyzer.env_map.each_value.select { |env| env[:state] == :degraded }
+
+        if degraded.length == 1
+          degraded = degraded.shift
+          puts "Repairing environment #{degraded[:env].name}."
+          update_zones(stage_decl, degraded[:env], options)
+          puts "Repair complete."
+        else
+          puts "Nothing to repair."
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fum/commands/status.rb

@@ -0,0 +1,45 @@
+module Fum
+  module Commands
+    class Status < Fum::Command
+      include Fum::DNS
+
+      def parse_options
+        opts = Trollop::options do
+          banner "usage: status [options] <stage-name>, where options are:"
+        end
+        if ARGV.empty?
+          die "Please specify a stage name."
+        end
+
+        opts[:stage_name] = ARGV.shift
+
+        opts
+      end
+
+      #
+      #
+      # * :type
+      def execute(options)
+
+        stage_name = options[:stage_name]
+        stage_decl = stage(@application.main_decl, stage_name)
+
+        analyzer = StageAnalyzer.new(stage_decl)
+        analyzer.analyze(options)
+
+        envs = analyzer.env_map.values
+
+        unless envs.empty?
+          envs.each { |env|
+            puts "#{env[:env].name} (#{env[:state]})"
+          }
+        else
+          puts "No environments found for stage #{stage_name}."
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/fum/commands/tail.rb

@@ -0,0 +1,89 @@
+module Fum
+  module Commands
+    class Tail < Fum::Command
+
+      def parse_options
+        Trollop::options do
+          banner "usage: tail [options], where options are:"
+          opt :application, "Show events only for the specified application", :type => :string
+          opt :environment, "Show events associated with the specified environment name or id", :type => :string
+          opt :directory, "Output log files to the directory specified.", :type => :string
+        end
+      end
+
+      def execute(options)
+        beanstalk = Fog::AWS[:beanstalk]
+
+        die "Directory #{options[:directory]} does not exist" if options[:directory] && !File.directory?(options[:directory])
+
+        if options[:environment].nil?
+          # Use the currently active environment
+
+        end
+        request_opts = {
+            'ApplicationName' => options[:application],
+            'EnvironmentName' => options[:environment],
+            'InfoType' => 'tail'
+        }
+
+        if options[:environment] && options[:environment].match(/e-[a-zA-Z0-9]{10}/)
+          request_opts['EnvironmentId'] = options[:environment]
+        else
+          request_opts['EnvironmentName'] = options[:environment]
+        end
+
+        puts "Requesting logs for environment #{options[:environment]}" if options[:verbose]
+        beanstalk.request_environment_info(request_opts)
+
+        begin
+          files = Timeout::timeout(360) do
+            # Sleep a few seconds
+            sleep(5)
+            begin
+              puts "Retrieving logs for environment #{options[:environment]}" if options[:verbose]
+              info = beanstalk.retrieve_environment_info(request_opts).body["RetrieveEnvironmentInfoResult"]["EnvironmentInfo"]
+              puts "Logs not yet available, will try again in 10 seconds." if options[:verbose] && info.length == 0
+            end while info.length == 0 && sleep(10)
+
+            info = info.sort_by { |i| i['SampleTimestamp'] }.reverse
+            instance_ids = []
+            info = info.select { |i|
+              seen = instance_ids.include?(i['Ec2InstanceId'])
+              instance_ids << i['Ec2InstanceId']
+              !seen
+            }
+          end
+        rescue Timeout::Error
+          die "Operation timed out, could not retrieve environment info."
+        end
+
+
+        require 'excon'
+        files.each { |file|
+          contents = Excon.get(file['Message']).body
+          if options[:directory]
+            filename = "#{file['Ec2InstanceId']}-#{file['SampleTimestamp'].strftime('%Y%m%dT%H%M')}.txt"
+            file = File.join(File.expand_path(options[:directory]),filename)
+            if File.exists?(file)
+              puts "File already exists #{file}, will not overwrite."
+              next
+            end
+            File.open(file, 'w') { |f|f.write(contents) }
+            puts "Created file #{file}"
+          else
+            puts "##########################################"
+            puts "# InstanceID #{file['Ec2InstanceId']}"
+            puts "# Timestamp #{file['SampleTimestamp']}"
+            puts "##########################################"
+            puts contents
+          end
+
+        }
+
+      end
+
+    end
+
+
+  end
+end