simplygenius-atmos 0.7.1 → 0.8.0

data/lib/atmos/commands/plan.rb

@@ -1,20 +0,0 @@
-require_relative 'terraform'
-
-module Atmos::Commands
-
-  class Plan < Atmos::Commands::Terraform
-
-    def self.description
-      "Runs terraform plan"
-    end
-
-    def execute
-      args = ["plan"]
-      args << "--get-modules" unless Atmos.config["disable_auto_modules"].to_s == "true"
-      @terraform_arguments.insert(0, *args)
-      super
-    end
-
-  end
-
-end

data/lib/atmos/commands/secret.rb

@@ -1,87 +0,0 @@
-require_relative 'base_command'
-require 'climate_control'
-
-module Atmos::Commands
-
-  class Secret < BaseCommand
-
-    def self.description
-      "Manages application secrets"
-    end
-
-    subcommand "get", "Gets the secret value" do
-
-      parameter "KEY",
-                "The secret key"
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            value = Atmos.config.provider.secret_manager.get(key)
-            logger.info "Secret value for #{key}: #{value}"
-          end
-        end
-
-      end
-
-    end
-
-    subcommand "set", "Sets the secret value" do
-
-      parameter "KEY",
-                "The secret key"
-
-      parameter "VALUE",
-                "The secret value"
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            Atmos.config.provider.secret_manager.set(key, value)
-            logger.info "Secret set for #{key}"
-          end
-        end
-
-      end
-
-    end
-
-    subcommand "list", "Lists all secret keys" do
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            logger.info "Secret keys are:"
-            Atmos.config.provider.secret_manager.to_h.keys.each {|k| logger.info k}
-          end
-        end
-
-      end
-
-    end
-
-    subcommand "delete", "Deletes the secret key/value" do
-
-      parameter "KEY",
-                "The secret key"
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            value = Atmos.config.provider.secret_manager.get(key)
-            Atmos.config.provider.secret_manager.delete(key)
-            logger.info "Deleted secret: #{key}=#{value}"
-          end
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/atmos/commands/terraform.rb

@@ -1,52 +0,0 @@
-require_relative 'base_command'
-require_relative '../../atmos/terraform_executor'
-
-module Atmos::Commands
-
-  class Terraform < BaseCommand
-
-    def self.description
-      "Runs terraform"
-    end
-
-    # override so we can pass all options/flags/parameters directly to
-    # terraform instead of having clamp parse them
-    def parse(arguments)
-      @terraform_arguments = arguments
-    end
-
-    def execute
-
-      unless Atmos.config.is_atmos_repo?
-        signal_usage_error <<~EOF
-          Atmos can only run terraform from a location configured for atmos. 
-          Have you run atmos init?"
-        EOF
-      end
-
-      Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-        begin
-
-          # TODO: hack to allow apply/etc for bootstrap group
-          # Fix this once we allow more extensive recipe grouping
-          working_group = 'default'
-          @terraform_arguments.each_with_index do |a, i|
-            if a == "--group"
-              @terraform_arguments.delete_at(i)
-              working_group = @terraform_arguments.delete_at(i)
-              break
-            end
-          end
-
-          exe = Atmos::TerraformExecutor.new(process_env: auth_env, working_group: working_group)
-          get_modules = @terraform_arguments.delete("--get-modules")
-          exe.run(*@terraform_arguments, get_modules: get_modules.present?)
-        rescue Atmos::TerraformExecutor::ProcessFailed => e
-          logger.error(e.message)
-        end
-      end
-    end
-
-  end
-
-end

data/lib/atmos/commands/user.rb

@@ -1,74 +0,0 @@
-require_relative 'base_command'
-require 'climate_control'
-
-module Atmos::Commands
-
-  class User < BaseCommand
-
-    def self.description
-      "Manages users in the cloud provider"
-    end
-
-    subcommand "create", "Create a new user" do
-
-      option ["-f", "--force"],
-             :flag, "forces deletion/updates for pre-existing resources\n",
-             default: false
-
-      option ["-l", "--login"],
-             :flag, "generate a login password\n",
-             default: false
-
-      option ["-m", "--mfa"],
-             :flag, "setup a mfa device\n",
-             default: false
-
-      option ["-k", "--key"],
-             :flag, "create access keys\n",
-             default: false
-
-      option ["-p", "--public-key"],
-             "PUBLIC_KEY", "add ssh public key\n"
-
-      option ["-g", "--group"],
-             "GROUP",
-             "associate the given groups to new user\n",
-             multivalued: true
-
-      parameter "USERNAME",
-                "The username of the user to add\nShould be an email address" do |u|
-        raise ArgumentError.new("Not an email") if u !~ URI::MailTo::EMAIL_REGEXP
-        u
-      end
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            manager = Atmos.config.provider.user_manager
-            user = manager.create_user(username)
-            user.merge!(manager.set_groups(username, group_list, force: force?)) if group_list.present?
-            user.merge!(manager.enable_login(username, force: force?)) if login?
-            user.merge!(manager.enable_mfa(username, force: force?)) if mfa?
-            user.merge!(manager.enable_access_keys(username, force: force?)) if key?
-            user.merge!(manager.set_public_key(username, public_key, force: force?)) if public_key.present?
-
-            logger.info "\nUser created:\n#{display user}\n"
-
-            if  mfa? && user[:mfa_secret]
-              save_mfa = agree("Save the MFA secret for runtime integration with auth? ") {|q|
-                q.default = 'y'
-              }
-              Atmos::Otp.instance.save if save_mfa
-            end
-
-          end
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/atmos/config.rb

@@ -1,208 +0,0 @@
-require_relative '../atmos'
-require_relative '../atmos/settings_hash'
-require_relative '../atmos/provider_factory'
-require 'yaml'
-require 'fileutils'
-require 'find'
-
-module Atmos
-  class Config
-    include GemLogger::LoggerSupport
-    include FileUtils
-
-    attr_accessor :atmos_env, :root_dir,
-                  :config_file, :configs_dir,
-                  :tmp_root
-
-    def initialize(atmos_env)
-      @atmos_env = atmos_env
-      @root_dir = File.expand_path(Dir.pwd)
-      @config_file = File.join(root_dir, "config", "atmos.yml")
-      @configs_dir = File.join(root_dir, "config", "atmos")
-      @tmp_root = File.join(root_dir, "tmp")
-    end
-
-    def is_atmos_repo?
-      File.exist?(config_file)
-    end
-
-    def [](key)
-      load
-      result = @config.notation_get(key)
-      return result
-    end
-
-    def to_h
-      load
-      @config.to_hash
-    end
-
-    def provider
-      @provider ||= Atmos::ProviderFactory.get(self[:provider])
-    end
-
-    def all_env_names
-      load
-      @full_config[:environments].keys
-    end
-
-    def account_hash
-      load
-      environments = @full_config[:environments] || {}
-      environments.inject(Hash.new) do |accum, entry|
-        accum[entry.first] = entry.last[:account_id]
-        accum
-      end
-    end
-
-    def tmp_dir
-      @tmp_dir ||= begin
-        dir = File.join(tmp_root, atmos_env)
-        logger.debug("Tmp dir: #{dir}")
-        mkdir_p(dir)
-        dir
-      end
-    end
-
-    def auth_cache_dir
-      @auth_cache_dir ||= begin
-        dir = File.join(tmp_dir, 'auth')
-        logger.debug("Auth cache dir: #{dir}")
-        mkdir_p(dir)
-        dir
-      end
-    end
-
-    def tf_working_dir(group='default')
-      @tf_working_dir ||= {}
-      @tf_working_dir[group] ||= begin
-        dir = File.join(tmp_dir, 'tf', group)
-        logger.debug("Terraform working dir: #{dir}")
-        mkdir_p(dir)
-        dir
-      end
-    end
-
-    private
-
-    INTERP_PATTERN = /(\#\{([^\}]+)\})/
-
-    def load
-      @config ||= begin
-
-        logger.debug("Atmos env: #{atmos_env}")
-
-        if ! File.exist?(config_file)
-          logger.warn "Could not find an atmos config file at: #{config_file}"
-          # raise RuntimeError.new("Could not find an atmos config file at: #{config_file}")
-        end
-
-        logger.debug("Loading atmos config file #{config_file}")
-        @full_config = SettingsHash.new((YAML.load_file(config_file) rescue Hash.new))
-
-        if Dir.exist?(configs_dir)
-         logger.debug("Loading atmos config files from #{configs_dir}")
-         Find.find(configs_dir) do |f|
-           if f =~ /\.ya?ml/i
-             logger.debug("Loading atmos config file: #{f}")
-             h = SettingsHash.new(YAML.load_file(f))
-             @full_config = @full_config.merge(h)
-           end
-         end
-        else
-         logger.debug("Atmos config dir doesn't exist: #{configs_dir}")
-        end
-
-        @full_config['provider'] = provider_name = @full_config['provider'] || 'aws'
-        global = SettingsHash.new(@full_config.reject {|k, v| ['environments', 'providers'].include?(k) })
-        begin
-          prov = @full_config.deep_fetch(:providers, provider_name)
-        rescue
-          logger.debug("No provider config found for '#{provider_name}'")
-          prov = {}
-        end
-
-        begin
-          env = @full_config.deep_fetch(:environments, atmos_env)
-        rescue
-          logger.debug("No environment config found for '#{atmos_env}'")
-          env = {}
-        end
-
-        conf = global.deep_merge(prov).
-           deep_merge(env).
-           deep_merge(
-               atmos_env: atmos_env,
-               atmos_version: Atmos::VERSION
-           )
-        expand(conf, conf)
-      end
-    end
-
-    def expand(config, obj)
-      case obj
-        when Hash
-          SettingsHash.new(Hash[obj.collect {|k, v| [k, expand(config, v)] }])
-        when Array
-          obj.collect {|i| expand(config, i) }
-        when String
-          result = obj
-          result.scan(INTERP_PATTERN).each do |substr, statement|
-            # TODO: check for cycles
-            if statement =~ /^[\w\.\[\]]$/
-              val = config.notation_get(statement)
-            else
-              # TODO: be consistent with dot notation between eval and
-              # notation_get.  eval ends up calling Hashie method_missing,
-              # which returns nil if a key doesn't exist, causing a nil
-              # exception for next item in chain, while notation_get returns
-              # nil gracefully for the entire chain (preferred)
-              begin
-                val = eval(statement, config.instance_eval("binding"))
-              rescue => e
-                file, line = find_config_error(substr)
-                file_msg = file.nil? ? "" : " in #{File.basename(file)}:#{line}"
-                raise RuntimeError.new("Failing config statement '#{substr}'#{file_msg} => #{e.class} #{e.message}")
-              end
-            end
-            result = result.sub(substr, expand(config, val).to_s)
-          end
-          result = true if result == 'true'
-          result = false if result == 'false'
-          result
-        else
-          obj
-      end
-    end
-
-    def find_config_error(statement)
-      filename = nil
-      line = 0
-
-      configs = []
-      configs << config_file if File.exist?(config_file)
-      if Dir.exist?(configs_dir)
-        Find.find(configs_dir) do |f|
-          if f =~ /\.ya?ml/i
-            configs << f
-          end
-        end
-      end
-
-      configs.each do |c|
-        current_line = 0
-        File.foreach(c) do |f|
-          current_line += 1
-          if f.include?(statement)
-            filename = c
-            line = current_line
-            break
-          end
-        end
-      end
-
-      return filename, line
-    end
-  end
-
-end

data/lib/atmos/exceptions.rb

@@ -1,9 +0,0 @@
-require_relative '../atmos'
-
-module Atmos
-  module Exceptions
-    class UsageError < Clamp::UsageError
-
-    end
-  end
-end