awx 0.1.0 → 0.2.0

data/lib/aws/aws_reports.rb

@@ -0,0 +1,271 @@
+module App
+
+    class AWSReports
+
+        CONST_ALL             = 'all'
+        CONST_GLOBAL          = 'Global'
+        KEY_CLI               = 'cli'
+        KEY_COLUMNS           = 'columns'
+        KEY_COMMAND           = 'command'
+        KEY_EXPORT            = 'export'
+        KEY_REGION            = 'region'
+        KEY_REGIONS           = 'regions'
+        KEY_REGIONS_PREFERRED = 'regionsPreferred'
+
+        YML_FILE = 'aws-reports.yml'
+
+        # Parses the YML file and returns a bunch of Hashes. Throws straight-up runtime errors if something is wrong.
+        # @return void
+        def self.parse_metadata(regions)
+
+            yml_file = "#{App::Opt::get_base_path}#{App::Opt::OPT_PATH_YML}/#{YML_FILE}"
+            Blufin::Terminal::error("File not found: #{Blufin::Terminal::format_directory(yml_file)}", 'This file should be located in the /opt folder of the my (ruby-gem) source-code.', true) unless Blufin::Files::file_exists(yml_file)
+
+            columns      = {}
+            table_widths = {}
+            export_map   = {}
+
+            begin
+                data = YAML.load_file(File.expand_path(yml_file))
+            rescue => e
+                Blufin::Terminal::error("Unable to parse #{Blufin::Terminal::format_action('YML')} file: #{Blufin::Terminal::format_directory(yml_file)}", e.message, true)
+            end
+
+            data.each do |resource, data|
+
+                # Validates keys (generically).
+                {
+                    KEY_REGIONS           => [],
+                    KEY_REGIONS_PREFERRED => [],
+                    KEY_CLI               => %w(command root)
+                }.each do |required_key, required_nested_keys|
+                    raise RuntimeError, "Missing key: #{required_key} for \xe2\x86\x92 #{resource}" unless data.has_key?(required_key)
+                    required_nested_keys.each do |required_nested_key|
+                        raise RuntimeError, "Missing key: #{required_key}.#{required_nested_key} for \xe2\x86\x92 #{resource}" unless data[required_key].has_key?(required_nested_key)
+                    end
+                end
+
+                # Validate regions.
+                validate_region_array(regions, data[KEY_REGIONS], resource) if data.has_key?(KEY_REGIONS)
+                validate_region_array(regions, data[KEY_REGIONS_PREFERRED], resource) if data.has_key?(KEY_REGIONS_PREFERRED)
+
+                # Validate (and parse) columns.
+                if !data[KEY_COLUMNS].nil? && data[KEY_COLUMNS].any?
+                    if data.has_key?(KEY_COLUMNS) && data[KEY_COLUMNS].is_a?(Array)
+                        columns[resource]           = {} unless columns.has_key?(resource)
+                        width_wildcard_count        = 0
+                        width_total                 = App::AWSOutputter::REGION_WIDTH # Start with 15 to account for hard-coded region column.
+                        columns[resource]['Region'] = {
+                            :key       => 'region',
+                            :width     => App::AWSOutputter::REGION_WIDTH,
+                            :formatter => 'region'
+                        }
+                        data[KEY_COLUMNS].each_with_index do |column, idx|
+                            title     = nil
+                            key       = nil
+                            width     = nil
+                            color     = 'default'
+                            formatter = nil
+                            column.each do |column_inner|
+                                column_inner.each do |k, v|
+                                    title     = v if k == 'title'
+                                    key       = v if k == 'key'
+                                    width     = v if k == 'width'
+                                    color     = v if k == 'color'
+                                    formatter = v if k == 'formatter'
+                                end
+                            end
+                            ['Region'].each do |reserved_column|
+                                raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 #{reserved_column} is a reserved column." if title.downcase == reserved_column.downcase
+                            end
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Missing: title" if title.nil?
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Missing: key" if key.nil?
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Missing: width" if width.nil?
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Title already exists: #{title}" if columns[resource].has_key?(title)
+                            raise RuntimeError, "Expected width to be wildcard (*) or Integer greater than 0, instead got: (#{width.class}) #{width}" unless width == '*' || width.is_a?(Integer)
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Title length (#{title.length}) is longer that column-width (#{width}) : #{title}" if title.length > width.to_i && width.to_s.strip != '*'
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Formatter not recognized: #{formatter}, valid formatters are: #{App::AWSOutputter::get_formatter.join(', ')}" unless App::AWSOutputter::get_formatter.include?(formatter) || formatter.nil?
+                            raise RuntimeError, "#{resource}.#{KEY_COLUMNS}[#{idx}] \xe2\x86\x92 Color not recognized: #{color}, valid colors are: #{App::AWSOutputter::get_color.join(', ')}" unless App::AWSOutputter::get_color.include?(color)
+                            width_wildcard_count     = width_wildcard_count + 1 if width == '*'
+                            width_total              = width_total + width unless width == '*'
+                            columns[resource][title] = {
+                                :key       => key,
+                                :width     => width,
+                                :color     => color,
+                                :formatter => formatter
+                            }
+                        end
+                        raise RuntimeError, "Wildcard width count must be exactly 1, got: #{width_wildcard_count}" unless width_wildcard_count == 1
+                        raise RuntimeError, "#{resource}.#{KEY_COLUMNS} \xe2\x86\x92 Total width of columns (#{width_total}) minus wildcard (*) & region exceeds 210." if width_total > 210
+                        table_widths[resource] = width_total
+                    end
+                end
+                # Validate Exports.
+                if !data[KEY_EXPORT].nil? && data[KEY_EXPORT].any?
+                    raise RuntimeError, "Expected #{Blufin::Terminal::format_highlight('export')} to be a Hash, instead got: #{data[KEY_EXPORT].class}" unless data[KEY_EXPORT].is_a?(Hash)
+                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: id" unless data[KEY_EXPORT].has_key?('id')
+                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: value" unless data[KEY_EXPORT].has_key?('value')
+                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: description" unless data[KEY_EXPORT].has_key?('description')
+                    # Make sure formatter exists.
+                    App::AWSOutputter::get_formatter(data[KEY_EXPORT]['valueFormatter']) if data[KEY_EXPORT].has_key?('valueFormatter')
+                    data[KEY_EXPORT].each { |key, val| raise RuntimeError, "Unexpected key: #{key} (#{val})" unless %w(id value valueFormatter description).include?(key) }
+                    export_map[data[KEY_EXPORT]['id']] = resource
+                end
+            end
+
+            # TODO - Maybe add "custom" resources here for WorkMailEmails and SES Identities, etc. here...?? If so, these need custom logic.
+
+            [columns, data, export_map, table_widths]
+        end
+
+        # This runs the AWS GET and does various things depending on the the flags passed.
+        # @return void
+        def self.get_aws_data(regions, resource, resource_title, silent: false)
+            response  = {}
+            results   = []
+            threads   = []
+            semaphore = Mutex.new
+            regions   = resource.has_key?(App::AWSReports::KEY_REGIONS) ? resource[App::AWSReports::KEY_REGIONS] : regions
+            puts unless silent
+            regions.each do |region|
+                response[region] = {} if response[region].nil?
+                sleep(0.01) unless silent
+                threads << Thread.new {
+                    cmd = "aws #{resource[App::AWSReports::KEY_CLI][App::AWSReports::KEY_COMMAND]}#{region == App::AWSReports::CONST_GLOBAL ? '' : " --region #{region}"}"
+                    puts "  \x1B[38;5;70m$ \x1B[38;5;240m#{cmd}\x1B[0m" unless silent
+                    json = `#{cmd}`
+                    begin
+                        semaphore.synchronize do
+                            if json.strip == ''
+                                response[region] = []
+                            else
+                                response[region] = JSON.parse(json)
+                            end
+                        end
+                    rescue => e
+                        puts json.inspect
+                        raise RuntimeError, "JSON parsing (for: #{resource_title}) failed:\n\n#{e.message}"
+                    end
+                }
+            end
+            sleep(0.1) unless silent
+            puts unless silent
+
+            # Display spinner while waiting for threads to finish.
+            Blufin::Terminal::execute_proc("AWS - Fetching: #{Blufin::Terminal::format_highlight(resource_title, false)}", Proc.new {
+                threads.each { |thread| thread.join }
+            }, verbose: !silent)
+            puts unless silent
+
+            # Extract the regional response(s) (from multi-calls to different regions) and aggregate into a single Array.
+            root_keys = resource[App::AWSReports::KEY_CLI]['root']
+
+            if resource[App::AWSReports::KEY_REGIONS].length == 1 && resource[App::AWSReports::KEY_REGIONS][0] == App::AWSReports::CONST_GLOBAL
+                results = recursively_get_results(App::AWSReports::CONST_GLOBAL, response[App::AWSReports::CONST_GLOBAL], root_keys)
+            else
+                response.each do |region, regional_response|
+                    recursively_get_results(region, regional_response, root_keys).each do |regional_result|
+                        results << regional_result
+                    end
+                end
+            end
+            results
+        end
+
+        # Returns a Hash with all the resources that can be auto-fetched using a script.
+        # @return Hash
+        def self.get_auto_fetch_resources(data)
+            auto_fetch_resources = {}
+            data.each do |resource|
+                if resource[1].has_key?(App::AWSReports::KEY_EXPORT)
+                    if resource[1][App::AWSReports::KEY_EXPORT].has_key?('id')
+                        auto_fetch_resources[resource[1][App::AWSReports::KEY_EXPORT]['id']] = {
+                            :resource_title => resource[0],
+                            :resource       => resource[1]
+                        }
+                    end
+                end
+            end
+            auto_fetch_resources
+        end
+
+        # Takes AWS api results and translates it to an array of key/value pairs we can pass to Blufin::Terminal::prompt_select().
+        # @return Array (of Hashes)
+        def self.parse_results_for_prompt(resource, results)
+            options = []
+            values  = []
+            results.each do |result|
+                value = result[resource[App::AWSReports::KEY_EXPORT]['value']]
+                value = App::AWSOutputter::get_formatter(resource[App::AWSReports::KEY_EXPORT]['valueFormatter']).call(value)[0] if resource[App::AWSReports::KEY_EXPORT].has_key?('valueFormatter')
+                values << value
+            end
+            results.each do |result|
+                value = result[resource[App::AWSReports::KEY_EXPORT]['value']]
+                value = App::AWSOutputter::get_formatter(resource[App::AWSReports::KEY_EXPORT]['valueFormatter']).call(value)[0] if resource[App::AWSReports::KEY_EXPORT].has_key?('valueFormatter')
+                options << {
+                    :value => value,
+                    :text  => "#{value.rjust(values.max_by(&:length).length.to_i, ' ')} \x1B[38;5;246m\xe2\x80\x94 \x1B[38;5;240m#{result[resource[App::AWSReports::KEY_EXPORT]['description']]}\x1B[0m",
+                }
+            end
+            options
+        end
+
+        private
+
+        # Validates a region array such as ['us-west-1','us-west-2'].
+        # @return void
+        def self.validate_region_array(regions, region_array, resource)
+            has_global = false
+            raise RuntimeError, "#{resource} \xe2\x86\x92 Expected regions to be an Array of Strings, instead got: (#{region_array.class}) #{region_array}" unless region_array.is_a?(Array)
+            region_array.each do |region|
+                raise RuntimeError, "#{resource} \xe2\x86\x92 Expected region to be a String, instead got: (#{region.class}) #{region}" unless region.is_a?(String)
+                raise RuntimeError, "#{resource} \xe2\x86\x92 Invalid region: #{Blufin::Terminal::format_invalid(region)}. Valid regions are: #{regions.inspect}" unless region == App::AWSReports::CONST_GLOBAL || regions.include?(region)
+                has_global = true if region == App::AWSReports::CONST_GLOBAL
+            end
+            raise RuntimeError, "#{resource} \xe2\x86\x92 Cannot have more than 1 region when #{App::AWSReports::KEY_REGIONS} has the #{App::AWSReports::CONST_GLOBAL} key. Found: #{region_array.inspect}" if has_global && region_array.length > 1
+        end
+
+        # Recursively gets results out of the JSON returned by AWS.
+        # @return Array
+        def self.recursively_get_results(region, response, keys)
+            ks        = keys.split('.')
+            first_key = ks[0]
+            is_array  = first_key != first_key.gsub(/\[\]$/, '')
+            first_key = first_key.gsub(/\[\]$/, '') if is_array
+            results   = []
+            if response.is_a?(Hash) || response.is_a?(Array)
+                check_root_key_exists(response, first_key) if response.is_a?(Hash)
+                ks.shift
+                if ks.length == 0
+                    response[first_key].each do |result|
+                        res                              = result
+                        res[App::AWSReports::KEY_REGION] = region
+                        results << res
+                    end
+                else
+                    if is_array
+                        results_aggregate = []
+                        response[first_key].each do |x|
+                            recursively_get_results(region, x, ks.join('.')).each do |y|
+                                results_aggregate << y
+                            end
+                        end
+                        results_aggregate
+                    else
+                        recursively_get_results(region, response[first_key], ks.join('.')) if response.is_a?(Hash)
+                    end
+                end
+            else
+                results
+            end
+        end
+
+        # Throw error if Root Key not found in response.
+        # @return void
+        def self.check_root_key_exists(data, root_key)
+            Blufin::Terminal::error("Root key not found in AWS response: #{Blufin::Terminal::format_invalid(root_key)}", data.to_yaml.split("\n"), true) unless data.has_key?(root_key)
+        end
+
+    end
+
+end

data/lib/aws/aws_validator.rb

@@ -0,0 +1,30 @@
+module App
+
+    class AWSValidator
+
+        # Helper method to get + validate regions. Probably going to be used in all AWS Cli calls.
+        # @return Array
+        def self.get_and_validate_regions(region_given)
+            regions = App::AWSCli::get_regions
+            if region_given
+                Blufin::Terminal::error("Invalid AWS region \xe2\x86\x92 #{Blufin::Terminal::format_invalid(region_given)}. Valid regions are:", regions) unless App::AWSValidator::validate_region(region_given)
+                @regions << region_given
+            else
+                @regions = regions
+            end
+        end
+
+        # Validates AWS region.
+        # @return boolean
+        def self.validate_region(region)
+            if App::Cache::exists?(App::CacheKey::ARRAY_AWS_REGIONS)
+                valid_regions = App::Cache::get(App::CacheKey::ARRAY_AWS_REGIONS)
+            else
+                valid_regions = App::AWSCli::get_regions
+            end
+            valid_regions.include?(region)
+        end
+
+    end
+
+end

data/lib/awx.rb

@@ -5,9 +5,10 @@ require 'blufin-lib'
 
 require_relative 'version'
 require 'core/config_unique'
-require 'core/aws/aws_config'
-require 'core/aws/aws_credentials'
+require 'aws/aws_config'
+require 'aws/aws_credentials'
 
+Dir["#{File.dirname(__FILE__)}/aws/**/*.rb"].each { |file| load(file) unless file =~ /\/(config_unique|aws_config|aws_credentials)\.rb\z/ }
 Dir["#{File.dirname(__FILE__)}/core/**/*.rb"].each { |file| load(file) unless file =~ /\/(config_unique|aws_config|aws_credentials)\.rb\z/ }
 Dir["#{File.dirname(__FILE__)}/routes/**/*.rb"].each { |file| load(file) }
 
@@ -21,96 +22,87 @@ module App
                 App::Config.initialize
             end
 
-            Convoy::App.create do |my|
+            Convoy::App.create do |awx|
 
-                #  COLOR OF TITLE TEXT
-                title_color = 255
+                awx.version AWX_VERSION
+                awx.summary "\x1B[38;5;198mAWX\x1B[0m \x1B[38;5;134m\xe2\x80\x94 Amazon Web-Services X-Tender (Beta)\x1B[0m"
+                awx.description 'An abstraction layer built around the AWS-cli (written by: Albert Rannetsperger)'
 
-                my.version VERSION
-                my.summary "\x1B[38;5;198mMY-CLI\x1B[0m \x1B[38;5;240m\xe2\x80\x94 BETA\x1B[0m"
-                my.description "\x1B[38;5;#{title_color}mA command line utility for myself.\nDesigned to work from anywhere on my mac.\n\nUse #{Blufin::Terminal::format_command('my')}\x1B[38;5;#{title_color}m to run.\x1B[0m"
-
-                # Checks whether a AWS 'blufin-cli' profile exists within ~/.aws ...
+                # Checks whether a AWS 'blufin-cli' profile exists within ~/.awx ...
                 unless App::AWSConfig::get_credentials(App::AWSConfig::AWS_PROFILE_ALBERT_CLI).nil?
-                    # a - AWS
-                    my.command :aws, :aliases => [:a] do |aws|
-                        aws.summary 'AWS related functionality'
-                        # cf - AWS CLOUD FORMATION
-                        aws.command :cloudformation, :aliases => [:c] do |aws_cloudformation|
-                            aws_cloudformation.summary 'Create, list and delete cloud-formation stacks'
-                            # c - AWS CLOUD FORMATION CREATE
-                            aws_cloudformation.command :create, :aliases => [:c] do |aws_cloudformation_create|
-                                aws_cloudformation_create.summary 'Create stack'
-                                aws_cloudformation_create.options do |opts|
-                                    opts.opt :test, 'Run through test-template.', :short => '-t', :long => '--test', :type => :boolean
-                                end
-                                aws_cloudformation_create.action do |opts, args|
-                                    AppCommand::AWSCloudFormationCreate.new(opts, args).execute
-                                end
-                            end
-                            # d - AWS CLOUD FORMATION DETECT-DRIFT
-                            aws_cloudformation.command :detect_drift, :aliases => [:d] do |aws_cloudformation_detect_drift|
-                                aws_cloudformation_detect_drift.summary 'Detect drift (for stack)'
-                                aws_cloudformation_detect_drift.action do |opts, args|
-                                    AppCommand::AWSCloudFormationDetectDrift.new(opts, args).execute
-                                end
+                    # cf - AWS CLOUD FORMATION
+                    awx.command :cloudformation, :aliases => [:c] do |awx_cloudformation|
+                        awx_cloudformation.summary 'Create, list and delete cloud-formation stacks'
+                        # c - AWS CLOUD FORMATION CREATE
+                        awx_cloudformation.command :create, :aliases => [:c] do |awx_cloudformation_create|
+                            awx_cloudformation_create.summary 'Create stack'
+                            awx_cloudformation_create.options do |opts|
+                                opts.opt :test, 'Run through test-template.', :short => '-t', :long => '--test', :type => :boolean
                             end
-                            # D - AWS CLOUD FORMATION DELETE
-                            aws_cloudformation.command :delete, :aliases => [:D] do |aws_cloudformation_delete|
-                                aws_cloudformation_delete.summary 'Delete stack'
-                                aws_cloudformation_delete.action do |opts, args|
-                                    AppCommand::AWSCloudFormationDelete.new(opts, args).execute
-                                end
-                            end
-                            aws_cloudformation.action do
-                                system("#{ConfigUnique::GEM_NAME} a c -h")
+                            awx_cloudformation_create.action do |opts, args|
+                                AppCommand::AWSCloudFormationCreate.new(opts, args).execute
                             end
                         end
-                        # l - AWS LIST
-                        aws.command :list, :aliases => [:l] do |aws_list|
-                            aws_list.summary 'List AWS instances/resources'
-                            aws_list.options do |opts|
-                                opts.opt :json, 'Return data as JSON', :short => '-j', :long => '--json', :type => :boolean
-                                opts.opt :json_prompt, 'Return data as JSON (for Terminal::prompt)', :short => '-J', :long => '--json-prompt', :type => :boolean
-                                opts.opt :yaml, 'Return data as Yaml', :short => '-y', :long => '--yaml', :type => :boolean
-                                opts.opt :resource, "Specify a resource. For all resources type: #{Blufin::Terminal::format_command('all')}", :short => '-r', :long => '--resource', :type => :string
-                                opts.opt :verbose, 'Output the original response from AWS (with all fields).', :short => '-v', :long => '--verbose', :type => :boolean
-                                opts.opt :metadata, 'Output the YML definition file metadata.', :short => '-m', :long => '--metadata', :type => :boolean
-                                # TODO - Implement Region + Project filtering (possibly more).
-                                opts.opt :region, 'Specify a region', :short => '-R', :long => '--region', :type => :string
-                                opts.opt :project, 'Specify a project (Tag: project)', :short => '-p', :long => '--project', :type => :string
-                            end
-                            aws_list.action do |opts, args|
-                                AppCommand::AWSList.new(opts, args).execute
+                        # d - AWS CLOUD FORMATION DETECT-DRIFT
+                        awx_cloudformation.command :detect_drift, :aliases => [:d] do |awx_cloudformation_detect_drift|
+                            awx_cloudformation_detect_drift.summary 'Detect drift (for stack)'
+                            awx_cloudformation_detect_drift.action do |opts, args|
+                                AppCommand::AWSCloudFormationDetectDrift.new(opts, args).execute
                             end
                         end
-                        # L - AWS LAMBDA
-                        aws.command :lambda, :aliases => [:L] do |aws_lambda|
-                            aws_lambda.summary 'Quickly invoke a Lambda function locally (without the need to deploy)'
-                            aws_lambda.options do |opts|
-                                opts.opt :headers_file, 'The path to a JSON containing HTTP Headers you want to send', :short => '-H', :long => '--headers-file', :type => :string
-                                opts.opt :payload_file, 'The path to a JSON payload you want to send', :short => '-p', :long => '--pay-load-file', :type => :string
-                            end
-                            aws_lambda.action do |opts, args|
-                                AppCommand::AWSLambda.new(opts, args).execute
+                        # D - AWS CLOUD FORMATION DELETE
+                        awx_cloudformation.command :delete, :aliases => [:D] do |awx_cloudformation_delete|
+                            awx_cloudformation_delete.summary 'Delete stack'
+                            awx_cloudformation_delete.action do |opts, args|
+                                AppCommand::AWSCloudFormationDelete.new(opts, args).execute
                             end
                         end
-                        aws.action do |opts, args|
-                            system("#{ConfigUnique::GEM_NAME} a -h")
+                        awx_cloudformation.action do
+                            system("#{ConfigUnique::GEM_NAME} c -h")
+                        end
+                    end
+                    # l - AWS LIST
+                    awx.command :list, :aliases => [:l] do |awx_list|
+                        awx_list.summary 'List AWS instances/resources'
+                        awx_list.options do |opts|
+                            opts.opt :json, 'Return data as JSON', :short => '-j', :long => '--json', :type => :boolean
+                            opts.opt :json_prompt, 'Return data as JSON (for Terminal::prompt)', :short => '-J', :long => '--json-prompt', :type => :boolean
+                            opts.opt :yaml, 'Return data as Yaml', :short => '-y', :long => '--yaml', :type => :boolean
+                            opts.opt :resource, "Specify a resource. For all resources type: #{Blufin::Terminal::format_command('all')}", :short => '-r', :long => '--resource', :type => :string
+                            opts.opt :verbose, 'Output the original response from AWS (with all fields).', :short => '-v', :long => '--verbose', :type => :boolean
+                            opts.opt :metadata, 'Output the YML definition file metadata.', :short => '-m', :long => '--metadata', :type => :boolean
+                            # TODO - Implement Region + Project filtering (possibly more).
+                            opts.opt :region, "Specify a region \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-R', :long => '--region', :type => :string
+                            opts.opt :environment, "Specify a environment \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-e', :long => '--environment', :type => :string
+                            opts.opt :project, "Specify a project \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-p', :long => '--project', :type => :string
+                        end
+                        awx_list.action do |opts, args|
+                            AppCommand::AWSList.new(opts, args).execute
+                        end
+                    end
+                    # L - AWS LAMBDA
+                    awx.command :lambda, :aliases => [:L] do |awx_lambda|
+                        awx_lambda.summary 'Quickly invoke a Lambda function locally (without the need to deploy)'
+                        awx_lambda.options do |opts|
+                            opts.opt :headers_file, 'The path to a JSON containing HTTP Headers you want to send', :short => '-H', :long => '--headers-file', :type => :string
+                            opts.opt :payload_file, 'The path to a JSON payload you want to send', :short => '-p', :long => '--pay-load-file', :type => :string
+                        end
+                        awx_lambda.action do |opts, args|
+                            AppCommand::AWSLambda.new(opts, args).execute
                         end
                     end
                 end
 
                 # x - SETUP
-                my.command :setup, :aliases => [:x] do |setup|
+                awx.command :setup, :aliases => [:x] do |setup|
                     setup.summary 'Setup your configuration file'
                     setup.action do |opts, args|
                         AppCommand::Setup.new(opts, args).execute
                     end
                 end
 
-                # MY (DEFAULT)
-                my.action do
+                # AWX (DEFAULT)
+                awx.action do
                     system("#{ConfigUnique::GEM_NAME} -h")
                 end
 
@@ -120,5 +112,7 @@ module App
 
             Blufin::Terminal::print_exception(e);
         end
+
     end
+
 end