knife-cloudformation 0.2.24 → 0.5.0

data/lib/chef/knife/cloudformation_inspect.rb

@@ -1,206 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation inspect command
-    class CloudformationInspect < Knife
-
-      include KnifeCloudformation::Knife::Base
-      include KnifeCloudformation::Utils::Ssher
-
-      banner 'knife cloudformation inspect NAME'
-
-      option(:attribute,
-        :short => '-a ATTR',
-        :long => '--attribute ATTR',
-        :description => 'Dot delimited attribute to view'
-      )
-
-      option(:nodes,
-        :short => '-N',
-        :long => '--[no-]nodes',
-        :boolean => true,
-        :description => 'Locate all instances'
-      )
-
-      option(:instance_failure,
-        :short => '-I [LOG_FILE_PATH]',
-        :long => '--instance-failure [LOG_FILE_PATH]',
-        :descrption => 'Display chef log file (defaults /var/log/chef/client.log)',
-        :proc => lambda{|val|
-          Chef::Config[:knife][:cloudformation][:failure_log_path] = val
-        }
-      )
-
-      option(:identity_file,
-        :short => '-i IDENTITY_FILE',
-        :long => '--identity-file IDENTITY_FILE',
-        :description => 'SSH identity file for authentication',
-        :proc => lambda{|val|
-          Chef::Config[:knife][:cloudformation][:identity_file] = val
-        }
-      )
-
-      option(:ssh_user,
-        :short => '-x SSH_USER',
-        :long => '--ssh-user SSH_USER',
-        :description => 'SSH username for inspection connect',
-        :proc => lambda{|val|
-          Chef::Config[:knife][:cloudformation][:ssh_user] = val
-        }
-      )
-
-      # Run the stack inspection action
-      def _run
-        stack_name = name_args.last
-        stack = provider.connection.stacks.get(stack_name)
-        ui.info "Stack inspection #{ui.color(stack_name, :bold)}:"
-        outputs = [:attribute, :nodes, :instance_failure].map do |key|
-          if(config.has_key?(key))
-            send("display_#{key}", stack)
-            key
-          end
-        end.compact
-        if(outputs.empty?)
-          ui.info '  Stack dump:'
-          ui.info MultiJson.dump(
-            MultiJson.load(
-              stack.reload.to_json
-            ),
-            :pretty => true
-          )
-        end
-      end
-
-      def display_instance_failure(stack)
-        instances = stack.resources.all.find_all do |resource|
-          resource.state.to_s.end_with?('failed')
-        end.map do |resource|
-          # If compute instance, simply expand
-          if(resource.within?(:compute, :servers))
-            resource.instance
-          # If a waitcondition, check for instance ID
-          elsif(resource.type.to_s.downcase.end_with?('waitcondition'))
-            if(resource.status_reason.to_s.include?('uniqueId'))
-              srv_id = resource.status_reason.split(' ').last.strip
-              provider.connection.api_for(:compute).servers.get(srv_id)
-            end
-          end
-        end.compact
-        if(instances.empty?)
-          ui.error 'Failed to locate any failed instances'
-        else
-          log_path = Chef::Config[:knife][:cloudformation][:failure_log_path]
-          if(log_path.to_s.empty?)
-            log_path = '/var/log/chef/client.log'
-          end
-          opts = ssh_key ? {:keys => [ssh_key]} : {}
-          instances.each do |instance|
-            ui.info "  -> Log inspect for #{instance.id}:"
-            address = instance.addresses_public.map do |address|
-              if(address.version == 4)
-                address.address
-              end
-            end
-            if(address)
-              ssh_attempt_users.each do |user|
-                begin
-                  ui.info remote_file_contents(address.first, user, log_path, opts)
-                  break
-                rescue Net::SSH::AuthenticationFailed
-                  ui.warn "Authentication failed for user #{user} on instance #{address}"
-                rescue => e
-                  ui.error "Failed to retrieve log: #{e}"
-                  _debug e
-                  break
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # Users to attempt SSH connection
-      #
-      # @return [Array<String>] usernames for ssh connect attempt
-      def ssh_attempt_users
-        base_user = Chef::Config[:knife][:cloudformation][:ssh_user] ||
-          Chef::Config[:knife][:ssh_user] ||
-          ENV['USER']
-        [base_user, Chef::Config[:knife][:cloudformation][:ssh_attempt_users]].flatten.compact
-      end
-
-      def ssh_key
-        Chef::Config[:knife][:cloudformation][:identity_file] ||
-          Chef::Config[:knife][:identity_file]
-      end
-
-      def display_attribute(stack)
-        attr = config[:attribute].split('.').inject(stack) do |memo, key|
-          args = key.scan(/\(([^)]*)\)/).flatten.first.to_s
-          if(args)
-            args = args.split(',').map{|a| a.to_i.to_s == a ? a.to_i : a}
-            key = key.split('(').first
-          end
-          if(memo.public_methods.include?(key.to_sym))
-            if(args.size == 1 && args.first.to_s.start_with?('&'))
-              memo.send(key, &args.first.slice(2, args.first.size).to_sym)
-            else
-              memo.send(*[key, args].flatten.compact)
-            end
-          else
-            raise NoMethodError.new "Invalid attribute requested! (#{memo.class}##{key})"
-          end
-        end
-        ui.info "  Attribute Lookup -> #{config[:attribute]}:"
-        ui.info MultiJson.dump(
-          MultiJson.load(
-            MultiJson.dump(attr)
-          ),
-          :pretty => true
-        )
-      end
-
-      def display_nodes(stack)
-        asg_nodes = Smash[
-          stack.resources.all.find_all do |resource|
-            resource.within?(:auto_scale, :groups)
-          end.map do |group_resource|
-            asg = group_resource.expand
-            [
-              asg.name,
-              Smash[
-                asg.servers.map(&:expand).map{|s|
-                  [s.id, Smash.new(
-                      :name => s.name,
-                      :addresses => s.addresses.map(&:address)
-                  )]
-                }
-              ]
-            ]
-          end
-        ]
-        compute_nodes = Smash[
-          stack.resources.all.find_all do |resource|
-            resource.within?(:compute, :servers)
-          end.map do |srv|
-            srv = srv.instance
-            [srv.id, Smash.new(
-                :name => srv.name,
-                :addresses => srv.addresses.map(&:address)
-            )]
-          end
-        ]
-        unless(asg_nodes.empty?)
-          ui.info '  AutoScale Group Instances:'
-          ui.info MultiJson.dump(asg_nodes, :pretty => true)
-        end
-        unless(compute_nodes.empty?)
-          ui.info '  Compute Instances:'
-          ui.info MultiJson.dump(compute_nodes, :pretty => true)
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/knife/cloudformation_list.rb

@@ -1,72 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation list command
-    class CloudformationList < Knife
-
-      include KnifeCloudformation::Knife::Base
-
-      banner 'knife cloudformation list NAME'
-
-      option(:attribute,
-        :short => '-a ATTR',
-        :long => '--attribute ATTR',
-        :description => 'Attribute to print. Can be used multiple times.',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:attributes] ||= []
-          Chef::Config[:knife][:cloudformation][:attributes].push(val).uniq!
-        }
-      )
-
-      option(:all,
-        :long => '--all-attributes',
-        :description => 'Print all attributes'
-      )
-
-      option(:status,
-        :short => '-S STATUS',
-        :long => '--status STATUS',
-        :description => 'Match given status. Use "none" to disable. Can be used multiple times.',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:status] ||= []
-          Chef::Config[:knife][:cloudformation][:status].push(val).uniq!
-        }
-      )
-
-      # Run the list command
-      def _run
-        things_output(nil, get_list, nil)
-      end
-
-      # Get the list of stacks to display
-      #
-      # @return [Array<Hash>]
-      def get_list
-        get_things do
-          provider.stacks.all.map do |stack|
-            Mash.new(stack.attributes)
-          end.sort do |x, y|
-            if(y[:created].to_s.empty?)
-              -1
-            elsif(x[:created].to_s.empty?)
-              1
-            else
-              Time.parse(y['created'].to_s) <=> Time.parse(x['created'].to_s)
-            end
-          end
-        end
-      end
-
-      # @return [Array<String>] default attributes to display
-      def default_attributes
-        if(provider.connection.provider == :aws)
-          %w(name created status template_description)
-        else
-          %w(name created status description)
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/knife/cloudformation_promote.rb

@@ -1,40 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    class CloudformationPromote < Knife
-
-      include KnifeCloudformation::Knife::Base
-
-      banner 'knife cloudformation promote NEW_STACK_NAME DESTINATION'
-
-      option(:accounts,
-        :long => '--accounts-file PATH',
-        :short => '-A PATH',
-        :description => 'JSON account file',
-        :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:promote_accounts] = JSON.load(File.read(v))
-        }
-      )
-
-      option(:storage_bucket,
-        :long => '--exports-bucket NAME',
-        :description => 'Bucket name containing the exports',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:promote_exports_bucket] = v }
-      )
-
-      option(:storage_prefix,
-        :long => '--exports-prefix PREFIX',
-        :description => 'Prefix of stack key',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:promote_exports_prefix] = v }
-      )
-
-
-      def _run
-        stack_name, destination = name_args
-
-      end
-
-    end
-  end
-end

data/lib/chef/knife/cloudformation_update.rb

@@ -1,137 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    class CloudformationUpdate < Knife
-
-      include KnifeCloudformation::Knife::Base
-      include KnifeCloudformation::Knife::Template
-      include KnifeCloudformation::Knife::Stack
-
-      option(:file_path_prompt,
-        :long => '--[no-]file-path-prompt',
-        :description => 'Interactive prompt for template path discovery',
-        :boolean => true,
-        :default => false,
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:file_path_prompt] = val
-        }
-      )
-      option(:apply_stacks,
-        :long => '--apply-stack NAME_OR_ID',
-        :description => 'Autofill parameters using existing stack outputs. Can be used multiple times',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:update] ||= Mash.new
-          Chef::Config[:knife][:cloudformation][:update][:apply_stacks] ||= []
-          Chef::Config[:knife][:cloudformation][:update][:apply_stacks].push(val).uniq!
-        }
-      )
-
-      banner 'knife cloudformation update NAME'
-
-      # Run the stack creation command
-      def _run
-        name = name_args.first
-        unless(name)
-          ui.fatal "Formation name must be specified!"
-          exit 1
-        end
-
-        stack_info = "#{ui.color('Name:', :bold)} #{name}"
-
-        if(Chef::Config[:knife][:cloudformation][:file])
-          file = load_template_file
-          stack_info << " #{ui.color('Path:', :bold)} #{Chef::Config[:knife][:cloudformation][:file]}"
-          nested_stacks = file.delete('sfn_nested_stack')
-        end
-
-        if(nested_stacks)
-
-          unpack_nesting(name, file, :update)
-
-        else
-          stack = provider.connection.stacks.get(name)
-
-          if(stack)
-            ui.info "#{ui.color('Cloud Formation:', :bold)} #{ui.color('update', :green)}"
-
-            unless(file)
-              if(Chef::Config[:knife][:cloudformation][:template])
-                file = Chef::Config[:knife][:cloudformation][:template]
-                stack_info << " #{ui.color('(template provided)', :green)}"
-              else
-                stack_info << " #{ui.color('(no template update)', :yellow)}"
-              end
-            end
-            ui.info "  -> #{stack_info}"
-
-            apply_stacks!(stack)
-
-            if(file)
-              populate_parameters!(file, stack.parameters)
-              stack.template = translate_template(file)
-              stack.parameters = Chef::Config[:knife][:cloudformation][:options][:parameters]
-              stack.template = KnifeCloudformation::Utils::StackParameterScrubber.scrub!(stack.template)
-            else
-              populate_parameters!(stack.template, stack.parameters)
-              stack.parameters = Chef::Config[:knife][:cloudformation][:options][:parameters]
-            end
-
-            begin
-              stack.save
-            rescue Miasma::Error::ApiError::RequestError => e
-              if(e.message.downcase.include?('no updates')) # :'(
-                ui.warn "No updates detected for stack (#{stack.name})"
-              else
-                raise
-              end
-            end
-
-            if(Chef::Config[:knife][:cloudformation][:poll])
-              poll_stack(stack.name)
-              if(stack.success?)
-                ui.info "Stack update complete: #{ui.color('SUCCESS', :green)}"
-                knife_output = Chef::Knife::CloudformationDescribe.new
-                knife_output.name_args.push(name)
-                knife_output.config[:outputs] = true
-                knife_output.run
-              else
-                ui.fatal "Update of stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
-                ui.info ""
-                knife_inspect = Chef::Knife::CloudformationInspect.new
-                knife_inspect.name_args.push(name)
-                knife_inspect.config[:instance_failure] = true
-                knife_inspect.run
-                exit 1
-              end
-            else
-              ui.warn 'Stack state polling has been disabled.'
-              ui.info "Stack update initialized for #{ui.color(name, :green)}"
-            end
-          else
-            ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
-            exit -1
-          end
-
-        end
-      end
-
-      # Update default values for parameters in template with
-      # currently used parameters on the existing stack
-      #
-      # @param template [Hash] stack template
-      # @param stack [Fog::Orchestration::Stack]
-      # @return [Hash]
-      # @todo to be scrubbed
-      def redefault_stack_parameters(template, stack)
-        stack.parameters.each do |key, value|
-          if(template['Parameters'][key])
-            template['Parameters'][key]['Default'] = value
-          end
-        end
-        template
-      end
-
-    end
-  end
-end