simplygenius-atmos 0.7.1 → 0.8.0

data/lib/atmos/commands/account.rb

@@ -1,65 +0,0 @@
-require_relative 'base_command'
-require_relative '../../atmos/settings_hash'
-require 'climate_control'
-
-module Atmos::Commands
-
-  class Account < BaseCommand
-
-    def self.description
-      "Manages accounts/envs in the cloud provider"
-    end
-
-    subcommand "create", "Create a new account" do
-
-      option ["-s", "--source-env"],
-             "SOURCE_ENV", "Base the new env on a clone of the given one\n"
-
-      option ["-e", "--email"],
-             "EMAIL", "override default email used for new account\n"
-
-      option ["-n", "--name"],
-             "NAME", "override default name used for new account\n"
-
-      parameter "ENV",
-                "The name of the new env to create"
-
-      def execute
-
-        Atmos.config.provider.auth_manager.authenticate(ENV) do |auth_env|
-          ClimateControl.modify(auth_env) do
-
-            config = YAML.load_file(Atmos.config.config_file)
-
-            if config['environments'][env]
-              signal_usage_error "Env '#{env}' is already present in atmos config"
-            end
-
-            source = {}
-            if source_env.present?
-              source = config['environments'][source_env]
-              if source.blank?
-                signal_usage_error "Source env '#{source_env}' does not exist"
-              end
-              source = source.clone
-            end
-
-            account = Atmos.config.provider.account_manager.create_account(env, name: name, email: email)
-            logger.info "Account created: #{display account}"
-
-            source['account_id'] = account[:account_id].to_s
-
-            new_yml = Atmos::SettingsHash.add_config(
-                Atmos.config.config_file,
-                "environments.#{env}", source
-            )
-            logger.info("Writing out new atmos.yml containing new account")
-            File.write(Atmos.config.config_file, new_yml)
-          end
-        end
-      end
-    end
-
-  end
-
-end

data/lib/atmos/commands/apply.rb

@@ -1,20 +0,0 @@
-require_relative 'terraform'
-
-module Atmos::Commands
-
-  class Apply < Atmos::Commands::Terraform
-
-    def self.description
-      "Runs terraform apply"
-    end
-
-    def execute
-      args = ["apply"]
-      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/auth_exec.rb

@@ -1,29 +0,0 @@
-require_relative 'base_command'
-require 'climate_control'
-
-module Atmos::Commands
-
-  class AuthExec < BaseCommand
-
-    def self.description
-      "Exec subprocess with an authenticated environment"
-    end
-
-    option ["-r", "--role"],
-           'ROLE', "overrides assume role name\n"
-
-    parameter "COMMAND ...", "command to exec", :attribute_name => :command
-
-    def execute
-      Atmos.config.provider.auth_manager.authenticate(ENV, role: role) do |auth_env|
-        result = system(auth_env, *command)
-        if ! result
-          logger.error("Process failed: #{command}")
-          exit(1)
-        end
-      end
-
-    end
-
-  end
-end

data/lib/atmos/commands/base_command.rb

@@ -1,12 +0,0 @@
-require_relative '../../atmos'
-require_relative '../../atmos/ui'
-require 'clamp'
-
-module Atmos::Commands
-
-  class BaseCommand < Clamp::Command
-    include GemLogger::LoggerSupport
-    include Atmos::UI
-  end
-
-end

data/lib/atmos/commands/bootstrap.rb

@@ -1,72 +0,0 @@
-require_relative 'base_command'
-
-module Atmos::Commands
-
-  class Bootstrap < BaseCommand
-
-    def self.description
-      "Sets up the initial aws account for use by atmos"
-    end
-
-    option ["-f", "--force"],
-           :flag, "forces bootstrap\n"
-
-    def execute
-
-      tf_init_dir = File.join(Atmos.config.tf_working_dir('bootstrap'), '.terraform')
-      tf_initialized = File.exist?(tf_init_dir)
-      backend_initialized = File.exist?(File.join(tf_init_dir, 'terraform.tfstate'))
-
-      rebootstrap_msg = <<~EOF
-        Bootstrap should only be performed when provisioning an account for the first
-        time.  Try 'atmos terraform init'
-      EOF
-
-      if !force? && tf_initialized
-        signal_usage_error(rebootstrap_msg)
-      end
-
-      Atmos.config.provider.auth_manager.authenticate(ENV, bootstrap: true) do |auth_env|
-        begin
-          exe = Atmos::TerraformExecutor.new(process_env: auth_env, working_group: 'bootstrap')
-
-          skip_backend = true
-          skip_secrets = true
-          if backend_initialized
-            skip_backend = false
-            skip_secrets = false
-          end
-
-          # Cases
-          # 1) bootstrap of new account - success
-          # 2) repeating bootstrap of new account due to failure partway - success
-          # 3) try to rebootstrap existing account on fresh checkout - should fail trying to create resources of same name, check output for this?
-          # 4) bootstrap new account with no-default secrets
-
-          # Need to init before we can create the resources to store state in bootstrap
-          exe.run("init", "-input=false", "-lock=false",
-                  skip_backend: true, skip_secrets: true)
-
-          # Bootstrap to create the resources needed to store state
-          exe.run("apply", "-input=false",
-                  skip_backend: true, skip_secrets: true)
-
-          # Need to init to setup the backend state after we create the resources
-          # to store state in bootstrap
-          exe.run("init", "-input=false", "-force-copy", skip_secrets: true)
-
-          # Might as well init the non-bootstrap case as well once the state
-          # storage has been setup in bootstrap
-          exe = Atmos::TerraformExecutor.new(process_env: auth_env)
-          exe.run("init", "-input=false", skip_secrets: true)
-
-        rescue Atmos::TerraformExecutor::ProcessFailed => e
-          logger.error(e.message)
-          logger.error(rebootstrap_msg)
-        end
-      end
-    end
-
-  end
-
-end

data/lib/atmos/commands/container.rb

@@ -1,58 +0,0 @@
-require_relative 'base_command'
-require_relative '../../atmos/settings_hash'
-require 'climate_control'
-
-module Atmos::Commands
-
-  class Container < BaseCommand
-
-    def self.description
-      "Manages containers in the cloud provider"
-    end
-
-    subcommand "deploy", "Deploy a container" do
-
-      option ["-c", "--cluster"],
-             "CLUSTER", "The cluster name\n",
-             required: true
-
-      option ["-r", "--role"],
-             "ROLE", "The role to assume when deploying\n"
-
-      option ["-i", "--image"],
-             "IMAGE", "The local container image to deploy\nDefaults to service/task name"
-
-      option ["-t", "--task"],
-             :flag, "Deploy as a task, not a service\n"
-
-      option ["-v", "--revision"],
-             "REVISION", "Use as the remote image revision\n"
-
-      parameter "NAME",
-                "The name of the service (or task) to deploy"
-
-      def default_image
-        name
-      end
-
-      def execute
-        Atmos.config.provider.auth_manager.authenticate(ENV, role: role) do |auth_env|
-          ClimateControl.modify(auth_env) do
-            mgr = Atmos.config.provider.container_manager
-
-            result = mgr.push(name, image, revision: revision)
-            if task?
-              result = result.merge(mgr.deploy_task(name, result[:remote_image]))
-            else
-              result = result.merge(mgr.deploy_service(cluster, name, result[:remote_image]))
-            end
-
-            logger.info "Container deployed:\n #{display result}"
-          end
-        end
-      end
-    end
-
-  end
-
-end

data/lib/atmos/commands/destroy.rb

@@ -1,18 +0,0 @@
-require_relative 'terraform'
-
-module Atmos::Commands
-
-  class Destroy < Atmos::Commands::Terraform
-
-    def self.description
-      "Runs terraform destroy"
-    end
-
-    def execute
-      @terraform_arguments.insert(0, "destroy")
-      super
-    end
-
-  end
-
-end

data/lib/atmos/commands/generate.rb

@@ -1,90 +0,0 @@
-require_relative 'base_command'
-require_relative '../../atmos/generator_factory'
-require_relative '../../atmos/utils'
-
-module Atmos::Commands
-
-  # From https://github.com/rubber/rubber/blob/master/lib/rubber/commands/vulcanize.rb
-  class Generate < BaseCommand
-
-    def self.description
-      <<~EOF
-        Installs configuration templates used by atmos to create infrastructure
-        resources e.g.
-        
-          atmos generate aws-vpc
-        
-        use --list to get a list of the template names for a given sourceroot
-      EOF
-    end
-
-    option ["-f", "--force"],
-           :flag, "Overwrite files that already exist"
-    option ["-n", "--dryrun"],
-           :flag, "Run but do not make any changes"
-    option ["-q", "--quiet"],
-           :flag, "Supress status output"
-    option ["-s", "--skip"],
-           :flag, "Skip files that already exist"
-    option ["-d", "--[no-]dependencies"],
-           :flag, "Walk dependencies, or not", default: true
-    option ["-l", "--list"],
-           :flag, "list available templates\n"
-    option ["-p", "--sourcepath"],
-           "PATH", "find templates at given path or github url\n",
-           multivalued: true
-
-    parameter "TEMPLATE ...", "atmos template(s)", required: false
-
-    def execute
-      signal_usage_error "template name is required" if template_list.blank? && ! list?
-
-      # don't want to fail for new repo
-      if  Atmos.config && Atmos.config.is_atmos_repo?
-        config_sourcepaths = Atmos.config['template_sources'].try(:collect, &:location) || []
-        sourcepath_list.concat(config_sourcepaths)
-      end
-
-      # Always search for templates against the bundled templates directory
-      sourcepath_list << File.expand_path('../../../../templates', __FILE__)
-
-      g = Atmos::GeneratorFactory.create(sourcepath_list,
-                                         force: force?,
-                                         pretend: dryrun?,
-                                         quiet: quiet?,
-                                         skip: skip?,
-                                         dependencies: dependencies?)
-      if list?
-        logger.info "Valid templates are:"
-        list_templates(g, template_list).each {|l| logger.info(l) }
-      else
-        g.generate(template_list)
-      end
-
-    end
-
-    def list_templates(generator, name_filters)
-      # Format templates into comma-separated paragraph with limt of 70 characters per line
-      filtered_names = generator.valid_templates.select do |name|
-        name_filters.blank? || name_filters.any? {|f| name =~ /#{f}/ }
-      end
-
-      lines = ['']
-      filtered_names.each do |template_name|
-        line = lines.last
-        if line.size == 0
-          line << template_name
-        elsif line.size + template_name.size > 68
-          line << ','
-          lines << template_name # new line
-        else
-          line << ", " + template_name
-        end
-      end
-
-      return lines
-    end
-
-  end
-
-end

data/lib/atmos/commands/init.rb

@@ -1,18 +0,0 @@
-require_relative 'terraform'
-
-module Atmos::Commands
-
-  class Init < Atmos::Commands::Terraform
-
-    def self.description
-      "Runs terraform init"
-    end
-
-    def execute
-      @terraform_arguments.insert(0, "init")
-      super
-    end
-
-  end
-
-end

data/lib/atmos/commands/new.rb

@@ -1,18 +0,0 @@
-require_relative 'generate'
-
-module Atmos::Commands
-
-  class New < Atmos::Commands::Generate
-
-    def self.description
-      "Sets up a new atmos project in the current directory"
-    end
-
-    def execute
-      template_list << "new"
-      super
-    end
-
-  end
-
-end

data/lib/atmos/commands/otp.rb

@@ -1,54 +0,0 @@
-require_relative 'base_command'
-require_relative '../../atmos/otp'
-require 'clipboard'
-
-module Atmos::Commands
-
-  class Otp < BaseCommand
-
-    def self.description
-      "Generates an otp token for the given user"
-    end
-
-    option ["-s", "--secret"],
-           'SECRET', "The otp secret\nWill save for future use"
-
-    option ["-c", "--clipboard"],
-           :flag,
-           <<~EOF
-            Automatically copy the token to the system
-            clipboard.  For dependencies see:
-            https://github.com/janlelis/clipboard
-            EOF
-
-    parameter "NAME",
-              "The otp name (IAM username)"
-
-    def execute
-      code = nil
-      if secret
-        Atmos::Otp.instance.add(name, secret)
-        code = Atmos::Otp.instance.generate(name)
-        Atmos::Otp.instance.save
-      else
-        code = Atmos::Otp.instance.generate(name)
-      end
-
-      if code.nil?
-        signal_usage_error <<~EOF
-          No otp secret has been setup for #{name}
-          Use the -m flag to 'atmos user create' to create/activate one
-          or associate an existing secret with 'atmos otp -s <secret> <name>'
-        EOF
-      else
-        puts code
-      end
-
-      if clipboard?
-        Clipboard.copy(code)
-      end
-    end
-
-  end
-
-end