fum 0.1.0

data/lib/fum/lang/fum_file.rb

@@ -0,0 +1,30 @@
+
+module Fum
+  module Lang
+    class FumFile
+
+      require 'fum/lang/stage'
+
+      attr_accessor :name
+
+      def self.load(filename)
+        file = self.new
+        file.instance_eval(File.read(filename), filename)
+        file
+      end
+
+      def application_name(name)
+        @name = name
+      end
+
+      def stages
+        @stages ||= {}
+      end
+
+      def stage(*args, &block)
+        stage = Fum::Lang::Stage.new(*args, &block)
+        stages[stage.id] = stage
+      end
+    end
+  end
+end

data/lib/fum/lang/stage.rb

@@ -0,0 +1,86 @@
+module Fum
+  module Lang
+    class Stage
+
+      require 'fum/lang/zone'
+
+      attr_accessor :zones, :environment_name, :id, :swap_cnames, :template_name, :solution_stack_name, :version_label
+      attr_accessor :env_description
+
+      def initialize(id, &block)
+        @zones = []
+        @environment_name = id.to_s
+        @id = id.to_s
+        @swap_cnames = false
+
+        if block_given?
+          if block.arity == 1
+            yield self
+          else
+            instance_eval &block
+          end
+        end
+      end
+
+      def timestamp_name(prefix)
+        raise ArgumentError, "Prefix must be less than 15" unless prefix.length < 15 && prefix.length > 1
+        return "#{prefix}-#{Time.now.to_i.to_s(16)}"
+      end
+
+      def timestamp_name_matcher(prefix)
+        raise ArgumentError, "Prefix must be less than 15" unless prefix.length < 15 && prefix.length > 1
+        /#{prefix}-[a-z0-9]{8}/
+      end
+
+      def zone(*args, &block)
+        @zones << Zone.new(*args, &block)
+      end
+
+      def template(arg, &block)
+        @template_name = arg
+      end
+
+      def name(arg)
+        @environment_name = arg
+      end
+
+      def matcher(arg)
+        @matcher = arg
+      end
+
+      def version(arg)
+        @version_label = arg
+      end
+
+      def description(value)
+        @env_description = value
+      end
+
+      def solution_stack(name, &block)
+        @solution_stack_name = name
+      end
+
+      def cname_prefix(name, opts = {})
+        @cname_prefix = name
+        if opts[:swap]
+          @swap_cnames = true
+        end
+      end
+
+      # Returns true if environment matches the matcher for this stage
+      def matches?(env)
+        if @matcher
+          if @matcher.is_a?(Regexp)
+            return env.name =~ @matcher
+          else
+            return env.name == @matcher
+          end
+        else
+          return env.name == @environment_name
+        end
+        false
+      end
+
+    end
+  end
+end

data/lib/fum/lang/zone.rb

@@ -0,0 +1,33 @@
+module Fum
+  module Lang
+    class Zone
+
+      attr_accessor :name, :records
+
+      def initialize(name, &block)
+        @name = name
+        @records = []
+
+        if block_given?
+          if block.arity == 1
+            yield self
+          else
+            instance_eval &block
+          end
+        end
+      end
+
+      def elb_alias(name, opts = {})
+        @records << { :name => name, :type => 'A', :target => :elb, :options => opts}
+      end
+
+      def elb_cname(name, opts = {})
+        @records << { :name => name, :type => 'CNAME', :target =>:elb, :options => opts}
+      end
+
+      def cname(name, opts = {})
+        @records << { :name => name, :type => 'CNAME', :target =>:env, :options => opts}
+      end
+    end
+  end
+end

data/lib/fum/stage_analyzer.rb

@@ -0,0 +1,172 @@
+module Fum
+
+  #
+  # Analyzes environments and DNS zone info to determine which environments belong to a particular stage
+  # and the status of each environment.
+  #
+  class StageAnalyzer
+    include Fum::DNS
+    include Fum::Util
+
+    attr_accessor :env_map, :zones_map
+
+    def initialize(stage_decl)
+      @stage_decl = stage_decl
+      @zones_map = {}
+      @env_map = {}
+    end
+
+    def analyze(options)
+      beanstalk = Fog::AWS[:beanstalk]
+      build_zone_map(@stage_decl.zones, options)
+      analyze_zone_map(beanstalk.environments.select { |env| @stage_decl.matches?(env) }, options)
+      @env_map
+    end
+
+    # Return the Active environment or nil
+    def active
+      @env_map.values.select { |e| e[:state] == :active }.map { |e| e[:env] }.shift
+    end
+
+    # Return the inactive environments or empty array
+    def inactive
+      @env_map.values.select { |e| e[:state] == :inactive }.map { |e| e[:env] }
+    end
+
+    private
+
+    #
+    # Build Map
+    #
+    def build_zone_map(zone_decls, options)
+      zone_decls.each { |zone_decl|
+        puts "Looking up zone #{zone_decl.name}." if options[:verbose]
+        zone = dns.zones.all({:domain => zone_decl.name}).shift
+        die "Could not find zone #{zone_decl.name} in account." unless zone
+
+        puts "Obtaining all records for zone #{zone_decl.name}" if options[:verbose]
+        all_records = zone.records.all!
+
+        zone_decl.records.each { |record_decl|
+          fqdn = "#{record_decl[:name]}.#{zone_decl.name}."
+
+          existing = all_records.select { |r| r.name == fqdn && ['A', 'AAAA', 'CNAME'].include?(r.type)}
+
+          if existing.length > 1
+            # We do not currently handle this case, which would occur if AAAA records exist or weighted/latency records used.
+            die "Cannot update record #{fqdn} in zone #{zone} because more than one A, AAAA, or CNAME record already exists."
+          end
+
+          @zones_map[fqdn] = {
+              :zone_decl => zone_decl,
+              :record_decl => record_decl,
+              :record => existing.shift
+          }
+        }
+
+      }
+    end
+
+    def analyze_zone_map(environments, options)
+
+      puts "Analyzing environments." if options[:verbose]
+
+      environments.each { |e|
+        @env_map[e.id] = {
+            :env => e,
+            :elb => e.load_balancer,
+            :record_count => 0,
+            :dns_records => [],
+            :missing_dns_names => [],
+            :state => e.ready? ? :inactive : e.status.downcase.to_sym,
+            :environment => nil
+        }
+      }
+
+      @zones_map.each { |fqdn, entry|
+        next if entry[:record].nil?
+
+        if entry[:record].type != entry[:record_decl][:type]
+          entry[:error] = "incorrect record type #{entry[:record].type}"
+          entry[:environment] = nil
+          next
+        end
+
+        entry[:environment] = case entry[:record_decl][:type]
+                                when "A"
+                                  environment_for_alias(entry[:record])
+                                when "CNAME"
+                                  case entry[:record_decl][:target]
+                                    when :elb
+                                      environment_for_elb_cname(entry[:record])
+                                    when :env
+                                      environment_for_cname(entry[:record])
+                                  end
+                                else
+                                  nil
+                              end
+
+        if entry[:environment]
+          @env_map[entry[:environment].id][:record_count] += 1
+        end
+      }
+
+      zone_count = @zones_map.size
+
+      envs_with_records = @env_map.values.select { |e| e[:record_count] > 0 }
+
+      if envs_with_records.length == 1
+        record = envs_with_records.shift
+        if record[:record_count] == zone_count
+          record[:state] = :active
+        else
+          record[:state] = :degraded
+        end
+      else
+        # More than one record has DNS records, let's determine which ones
+        envs_with_records.each { |e|
+          e[:state] = :indeterminate
+        }
+      end
+
+    end
+
+    def environment_for_alias(record)
+      return nil unless record.alias_target
+      @env_map.each_value { |e|
+        next unless e[:env].ready? # Skip if environment not ready.
+        if e[:elb] && dns_names_equal(e[:elb].dns_name, record.alias_target['DNSName']) &&
+            e[:elb].hosted_zone_name_id == record.alias_target['HostedZoneId']
+          return e[:env]
+        end
+      }
+      nil
+    end
+
+    def environment_for_elb_cname(record)
+      dns_name = record.value.shift
+
+      @env_map.each_value { |e|
+        next unless e[:env].ready? # Skip if environment not ready.
+        if e[:elb] && dns_names_equal(e[:elb].dns_name, dns_name)
+          return e[:env]
+        end
+      }
+      nil
+    end
+
+    def environment_for_cname(record)
+      dns_name = record.value.shift
+
+      @env_map.each_value { |e|
+        next unless e[:env].ready? # Skip if environment not ready.
+        if dns_names_equal(e[:env].cname, dns_name)
+          return e[:env]
+        end
+      }
+      nil
+    end
+
+  end
+
+end

data/lib/fum/util.rb

@@ -0,0 +1,10 @@
+module Fum
+  module Util
+
+    def die(msg)
+      puts msg
+      exit 1
+    end
+
+  end
+end

data/lib/fum/version.rb

@@ -0,0 +1,3 @@
+module Fum
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: fum
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- George Scott
+- RumbleWare Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 3
+        - 1
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 83
+        segments: 
+        - 1
+        - 16
+        - 2
+        version: 1.16.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 6
+        - 5
+        version: 1.6.5
+  type: :runtime
+  version_requirements: *id003
+description: fum helps you manage your AWS Elastic Beanstalk environments
+email: 
+- foss@rumbleware.com
+executables: 
+- fum
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- bin/fum
+- examples/hello.fum
+- fum.gemspec
+- lib/fum.rb
+- lib/fum/application.rb
+- lib/fum/command.rb
+- lib/fum/command_manager.rb
+- lib/fum/commands/events.rb
+- lib/fum/commands/launch.rb
+- lib/fum/commands/list.rb
+- lib/fum/commands/repair.rb
+- lib/fum/commands/status.rb
+- lib/fum/commands/tail.rb
+- lib/fum/commands/template.rb
+- lib/fum/commands/terminate.rb
+- lib/fum/dns.rb
+- lib/fum/lang/fum_file.rb
+- lib/fum/lang/stage.rb
+- lib/fum/lang/zone.rb
+- lib/fum/stage_analyzer.rb
+- lib/fum/util.rb
+- lib/fum/version.rb
+homepage: http://github.com/rumbleware/fum
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fum
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Management tool for AWS Elastic Beanstalk
+test_files: []
+