terraform-enterprise-client 0.0.6 → 0.0.7

data/bin/tfe

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

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

@@ -1,29 +0,0 @@
-require 'thor'
-
-require 'terraform-enterprise/version'
-require 'terraform-enterprise/commands/organizations_command'
-require 'terraform-enterprise/commands/workspaces_command'
-require 'terraform-enterprise/commands/oauth_tokens_command'
-require 'terraform-enterprise/commands/teams_command'
-require 'terraform-enterprise/commands/variables_command'
-
-module TerraformEnterprise
-  class CommandLine < Thor
-    desc 'organizations <subcommand>', 'Manage organizations'
-    subcommand 'organizations', TerraformEnterprise::Commands::OrganizationsCommand
-
-    desc 'workspaces <subcommand>', 'Manage workspaces'
-    subcommand 'workspaces', TerraformEnterprise::Commands::WorkspacesCommand
-
-    desc 'oauth_tokens <subcommand>', 'Manage OAuth tokens'
-    subcommand 'oauth_tokens', TerraformEnterprise::Commands::OAuthTokensCommand
-
-    desc 'teams <subcommand>', 'Manage teams'
-    subcommand 'teams', TerraformEnterprise::Commands::TeamsCommand
-
-    desc 'variables <subcommand>', 'Manage variables'
-    subcommand 'variables', TerraformEnterprise::Commands::VariablesCommand
-  end
-end
-
-TerraformEnterprise::CommandLine.start(ARGV)

data/lib/terraform-enterprise/client/request.rb

@@ -1,82 +0,0 @@
-require 'terraform-enterprise/client/response'
-
-module TerraformEnterprise
-  module API
-    class Request
-      attr_accessor :base
-
-      def initialize(api_key:, host: 'https://app.terraform.io/api/v2', debug: false)
-        @base    = host
-        @api_key = api_key
-        @debug   = debug
-        @headers = {
-          'Authorization' => "Bearer #{@api_key}",
-          'Content-Type' => 'application/vnd.api+json'
-        }
-      end
-
-      def get(*path)
-        data = path.pop if path.last.is_a?(Hash)
-        request(:get, path, data)
-      end
-
-      def delete(*path)
-        data = path.pop if path.last.is_a?(Hash)
-        request(:delete, path,data)
-      end
-
-      def post(*path)
-        data = path.pop if path.last.is_a?(Hash)
-        request(:post, path, data)
-      end
-
-      def put(*path)
-        data = path.pop if path.last.is_a?(Hash)
-        request(:put,data,data)
-      end
-
-      def patch(*path)
-        data = path.pop if path.last.is_a?(Hash)
-        request(:patch,path,data)
-      end
-
-      def request(method, path, data={}, headers={})
-        request = {
-          method:  method,
-          url:     uri(path),
-          headers: @headers.merge(headers || {})
-        }
-        if data
-          if method==:get || method==:delete
-            request[:headers][:params] = data
-          else
-            request[:payload] = data.is_a?(String) ? data : data.to_json
-          end
-        end
-
-        response = begin
-          RestClient::Request.execute(request)
-        rescue RestClient::ExceptionWithResponse => ex
-          ex.response
-        end
-
-        if @debug
-          puts "[DEBUG] [REQUEST:METHOD]  #{request[:method].to_s.upcase} #{request[:url]}"
-          puts "[DEBUG] [REQUEST:HEADERS] #{request[:headers]}"
-          puts "[DEBUG] [REQUEST:PAYLOAD] #{data}"
-          puts "[DEBUG] [RESPONSE:CODE]   #{response.code}" 
-          puts "[DEBUG] [RESPONSE:BODY]   #{response.body}" 
-        end
-
-        TerraformEnterprise::API::Response.new(response)
-      end
-
-      private
-
-      def uri(path=[])
-        return path if path.is_a?(String) && path.start_with?("http")
-        "#{@base}/#{path.map{|p| p.to_s}.join('/')}"
-      end
-    end
-  end
-end

data/lib/terraform-enterprise/client/resource.rb

@@ -1,19 +0,0 @@
-module TerraformEnterprise
-  module API
-    class Resource
-      attr_accessor :type, :attributes, :id, :relationships, :links, :errors, :success
-      def initialize(data)
-        @id               = data['id']
-        @type             = data['type']
-        @attributes       = data['attributes'] || {}
-        @relationships    = data['relationships'] || {}
-        @links            = data['links'] || []
-        @errors           = data['errors'] || []
-      end
-
-      def has_errors?
-        !@errors.empty?
-      end
-    end
-  end
-end

data/lib/terraform-enterprise/client/resource_request.rb

@@ -1,10 +0,0 @@
-module TerraformEnterprise
-  module API
-    class ResourceRequest
-      def initialize(request, params={})
-        @request = request
-        @params  = params
-      end
-    end
-  end
-end

data/lib/terraform-enterprise/client/response.rb

@@ -1,37 +0,0 @@
-require 'terraform-enterprise/client/resource'
-
-module TerraformEnterprise
-  module API
-    class Response
-      attr_reader :code, :body, :data, :resource, :resources, :errors
-      def initialize(rest_client_response)
-        @code = rest_client_response.code
-        @body = parse(rest_client_response.body)
-        @data = (@body.is_a?(Hash) && @body['data']) ? @body['data'] : @body
-        if @data.is_a?(Hash)
-          @resource = TerraformEnterprise::API::Resource.new(@data) 
-        end
-        if @data.is_a?(Array) && @data.all?{|a| a.is_a?(Hash)}
-          @resources = @data.map do |item|
-            TerraformEnterprise::API::Resource.new(item)
-          end
-        end
-        if has_errors?
-          @errors = @body['errors']
-        end
-      end
-
-      def has_errors?
-        @body.is_a?(Hash) && @body['errors'] && @body['errors'].is_a?(Array)
-      end
-
-      private
-
-      def parse(str)
-        JSON.parse(str)
-      rescue JSON::ParserError
-        str
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'json'
-
-require 'terraform-enterprise-client'
-require 'terraform-enterprise/commands/formatter'
-require 'terraform-enterprise/commands/strings'
-
-module TerraformEnterprise
-  module Commands
-    class Command < Thor
-      class_option :host, type: :string, desc: 'Set host address for private Terraform Enterprise'
-      class_option :token, type: :string, desc: 'Set the auth token, defaults to TERRAFORM_ENTERPRISE_TOKEN environment variable'
-      class_option :color, type: :boolean, default: true, desc: 'If disabled the ANSI color codes will not be used'
-      class_option :except, type: :array, desc: 'List of fields that should not be displayed'
-      class_option :only, type: :array, desc: 'List of fields that should be displayed'
-      class_option :all, type: :boolean, default: false, desc: "Return all fields, not just summary"
-      class_option :value, type: :boolean, default: false, desc: 'Only return the value; i.e. do not show keys'
-      class_option :debug, type: :boolean, default: false, desc: 'Show debug logs'
-
-      no_commands do
-        def render(obj, default_options={})
-          calculated_options = if(options[:all])
-            symbolize_keys(options.to_h)
-          else
-            symbolize_keys(default_options).merge(symbolize_keys(options.to_h))
-          end
-          TerraformEnterprise::Commands::Formatter.render obj, calculated_options
-        end
-
-        def client
-          settings           = { }
-          settings[:api_key] = options[:token] || ENV['TERRAFORM_ENTERPRISE_TOKEN']
-          settings[:host]    = options[:host] if options[:host]
-          settings[:debug]   = options[:debug] if options[:debug]
-          TerraformEnterprise::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/commands/formatter.rb

@@ -1,93 +0,0 @@
-require 'yaml'
-require 'colorize'
-require 'terminal-table'
-
-require 'terraform-enterprise-client'
-
-module TerraformEnterprise
-  module Commands
-    module Formatter
-      def self.render(obj, options={})
-        String.disable_colorization = !options[:color]
-        if obj.is_a?(TerraformEnterprise::API::Response)
-          if obj.code >= 200 && obj.code < 300
-            if obj.resources
-              puts render_resource_table(obj.resources, options)
-            elsif obj.resource
-              puts render_resource(obj.resource, options) 
-            else
-              puts "Success (#{obj.code})".green
-            end
-          elsif obj.has_errors?
-            obj.errors.each do |error|
-              if error['status'] && error['title']
-                puts "Error (#{error['status']}): #{error['title']}".red
-              else
-                puts "Error (#{obj.code}): #{error}".red
-              end
-              exit(false)
-            end
-          else
-            puts "Unknown server response (#{obj.code})".yellow
-            puts obj.body
-            exit(false)
-          end
-        else
-          puts "Unknown content".yellow
-          puts obj
-          exit(false)
-        end
-      end
-
-      private
-
-      def self.parse_resource(resource, options)
-        parsed_resource = flatten_dotted_hash(resource.attributes)
-        parsed_resource = {'id' => resource.id}.merge(parsed_resource) if resource.id
-        (options[:except] || []).each do |excluded|
-          parsed_resource.delete_if {|key,value| key.to_s.start_with?(excluded.to_s) }
-        end
-        if options[:only] && options[:only].length > 0
-          parsed_resource.select! do |key, value|
-            options[:only].any?{ |included| key.to_s.start_with?(included.to_s) }
-          end
-        end
-        parsed_resource
-      end
-
-      def self.render_resource(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 self.render_resource_table(resources, options)
-        if options[:table] && !options[:value]
-          parsed_resources = resources.map{|resource| parse_resource(resource,options)}
-          keys = parsed_resources.map{|resource| resource.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
-          out = resources.map{|resource| render_resource(resource, options)}.join("\n#{'-' * 10}\n")
-        end
-      end
-
-      def self.flatten_hash(h,f=[],g={})
-        return g.update({ f=>h }) unless h.is_a?(Hash) || h.is_a?(Array)
-        h.each { |k,r| flatten_hash(r,f+[k],g) } if h.is_a?(Hash)
-        h.each_with_index { |r, k| flatten_hash(r,f+[k],g) } if h.is_a?(Array)
-        g
-      end
-
-      def self.flatten_dotted_hash(source)
-        flat = flatten_hash(source)
-        flat.keys.each_with_object({}) { |key, h| h[key.join('.')] = flat[key] }  
-      end
-    end
-  end
-end

data/lib/terraform-enterprise/commands/oauth_tokens_command.rb

@@ -1,16 +0,0 @@
-require 'terraform-enterprise/commands/command'
-require 'terraform-enterprise-client'
-
-module TerraformEnterprise
-  module Commands
-    class OAuthTokensCommand < TerraformEnterprise::Commands::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/commands/organizations_command.rb

@@ -1,30 +0,0 @@
-require 'terraform-enterprise/commands/command'
-
-module TerraformEnterprise
-  module Commands
-    class OrganizationsCommand < TerraformEnterprise::Commands::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/commands/strings.rb

@@ -1,79 +0,0 @@
-
-
-module TerraformEnterprise
-  module Commands
-    STRINGS = {
-      options: {
-        table: 'Format list output as a table'
-      },
-      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 worksapces 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'
-        }
-      },
-      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.'
-        }
-      },
-      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 cateogry, probably "terrafomr" or "environment"',
-          hcl: 'Variable should be parsed using HCL',
-          sensitive:'Variable should be marked as sensitive',
-          value: 'Variable value',
-          key: 'Variable key',
-        }
-      },
-    }
-  end
-end