fum 0.1.0

data/lib/fum/commands/template.rb

@@ -0,0 +1,301 @@
+require 'formatador'
+require 'formatador/table'
+require 'json'
+
+module Fum
+  module Commands
+    class Template < Fum::Command
+
+      def parse_options
+        options = Trollop::options do
+          banner "usage: template [options] <environment-id>, where options are:"
+          opt :options, "Describe Configuration Options"
+          opt :json, "Output in JSON format"
+          opt :application, "Application name (for creating templates only)", :type => :string
+          opt :description, "Description (update/create only)", :type => :string
+          #opt :prompt, "Prompt for options when updating or creating"
+          opt :stack, "Use the specified solution stack.", :type => :string
+          opt :create, "Create the specified template"
+          opt :update, "Update the specified template"
+          opt :delete, "Delete the specified template"
+          opt :list, "List all templates with some details"
+          opt :settings, "Print the current settings of the template"
+          opt :compare, "Compares two or more templates"
+          opt :from_template, "Base template to use when creating a new template", :type => :string
+          opt :from_json, "JSON File to use for create or update", :type => :string
+          opt :from_application, "Application to use for source template", :type => :string
+        end
+        if options[:options] || options[:settings] || options[:create] || options[:update] || options[:delete]
+          if ARGV.empty?
+            die "Please specify a template name for this operation"
+          else
+            options[:template_name] = ARGV.shift
+          end
+        elsif options[:compare]
+          die "Please specify two templates to compare" unless ARGV.length >= 2
+          options[:template_names] = ARGV.dup
+        end
+
+
+        options
+      end
+
+      #
+      #
+      # * :type
+      def execute(options)
+        app = @application.main_decl
+
+        # TODO make sure only one of these is is set, for now do least destructive order.
+        if options[:settings] || options[:update] || options[:options] || options[:delete]
+
+          template = Fog::AWS[:beanstalk].templates.get(app.name, options[:template_name])
+          die "No configuration template named #{options[:template_name]}" if template.nil?
+
+          if options[:settings]
+            display_settings(template.option_settings, options)
+          elsif options[:options]
+            display_options(template.options, options)
+          elsif options[:update]
+            update_template(template, options)
+          elsif options[:delete]
+            template.destroy
+            puts "Deleted template #{template.name}."
+          end
+        elsif options[:create]
+          create_template(options)
+        elsif options[:compare]
+          compare_settings(options)
+        elsif options[:list]
+          list_templates(options)
+        elsif options[:stack]
+          begin
+            config_opts = Fog::AWS[:beanstalk].describe_configuration_options('SolutionStackName' => options[:stack])
+            config_opts = config_opts.body['DescribeConfigurationOptionsResult']['Options']
+            display_options(config_opts, options)
+          rescue Fog::AWS::ElasticBeanstalk::InvalidParameterError => ex
+            die ex.message
+          end
+        end
+
+      end
+
+      def list_templates(options)
+        templates = Fog::AWS[:beanstalk].templates
+
+        templates = templates.sort_by { |a| [ a.application_name, a.name ] }
+
+        table = []
+        templates.each { |template|
+          table << {
+              'name' => template.name,
+              'application' => template.application_name,
+              'description' => template.description,
+              'created' => template.created_at,
+              'updated' => template.updated_at
+          }
+        }
+        Formatador.display_compact_table(table, %w(application name description created updated))
+      end
+
+      def display_settings(values, options)
+        values = values.sort_by { |a| [ a["Namespace"], a["OptionName"]]}
+        if options[:json]
+          # Prune nil values in JSON, or we can't update from JSON
+          values = values.select { |v| !v["Value"].nil? }
+          puts JSON.pretty_generate(values)
+        else
+          values.each { |value|
+            value['Namespace'] = "[bold]#{value['Namespace']}[/]"
+          }
+          Formatador.display_compact_table(values, %w(Namespace OptionName Value))
+        end
+      end
+
+      def compare_settings(options)
+        templates = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
+        table = []
+        all_names = {}
+        columns = %w(Namespace Name)
+
+        options[:template_names].each { |name|
+          template = Fog::AWS[:beanstalk].templates.get(@application.main_decl.name, name)
+          die "No configuration template named #{name}" if template.nil?
+          settings = template.option_settings #.sort_by { |a| [ a["Namespace"], a["OptionName"]]}
+                                              #templates[name] = settings
+
+          settings.each { |setting|
+            namespace = setting['Namespace']
+            option_name = setting['OptionName']
+
+            # Maintain a list of all unique namespace/name combinations
+            names = all_names[setting['Namespace']] || []
+            names << setting['OptionName'] unless names.include?(setting['OptionName'])
+            all_names[setting['Namespace']] = names
+
+            # Build Index for comparison later
+
+            templates[name][namespace][option_name] = setting['Value']
+          }
+
+          columns << name
+        }
+
+        all_names.each { |namespace, option_names|
+
+          option_names.each { |option_name|
+            line = {
+                'Namespace' => namespace,
+                'Name' => option_name
+            }
+
+            values = {}
+            prev_value = :init
+            values_differ = false
+
+            options[:template_names].each { |template_name|
+              value = templates[template_name][namespace][option_name]
+
+              if !values_differ && prev_value != :init
+                values_differ = value != prev_value
+                prev_value = value
+              end
+              prev_value = value if prev_value == :init
+
+              values[template_name] = value
+            }
+
+            if values_differ
+              values.each { |key, value|
+                values[key] = "[bold]#{value.to_s}[/]"
+              }
+            end
+
+            table << line.merge(values)
+          }
+        }
+
+        table.sort_by { |a| [ a["Namespace"], a["Name"]]}
+
+        Formatador.display_compact_table(table, columns)
+
+
+      end
+
+      def display_options(values, options)
+        values = values.sort_by { |a| [ a["Namespace"], a["Name"]]}
+
+        if options[:json]
+          puts JSON.pretty_generate(values)
+        else
+          values.each { |value|
+            constraints = ''
+            if value['MinValue'] && value['MaxValue']
+              constraints = "Range(#{value['MinValue']}-#{value['MaxValue']})"
+            elsif value['ValueOptions']
+              type = value['ValueType'] == 'List' ? 'List' : 'Scalar'
+              constraints = "#{type}(#{value['ValueOptions'].join(', ')})"
+            elsif value['Regex']
+              constraints = "Regex(#{value['Regex']['Label']} = #{value['Regex']['Pattern']})"
+            elsif value['ValueType'] == 'Boolean'
+              constraints = "Boolean(true, false)"
+            end
+
+            if value['MaxLength']
+              max_length_constraint = "MaxLength(#{value['MaxLength']})"
+              constraints += ', ' unless constraints.empty?
+              constraints += max_length_constraint
+            end
+            value['Constraints'] = constraints
+          }
+          Formatador.display_compact_table(values, %w(Namespace Name DefaultValue Constraints))
+        end
+
+      end
+
+      def create_template(options)
+
+        die "Must specify application name " if options[:application].nil?
+
+        create_opts = {
+            :name => options[:template_name],
+            :application_name => options[:application]
+        }
+
+        create_opts[:solution_stack_name] = options[:stack] if options[:stack]
+        create_opts[:description] = options[:description] unless options[:description].nil?
+        create_opts[:source_configuration] = {
+            'ApplicationName' => options[:from_application].nil? ? options[:application] : options[:from_application],
+            'TemplateName' => options[:from_template]
+        } if options[:from_template]
+
+        begin
+          template = Fog::AWS[:beanstalk].templates.create(create_opts)
+          puts "Created template #{template.name}"
+        rescue Fog::AWS::ElasticBeanstalk::InvalidParameterError => ex
+          die ex
+        end
+
+      end
+
+      def update_template(template, options)
+
+        settings = []
+        if options[:from_json]
+          settings = JSON.parse(File.read(options[:from_json]))
+          # TODO add some sanity checks, verify array of hashes, etc.
+        end
+        new_attributes = {
+            :option_settings => settings
+        }
+        new_attributes[:description] = options[:description] unless options[:description].nil?
+
+        begin
+          template.modify(new_attributes)
+          puts "Updated template #{template.name}"
+        rescue Fog::AWS::ElasticBeanstalk::InvalidParameterError => ex
+          die ex
+        end
+
+      end
+
+      private
+
+      # Work in progress on prompting for options
+      def prompt_options(template, options)
+        require 'highline/import'
+        opts = template.options.sort_by { |a| [ a["Namespace"], a["Name"]]}
+        option_settings = template.option_settings
+
+        opts.each { |option|
+
+          answer_type = nil
+          if option['MinValue'] && option['MaxValue']
+            answer_type = Integer
+          elsif option['ValueOptions']
+            #type = value['ValueType'] == 'List' ? 'List' : 'Scalar'
+            answer_type = option['ValueOptions']
+            answer_type << ""
+          elsif option['Regex']
+            #answer_type = "Regex(#{value['Regex']['Label']} = #{value['Regex']['Pattern']})"
+          elsif option['ValueType'] == 'Boolean'
+            answer_type = %w(true false)
+          end
+
+          value = ask("#{option['Namespace']}:#{option['Name']} ? ", answer_type) { |q|
+            setting = option_settings.select { |a| a['OptionName'] == option['Name'] && a['Namespace'] == option['Namespace']}.shift
+            q.default = setting['Value'] unless setting.nil?
+            q.readline = true
+            if option['ValueType'] == 'List'
+              q.gather = ''
+            end
+
+          }
+          #pp value
+        }
+      end
+
+
+    end
+  end
+end

data/lib/fum/commands/terminate.rb

@@ -0,0 +1,54 @@
+module Fum
+  module Commands
+    class Terminate < Fum::Command
+
+      def parse_options
+        opts = Trollop::options do
+          banner "usage: terminate [options] <stage>, where options are:"
+          opt :all, "Terminate all environments for this stage (use with caution)."
+        end
+        if ARGV.empty?
+          die "Please specify a stage name type to terminate."
+        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)
+
+        env_info = analyzer.env_map.values
+
+        targets = []
+
+        if options[:all]
+          targets = env_info.map { |e| e[:env] }
+        else
+          targets = env_info.select { |e| e[:state] == :inactive }.map { |e| e[:env] }
+        end
+
+        if targets.length > 0
+          targets.each { |target|
+            if target.ready?
+              puts "Terminating inactive environment #{target.name}."
+              target.destroy
+            end
+
+          }
+        else
+          puts "No environments to terminate."
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fum/dns.rb

@@ -0,0 +1,135 @@
+module Fum
+
+  # Mixin for common DNS methods
+  module DNS
+
+    require 'fog'
+
+    def dns
+      Fog::DNS[:AWS]
+    end
+
+    def update_zones(stage_decl, env, options)
+      zones = stage_decl.zones
+
+      hosted_zone_name_id = nil
+      dns_name = nil
+
+      unless options[:noop]
+        lb = env.load_balancer
+
+        hosted_zone_name_id = lb.hosted_zone_name_id
+        dns_name = lb.dns_name
+      end
+
+      zones.each { |zone| update_zone(zone, hosted_zone_name_id, dns_name, env.cname, options) }
+
+    end
+
+    def update_zone(zone_decl, hosted_zone_name_id, dns_name, env_cname, options)
+      dns = Fog::DNS[:aws]
+
+      zone = dns.zones.all({:domain => zone_decl.name}).shift
+      die "Could not find zone #{zone_decl.name} in account." unless zone
+
+      puts "Updating records in zone #{zone.domain}"
+      create_list = []
+      modify_list = []
+
+      zone_decl.records.each { |record|
+        fqdn = "#{record[:name]}.#{zone_decl.name}."
+
+        create_opts = {
+            :name => fqdn,
+            :type => record[:type]
+        }
+
+        case record[:type]
+          when 'CNAME'
+            create_opts[:value] = case record[:target]
+                                    when :elb
+                                      ensure_trailing_dot(dns_name)
+                                    when :env
+                                      ensure_trailing_dot(env_cname)
+                                  end
+          when 'A'
+            create_opts[:alias_target] = {
+                :hosted_zone_id => hosted_zone_name_id,
+                :dns_name => dns_name
+            }
+          else
+            raise RuntimeError, "Unknown type #{record[:type]}"
+        end
+
+        existing = find_records(zone, fqdn)
+
+        if existing.length > 1
+          # We do not currently handle this case, which would occur if AAAA records exist or weighted/latency records used.
+          puts "Cannot update record #{fqdn} in zone #{zone} because more than one A, AAAA, or CNAME record already exists."
+        end
+
+        if existing.length == 0
+          create_list << create_opts
+        else
+          modify_list << {
+              :record => existing.shift,
+              :create_opts => create_opts
+          }
+        end
+
+      }
+
+      # We do not currently do this atomically, but one record at a time.  Should probably move to atomic at some
+      # point.
+
+      new_records = []
+
+      create_list.each { |create_options|
+        puts "Creating #{create_options[:type]} record with name #{create_options[:name]} in zone #{zone.domain}"
+        unless options[:noop]
+          new_records << zone.records.create(create_options)
+        end
+      }
+
+      modify_list.each { |record|
+        puts "Updating #{record[:create_opts][:type]} record with name #{record[:create_opts][:name]} in zone #{zone.domain}"
+        unless options[:noop]
+          record[:record].modify(record[:create_opts])
+          new_records << record[:record]
+        end
+      }
+
+      puts "Waiting for DNS records to sync in zone #{zone.domain}..."
+      # Wait for records to be ready.
+      new_records.each { |record|
+        record.wait_for { record.ready? }
+      }
+      puts "Updated records are now in sync in zone #{zone.domain}"
+
+    end
+
+
+    def find_records(zone, name)
+      existing_records = zone.records.all({:name => name})
+
+      matching = []
+      types = ['A', 'AAAA', 'CNAME']
+      existing_records.each { |record|
+        matching << record if record.name == name && types.include?(record.type)
+      }
+      matching
+    end
+
+    # Appends a trailing . to the given name if it doesn't have one
+    def ensure_trailing_dot(name)
+      name = "#{name}." unless name.nil? || name.end_with?(".")
+      name
+    end
+
+    # Returns true if the specified dns names equal, ignoring any trailing "."
+    def dns_names_equal(a, b)
+      ensure_trailing_dot(a) == ensure_trailing_dot(b)
+    end
+
+  end
+end