fhcap-cli 0.4.5 → 0.4.6

data/lib/fhcap/cluster.rb

@@ -8,34 +8,70 @@ module Fhcap
       add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
       add_shared_option :name, :type => :string, :required => true, :desc => "Cluster name"
       add_shared_option :interactive, :aliases => "-i", :desc => "Interactive mode (Stops for input)", :type => :boolean, :required => false, :default => false
+      add_shared_option :'dry-run', :desc => "Dry Run only, nothing will be modified, but instead will display things that would be changed if this command was executed.", :type => :boolean, :required => false, :default => false
+      add_shared_option :'run-options', :type => :hash, :required => false, :desc => 'Run specific options, will be set as attributes on the node during the chef provisioning run!'
+
+      #Generate options
+      add_shared_option :template, :type => :string, :desc => "Cluster template i.e. [1, 3 , 5 node cluster setup, core or mbaas]", :enum => cluster_template_names
+      add_shared_option :domain, :type => :string, :desc => "host names to register with DNS / base host name"
+      add_shared_option :'ssl-cert', :type => :string, :desc => "ssl cert to use"
+      add_shared_option :'dns-provider-id', :type => :string, :desc => "DNS Provider Id"
+      add_shared_option :'repo', :type => :string, :desc => "Fhcap Repo where all config should be saved", :enum => repo_names
+      add_shared_option :'chef-server', :type => :string, :desc => "Chef Server to use", :enum => chef_server_names
+      add_shared_option :'provider-id', :type => :string, :desc => "Provider Id", :enum => provider_names_for('compute')
+      add_shared_option :'provider-config', :type => :hash, :desc => "Provider specific config"
+
+      desc "generate", "Generate/Update cluster configuration"
+      long_desc <<-LONGDESC
+      Generate/Update cluster configuration.
+
+      This task will generate/update all the configuration and chef files required to create a new cluster using the create task.
+      LONGDESC
+
+      shared_options :verbose, :name, :interactive, :'dry-run', :'run-options',
+                     :template, :domain, :'ssl-cert', :'dns-provider-id', :'repo', :'chef-server', :'provider-id', :'provider-config'
+
+      def generate
+        require "fhcap/tasks/cluster/generate"
+        Tasks::Cluster::Generate.new(task_options(options.dup)).run
+      end
 
       desc "create", "Create a new cluster"
 
-      shared_options :verbose, :name, :interactive
+      shared_options :verbose, :name, :interactive, :'dry-run',
+                     :template, :domain, :'ssl-cert', :'dns-provider-id', :'repo', :'chef-server', :'provider-id', :'provider-config'
 
-      method_option 'template', :type => :string, :desc => "Cluster template i.e. [1, 3 , 5 node cluster setup, core or mbaas]", :enum => cluster_template_names
-      method_option 'git-ref', :type => :string, :desc => "fhcap git ref, can be a branch, tag or commit hash"
-      method_option 'git-remote', :type => :string, :desc => "git remote to use, default is the remote for the configured repos url"
-      method_option 'domain', :type => :string, :desc => "host names to register with DNS / base host name"
-      method_option 'ssl-cert', :type => :string, :desc => "ssl cert to use"
-      method_option 'dns-provider-id', :type => :string, :desc => "DNS Provider Id"
-      method_option 'repo', :type => :string, :desc => "Fhcap Repo where all config should be saved", :enum => repo_names
-      method_option 'chef-server', :type => :string, :desc => "Chef Server to use", :enum => chef_server_names
-      method_option 'provider-id', :type => :string, :desc => "Provider Id", :enum => provider_names_for('compute')
-      method_option 'provider-config', :type => :hash, :desc => "Provider specific config"
+      method_option :generate, :type => :boolean, :default => true, :desc => "Run generate task before create"
+      method_option :'git-ref', :type => :string, :desc => "fhcap git ref, can be a branch, tag or commit hash"
+      method_option :'git-remote', :type => :string, :desc => "git remote to use, default is the remote for the configured repos url"
       create_steps = %w{repo-checkout cookbook-promote server-bootstrap create provision dns-record}
       create_steps.each do |step|
         method_option :"skip-#{step}", :type => :boolean, :default => false, :desc => "Skip #{step}"
       end
 
       def create
+        require "fhcap/tasks/cluster/generate"
         require "fhcap/tasks/cluster/create"
+        Tasks::Cluster::Generate.new(task_options(options.dup)).run if options[:generate]
         Tasks::Cluster::Create.new(task_options(options.dup)).run
       end
 
-      desc "provision", "Provision a cluster"
+      desc "create_dns_records", "Create/Update a clusters DNS records"
+      long_desc <<-LONGDESC
+      Create/Update a clusters DNS records.
+      LONGDESC
 
       shared_options :verbose, :name
+
+      def create_dns_records
+        require "fhcap/tasks/cluster/create_dns_records"
+        Tasks::Cluster::CreateDNSRecords.new(task_options(options.dup)).run
+      end
+
+      desc "provision", "Provision a cluster"
+
+      shared_options :verbose, :name, :'dry-run', :'run-options'
+
       method_option 'git-ref', :type => :string, :desc => "fhcap git ref, can be a branch, tag or commit hash"
       method_option 'git-remote', :type => :string, :desc => "git remote to use, default is the remote for the configured repos url"
       method_option 'nodes', :type => :string, :desc => "Query to pass to name"
@@ -74,7 +110,7 @@ module Fhcap
 
       desc "destroy", "Destroy a cluster"
 
-      shared_options :verbose
+      shared_options :verbose, :'dry-run'
 
       method_option 'name', :type => :string, :required => true, :desc => "Cluster name"
 
@@ -109,8 +145,24 @@ module Fhcap
       end
 
       desc "chef_provision", "[ADVANCED USAGE] Run a chef provisioning task against a particular cluster"
+      long_desc <<-LONGDESC
+      Allows the execution of any chef provisioning recipe on the given cluster.
+      Available recipes can be viewed here https://github.com/fheng/fhcap-cli/tree/master/lib/cookbooks/provision/recipes
 
-      shared_options :verbose
+      With --run-options option, allows advanced configuration to be applied during the chef provisioning run.
+      These key:value pairs are added as attributes to the provisioning node and can alter the behaviour of the run.
+
+      env-regexp: Filter environments e.g. --run-options env-regexp:farm - Only environments with farm in the name will be acted upon (qed1-farm)
+
+      node-regexp: Filter nodes e.g. --run-options node-regexp:app - Only nodes with app in the name will be acted upon (qed1-core-app1, qed1-core-app2)
+
+      Examples:
+
+      fhcap cluster chef_provision --name qed1 --run-list provision::cluster_provision_instances
+
+      fhcap cluster chef_provision --name qed1 --run-list provision::cluster_provision_instances --run-options env-regexp:farm node-regexp:linux
+      LONGDESC
+      shared_options :verbose, :'dry-run', :'run-options'
 
       method_option 'name', :type => :string, :required => true, :desc => 'Cluster name'
       method_option 'run-list', :type => :array, :required => true, :desc => 'Chef Provisioning Run List i.e provision::cluster_provision'

data/lib/fhcap/cookbook.rb

@@ -35,6 +35,7 @@ module Fhcap
 
       method_option 'level', :type => :string, :aliases => "-l", :desc => "Cookbook Bump level", :default => 'minor', :enum => %w{major minor patch}
       method_option 'version', :type => :string, :aliases => "-v", :desc => "Version to set manually"
+      method_option 'base-branch', :type => :string, :default => 'origin/master', :desc => "Base branch to check modified cookbooks against"
 
       def update
         require "fhcap/tasks/chef/cookbook/update_version"

data/lib/fhcap/kitchen.rb

@@ -13,14 +13,16 @@ module Fhcap
 
       add_shared_option :cookbooks, :aliases => "-c", :desc => "Apply to these Cookbooks", :type => :array
       add_shared_option :roles, :aliases => "-r", :desc => "Roles to generate kitchen for", :type => :array
-      add_shared_option :driver, :aliases => "-d", :desc => "Kitchen Driver", :type => :string, :default => 'openstack', :enum => %w{aws openstack docker}
+      add_shared_option :driver, :aliases => "-d", :desc => "Kitchen Driver", :type => :string, :default => 'openstack', :enum => %w{aws openstack docker vagrant}
       add_shared_option :modified, :aliases => "-m", :desc => "Apply only to modified Cookbooks", :type => :boolean, :required => false, :default => false
       add_shared_option :provisioner, :aliases => "-p", :desc => "Kitchen Provisioner", :type => :string, :default => 'chef_solo', :enum => %w{chef_solo chef_zero}
+      add_shared_option :'base-branch', :type => :string, :default => 'origin/master', :desc => "Base branch to check modified cookbooks against"
+      add_shared_option :'kitchen-options', :type => :hash, :default => {}, :desc => "Options to pass to kitchen command i.e. concurrency:10 = --concurrency=10 "
 
 
       desc "generate", "Generate"
 
-      shared_options :cookbooks, :roles, :modified, :driver, :provisioner
+      shared_options :cookbooks, :roles, :modified, :driver, :provisioner, :'base-branch', :'kitchen-options'
       method_option 'only', :type => :array, :default => nil, :desc => "Only include tests for cookbooks matching these names."
       method_option 'exclude', :type => :array, :default => nil, :desc => "Exclude tests for cookbooks matching these names, takes precedence over 'only' option."
       method_option 'clean', :type => :boolean, :default => true, :desc => "Clean the current generated kitchen prior to creating the new one"
@@ -128,16 +130,24 @@ module Fhcap
       %w{create converge setup verify test list login destroy diagnose}.each do |cmd|
 
         desc "#{cmd} [INSTANCE|REGEXP|all]", "Run '#{cmd}' command against current kitchen instances."
-        shared_options :cookbooks, :roles, :modified, :driver, :provisioner if %w{create converge setup verify test}.include? cmd
+        shared_options :cookbooks, :roles, :modified, :driver, :provisioner, :'base-branch', :'kitchen-options' if %w{create converge setup verify test list}.include? cmd
+        method_option :'log-level', :aliases => "-l", :desc => "Set the log level", :type => :string, :default => 'info', :enum => %w{debug info warn error fatal}
 
         define_method(cmd) do |instance='all'|
+          kitchen_options = options[:'kitchen-options'] || {}
           Fhcap::CLI::Kitchen.new.invoke(:generate, [], options) if options[:cookbooks] || options[:modified] || options[:roles]
           if is_kitchen_generated?
             Dir.chdir test_suite_dir do
               cmd_options = options.dup
               cmd_options['instance'] = instance
               cmd_options['kitchen-yaml'] = test_suite_kitchen_yml
-              cmd_options['kitchen-options'] = '--concurrency=10'
+              cmd_options['kitchen-options'] = kitchen_options_for(
+                  default_kitchen_options.merge(
+                      {:'log-level' => options[:'log-level']}
+                  ).merge(
+                      JSON.parse(kitchen_options.to_json, {:symbolize_names => true})
+                  )
+              )
               run_kitchen_cmd(cmd, cmd_options)
             end
           else
@@ -149,6 +159,19 @@ module Fhcap
 
       protected
 
+      def kitchen_options_for(opts)
+        opts.collect do |key,val|
+          "--#{key}=#{val}"
+        end.join(' ')
+      end
+
+      def default_kitchen_options
+        {
+            :concurrency => 10,
+            :'log-level' => 'info'
+        }
+      end
+
       def test_suite_dir
         File.join(config.default_dir, 'tmp', 'kitchen')
       end

data/lib/fhcap/provider.rb

@@ -8,7 +8,7 @@ module Fhcap
       add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
       add_shared_option :interactive, :aliases => "-i", :desc => "Interactive mode (Stops for input)", :type => :boolean, :required => false, :default => false
       add_shared_option :name, :type => :string, :required => true, :desc => "Provider Name"
-      add_shared_option :type, :type => :string, :required => true, :desc => "Provider Type", :enum => %w{aws openstack}
+      add_shared_option :type, :type => :string, :required => true, :desc => "Provider Type", :enum => %w{aws openstack dnsmadeeasy}
       add_shared_option :credentials, :type => :hash, :desc => "Provider specific credentials"
 
       desc "add", "Add a provider"

data/lib/fhcap/repos_helper.rb

@@ -134,7 +134,7 @@ module Fhcap
       modified = []
       cookbook_loader(paths).cookbook_names.each do |name|
         cookbook_dir = cookbook_loader.cookbooks_by_name[name].root_dir
-        modified << name if modified?(cookbook_dir)
+        modified << name if modified?(cookbook_dir, options[:'base-branch'] || 'origin/master')
       end
       modified
     end

data/lib/fhcap/tasks/chef/chef_task_base.rb

@@ -21,7 +21,9 @@ module Fhcap
           user = options[:knife_user] || 'hadmin'
           attr = options[:knife_attr] || 'cloud.public_ipv4'
           knife_options = options[:knife_options]
-          run_knife_cmd("ssh \"#{query}\" \"#{cmd}\" -x #{user} -a #{attr} #{knife_options}", server, false)
+          ssh_cmd = ["ssh \"#{query}\" \"#{cmd}\" -x #{user} -a #{attr} #{knife_options}"]
+          ssh_cmd << "--concurrency 1" if options[:series]
+          run_knife_cmd(ssh_cmd.join(' '), server, false)
         end
 
         def run_knife_cmd(cmd, server, capture=true)

data/lib/fhcap/tasks/chef/chef_zero_server.rb

@@ -1,4 +1,5 @@
 require 'chef_zero/server'
+require 'extensions/chef/solr/query/regexpable_query'
 
 module Fhcap
   module Tasks

data/lib/fhcap/tasks/chef/cookbook/update_version.rb

@@ -16,7 +16,6 @@ module Fhcap
           end
 
           def run
-            thor.say "Chef::Cookbook::UpdateVersion cookbook = #{name}", :yellow
             cookbook = cookbook_loader.cookbooks_by_name[name]
             metadata_file = cookbook.metadata_filenames.first
 
@@ -51,7 +50,7 @@ module Fhcap
             new_contents = File.read(metadata_file).gsub(/(version\s+['"])[0-9\.]+(['"])/, "\\1#{new_version}\\2")
             File.open(metadata_file, 'w') { |f| f.write(new_contents) }
 
-            thor.say "Successfully bumped #{cookbook.name} to v#{new_version}!"
+            thor.say "Updated #{cookbook.name} cookbook version to v#{new_version}!"
           end
 
           def bump_type

data/lib/fhcap/tasks/chef/provisioning/chef_provisioning_task_base.rb

@@ -1,6 +1,7 @@
 require 'fhcap/tasks/chef/chef_server_task'
 require 'fhcap/tasks/chef/cookbook/archive'
 require 'fhcap/chef-dk/chef_runner'
+require 'deep_merge'
 
 module Fhcap
   module Tasks
@@ -8,7 +9,7 @@ module Fhcap
       module Provisioning
         class ChefProvisioningTaskBase < ChefServerTask
 
-          attr_reader :name, :cluster_config, :cluster_filepath
+          attr_reader :name, :cluster_config, :cluster_filepath, :run_options
 
           def initialize(options)
             super
@@ -20,12 +21,13 @@ module Fhcap
                                          local_repo_path: repo_dir(@chef_repo),
                                          local_repo_clusters_dir: repo_clusters_dir(@chef_repo),
                                          chef_server_config: chef_server_config_hash_for(@chef_server),
-                                         provider_credentials:  provider_credentials(@cluster_config[:provider_id]),
+                                         provider_credentials: provider_credentials(@cluster_config[:provider_id]),
                                          max_simultaneous: options[:series] ? 1 : nil
                                      })
             else
               exit_with_error("Unknown cluster #{@name}")
             end
+            @run_options = options[:'run-options']
           end
 
           def seed_cookbooks
@@ -35,10 +37,23 @@ module Fhcap
             do_chef_run("provision::seed_cookbooks")
           end
 
-          def do_chef_run(run_list)
+          def default_run_options
+            {
+              max_simultaneous: options[:series] ? 1 : nil,
+              "env-regexp" => '.',
+              "node-regexp" => '.'
+            }
+          end
+
+          def get_run_options(opts)
+            default_run_options.deep_merge!(opts)
+          end
+
+          def do_chef_run(run_list, dry_run=options[:'dry-run'])
             cookbook_path = File.join(Fhcap.source_root, 'lib', 'cookbooks')
             private_key_paths = [File.join(cluster_config[:local_repo_path], cluster_config[:local_repo_clusters_dir], 'key_pairs')]
-            Fhcap::ChefRunner.new(cookbook_path, run_list, cluster_config, private_key_paths).converge
+            node_attrs = cluster_config.deep_merge(get_run_options(run_options))
+            Fhcap::ChefRunner.new(cookbook_path, run_list, dry_run, node_attrs, private_key_paths).converge
           end
 
         end

data/lib/fhcap/tasks/chef/provisioning/create.rb

@@ -14,8 +14,13 @@ module Fhcap
               knife_download(repo_dir(chef_repo), chef_server, ['/nodes']) if local_chef_server?
 
               unless options[:'skip-provision']
+                do_chef_run("provision::cluster_bootstrap")
                 seed_cookbooks if local_chef_server?
                 do_chef_run("provision::post_create_instances")
+
+                #Need to set run list correctly here after post create stuff since provision no longer does it
+                do_chef_run("provision::cluster_bootstrap")
+
                 do_chef_run("provision::cluster_provision")
               end
             end
@@ -25,6 +30,4 @@ module Fhcap
       end
     end
   end
-end
-
-
+end

data/lib/fhcap/tasks/cluster/cluster_task_base.rb

@@ -1,4 +1,5 @@
 require 'fhcap/tasks/task_base'
+require 'erubis'
 
 module Fhcap
   module Tasks

data/lib/fhcap/tasks/cluster/create.rb

@@ -5,7 +5,7 @@ require 'fhcap/tasks/chef/environments/promote_cookbooks'
 require 'fhcap/tasks/chef/environments/create'
 require 'fhcap/tasks/chef/server/bootstrap'
 require 'fhcap/tasks/repo/checkout'
-require "fhcap/tasks/dns/create_record"
+require "fhcap/tasks/cluster/create_dns_records"
 
 module Fhcap
   module Tasks
@@ -15,35 +15,14 @@ module Fhcap
         attr_reader :name, :cluster_config
 
         def initialize(options)
-          super(options, false)
-          @template = options[:template]
-          @repo = options[:'repo']
-          @provider_config = options[:'provider-config'] || {}
+          super(options)
           @gitref = options[:'git-ref']
-          @domain = options[:domain]
-          @ssl_cert = options[:'ssl-cert']
-          @dns_provider_id = options[:'dns-provider-id']
-          @chef_server = options[:'chef-server']
-          @provider_id = options[:'provider-id']
           @skip_repo_checkout = options[:'skip-repo-checkout']
           @skip_cookbook_promote = options[:'skip-cookbook-promote']
           @skip_server_bootstrap = options[:'skip-server-bootstrap']
           @skip_dns_record = options[:'skip-dns-record']
           @skip_create = options[:'skip-create']
           @skip_provision = options[:'skip-provision']
-
-          @cluster_config = {
-              id: @name,
-              template: @template,
-              driver: "",
-              domain: @domain,
-              repo: @repo,
-              chef_server: @chef_server,
-              provider_id: @provider_id
-          }.merge(@cluster_config)
-
-          @cluster_config[:provider_config] = @cluster_config[:provider_config] || {}
-          @cluster_config[:provider_config].merge!(@provider_config)
         end
 
         def run
@@ -52,16 +31,6 @@ module Fhcap
           #Checkout repos
           checkout_repos unless @skip_repo_checkout
 
-          #Generate cluster config
-          generate_cluster_config
-
-          #Create environment files
-          create_cluster_environments
-
-          #Write config to disk
-          cluster_file = find_cluster(name) || File.join(repo_dir(cluster_config[:repo]), repo_clusters_dir(cluster_config[:repo]), "#{name}.json")
-          thor.create_file(cluster_file, JSON.pretty_generate(cluster_config))
-
           #Chef Stuff
           #Promote cookbooks
           Chef::Environments::PromoteCookbooks.new(@options.dup.merge({:environments => cluster_environments})).run unless @skip_cookbook_promote
@@ -72,176 +41,10 @@ module Fhcap
           #Provisioning create
           Chef::Provisioning::Create.new(@options.dup.merge(chef_task_options)).run unless @skip_create
 
-          create_dns_record unless @skip_dns_record
-        end
-
-        private
-
-        def required_config
-          {
-              repo: {
-                  msg: "In which repo should this clusters config and environment files be stored?",
-                  options: {:limited_to => repo_names}
-              },
-              domain: {
-                msg: "Base domain/hostname (e.g. foo.skunkhenry.com) for this cluster?",
-              },
-              chef_server: {
-                  options: {:limited_to => chef_server_names}
-              },
-              provider_id: {
-                  options: {:limited_to => provider_names_for('compute')}
-              },
-              template: {
-                  options: {:limited_to => cluster_template_names}
-              }
-          }
-        end
-
-        def aws_required_config
-          aws_regions = provider_config(@cluster_config[:provider_id])[:regions]
-          {
-              region: {
-                  options: {:limited_to => aws_regions.keys.collect { |k| k.to_s }}
-              },
-              cidr: {
-                msg: "CIDR block for AWS VPC (e.g. 10.123.0.0/16)?",
-              }
-          }
+          #Create/Update DNS Records
+          Cluster::CreateDNSRecords.new(@options.dup.merge(chef_task_options)).run unless @skip_dns_record
         end
 
-        def generate_cluster_config
-          ask_config(required_config, cluster_config)
-          cluster_config[:driver] = provider_type(cluster_config[:provider_id])
-          send(:"generate_cluster_config_#{cluster_config[:driver]}")
-          driver_template_file = File.join(Fhcap.source_root, 'templates', 'cluster', cluster_config[:driver], "common.json.erb")
-          driver_template_config = template_as_object(driver_template_file, cluster_config)
-          cluster_config.merge!(driver_template_config)
-        end
-
-        def generate_cluster_config_aws
-          ask_config(aws_required_config, cluster_config[:provider_config])
-          aws_regions = provider_config(cluster_config[:provider_id])[:regions]
-          cluster_config[:default_instance_options] = cluster_config[:default_instance_options] || {}
-          cluster_config[:default_instance_options][:image_id] = aws_regions[cluster_config[:provider_config][:region].to_sym][:base_image]
-        end
-
-        def generate_cluster_config_openstack
-          cluster_config[:default_instance_options] = cluster_config[:default_instance_options] || {}
-          cluster_config[:default_instance_options][:image_ref] = provider_config(@cluster_config[:provider_id])[:image_ref]
-          cluster_config[:default_instance_options][:flavor_ref] = provider_config(@cluster_config[:provider_id])[:flavor_ref]
-          cluster_config[:default_instance_options][:floating_ip_pool] = provider_config(@cluster_config[:provider_id])[:floating_ip_pool]
-          cluster_config[:default_instance_options][:ssh_username] = provider_config(@cluster_config[:provider_id])[:ssh_username]
-        end
-
-        def create_cluster_environments
-          env_template_file = File.join(Fhcap.source_root, 'templates', 'cluster', "#{cluster_config[:template]}.json.erb")
-          template_config = template_as_object(env_template_file, cluster_config)
-
-          template_config[:environments].each do |env|
-            env_template_file = File.join(Fhcap.source_root, 'templates', 'cluster', cluster_config[:driver], "#{env[:template]}.json.erb")
-            template_config = template_as_object(env_template_file, cluster_config)
-
-            env_domain = [env[:'domain-prefix'], cluster_config[:domain]].compact.join('.')
-            env_cfg = {
-                :name => name,
-                :'environment-name' => env[:name],
-                :domain => env_domain,
-                :template => env[:template],
-                :'cluster-config' => cluster_config,
-                :'skip-create-cluster-file' => true
-            }
-
-            CreateEnvironment.new(@options.dup.merge(env_cfg)).run
-          end
-        end
-
-        def create_dns_record
-          send(:"create_dns_record_#{cluster_config[:driver]}")
-        end
-
-        def create_dns_record_aws
-          cluster_config[:environments].each do |env_name, env_cfg|
-            env_cfg[:load_balancers].each do |lb_name, lb_cfg|
-              if lb_cfg[:scheme] == "internet-facing"
-                begin
-                  require 'aws-sdk'
-
-                  cfg = provider_config(cluster_config[:provider_id])
-                  creds = cfg[:credentials]
-
-                  elb = Aws::ElasticLoadBalancing::Client.new(
-                      region: cluster_config[:provider_config][:region],
-                      access_key_id: creds[:'aws-access-key'],
-                      secret_access_key: creds[:'aws-secret-key']
-                  )
-
-                  lb = load_balancer_name_for(name, env_name, lb_name)
-                  resp = elb.describe_load_balancers({
-                                                         load_balancer_names: [lb],
-                                                         page_size: 1,
-                                                     })
-
-                  elb = resp.load_balancer_descriptions.first
-                  thor.say "Found ELB name: #{elb.load_balancer_name}, dns_name: #{elb.dns_name}, zone_id: #{elb.canonical_hosted_zone_name_id}"
-
-                  dns_record_cfg = {
-                      domain: "*.#{env_cfg[:domain]}",
-                      :"alias-target" => {
-                          dns_name: elb.dns_name,
-                          hosted_zone_id: elb.canonical_hosted_zone_name_id
-                      }
-                  }
-                  Dns::CreateRecord.new(@options.dup.merge(dns_record_cfg)).run
-                rescue Aws::ElasticLoadBalancing::Errors::LoadBalancerNotFound => e
-                  thor.say_status 'error', "LoadBalancer #{lb} not found, unable to create DNS Entry", :red
-                rescue Aws::ElasticLoadBalancing::Errors::ServiceError => e
-                  thor.say_status 'error', e.message, :red
-                end
-              end
-            end if env_cfg[:load_balancers]
-          end
-        end
-
-        def create_dns_record_openstack
-          cluster_config[:environments].each do |env_name, env_cfg|
-            env_name = "#{name}-#{env_name}"
-            knife_config_file = knife_config_file_for(cluster_config[:chef_server])
-            #ToDo [RHMAP-2898] Use knife object
-            nodes = JSON.parse(`knife search "chef_environment:#{env_name} AND recipes:nginx_feedhenry\\:\\:loadbalancer" -c #{knife_config_file} -F json -a name -a cloud.public_ipv4`)
-
-            lb_node = nodes['rows'].collect do |row|
-              name, attrs = row.first
-              attrs
-            end.first
-
-            if lb_node
-              if lb_node['cloud.public_ipv4']
-                dns_record_cfg = {
-                    domain: "*.#{env_cfg[:domain]}",
-                    ipaddress: lb_node['cloud.public_ipv4']
-                }
-                Dns::CreateRecord.new(@options.dup.merge(dns_record_cfg)).run
-              else
-                thor.say "Found lb node '#{lb_node['name']}', but was unable to retrieve it's IP!!}"
-              end
-            else
-              thor.say "Unable to locate lb node in cluster!!"
-            end
-          end
-        end
-
-        def load_balancer_name_for(org_name, environment, lb_name)
-          fh_name_for('fh-lb', org_name, environment, lb_name)[0..31] #elb names have a max length of 32
-        end
-
-        def fh_name_for(*args)
-          args.collect do |str|
-            str.to_s.split('-')
-          end.flatten.uniq.join('-')
-        end
-
-
       end
     end
   end