terraform-enterprise-cli 0.0.6

data/bin/tfe

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require File.expand_path('../../lib/terraform-enterprise-command-line', __FILE__)

data/lib/terraform-enterprise-command-line.rb

@@ -0,0 +1,79 @@
+require 'thor'
+
+require_relative 'terraform_enterprise/command_line/command'
+require_relative 'terraform_enterprise/command_line/commands/configuration_versions'
+require_relative 'terraform_enterprise/command_line/commands/oauth_tokens'
+require_relative 'terraform_enterprise/command_line/commands/organizations'
+require_relative 'terraform_enterprise/command_line/commands/policies'
+require_relative 'terraform_enterprise/command_line/commands/policy_checks'
+require_relative 'terraform_enterprise/command_line/commands/runs'
+require_relative 'terraform_enterprise/command_line/commands/teams'
+require_relative 'terraform_enterprise/command_line/commands/variables'
+require_relative 'terraform_enterprise/command_line/commands/workspaces'
+
+module TerraformEnterprise
+  # Terraform Enterprise Command Line class
+  class MainCommand < TerraformEnterprise::CommandLine::Command
+    include TerraformEnterprise::CommandLine
+
+    desc 'organizations <subcommand>', 'Manage organizations'
+    subcommand 'organizations', OrganizationsCommand
+
+    desc 'workspaces <subcommand>', 'Manage workspaces'
+    subcommand 'workspaces', WorkspacesCommand
+
+    desc 'oauth-tokens <subcommand>', 'Manage OAuth tokens'
+    subcommand 'oauth_tokens', OAuthTokensCommand
+
+    desc 'teams <subcommand>', 'Manage teams'
+    subcommand 'teams', TeamsCommand
+
+    desc 'variables <subcommand>', 'Manage variables'
+    subcommand 'variables', VariablesCommand
+
+    desc 'configuration-versions <subcommand>', 'Manage configuration versions'
+    subcommand 'configuration_versions', ConfigurationVersionsCommand
+
+    desc 'policies <subcommand>', 'Manage policies'
+    subcommand 'policies', PoliciesCommand
+
+    desc 'policy-checks <subcommand>', 'Manage policy checks'
+    subcommand 'policy_checks', PolicyChecksCommand
+
+    desc 'runs <subcommand>', 'Manage runs'
+    subcommand 'runs', RunsCommand
+
+    desc 'push <organization>/<workspace>', STRINGS[:push][:commands][:push]
+    option :path, required: true, default: '.', desc: STRINGS[:push][:attributes][:path]
+    def push(name)
+      name_parts        = name.split('/')
+      organization_name = name_parts[0]
+      workspace_name    = name_parts[1]
+      workspace_params  = {
+        organization: organization_name,
+        workspace: workspace_name
+      }
+
+      begin
+        content = tarball(options[:path])
+      rescue
+        error! "could not open that file or directory"
+      end
+
+      # Look up the workspace ID
+      workspace_response = client.workspaces.get(workspace_params)
+      workspace_id = workspace_response&.resource&.id
+      error! "workspace '#{organization_name}/#{workspace_name}' was not found!" unless workspace_id
+
+      # Create a configuration version and get upload-url
+      configuration_version_response = client.configuration_versions.create(workspace: workspace_id)
+      upload_url = (configuration_version_response&.resource&.attributes || {})['upload-url']
+      error! "failed creationg configuration version with workspace id `#{workspace_id}`" unless upload_url      
+
+      upload_params = { content: content, url: upload_url }
+      render client.configuration_versions.upload(upload_params)
+    end
+  end
+end
+
+TerraformEnterprise::MainCommand.start(ARGV)

data/lib/terraform_enterprise/command_line/command.rb

@@ -0,0 +1,61 @@
+require 'json'
+require 'terraform-enterprise-client'
+
+require_relative 'formatter'
+require_relative 'strings'
+require_relative 'util'
+
+module TerraformEnterprise
+  module CommandLine
+    # Base class for all commands
+    class Command < Thor
+      include TerraformEnterprise::CommandLine
+      include TerraformEnterprise::CommandLine::Util::Tar
+
+      CMD_STR = STRINGS[:options]
+
+      class_option :host, type: :string, desc: CMD_STR[:host]
+      class_option :token, type: :string, desc: CMD_STR[:token]
+      class_option :color, type: :boolean, default: true, desc: CMD_STR[:color]
+      class_option :except, type: :array, desc: CMD_STR[:except]
+      class_option :only, type: :array, desc: CMD_STR[:only]
+      class_option :all, type: :boolean, default: false, desc: CMD_STR[:all]
+      class_option :value, type: :boolean, default: false, desc: CMD_STR[:value]
+      class_option :debug, type: :boolean, default: false, desc: CMD_STR[:debug]
+
+      no_commands do
+        def render(obj, default_options = {})
+          normalized_options = symbolize_keys(options.to_h)
+          calculated_options =
+            if options[:all]
+              normalized_options
+            else
+              symbolize_keys(default_options).merge(normalized_options)
+            end
+          formatter = Formatter.new
+          formatter.render obj, calculated_options
+        end
+
+        def error!(message)
+          formatter = Formatter.new
+          formatter.error(message)
+          exit(false)
+        end
+
+        def client
+          settings         = {}
+          settings[:token] = options[:token] || ENV['TFE_TOKEN']
+          settings[:host]  = options[:host] if options[:host]
+          settings[:debug] = options[:debug] if options[:debug]
+          TerraformEnterprise::API::Client.new(settings)
+        end
+
+        private
+
+        def symbolize_keys(hash)
+          JSON.parse(JSON[hash], symbolize_names: true)
+        end
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/configuration_versions.rb

@@ -0,0 +1,37 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    # Configuration Version Commoand
+    class ConfigurationVersionsCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:configuration_versions][:attributes]
+      CMD_STR = STRINGS[:configuration_versions][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+      def list
+        render client.configuration_versions.list(workspace: options[:workspace_id])
+      end
+
+      desc 'create', CMD_STR[:list]
+      option :workspace_id, required: true, type: :string, desc: STRINGS[:options][:workspace_id]
+      def create
+        render client.configuration_versions.create(workspace: options[:workspace_id])
+      end
+
+      desc 'get <id>', CMD_STR[:get]
+      def get(id)
+        render client.configuration_versions.get(id: id)
+      end
+
+      desc 'upload <path> <upload-url>', CMD_STR[:upload]
+      def upload(path, url)
+        content = tarball(path)
+        params  = { content: content, url: url }
+
+        render client.configuration_versions.upload(params)
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/oauth_tokens.rb

@@ -0,0 +1,15 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class OAuthTokensCommand < TerraformEnterprise::CommandLine::Command
+      class_option :organization, required: true, type: :string, desc: STRINGS[:oauth_tokens][:attributes][:organization]
+
+      desc 'list', STRINGS[:oauth_tokens][:commands][:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      def list
+        render client.oauth_tokens.list(options)
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/organizations.rb

@@ -0,0 +1,30 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class OrganizationsCommand < TerraformEnterprise::CommandLine::Command
+      CMD_STR = STRINGS[:organizations][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      def list
+        render client.organizations.list, only: [:id, :name, 'created-at', :email]
+      end
+
+      desc 'create <name> <email>', CMD_STR[:create]
+      def create(name, email)
+        render client.organizations.create(name: name, email: email)
+      end
+
+      desc 'get <name>', CMD_STR[:get]
+      def get(name)
+        render client.organizations.get(name:name)
+      end
+
+      desc 'delete <name>', CMD_STR[:delete]
+      def delete(name)
+        render client.organizations.delete(name:name)
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/policies.rb

@@ -0,0 +1,72 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class PoliciesCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:policies][:attributes]
+      CMD_STR = STRINGS[:policies][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def list
+        render client.policies.list(organization: options[:organization])
+      end
+
+      desc 'create <name>', CMD_STR[:create]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory']
+      def create(name)
+        params = {
+          name: name,
+          organization: options[:organization],
+          enforce: [
+            {
+              path: "#{name}.sentinel",
+              mode: options[:mode]
+            }
+          ]
+        }
+        render client.policies.create(params)
+      end
+
+      desc 'update <id>', CMD_STR[:create]
+      option :mode, type: :string, required: true, enum: ['soft-mandatory', 'hard-mandatory', 'advisory'], desc: ATTR_STR[:mode]
+      def update(id)
+        name = ''
+        params = {
+          id: id,
+          name: name,
+          enforce: [
+            {
+              path: 'default.sentinel',
+              mode: options[:mode]
+            }
+          ]
+        }
+
+        render client.policies.update(params)
+      end
+
+      desc 'get <id>', CMD_STR[:get]
+      def get(id)
+        render client.policies.get(id:id)
+      end
+
+      desc 'delete <id>', CMD_STR[:delete]
+      def delete(id)
+        render client.policies.delete(id: id)
+      end
+
+      desc 'upload <path> <policy-id>', CMD_STR[:upload]
+      def upload(path, policy_id)
+        full_path = File.expand_path(path)
+        content = File.read(full_path)
+
+        params = { content: content, id: policy_id }
+
+        render client.policies.upload(params)
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/policy_checks.rb

@@ -0,0 +1,29 @@
+require 'terraform_enterprise/command_line/command'
+require 'terraform_enterprise/command_line/util'
+
+module TerraformEnterprise
+  module CommandLine
+    # Configuration Version Commoand
+    class PolicyChecksCommand < TerraformEnterprise::CommandLine::Command
+      include TerraformEnterprise::CommandLine::Util::Tar
+
+      ATTR_STR = STRINGS[:policy_checks][:attributes]
+      CMD_STR = STRINGS[:policy_checks][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: false, desc: STRINGS[:options][:table]
+      option :run_id, required: true, type: :string, desc: ATTR_STR[:run_id]
+      def list
+        render client.policy_checks.list(run_id: options[:run_id])
+      end
+
+      desc 'override <policy-check-id>', CMD_STR[:override]
+      option :comment, type: :string, desc: ATTR_STR[:comment]
+      def override(id)
+        params = { id: id, action: :override }
+        params[:comment] = options[:comment] if options[:comment]
+        render client.policy_checks.action(params)
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/runs.rb

@@ -0,0 +1,88 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class RunsCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:runs][:attributes]
+      CMD_STR = STRINGS[:runs][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+      def list
+        render client.runs.list(id: options[:workspace_id]), except: [:permissions]
+      end
+
+      desc 'create', CMD_STR[:create]
+      option :workspace_id, required: true, type: :string, desc: ATTR_STR[:workspace_id]
+      option :configuration_version_id, type: :string, desc: ATTR_STR[:configuration_version_id]
+      option :destroy, type: :boolean, default: false, desc: ATTR_STR[:destroy]
+      def create
+        render client.runs.create(options), except: [:permissions]
+      end
+
+      desc 'get <id>', CMD_STR[:get]
+      def get(id)
+        render client.runs.get(id: id), except: [:permissions]
+      end
+
+      desc 'apply <id>', CMD_STR[:apply]
+      option :comment, type: :string, desc: ATTR_STR[:comment]
+      def apply(id)
+        params = { id: id, action: :apply }
+        params[:comment] = options[:comment] if options[:comment]
+        render client.runs.action(params)
+      end
+
+      desc 'discard <id>', CMD_STR[:discard]
+      option :comment, type: :string, desc: ATTR_STR[:comment]
+      def discard(id)
+        params = { id: id, action: :discard }
+        params[:comment] = options[:comment] if options[:comment]
+        render client.runs.action(params)
+      end
+
+      desc 'logs <id>', 'Logs'
+      option :event, type: :string, required: true, desc: ATTR_STR[:event], enum:['plan', 'apply']
+      option :follow, type: :boolean, default: false, desc: ATTR_STR[:follow]
+      def logs(id)
+        following       = options[:follow]
+        finished        = false
+        exit_requested  = false
+        finished_states = %w[errored canceled finished]
+
+        # Listens for "control-c" to exit
+        Kernel.trap('INT') { exit_requested = true }
+
+        loop do
+          event    = get_event_resource(id, options[:event])
+          url      = event.attributes['log-read-url']
+          finished = finished_states.include?(event.attributes['status'].to_s)
+          logs     = RestClient.get(url).body
+          
+          # errase screen and go to (0,0)
+          print "\033[2J" if following
+          print logs
+
+          break if !following || exit_requested || finished
+          
+          sleep 2
+        end 
+      end
+
+      private
+
+      def get_event_resource(id, event)
+        event_type    = event == 'plan' ? 'plans' : 'applies'
+        error_message = "#{options[:event].to_s.capitalize} not started yet"
+        run_response  = client.runs.get(id: id, include: [event.to_sym])
+        render run_response unless run_response.success?
+        event_resource = run_response.resource.included.find do |er|
+          er.type.to_s == event_type
+        end
+        error! error_message unless event_resource
+        event_resource
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/commands/teams.rb

@@ -0,0 +1,33 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class TeamsCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:teams][:attributes]
+      CMD_STR = STRINGS[:teams][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def list
+        render client.teams.list(organization: options[:organization]), except: [:permissions]
+      end
+
+      desc 'create <name>', CMD_STR[:create]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def create(name)
+        render client.teams.create(name: name, organization: options[:organization])
+      end
+
+      desc 'get <id>', CMD_STR[:get]
+      def get(id)
+        render client.teams.get(id:id), except: [:permissions]
+      end
+
+      desc 'delete <id>', CMD_STR[:delete]
+      def delete(id)
+        render client.teams.delete(id: id), except: [:permissions]
+      end
+    end
+  end
+end