simplygenius-atmos 0.7.0

data/lib/atmos/commands/terraform.rb

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,208 @@
+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

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

data/lib/atmos/generator.rb

@@ -0,0 +1,199 @@
+require_relative '../atmos'
+require_relative '../atmos/ui'
+require 'thor'
+require 'find'
+
+module Atmos
+
+  # From https://github.com/rubber/rubber/blob/master/lib/rubber/commands/vulcanize.rb
+  class Generator < Thor
+
+    include Thor::Actions
+
+    def initialize(*args, **opts)
+      super
+      @dependencies = opts[:dependencies]
+    end
+
+    no_commands do
+
+      include GemLogger::LoggerSupport
+      include Atmos::UI
+
+      TEMPLATES_SPEC_FILE = 'templates.yml'
+      TEMPLATES_ACTIONS_FILE = 'templates.rb'
+
+      def self.valid_templates
+        all_entries = []
+        source_paths_for_search.collect do |path|
+          entries = []
+          if Dir.exist?(path)
+            Find.find(path) do |f|
+              Find.prune if File.basename(f) =~  /(^\.)|svn|CVS/
+
+              template_spec = File.join(f, TEMPLATES_SPEC_FILE)
+              if File.exist?(template_spec)
+                entries << f.sub(/^#{path}\//, '')
+                Find.prune
+              end
+            end
+            all_entries << entries.sort
+          else
+            logger.warn("Sourcepath does not exist: #{path}")
+          end
+        end
+
+        return all_entries.flatten
+      end
+
+      def valid_templates
+        self.class.valid_templates
+      end
+
+      def generate(template_names)
+        seen = Set.new
+        Array(template_names).each do |template_name|
+          template_dependencies = find_dependencies(template_name)
+          template_dependencies << template_name
+          template_dependencies.each do |tname|
+            apply_template(tname) unless seen.include?(tname)
+            seen << tname
+          end
+        end
+      end
+
+    end
+
+    protected
+
+    def template_dir(name)
+      template_dir = nil
+      source_path = nil
+      source_paths.each do |sp|
+        potential_template_dir = File.join(sp, name, '')
+        template_spec = File.join(sp, name, TEMPLATES_SPEC_FILE)
+        if File.exist?(template_spec) && File.directory?(potential_template_dir)
+          template_dir = potential_template_dir
+          source_path = sp
+          break
+        end
+      end
+
+      unless template_dir.present?
+        raise ArgumentError.new("Invalid template #{name}, use one of: #{valid_templates.join(', ')}")
+      end
+
+      return template_dir, source_path
+    end
+
+    def find_dependencies(name, seen=[])
+      template_dir, source_path = template_dir(name)
+
+      return [] unless @dependencies
+
+      if seen.include?(name)
+          seen << name
+          raise ArgumentError.new("Circular template dependency: #{seen.to_a.join(" => ")}")
+      end
+      seen << name
+
+      template_conf = load_template_config(template_dir)
+      template_dependencies = Set.new(Array(template_conf['dependent_templates'] || []))
+
+      template_dependencies.clone.each do |dep|
+        template_dependencies.merge(find_dependencies(dep, seen.dup))
+      end
+
+      return template_dependencies.to_a
+    end
+
+    def apply_template(name)
+      template_dir, source_path = template_dir(name)
+      logger.debug("Applying template '#{name}' from '#{template_dir}' in sourcepath '#{source_path}'")
+      template_conf = load_template_config(template_dir)
+
+      extra_generator_steps_file = File.join(template_dir, TEMPLATES_ACTIONS_FILE)
+
+      Find.find(template_dir) do |f|
+        Find.prune if f == File.join(template_dir, TEMPLATES_SPEC_FILE)  # don't copy over templates.yml
+        Find.prune if f == extra_generator_steps_file # 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(source_path, '')}/, '')
+        dest_rel   = source_rel.gsub(/^#{File.join(name, '')}/, '')
+
+        # prune non-directories at top level (the top level directory is the
+        # template dir itself)
+        if f !~ /\// && ! File.directory?(f)
+          Find.prune
+        end
+
+        # Only include optional files when their conditions eval to true
+        optional = template_conf['optional'][template_rel] rescue nil
+        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
+
+      if File.exist? extra_generator_steps_file
+        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
+      end
+    end
+
+    def load_template_config(template_dir)
+      YAML.load(File.read(File.join(template_dir, 'templates.yml'))) || {} rescue {}
+    end
+
+    def raw_config(yml_file)
+      @raw_configs ||= {}
+      @raw_configs[yml_file] ||= SettingsHash.new((YAML.load_file(yml_file) rescue {}))
+    end
+
+    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
+
+    def get_config(yml_file, key)
+      config = raw_config(yml_file)
+      config.notation_get(key)
+    end
+
+    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
+
+    # TODO make a context object for these actions, and populate it with things
+    # like template_dir from within apply
+    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