simplygenius-atmos 0.7.0

data/lib/atmos/commands/auth_exec.rb

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

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

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

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

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

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

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

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

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

data/lib/atmos/commands/plan.rb

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

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