opensecret 0.0.913 → 0.0.941

data/lib/opensecret/commons/eco.cmdline.rb

@@ -1,446 +0,0 @@
-#!/usr/bin/ruby
-
-# -- --------------------------------------------------------------------------------- -- #
-# -- The [Command Interpreter]                                                         -- #
-# -- --------------------------------------------------------------------------------- -- #
-# --                                                                                   -- #
-# -- From the command line we receive the below asset groups.                          -- #
-# --                                                                                   -- #
-# --   [1] - major use case commands like "create", "register", "destroy"              -- #
-# --   [2] - specifiers telling us "create what", "destroy which ones"                 -- #
-# --   [3] - boolean flags that dictate which way the hammer should fall               -- #
-# --   [4] - option / arg config pairs (options can be long or short)                  -- #
-# --                                                                                   -- #
-# -- Some flags and options are mandatory - others are optional. Argument types        -- #
-# -- are usually => [ booleans, strings, lists, sets or numbers ].                     -- #
-# --                                                                                   -- #
-# -- --------------------------------------------------------------------------------- -- #
-# -- Art or Science                                                                    -- #
-# -- --------------------------------------------------------------------------------- -- #
-# --                                                                                   -- #
-# -- Parsing the command line and returning concise error messages is much more        -- #
-# -- [ART] than it is [SCIENCE]. This is because the permutations and combinations     -- #
-# -- are mind bogglingly vast. Hence this code is strictly ["best efforts"].           -- #
-# --                                                                                   -- #
-# -- That said, the invoked commands should be belt and braces in processing the       -- #
-# -- arguments and switches provided on the command line.                              -- #
-# --                                                                                   -- #
-# -- This command interpreter in no way absolves the evoked software from the legwork  -- #
-# -- of security, validation and semantic assessments.                                 -- #
-# --                                                                                   -- #
-# -- --------------------------------------------------------------------------------- -- #
-class CmdLine
-  include Singleton
-
-  attr_reader :create
-  attr_reader :task
-  attr_reader :do_read_db_names
-  attr_reader :do_register_user
-  attr_reader :do_destroy_app
-
-  attr_reader :key_values
-  attr_reader :args_cache
-  attr_reader :args_after
-
-
-  def initialize
-
-    # -- ----------------------------------------------------------- --- #
-    # -- If no commands to interpret - assume the caller needs help. --- #
-    # -- ----------------------------------------------------------- --- #
-    ARGV.push "--help" if ARGV.length == 0
-
-    @key_values = {}
-    @args_cache = [].replace ARGV
-
-    # --- ------------------------------------------------------------- --- #
-    # --- [--help] is a peripheral command with no [do] [what] pattern. --- #
-    # --- ------------------------------------------------------------- --- #
-    print_help_screen       if ARGV.include? "--help"
-    print_help_screen       if ARGV.include? "-h"
-
-    # --- -------------------------------------------------- --- #
-    # --- Each line below pertains to a [do] [what] command. --- #
-    # --- -------------------------------------------------- --- #
-    read_eco_create_args     if command_matches? "create", "what", "w"
-    read_read_db_names_args  if command_matches? "read", "s3", "s"
-    read_aws_register_args   if command_matches? "register", "aws-user", "a"
-    read_destroy_app_args    if command_matches? "destroy", "app", "a"
-    read_task_args           if command_matches? "task", "what", "w"
-
-    # --- --------------------------------------------------------- --- #
-    # --- Notify caller if [do] [what] portion could not be mapped. --- #
-    # --- --------------------------------------------------------- --- #
-    handle_cmd_match_fail  if @options_parser == nil
-
-    begin
-
-      @options_parser.parse!
-      @args_after = ARGV
-
-      missing_args = @mandatory_options.select{ |param| @key_values[param].nil? }
-      unless missing_args.empty?
-        raise OptionParser::MissingArgument.new(missing_args.join(', '))
-      end
-
-    rescue OptionParser::InvalidOption => exception
-
-      log.warn(ere) { "#--- ---------------------------------------------- --- #" }
-      log.warn(ere) { "#--- eco did not recognize a command option.        --- #" }
-      log.warn(ere) { "#--- ---------------------------------------------- --- #" }
-      log.warn(ere) { "#--- #{exception}" }
-      log.warn(ere) { "#--- #{exception.inspect}" }
-
-#### Fix this if too spurious
-#### Fix this if too spurious
-#### Fix this if too spurious
-#### Fix this if too spurious
-################      puts exception.backtrace if @@VERBOSE_MODE
-
-      log.warn(ere) { "#{exception.backtrace}" } ##### may be add if ARGV.include? "--debug"
-      log.warn(ere) { @options_parser.help }
-      log.warn(ere) { "#--- ---------------------------------------------- --- #" }
-
-      # @@
-      # @@ No need to exit from this - this script does not need
-      # @@ to be hard-coded with every command line option.
-      # @@ (We need only know the [Mandatory] ones which is
-      # @@ handled by the below rescue block.
-      # @@
-
-##################  DELETE ME ASAP
-##############      exit
-##################  DELETE ME ASAP
-
-
-    rescue OptionParser::MissingArgument => missing_arg
-
-      log.fatal(ere) { $!.to_s }
-      log.fatal(ere) { @options_parser }
-      exit
-
-    end
-
-  end
-
-
-  # --
-  # -- Returns true if the option text was included on the command line.
-  # --
-  # -- This method does not look within a list of values. Only call this
-  # -- method if the text is a free form switch WITHOUT an equal sign.
-  # --
-  def self.has? a_string
-    return CmdLine.instance.args_cache.include? a_string
-  end
-
-
-  # --
-  # -- Return true if symbol (switch) was included on the command line.
-  # --
-  # -- WARNING - Do not use externally as the line is cleared.
-  # --         - Call has? like =] if CmdLine.has? --debug
-  # --
-  def self.include? a_symbol
-    return CmdLine.instance.key_values.include? a_symbol
-  end
-
-
-  # -- ---------------------------------------------------------------------------- -- #
-  # -- Does the command line contain a specific command and a flag in either of its -- #
-  # -- forms - long and short. If yes then this method will return true.            -- #
-  # -- ---------------------------------------------------------------------------- -- #
-  def command_matches? cmd_str, flag_long, flag_short
-
-    return ( ARGV.include?( cmd_str ) && ARGV.include?("--#{flag_long}") ) ||
-       ( ARGV.include?( cmd_str ) && ARGV.include?("-#{flag_short}") )
-
-  end
-
-
-  # -- ---------------------------------------------------------------------------- -- #
-  # -- forms - long and short. If yes then this method will return true.            -- #
-  # -- ---------------------------------------------------------------------------- -- #
-  def handle_cmd_match_fail
-
-    log.fatal(ere) { "    # - ------------------------------------------------------------ - #" }
-    log.fatal(ere) { "    # - eco command ==> could not match == [do] [what] [how] [where] - #" }
-    log.fatal(ere) { "    # - ------------------------------------------------------------ - #" }
-    log.fatal(ere) { "    eco [do] [what]" }
-    log.fatal(ere) { "    Could not match the [do what] branch of the command tree." }
-    log.fatal(ere) { "    [do] is CRUD based eg [create, register, read, update, destroy]." }
-    log.fatal(ere) { "    The [what] part tells the command interpreter what you want to do." }
-    log.fatal(ere) { "    eco optional arguments == [how] [where] [to]" }
-    log.fatal(ere) { "    [how]   -   do it how   eg | --clean      | --dry-run |" }
-    log.fatal(ere) { "    [where] -   (on what)   eg | --cloud      | --local   |" }
-    log.fatal(ere) { "    [to]    -   do it to    eg | --eco-system | --service |" }
-
-    exit
-
-  end
-
-
-  ## --- --------------------------------------------------------- --- ##
-  ## --- How to use Declarative and Dynamic Command Interpretation --- ##
-  ## --- --------------------------------------------------------- --- ##
-  ## --- 
-  ## --- Once SREs are familiar with this command interpreter class
-  ## --- the next refactor step is to generate the whole thing dynamically.
-  ## --- I will probably write a ruby gem to do exactly this.
-  ## --- 
-  ## --- The essence is to create a JSON or YAML configuration file that
-  ## --- holds the command line interpretation variables. This is used to
-  ## --- dynamically generate the optparse blocks.
-  ## --- 
-  ## --- --------------------------------------------------------- --- ##
-  ## --- How to use Dynamically Generate the Help Screen           --- ##
-  ## --- --------------------------------------------------------- --- ##
-  ## --- 
-  ## --- To generate the help screen you can loop round calling each
-  ## --- parser block (without any actual cmd line arguments)!
-  ## --- 
-  ## --- Then you loop doing a to_string puts opt_parser for each
-  ## --- parser and all the options will be ejected automatically!
-  ## --- 
-  ## --- You are done when all read methods vanish (ruby magic)!
-  ## --- 
-  ## --- --------------------------------------------------------- --- ##
-
-
-  ## --- ---------------------- --- ##
-  ## --- Create the application --- ##
-  ## --- ---------------------- --- ##
-  def read_eco_create_args
-
-    ## ---------------------------------------------------------- #
-    @create = true
-    @mandatory_options = [:service_descriptors]
-    ## ---------------------------------------------------------- #
-    @options_parser = OptionParser.new do | the_options |
-
-      the_options.banner = "    eco create --what   => create which eco systems\n\n"
-
-##      the_options.on( "-f", "--versions-file FILE_PATH", "Service versions file in JSON (mandatory)") do | versions_file |
-
-##        @key_values[:versions_file] = versions_file
-
-##      end
-
-      the_options.on( "-w", "--what mongo,email,...", Array, "Comma separated service descriptors (mandatory)") do | service_descriptors_list |
-
-        @key_values[:service_descriptors] = service_descriptors_list
-
-      end
-
-    end
-
-  end
-
-
-  ## --- -------------------- --- ##
-  ## --- Register an AWS User --- ##
-  ## --- -------------------- --- ##
-  def read_aws_register_args
-
-    ## ---------------------------------------------------------- #
-    @do_register_user = true
-    @mandatory_options = [:aws_user, :aws_user_id, :aws_password]
-    ## ---------------------------------------------------------- #
-    @options_parser = OptionParser.new do | the_options |
-
-      the_options.banner = "    eco register --aws-user   => options to register [aws credentials]\n\n"
-
-      the_options.on( "-a", "--aws-user", "Registering AWS Credentials") do
-
-        @key_values[:aws_user] = true
-
-      end
-
-      the_options.on( "-u", "--aws-user-id AWS_USER_ID", "Your AWS User ID Key (mandatory)") do | aws_user_id |
-
-        @key_values[:aws_user_id] = aws_user_id
-
-      end
-
-      the_options.on( "-p", "--aws-password AWS_PASSWORD", "Your AWS User Password (mandatory)") do | aws_password |
-
-        @key_values[:aws_password] = aws_password
-
-      end
-
-    end
-
-  end
-
-
-  # --
-  # -- Task does something (encrypts or decrypts) some text.
-  # --
-  # --  main command  => encrypt
-  # --  mandatory arg => --text=abc123 or -t
-  # --
-  # --
-  def read_task_args
-
-    ## ------------------------------------------------------------------ #
-    @task = true
-    @mandatory_options = [:service_descriptors]
-    ## ------------------------------------------------------------------ #
-    @options_parser = OptionParser.new do | the_options |
-
-      the_options.banner = "    eco encrypt --text   => options to encrypt [some text]\n\n"
-
-
-      the_options.on( "-w", "--what mongo,email,...", Array, "Comma separated descriptors (mandatory)") do | service_descriptors_list |
-
-        @key_values[:service_descriptors] = service_descriptors_list
-
-      end
-
-
-      the_options.on( "-n", "--name NAME", "The name (reference) of the encryptee.") do | name |
-
-        @key_values[:name] = name
-
-      end
-
-      the_options.on( "-f", "--file FILE", "The name of the file whose text is to be decrypted") do | file |
-
-        @key_values[:file] = file
-
-      end
-
-    end
-
-  end
-
-
-  ## --- -------------------------- --- ##
-  ## --- Read the DB Name Arguments --- ##
-  ## --- -------------------------- --- ##
-  def read_read_db_names_args
-
-    ## ---------------------------------------------------------- #
-    @do_read_db_names = true
-    @mandatory_options = [:read_db_names]
-    ## ---------------------------------------------------------- #
-    @options_parser = OptionParser.new do | the_options |
-
-      the_options.banner = "    eco read --s3   => reading names of customer databases in S3\n\n"
-
-      the_options.on( "-s", "--s3", "Available Customer DBs in S3") do
-
-        @key_values[:read_db_names] = true
-
-      end
-
-    end
-
-  end
-
-
-  ## --- -------------------------------------------------------- --- ##
-  ## --- Destroy and reclaim resources from created applications. --- ##
-  ## --- -------------------------------------------------------- --- ##
-  def read_destroy_app_args
-
-    ## ---------------------------------------------------------- #
-    @do_destroy_app = true
-    @mandatory_options = [:destroy_app, :key]
-    ## ---------------------------------------------------------- #
-    @options_parser = OptionParser.new do | the_options |
-
-      the_options.banner = "    eco destroy --app   => destroying an eco system\n\n"
-
-      the_options.on( "-a", "--app", "Destroy enterprise application") do
-
-        @key_values[:destroy_app] = true
-
-      end
-
-      the_options.on( "-k", "--key APP_KEY", "Key (ref) of app to delete (mandatory)") do | key_value |
-
-        @key_values[:key] = key_value
-
-      end
-
-    end
-
-  end
-
-
-  ## --- --------------------------------------------------------- --- ##
-  ## --- How to use Declarative and Dynamic Command Interpretation --- ##
-  ## --- --------------------------------------------------------- --- ##
-  ## --- 
-  ## --- Once SREs are familiar with this command interpreter class
-  ## --- the next refactor step is to generate the whole thing dynamically.
-  ## --- I will probably write a ruby gem to do exactly this.
-  ## --- 
-  ## --- The essence is to create a JSON or YAML configuration file that
-  ## --- holds the command line interpretation variables. This is used to
-  ## --- dynamically generate the optparse blocks.
-  ## --- 
-  ## --- --------------------------------------------------------- --- ##
-  ## --- How to use Dynamically Generate the Help Screen           --- ##
-  ## --- --------------------------------------------------------- --- ##
-  ## --- 
-  ## --- To generate the help screen you can loop round calling each
-  ## --- parser block (without any actual cmd line arguments)!
-  ## --- 
-  ## --- Then you loop doing a to_string puts opt_parser for each
-  ## --- parser and all the options will be ejected automatically!
-  ## --- 
-  ## --- --------------------------------------------------------- --- ##
-
-  def print_help_screen
-
-    read_eco_create_args
-    args_documented = @options_parser.to_s
-    read_aws_register_args
-    args_documented = "#{args_documented}\n\n#{@options_parser.to_s}"
-    read_read_db_names_args
-    args_documented = "#{args_documented}\n\n#{@options_parser.to_s}"
-    read_destroy_app_args
-    args_documented = "#{args_documented}\n\n#{@options_parser.to_s}"
-
-    if false then
-      log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-      log.warn(ere) { "    # --- create executable  => =>  [only for DevOps and SRE personnel]         --- #" }
-      log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-
-      log.warn(ere) { "        ruby eco-invoke.rb [do] [what]" }
-      log.warn(ere) { "        ruby eco-invoke.rb [create] [--exe]" }
-      log.warn(ere) { "        ruby eco-invoke.rb create --exe" }
-    end
-
-    log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-    log.warn(ere) { "    # --- eco peripheral commands                                               --- #" }
-    log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-    log.warn(ere) { "        eco --help" }
-    log.warn(ere) { "        eco -h" }
-    log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-    log.warn(ere) { "    # --- eco arguments documentation                                           --- #" }
-    log.warn(ere) { "    # --- --------------------------------------------------------------------- --- #" }
-    log.warn(ere) { args_documented }
-
-    exit
-
-  end
-
-
-  # -- -------------------------------------------------------- #
-  # -- [Cold Call Pattern]                                   -- #
-  # --    If class has no [internal] dependencies it can     -- #
-  # --    initialize itself ignoring any require order.      -- #
-  # --                                                       -- #
-  # -- [Advantage of Cold Call Pattern]                      -- #
-  # --    The class [dependency] is not [hardcoded] into     -- #
-  # --    any other class. Others benefit from initialize    -- #
-  # --    activities without a create / handshake call.      -- #
-  # --                                                       -- #
-  # -- -------------------------------------------------------- #
-  CmdLine.instance
-
-
-end

data/lib/opensecret/eco.do.rb

@@ -1,46 +0,0 @@
-#!/usr/bin/ruby
-
-require 'pp'
-require 'json'
-require 'inifile'
-require 'singleton'
-require 'filesize'
-require 'tmpdir'
-require 'base64'
-require 'date'
-require 'etc'
-require 'optparse'
-require 'securerandom'
-require 'digest'
-require 'net/http'
-require 'net/ssh'
-require 'net/scp'
-require 'aws-sdk'
-require 'aws-sdk-resources'
-require 'nokogiri'
-require 'openssl'
-require 'io/console'
-
-# --
-# -- Require modules that read config and require modules
-# --
-require_relative '../iaas.tool.collection/user.home'
-require_relative '../iaas.tool.collection/throw.error'
-require_relative '../iaas.tool.collection/ruby.require'
-require_relative '../reusable.classes/logs/logging'
-
-
-# --
-# -- Flush logs destined for STDOUT immediately.
-# -- Do not wait for a full cache or script end.
-# --
-$stdout.sync = true
-
-include Logging
-
-log.debug(ere) { "Require of ruby modules has been completed." }
-
-EcoSystems.create
-
-exit
-