simplygenius-atmos 0.7.1 → 0.8.0

data/lib/simplygenius/atmos/commands/user.rb

@@ -0,0 +1,78 @@
+require_relative 'base_command'
+require 'climate_control'
+
+module SimplyGenius
+  module Atmos
+    module 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
+  end
+end

data/lib/simplygenius/atmos/config.rb

@@ -0,0 +1,279 @@
+require_relative '../atmos'
+require_relative '../atmos/settings_hash'
+require_relative '../atmos/provider_factory'
+require_relative '../atmos/plugin_manager'
+require 'yaml'
+require 'fileutils'
+require 'find'
+
+module SimplyGenius
+  module Atmos
+
+    class Config
+      include GemLogger::LoggerSupport
+      include FileUtils
+
+      attr_accessor :atmos_env, :root_dir,
+                    :config_file,
+                    :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")
+        @tmp_root = File.join(root_dir, "tmp")
+        @included_configs = []
+      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 ||= ProviderFactory.get(self[:provider])
+      end
+
+      def plugin_manager
+        @plugin_manager ||= PluginManager.new(self[:plugins])
+      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
+
+      def add_user_load_path(*paths)
+        load_path = paths + Array(self[:load_path])
+        if load_path.present?
+          load_path = load_path.collect { |path| File.expand_path(path) }
+          logger.debug("Adding to load path: #{load_path.inspect}")
+          $LOAD_PATH.insert(0, *load_path)
+        end
+      end
+
+      private
+
+      INTERP_PATTERN = /(\#\{([^\}]+)\})/
+
+      def config_merge(lhs, rhs)
+        result = nil
+
+        return rhs if lhs.nil?
+        return lhs if rhs.nil?
+
+        # Warn if user fat fingered config
+        unless lhs.is_a?(rhs.class) || rhs.is_a?(lhs.class)
+          logger.warn("Different types in deep merge: #{lhs.class}, #{rhs.class}")
+        end
+
+        case rhs
+        when Hash
+          result = lhs.deep_dup
+
+          lhs.each do |k, v|
+            if k =~ /^\^(.*)/
+              key = k.is_a?(Symbol) ? $1.to_sym : $1
+              result[key] = result.delete(k)
+            end
+          end
+
+          rhs.each do |k, v|
+            if k =~ /^\^(.*)/
+              key = k.is_a?(Symbol) ? $1.to_sym : $1
+              result[key] = v
+            else
+              result[k] = config_merge(result[k], v)
+            end
+          end
+        when Enumerable
+          result = lhs + rhs
+        else
+          result = rhs
+        end
+
+        return result
+      end
+
+      def load_config_sources(relative_root, config, *patterns)
+        patterns.each do |pattern|
+          logger.debug("Loading atmos config files using pattern: #{pattern}")
+
+          # relative to main atmos config file unless qualified
+          if pattern !~ /^[\/~]/
+            pattern = File.join(relative_root, pattern)
+          end
+          # expand to handle tilde/etc
+          pattern = File.expand_path(pattern)
+          logger.debug("Expanded pattern: #{pattern}")
+
+          Dir[pattern].each do |f|
+            logger.debug("Loading atmos config file: #{f}")
+            h = SettingsHash.new(YAML.load_file(f))
+            config = config_merge(config, h)
+            @included_configs << f
+          end
+        end
+
+        config
+      end
+
+      def load_submap(relative_root, group, name, config)
+        submap_dir = File.join(relative_root, 'atmos', group)
+        submap_file = File.join(submap_dir, "#{name}.yml")
+        if File.exist?(submap_file)
+          logger.debug("Loading atmos #{group} config file: #{submap_file}")
+          h = SettingsHash.new({group => {name => YAML.load_file(submap_file)}})
+          config = config_merge(config, h)
+          @included_configs << submap_file
+        end
+
+        begin
+          submap = config.deep_fetch(group, name)
+          config = config_merge(config, submap)
+        rescue
+          logger.debug("No #{group} config found for '#{name}'")
+        end
+
+        config
+      end
+
+      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}"
+            @full_config = SettingsHash.new
+          else
+            logger.debug("Loading atmos config file #{config_file}")
+            @full_config = SettingsHash.new(YAML.load_file(config_file))
+            @included_configs << config_file
+          end
+
+          @full_config = load_config_sources(File.dirname(config_file), @full_config, *Array(@full_config[:config_sources]))
+
+          @full_config['provider'] = provider_name = @full_config['provider'] || 'aws'
+
+          @full_config = load_submap(File.dirname(config_file), 'providers', provider_name, @full_config)
+          @full_config = load_submap(File.dirname(config_file), 'environments', atmos_env, @full_config)
+
+          global = SettingsHash.new(@full_config.reject {|k, v| ['providers', 'environments'].include?(k) })
+          conf = config_merge(global, {
+              atmos_env: atmos_env,
+              atmos_version: 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
+            result = obj.collect {|i| expand(config, i) }
+            # HACK: accounting for the case when someone wants to force an override using '^' as the first list item, when
+            # there is no upstream to override (i.e. merge proc doesn't get triggered as key is unique, so just added verbatim)
+            result.delete_at(0) if result[0] == "^"
+            result
+          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
+
+        @included_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
+end

data/lib/simplygenius/atmos/exceptions.rb

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

data/lib/simplygenius/atmos/generator.rb

@@ -0,0 +1,232 @@
+require_relative '../atmos'
+require_relative '../atmos/ui'
+require 'thor'
+require 'find'
+
+module SimplyGenius
+  module Atmos
+
+    # From https://github.com/rubber/rubber/blob/master/lib/rubber/commands/vulcanize.rb
+    class Generator
+
+      include GemLogger::LoggerSupport
+
+      attr_reader :visited_templates
+
+      def initialize(**opts)
+        if opts.has_key?(:dependencies)
+          @dependencies = opts.delete(:dependencies)
+        else
+          @dependencies = true
+        end
+        @thor_opts = opts
+        @thor_generators = {}
+        @resolved_templates = {}
+        @visited_templates = []
+      end
+
+      def generate(*template_names, context: {})
+        seen = Set.new
+
+        template_names.each do |template_name|
+
+          # clone since we are mutating context and can be called from within a
+          # template, walk_deps also clones
+          tmpl = SourcePath.find_template(template_name)
+          tmpl.clone.context.merge!(context)
+
+          if @dependencies
+            deps = tmpl.walk_dependencies.to_a
+          else
+            deps = [tmpl]
+          end
+
+          deps.each do |dep_tmpl|
+            seen_tmpl = [dep_tmpl.name, dep_tmpl.scoped_context]
+            unless seen.include?(seen_tmpl)
+              apply_template(dep_tmpl)
+            end
+            seen <<  seen_tmpl
+          end
+
+        end
+
+        return visited_templates
+      end
+
+      def apply_template(tmpl)
+        @thor_generators[tmpl.source] ||= Class.new(ThorGenerator) do
+          source_root tmpl.source.directory
+        end
+
+        gen = @thor_generators[tmpl.source].new(tmpl, self, **@thor_opts)
+        gen.apply
+        visited_templates << tmpl
+
+        gen # makes testing easier by giving a handle to thor generator instance
+      end
+
+      protected
+
+      class ThorGenerator < Thor
+
+        include Thor::Actions
+        attr_reader :tmpl, :parent
+
+        def initialize(tmpl, parent, **opts)
+          @tmpl = tmpl
+          @parent = parent
+          super([], **opts)
+        end
+
+        no_commands do
+
+          include GemLogger::LoggerSupport
+          include UI
+
+          def apply
+            template_dir = tmpl.directory
+            path = tmpl.source.directory
+
+            logger.debug("Applying template '#{tmpl.name}' from '#{template_dir}' in sourcepath '#{path}'")
+
+            Find.find(template_dir) do |f|
+              next if f == template_dir  # don't create a directory for the template dir itself, but don't prune so we recurse
+              Find.prune if f == tmpl.config_path  # don't copy over templates.yml
+              Find.prune if f == tmpl.actions_path # don't copy over templates.rb
+
+              # Using File.join(x, '') to ensure trailing slash to make sure we end
+              # up with a relative path
+              template_rel = f.gsub(/#{File.join(template_dir, '')}/, '')
+              source_rel = f.gsub(/#{File.join(path, '')}/, '')
+              dest_rel   = source_rel.gsub(/^#{File.join(tmpl.name, '')}/, '')
+
+              # Only include optional files when their conditions eval to true
+              optional = tmpl.optional[template_rel]
+              if optional
+                exclude = ! eval(optional)
+                logger.debug("Optional template '#{template_rel}' with condition: '#{optional}', excluding=#{exclude}")
+                Find.prune if exclude
+              end
+
+              logger.debug("Template '#{source_rel}' => '#{dest_rel}'")
+              if File.directory?(f)
+                empty_directory(dest_rel)
+              else
+                copy_file(source_rel, dest_rel, mode: :preserve)
+              end
+            end
+
+            eval tmpl.actions, binding, tmpl.actions_path
+          end
+
+          def context
+            tmpl.context
+          end
+
+          def scoped_context
+            tmpl.scoped_context
+          end
+
+          def lookup_context(varname)
+            varname.blank? ? nil: tmpl.scoped_context[varname]
+          end
+
+          def track_context(varname, value)
+            varname.blank? || value.nil? ? nil: tmpl.scoped_context[varname] = value
+          end
+
+          def respond_to_missing?(method_name, *args)
+            scoped_context.respond_to_missing?(method_name, *args)
+          end
+
+          def method_missing(method_name, *args, &blk)
+            scoped_context.method_missing(method_name, *args, &blk)
+          end
+
+        end
+
+        desc "ask <question string> [varname: name]", "Asks a question, allowing context to provide answer using varname"
+        def ask(question, answer_type = nil, varname: nil, &details)
+          result = lookup_context(varname)
+          if result.nil?
+            result = super(question, answer_type, &details)
+          end
+          track_context(varname, result)
+          result
+        end
+
+        desc "agree <question string> [varname: name]", "Asks a Y/N question, allowing context to provide answer using varname"
+        def agree(question, character = nil, varname: nil, &details)
+          result = lookup_context(varname)
+          if result.nil?
+            result = super(question, character, &details)
+          end
+          result = !!result
+          track_context(varname, result)
+          result
+        end
+
+        desc "choose menu_block [varname: name]", "Provides a menu with choices, allowing context to provide answer using varname"
+        def choose(*items, varname: nil, &details)
+          result = lookup_context(varname)
+          if result.nil?
+            result = super(*items, &details)
+          end
+          track_context(varname, result)
+          result
+        end
+
+        desc "generate <tmpl_name> [context_hash]", "Generates the given template with optional context"
+        def generate(name, ctx: context)
+          parent.generate(name, context: ctx.clone)
+        end
+
+        desc "raw_config <yml_filename>", "Loads yml file"
+        def raw_config(yml_file)
+          @raw_configs ||= {}
+          @raw_configs[yml_file] ||= SettingsHash.new((YAML.load_file(yml_file) rescue {}))
+        end
+
+        desc "add_config <yml_filename> <key> <value> [additive: true]", "Adds config to yml file if not there (additive=true)"
+        def add_config(yml_file, key, value, additive: true)
+          new_yml = SettingsHash.add_config(yml_file, key, value, additive: additive)
+          create_file yml_file, new_yml
+          @raw_configs.delete(yml_file) if @raw_configs
+        end
+
+        desc "get_config <yml_filename> <key>", "Gets value of key (dot-notation for nesting) from yml file"
+        def get_config(yml_file, key)
+          config = raw_config(yml_file)
+          config.notation_get(key)
+        end
+
+        desc "config_present? <yml_filename> <key> <value>", "Tests if key is in yml file and equal to value if supplied"
+        def config_present?(yml_file, key, value=nil)
+          val = get_config(yml_file, key)
+
+          result = val.present?
+          if value && result
+            if val.is_a?(Array)
+              result = Array(value).all? {|v| val.include?(v) }
+            else
+              result = (val == value)
+            end
+          end
+
+          return result
+        end
+
+        desc "new_keys? <src_yml_filename> <dest_yml_filename>", "Tests if src yml has top level keys not present in dest yml"
+        def new_keys?(src_yml_file, dest_yml_file)
+          src = raw_config(src_yml_file).keys.sort
+          dest = raw_config(dest_yml_file).keys.sort
+          (src - dest).size > 0
+        end
+
+      end
+
+    end
+
+  end
+end