terraform-enterprise-cli 0.0.6

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

@@ -0,0 +1,61 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class VariablesCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:variables][:attributes]
+      CMD_STR = STRINGS[:variables][: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]
+      option :workspace, type: :string, desc: ATTR_STR[:workspace]
+      def list
+        render client.variables.list(options)
+      end
+
+      desc 'create <key> <value>', CMD_STR[:create]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      option :workspace, required: true, type: :string, desc: ATTR_STR[:workspace]
+      option :category, default: 'terraform', type: :string, desc: ATTR_STR[:category], enum:['terraform', 'env']
+      option :hcl, default: false, type: :boolean, desc: ATTR_STR[:hcl]
+      option :sensitive, default: false, type: :boolean, desc: ATTR_STR[:sensitive]
+      def create(key, value)
+        params = {
+          category: options[:category],
+          hcl: options[:hcl],
+          key: key,
+          organization: options[:organization],
+          sensitive: options[:sensitive],
+          value: value,
+          workspace: options[:workspace],
+        }
+        render client.variables.create(params)
+      end
+
+      desc 'update <id>', CMD_STR[:update]
+      option :hcl, type: :boolean, desc: ATTR_STR[:hcl]
+      option :sensitive, type: :boolean, desc: ATTR_STR[:sensitive]
+      option :key, type: :string, desc: ATTR_STR[:key]
+      option :value, type: :string, desc: ATTR_STR[:value]
+      def update(id)
+        params             = {id: id}
+        params[:hcl]       = options[:hcl] if options.include?('hcl')
+        params[:key]       = options[:key] if options[:key]
+        params[:sensitive] = options[:sensitive] if options.include?('sensitive')
+        params[:value]     = options[:value] if options[:value]
+        render client.variables.update(params)
+      end
+
+      desc 'get <id>', CMD_STR[:get]
+      def get(id)
+        render client.variables.get(id:id)
+      end
+
+      desc 'delete <id>', CMD_STR[:delete]
+      def delete(id)
+        render client.variables.delete(id: id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'terraform_enterprise/command_line/command'
+
+module TerraformEnterprise
+  module CommandLine
+    class WorkspacesCommand < TerraformEnterprise::CommandLine::Command
+      ATTR_STR = STRINGS[:workspaces][:attributes]
+      CMD_STR = STRINGS[:workspaces][:commands]
+
+      desc 'list', CMD_STR[:list]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      option :table, type: :boolean, default: true, desc: STRINGS[:options][:table]
+      def list
+        render client.workspaces.list(options), except:[:permissions, :actions, :environment, 'created-at']
+      end
+
+      desc 'create <name>', CMD_STR[:create]
+      option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
+      option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
+      option :oauth_token, type: :string, desc: ATTR_STR[:oauth_token]
+      option :branch, type: :string, desc: ATTR_STR[:branch]
+      option :ingress_submodules, type: :boolean, desc: ATTR_STR[:ingress_submodules]
+      option :repo, type: :string, desc: ATTR_STR[:repos]
+      option :import_legacy_environment, type: :string, desc: ATTR_STR[:import_legacy]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def create(name)
+        params = {
+          organization: options[:organization],
+          name: name,
+          'working-directory' => options[:working_directory] || '',
+        }
+        if options[:repo] && options[:oauth_token]
+          repo = {}
+          repo['branch']             = options[:branch] || ''
+          repo['identifier']         = options[:repo]
+          repo['oauth-token-id']     = options[:oauth_token]
+          repo['ingress-submodules'] = options[:ingress_submodules] || false
+          params['vcs-repo'] = repo
+        end
+
+        params['migration-environment'] = options[:import_legacy_environment] if options[:import_legacy_environment]
+        params['terraform_version']     = options[:terraform_version] if options[:terraform_version]
+        render client.workspaces.create(params), except:[:permissions, :actions, :environment]
+      end
+
+      desc 'get <name>', CMD_STR[:get]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def get(name)
+        params = {
+          organization: options[:organization],
+          workspace: name
+        }
+        render client.workspaces.get(params), except:[:permissions, :environment]
+      end
+
+      desc 'delete <name>', CMD_STR[:delete]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def delete(name)
+        params = {
+          organization: options[:organization],
+          workspace: name
+        }
+        render client.workspaces.delete(params), except:[:permissions, :actions, :environment]
+      end
+
+      desc 'update <name>', CMD_STR[:update]
+      option :working_directory, type: :string, desc: ATTR_STR[:working_directory]
+      option :terraform_version, type: :string, desc: ATTR_STR[:terraform_version]
+      option :auto_apply, type: :boolean, desc: ATTR_STR[:auto_apply]
+      option :organization, required: true, type: :string, desc: ATTR_STR[:organization]
+      def update(name)
+        params = options
+        params[:workspace] = name
+        render client.workspaces.update(params), except:[:permissions, :environment]
+      end
+
+      desc 'lock <id>', CMD_STR[:lock]
+      def lock(id)
+        render client.workspaces.action(action: :lock, id: id), except:[:permissions, :environment]
+      end
+
+      desc 'unlock <id>', CMD_STR[:unlock]
+      def unlock(id)
+        render client.workspaces.action(action: :unlock, id: id), except:[:permissions, :environment]
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/formatter.rb

@@ -0,0 +1,131 @@
+require 'yaml'
+require 'colorize'
+require 'terminal-table'
+
+require 'terraform-enterprise-client'
+
+module TerraformEnterprise
+  module CommandLine
+    # Module with render method to render the Resource object
+    class Formatter
+      def render(obj, options = {})
+        String.disable_colorization = !options[:color]
+
+        if !obj.is_a?(TerraformEnterprise::API::Response)
+          unkown_response(obj)
+        elsif obj.success?
+          render_resource(obj, options)
+        elsif obj.errors?
+          render_errors(obj)
+        else
+          unkown_response(obj.body)
+        end
+      end
+
+      def error(message)
+        puts "Error: #{message}".red
+      end
+
+      def success(message)
+        puts message.green
+      end
+
+      private
+
+      def unkown_response(obj)
+        puts 'Unknown response'.yellow
+        puts obj
+        exit(false)
+      end
+
+      def render_resource(obj, options)
+        if obj.resources
+          puts render_resource_list(obj.resources, options)
+        elsif obj.resource
+          puts render_resource_item(obj.resource, options)
+        else
+          success "Success (#{obj.code})"
+        end
+      end
+
+      def render_errors(obj)
+        obj.errors.each do |error|
+          message = error['detail'] || error['title'] || error.to_s
+          code    = error['status'] || obj.code
+          error "[#{code}] #{message}"
+        end
+        exit(false)
+      end
+
+      def parse_resource(resource, options)
+        parsed_resource = flatten_dotted_hash(resource.attributes)
+        if resource.id
+          parsed_resource = { 'id' => resource.id }.merge(parsed_resource)
+        end
+        (options[:except] || []).each do |excluded|
+          parsed_resource.delete_if do |key, _|
+            key.to_s.start_with?(excluded.to_s)
+          end
+        end
+        if options[:only] && !options[:only].empty?
+          parsed_resource.select! do |key, _|
+            options[:only].any? do |included|
+              key.to_s.start_with?(included.to_s)
+            end
+          end
+        end
+        parsed_resource
+      end
+
+      def render_resource_item(resource, options)
+        parsed_resource = parse_resource(resource, options)
+        parsed_resource.keys.map do |key|
+          value = parsed_resource[key]
+          options[:value] ? value : "#{key.bold}: #{value}"
+        end.join("\n")
+      end
+
+      def render_resource_list(resources, options)
+        if options[:table] && !options[:value]
+          parsed_resources = resources.map do |resource|
+            parse_resource(resource, options)
+          end
+          keys = parsed_resources.map(&:keys).flatten.uniq
+          rows = parsed_resources.map do |resource|
+            keys.map { |key| resource[key] }
+          end
+          table = Terminal::Table.new headings: keys, rows: rows
+          table
+        else
+          line_separator = "\n#{'-' * 10}\n"
+          out = resources.map do |resource|
+            render_resource_item(resource, options)
+          end
+          out.join(line_separator)
+        end
+      end
+
+      def flatten_hash(hash, new_key = [], new_hash = {})
+        if hash.is_a?(Array)
+          hash.each_with_index do |item, obj|
+            flatten_hash(item, new_key + [obj], new_hash)
+          end
+        elsif hash.is_a?(Hash)
+          hash.each do |key, value|
+            flatten_hash(value, new_key + [key], new_hash)
+          end
+        else
+          return new_hash.update(new_key => hash)
+        end
+        new_hash
+      end
+
+      def flatten_dotted_hash(source)
+        flat = flatten_hash(source)
+        flat.keys.each_with_object({}) do |key, h|
+          h[key.join('.')] = flat[key]
+        end
+      end
+    end
+  end
+end

data/lib/terraform_enterprise/command_line/strings.rb

@@ -0,0 +1,149 @@
+
+
+module TerraformEnterprise
+  module CommandLine
+    STRINGS = {
+      options: {
+        table: 'Format list output as a table',
+        host: 'Set host address for private Terraform Enterprise',
+        token: 'Set the auth token, defaults to TFE_TOKEN environment variable',
+        color: 'If disabled the ANSI color codes will not be used',
+        except: 'List of fields that should not be displayed',
+        only: 'List of fields that should be displayed',
+        all: 'Return all fields, not just summary',
+        value: 'Only return the value; i.e. do not show keys',
+        debug: 'Show debug logs'
+      },
+      push: {
+        attributes: {
+          path: 'Path of directory or tar.gz file to push to the workspace'
+        },
+        commands: {
+          push: 'Pushes the configuration to the workspace'
+        }
+      },
+      workspaces: {
+        attributes: {
+          terraform_version: 'Version of Terraform to use for this workspace.',
+          working_directory: 'Relative path that Terraform will execute within.',
+          oauth_token: 'VCS Connection (OAuth Conection + Token) to use as identified; obtained from the oauth_tokens subcommand.',
+          branch: 'Repository branch that Terraform will execute from.',
+          ingress_submodules: 'Submodules should be fetched when cloning the VCS repository.',
+          repo: 'Reference to VCS repository in the format :org/:repo.',
+          import_legacy: 'Specifies the legacy Environment to use as the source of the migration/',
+          organization: 'Organization to which this workspaces belongs to.',
+          auto_apply: 'Auto-apply enabled'
+        },
+        commands: {
+          create: 'Create a new workspace',
+          list: 'List workspaces in the organization',
+          get: 'Get workspace details by name',
+          delete: 'Delete the workspace',
+          update: 'Update the workspace',
+          lock: 'Lock the workspace by workspace ID',
+          unlock: 'Unlock the workspace by workspace ID'
+        }
+      },
+      configuration_versions: {
+        attributes: {
+          workspace_id: 'Workspace ID of the workspace to which the configuration version belongs to.',
+          path: 'Path to the tar.gz file'
+        },
+        commands: {
+          create: 'Create a new configuration version',
+          list: 'List configuration versions in the organization',
+          get: 'Get configuration version details by name',
+          upload: 'Upload a file to the configuration version'
+        }
+      },
+      organizations: {
+        commands: {
+          create: 'Create a new organization',
+          list: 'List all the organizations',
+          get: 'Get organization details by name',
+          delete: 'Delete the organization'
+        },
+        attributes: {}
+      },
+      teams: {
+        commands: {
+          create: 'Create a new team',
+          delete: 'Delete the team by ID',
+          list: 'List teams in organization',
+          get: 'Get team details'
+        },
+        attributes: {
+          organization: 'Organization to which this Team belongs to.'
+        }
+      },
+      policies: {
+        commands: {
+          create: 'Create a new policy',
+          delete: 'Delete a policy by ID',
+          list: 'List policies in organization',
+          get: 'Get policy details',
+          upload: 'Upload a policy'
+        },
+        attributes: {
+          organization: 'Organization to which this Team belongs to.',
+          mode: 'Policy mode, hard-mandatory, soft-mandatory or advisory',
+          name: 'Policy name'
+        }
+      },
+      runs: {
+        commands: {
+          create: 'Create a new run',
+          list: 'List runs in a workspace',
+          get: 'Get run details',
+          apply: 'Apply the plan',
+          discard: 'Discard the plan',
+          log: 'Return logs for the plan or apply'
+        },
+        attributes: {
+          workspace_id: 'Workspace ID of which the run belongs to.',
+          configuration_version_id: 'Configuration Version ID of the configuration version to run',
+          destroy: 'The run should be a destroy plan',
+          comment: 'Add a comment for the action',
+          follow: 'Follow the logs until output is complete',
+          event: 'Run event for which to get logs (plan or apply)'
+        }
+      },
+      policy_checks: {
+        commands: {
+          list: 'List policy checks on run',
+          override: 'Override the soft-mandatory or advisory policy'
+        },
+        attributes: {
+          run_id: 'Run ID to which the policy check belongs to.',
+          comment: 'Add a comment for the action'
+        }
+      },
+      oauth_tokens: {
+        commands: {
+          list: 'List the OAuth tokens in the organization'
+        },
+        attributes: {
+          organization: 'Organization to which this OAuth Token belongs to.'
+        }
+      },
+      variables: {
+        commands: {
+          create: 'Create a new variable',
+          delete: 'Delete the variable by ID',
+          get: 'Get variable details',
+          list: 'List variables in organization',
+          update: 'Update a variable by ID'
+        },
+        attributes: {
+          organization: 'Organization to which this Variable belongs to.',
+          workspace: 'Workspace to which this Variable belongs to.',
+          category: 'The type of category, probably "terraform" or "env"',
+          hcl: 'Variable should be parsed using HCL',
+          sensitive: 'Variable should be marked as sensitive',
+          value: 'Variable value',
+          key: 'Variable key'
+        }
+      }
+    }.freeze
+  end
+end

data/lib/terraform_enterprise/command_line/util.rb

@@ -0,0 +1,50 @@
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module TerraformEnterprise
+  module CommandLine
+    module Util
+      # Module to perform a tar and gz of a directory
+      module Tar
+        def tar(path)
+          tarfile = StringIO.new('')
+          Gem::Package::TarWriter.new(tarfile) do |tar|
+            Dir[File.join(path, '**/*')].each do |file|
+              mode          = File.stat(file).mode
+              relative_file = file.sub /^#{Regexp.escape(path)}\/?/, ''
+              
+              if File.directory?(file)
+                tar.mkdir relative_file, mode
+              else
+                tar.add_file relative_file, mode do |tf|
+                  File.open(file, 'rb') { |f| tf.write f.read }
+                end
+              end
+            end
+          end
+          
+          tarfile.rewind
+          tarfile
+        end
+        
+        def gzip(tarfile)
+          gzip_string = StringIO.new('')
+          gzip_writer = Zlib::GzipWriter.new(gzip_string)
+          gzip_writer.write tarfile.string
+          gzip_writer.close
+          gzip_string.string
+        end
+
+        def tarball(path)
+          full_path = File.expand_path(path)
+          if File.directory?(full_path)
+            gzip(tar(full_path))
+          else
+            File.read(full_path)
+          end
+        end
+      end
+    end
+  end
+end