├── .github
    └── workflows
    │   └── continuous-integration.yml
├── .gitignore
├── .gitmodules
├── LICENSE
├── Makefile
├── README.md
├── acc-test-environment
    ├── README.md
    ├── database.tf
    ├── main.tf
    ├── network.tf
    ├── scripts
    │   └── Install-OctopusServer.ps1
    ├── storage.tf
    └── vm.tf
├── datasource_environment.go
├── datasource_machine.go
├── datasource_project.go
├── datasource_variable.go
├── main.go
├── provider.go
├── provisioner.go
├── resource_environment.go
├── resource_helper.go
├── resource_variable.go
└── utilities.go


/.github/workflows/continuous-integration.yml:
--------------------------------------------------------------------------------
 1 | name: Continuous Integration
 2 | on: [push]
 3 | jobs:
 4 |   build:
 5 |     name: Build
 6 |     runs-on: ${{ matrix.os }}
 7 |     strategy:
 8 |       matrix:
 9 |         go: ["1.12", "1.13"]
10 |         os: [ubuntu-latest, macos-latest, windows-latest]
11 |     steps:
12 |       - name: Set up Go
13 |         uses: actions/setup-go@v1
14 |         with:
15 |           go-version: ${{ matrix.go }}
16 |         id: go
17 | 
18 |       - name: Check out code into the Go module directory
19 |         uses: actions/checkout@v1
20 | 
21 |       - name: Get dependencies
22 |         run: |
23 |           go get -v -t -d ./...
24 | 
25 |       - name: Build
26 |         run: go build -v .
27 | 
28 |       - name: Run Unit Tests
29 |         run: go test -v .
30 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | _bin
10 | 
11 | # Architecture specific extensions/prefixes
12 | *.[568vq]
13 | [568vq].out
14 | 
15 | *.cgo1.go
16 | *.cgo2.c
17 | _cgo_defun.c
18 | _cgo_gotypes.go
19 | _cgo_export.*
20 | 
21 | _testmain.go
22 | 
23 | *.exe
24 | *.test
25 | *.prof
26 | 
27 | # Mac
28 | .DS_Store
29 | 
30 | # Terraform local state and variables
31 | .terraform/
32 | .terraform.tfstate*
33 | terraform.tfstate*
34 | terraform.tfvars
35 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "vendor/octopus"]
2 | 	path = vendor/octopus
3 | 	url = https://github.com/DimensionDataResearch/go-octo-api.git
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Dimension Data Research
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | default: build test
 2 | 
 3 | fmt:
 4 | 	go fmt github.com/DimensionDataResearch/terraform-octopus/...
 5 | 
 6 | build: fmt
 7 | 	go build -o _bin/terraform-provider-octopus
 8 | 	cp _bin/terraform-provider-octopus _bin/terraform-provisioner-octopus
 9 | 
10 | test: fmt
11 | 	go test -v github.com/DimensionDataResearch/terraform-octopus/vendor/octopus
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # terraform-octopus
 2 | A plugin for Terraform to control / integrate with [Octopus Deploy](https://octopus.com/).
 3 | 
 4 | This is a work in progress. More providers and data-sources are planned, as well as a [Provisioner](https://www.terraform.io/docs/provisioners/index.html) to install the Octopus tentacle.
 5 | 
 6 | Tested against Octopus Deploy v3.3.17.
 7 | 
 8 | The following resource types are currently supported:
 9 | 
10 | * `octopus_environment`: Creates and manages an Octopus Deploy environment
11 | * `octopus_variable`: Creates and manages an Octopus Deploy variable (currently only project-level variables are supported)
12 | 
13 | Note that variables are matched on both name and combined scopes (Environments, Roles, Machines, Actions). If a variable already exists with the specified name and scopes, the provider will start managing the existing variable.
14 | 
15 | The following data-source types are currently supported:
16 | * `octopus_environment`: Tracks an existing Octopus Deploy environment
17 | * `octopus_machine`: Tracks an existing Octopus Deploy machine
18 | * `octopus_project`: Tracks an existing Octopus Deploy project
19 | * `octopus_variable`: Tracks an existing Octopus Deploy variable (currently only project-level variables are supported)
20 | 
21 | Data-sources are similar to variables, except they are read-only. The provider will read and track their state but never modify it.
22 | 
23 | To get started:
24 | 
25 | * On windows, create / update `$HOME\terraform.rc`
26 | * On Linux / OSX, create / update `~/.terraformrc`
27 | 
28 | And add the following contents:
29 | 
30 | ```hcl
31 | providers {
32 | 	octopus = "path-to-the-folder/containing/terraform-provider-octopus"
33 | }
34 | ```
35 | 
36 | Create a folder containing a single `.tf` file:
37 | 
38 | ```hcl
39 | #
40 | # This configuration will create an Octopus environment called "MyEnvironment" and configure a project-level variable named "MyVariable" to be scoped to it.
41 | #
42 | 
43 | provider "octopus" {
44 | 	server_url   = "https://my-octopus-server/"
45 | 	api_key      = "my-octopus-api-key"
46 | }
47 | 
48 | # Projects are a data source - the provider can read from them but not create or manage them.
49 | data "octopus_project" "my_project" {
50 | 	slug         = "terraformtest" # The last segment of the URL in the browser when viewing the project home page.
51 | }
52 | 
53 | data "octopus_machine" "my_machine" {
54 | 	slug         = "Machines-351" # The last segment of the URL in the browser when viewing the machine details home page.
55 | }
56 | 
57 | resource "octopus_environment" "my_environment" {
58 | 	name         = "MyEnvironment"
59 | }
60 | 
61 | resource "octopus_variable" "my_variable" {
62 | 	# This is the Id (or slug) of the project in which the variable is defined.
63 | 	project      = "${data.octopus_project.my_project.id}"
64 | 
65 | 	name         = "MyVariable"
66 | 	value        = "Hello World"
67 | 
68 | 	# The scopes (environment, role, machine, action) to which the variable applies.
69 | 	environments = ["${octopus_environment.my_environment.id}"]
70 | }
71 | ```
72 | 
73 | 1. Run `terraform plan -out tf.plan`.
74 | 2. Verify that everything looks ok.
75 | 3. Run `terraform apply tf.plan`
76 | 4. Have a look around and
77 | 5. Run `terraform show` to inspect the current state.
78 | 6. when it's time to clean up...
79 | 7. Run `terraform plan -destroy -out tf.plan`
80 | 8. Verify that everything looks ok.
81 | 9. Run `terraform apply tf.plan`
82 | 


--------------------------------------------------------------------------------
/acc-test-environment/README.md:
--------------------------------------------------------------------------------
 1 | # Acceptance test environment
 2 | 
 3 | This configuration creates (in Azure) the Octopus Deploy server used in Terraform acceptance tests.
 4 | 
 5 | You can create credentials for use in tests using the [Azure cross-platform CLI](https://www.terraform.io/docs/providers/azurerm/index.html#creating-credentials-using-the-azure-cli).
 6 | 
 7 | You'll need to supply a couple of values in `terraform.tfvars`:
 8 | 
 9 | * `azure_subscription_id` - The Id of your Azure subscription.
10 | * `azure_client_id` - The client Id you created in the Azure CLI.
11 | * `azure_client_secret` - The client secret you created in the Azure CLI.
12 | * `azure_tenant_id` - The name of the Azure AD tenant that the subscription belongs to.
13 | 
14 | There are also a couple of option values in `main.tf` that you can override by supplying their values in `terraform.tfvars`:
15 | 
16 | * `region_name` - The name of the target region where you will be deploying the environment.  
17 | **Note** - the VM and the storage account _must_ be the same location.
18 | * `resource_group_name` - The name of the resource group where the environment will be deployed (must already exist; the configuration will not create it).
19 | * `storage_account_name` - The name of the Azure Storage account where VM disks (etc) will be stored.
20 | * `uniqueness_key` - A unique value added to resource names so that your deployment doesn't clash with other deployments.
21 | 


--------------------------------------------------------------------------------
/acc-test-environment/database.tf:
--------------------------------------------------------------------------------
 1 | ## Database for Octopus Deploy
 2 | 
 3 | # SQL Server for the acceptance test environment
 4 | resource "azurerm_sql_server" "primary" {
 5 |     name                = "tfoctoacctest${var.uniqueness_key}"
 6 |     resource_group_name = "${var.resource_group_name}"
 7 |     location            = "${var.region_name}"
 8 |     version             = "12.0"
 9 | 
10 |     administrator_login          = "${var.admin_username}"
11 |     administrator_login_password = "${var.admin_password}"
12 | }
13 | 
14 | # Database used by the environment's Octopus server
15 | resource "azurerm_sql_database" "octo" {
16 |     name                = "tfoctoacctest${var.uniqueness_key}"
17 |     resource_group_name = "${var.resource_group_name}"
18 |     location            = "${var.region_name}"
19 | 
20 |     edition     = "Basic"
21 |     server_name = "${azurerm_sql_server.primary.name}"
22 | }
23 | 
24 | # Permit T-SQL access from the Octopus server to the SQL server.
25 | resource "azurerm_sql_firewall_rule" "octo_server" {
26 |     name                = "octo_server_${var.uniqueness_key}"
27 |     resource_group_name = "${var.resource_group_name}"
28 |     
29 |     server_name         = "${azurerm_sql_server.primary.name}"
30 |     start_ip_address    = "${azurerm_network_interface.octo.private_ip_address}"
31 |     end_ip_address      = "${azurerm_network_interface.octo.private_ip_address}"
32 | }
33 | 


--------------------------------------------------------------------------------
/acc-test-environment/main.tf:
--------------------------------------------------------------------------------
 1 | ## Provider configuration
 2 | 
 3 | # The Id of the target Azure subscription.
 4 | variable "azure_subscription_id"    { }
 5 | 
 6 | # The client Id used to authenticate to Azure.
 7 | variable "azure_client_id"          { }
 8 | 
 9 | # The client secret used to authenticate to Azure.
10 | variable "azure_client_secret"      { }
11 | 
12 | # The Id of target Azure AD tenant.
13 | variable "azure_tenant_id"          { }
14 | 
15 | provider "azurerm" {
16 |   subscription_id = "${var.azure_subscription_id}"
17 |   client_id       = "${var.azure_client_id}"
18 |   client_secret   = "${var.azure_client_secret}"
19 |   tenant_id       = "${var.azure_tenant_id}"
20 | }
21 | 
22 | ## Common configuration
23 | 
24 | # The name of the target Azure region (i.e. datacenter).
25 | variable "region_name"              { default = "West US" }
26 | 
27 | # The name of the resource group that holds the Octopus server used by acceptance tests.
28 | variable "resource_group_name"      { default = "terraform-provider-octopus-acctest" }
29 | 
30 | # The name of the storage account where VM disks (etc) are located.
31 | variable "storage_account_name"     { default = "tfprovideroctopusacctest" }
32 | 
33 | # Used to prevent naming clashes between multiple concurrent deployments.
34 | variable "uniqueness_key"           { default = "acctest" }
35 | 
36 | # The instance type for the Octopus Server VM.
37 | variable "octo_vm_instance_type"    { default = "Standard_A3" }
38 | 
39 | # The administrator username for the Octopus and SQL servers.
40 | variable "admin_username"           { default = "octo-admin" }
41 | 
42 | # The administrator password for the Octopus and SQL servers.
43 | variable "admin_password"   { }
44 | 


--------------------------------------------------------------------------------
/acc-test-environment/network.tf:
--------------------------------------------------------------------------------
 1 | # The primary network for the acceptance test environment.
 2 | resource "azurerm_virtual_network" "primary" {
 3 | 	name 				= "tf-octo-acc-test-${var.uniqueness_key}-network"
 4 | 	address_space 		= ["10.7.0.0/16"]
 5 | 	location 			= "${var.region_name}"
 6 | 	resource_group_name = "${var.resource_group_name}"
 7 | }
 8 | 
 9 | # The primary subnet for the acceptance test environment.
10 | resource "azurerm_subnet" "primary" {
11 | 	name 					= "tf-octo-acc-test-${var.uniqueness_key}-subnet"
12 | 	resource_group_name		= "${var.resource_group_name}"
13 | 	virtual_network_name    = "${azurerm_virtual_network.primary.name}"
14 | 	address_prefix 			= "10.7.1.0/24"
15 | }
16 | 
17 | # The primary network adapter for the Octopus Server VM.
18 | resource "azurerm_network_interface" "octo" {
19 | 	name 				= "octo-${var.uniqueness_key}-ni"
20 | 	location 			= "${var.region_name}"
21 | 	resource_group_name = "${var.resource_group_name}"
22 | 
23 | 	ip_configuration {
24 | 		name 		= "octo-${var.uniqueness_key}-ni-config"
25 | 		subnet_id   = "${azurerm_subnet.primary.id}"
26 | 
27 | 		# Hook up public IP to private IP.
28 | 		public_ip_address_id            = "${azurerm_public_ip.octo.id}"
29 | 		private_ip_address_allocation   = "dynamic"
30 | 	}
31 | }
32 | 
33 | # The default network security group for the acceptance test environment.
34 | resource "azurerm_network_security_group" "default" {
35 |     name                = "octo-${var.uniqueness_key}-default-nsg"
36 |     location            = "${var.region_name}"
37 |     resource_group_name = "${var.resource_group_name}"
38 | 
39 |     # Remote Desktop
40 |     security_rule {
41 |         name                        = "rdp"
42 |         priority                    = 100
43 |         direction                   = "Inbound"
44 |         access                      = "Allow"
45 |         protocol                    = "Tcp"
46 |         source_port_range           = "*"
47 |         destination_port_range      = "3389"
48 |         source_address_prefix       = "*"
49 |         destination_address_prefix  = "*"
50 |     }
51 | 
52 |     # WinRM
53 |     security_rule {
54 |         name                        = "winrm"
55 |         priority                    = 101
56 |         direction                   = "Inbound"
57 |         access                      = "Allow"
58 |         protocol                    = "Tcp"
59 |         source_port_range           = "*"
60 |         destination_port_range      = "5986" # HTTPS
61 |         source_address_prefix       = "*"
62 |         destination_address_prefix  = "*"
63 |     }
64 | }
65 | 
66 | # Public IP address for access to the Octopus Server VM.
67 | resource "azurerm_public_ip" "octo" {
68 | 	name 				= "tf-octo-acc-test-${var.uniqueness_key}-pip"
69 | 	location 			= "${var.region_name}"
70 | 	resource_group_name = "${var.resource_group_name}"
71 | 
72 |     domain_name_label               = "tf-octo-acc-test-${var.uniqueness_key}"
73 | 	public_ip_address_allocation    = "static"
74 | }
75 | 


--------------------------------------------------------------------------------
/acc-test-environment/scripts/Install-OctopusServer.ps1:
--------------------------------------------------------------------------------
 1 | Param(
 2 |     [Parameter(Mandatory = $true)]
 3 |     [string] $SqlServerHost,
 4 | 
 5 |     [Parameter(Mandatory = $true)]
 6 |     [string] $Database,
 7 | 
 8 |     [Parameter(Mandatory = $true)]
 9 |     [string] $User,
10 | 
11 |     [Parameter(Mandatory = $true)]
12 |     [string] $Password
13 | )
14 | 
15 | Import-Module PowerShellGet
16 | Install-Module OctopusDSC -Force
17 | Import-Module OctopusDSC
18 | 
19 | Configuration Octopus {
20 |     Import-DscResource -Module OctopusDSC
21 | 
22 |     Node "localhost" {
23 |         cOctopusServer OctopusServer {
24 |             Ensure = "present"
25 |             State = "started"
26 | 
27 |             Name = "OctopusServer"
28 | 
29 |             WebListenPrefix = "http://localhost:9081"
30 |             SqlDbConnectionString = "Server=$SqlServerHost;Database=$Database;UID=$User;PWD=$Password"
31 | 
32 |             OctopusAdminUsername = $User
33 |             OctopusAdminPassword = $Password
34 | 
35 |             # AllowUpgradeCheck = $false
36 |             # AllowCollectionOfAnonymousUsageStatistics = $false
37 |             # ForceSSL = $false
38 |             # ListenPort = 10943
39 |         }
40 |     }
41 | }
42 | Octopus
43 | 
44 | Start-DscConfiguration .\Octopus -Verbose -Wait
45 | Test-DscConfiguration
46 | 


--------------------------------------------------------------------------------
/acc-test-environment/storage.tf:
--------------------------------------------------------------------------------
1 | # Storage configuration
2 | 
3 | resource "azurerm_storage_container" "primary" {
4 | 	name 					= "tf-octo-acc-test-${var.uniqueness_key}"
5 | 	resource_group_name 	= "${var.resource_group_name}"
6 | 	storage_account_name 	= "${var.storage_account_name}"
7 | 	container_access_type 	= "private"
8 | }
9 | 


--------------------------------------------------------------------------------
/acc-test-environment/vm.tf:
--------------------------------------------------------------------------------
  1 | # The Octopus Deploy virtual machine.
  2 | resource "azurerm_virtual_machine" "octo" {
  3 | 	name 					= "octo-${var.uniqueness_key}"
  4 | 	location 				= "${var.region_name}"
  5 | 	resource_group_name 	= "${var.resource_group_name}"
  6 | 	network_interface_ids 	= [ "${azurerm_network_interface.octo.id}" ]
  7 | 
  8 | 	vm_size 				= "${var.octo_vm_instance_type}"
  9 | 
 10 | 	storage_image_reference {
 11 | 		publisher = "MicrosoftWindowsServer"
 12 | 		offer     = "WindowsServer"
 13 | 		sku       = "2012-R2-Datacenter"
 14 | 		version   = "latest"
 15 | 	}
 16 | 
 17 | 	storage_os_disk {
 18 | 		name 				= "octo-${var.uniqueness_key}-osdisk1"
 19 | 		vhd_uri 			= "https://${var.storage_account_name}.blob.core.windows.net/${azurerm_storage_container.primary.name}/octo-${var.uniqueness_key}-osdisk1.vhd"
 20 | 		caching 			= "ReadWrite"
 21 | 		create_option 		= "FromImage"
 22 | 	}
 23 | 
 24 | 	os_profile {
 25 | 		computer_name 		= "octo-${var.uniqueness_key}"
 26 | 		admin_username 		= "${var.admin_username}"
 27 | 		admin_password		= "${var.admin_password}"
 28 | 	}
 29 | 
 30 | 	os_profile_windows_config {
 31 | 		provision_vm_agent			= true
 32 | 		enable_automatic_upgrades	= true
 33 | 
 34 | 		winrm {
 35 | 			protocol = "http"
 36 | 		}
 37 | 	}
 38 | 
 39 | 	tags {
 40 | 		public_ip			= "${azurerm_public_ip.octo.ip_address}"
 41 | 		private_ip			= "${azurerm_network_interface.octo.private_ip_address}"
 42 | 	}
 43 | }
 44 | 
 45 | # Configure WinRM to enable SSL (since it's otherwise unusable, given Azure's default config).
 46 | resource "azurerm_virtual_machine_extension" "configure_winrm" {
 47 | 	name                 = "ConfigureWinRM"
 48 | 	location             = "${var.region_name}"
 49 | 	resource_group_name  = "${var.resource_group_name}"
 50 | 	virtual_machine_name = "${azurerm_virtual_machine.octo.name}"
 51 | 	publisher            = "Microsoft.Compute"
 52 | 	type                 = "CustomScriptExtension"
 53 | 	type_handler_version = "1.8"
 54 | 
 55 | 	settings = <<SETTINGS
 56 | 		{
 57 | 			"fileUris": [
 58 | 				"https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vm-winrm-windows/ConfigureWinRM.ps1",
 59 | 				"https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vm-winrm-windows/makecert.exe",
 60 | 				"https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vm-winrm-windows/winrmconf.cmd"
 61 | 			],
 62 | 			"commandToExecute": "Powershell -ExecutionPolicy Unrestricted -file ConfigureWinRM.ps1 -HostName '${azurerm_public_ip.octo.fqdn}'"
 63 | 		}
 64 | SETTINGS
 65 | }
 66 | 
 67 | # Install and configure the Octopus Deploy server.
 68 | resource "null_resource" "octo_server_install" {
 69 | 	provisioner "file" {
 70 | 		source		= "scripts/Install-OctopusServer.ps1"
 71 | 		destination	= "C:\\Install-OctopusServer.ps1"
 72 | 
 73 | 		connection {
 74 | 			type 		= "winrm"
 75 | 			host 		= "${azurerm_public_ip.octo.ip_address}"
 76 | 			port		= 5986
 77 | 			user 		= "${var.admin_username}"
 78 | 			password 	= "${var.admin_password}"
 79 | 			https		= true
 80 | 			insecure	= true # We're using a self-signed certificate
 81 | 		}
 82 | 	}
 83 | 	
 84 | 	provisioner "remote-exec" {
 85 | 		inline = [
 86 | 			"C:\\Install-OctopusServer.ps1 -SqlServerHost '${azurerm_sql_server.primary.fully_qualified_domain_name}' -Database '${azurerm_sql_database.octo.name}' -User '${var.admin_username}' -Password '${var.admin_password}'"
 87 | 		]
 88 | 		
 89 | 		connection {
 90 | 			type 		= "winrm"
 91 | 			host 		= "${azurerm_public_ip.octo.ip_address}"
 92 | 			port		= 5986
 93 | 			user 		= "${var.admin_username}"
 94 | 			password 	= "${var.admin_password}"
 95 | 			https		= true
 96 | 			insecure	= true # We're using a self-signed certificate
 97 | 		}
 98 | 	}
 99 | 	
100 | 	depends_on = [
101 | 		"azurerm_virtual_machine.octo",
102 | 		"azurerm_virtual_machine_extension.configure_winrm",
103 | 		"azurerm_public_ip.octo",
104 | 		"azurerm_network_security_group.default",
105 | 		"azurerm_sql_database.octo"
106 | 	]
107 | }
108 | 


--------------------------------------------------------------------------------
/datasource_environment.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/helper/schema"
 5 | 	"log"
 6 | 	"octopus"
 7 | )
 8 | 
 9 | const (
10 | 	datasourceKeyEnvironmentSlug        = "slug"
11 | 	datasourceKeyEnvironmentName        = "name"
12 | 	datasourceKeyEnvironmentDescription = "description"
13 | )
14 | 
15 | func datasourceEnvironment() *schema.Resource {
16 | 	return &schema.Resource{
17 | 		Read:   datasourceEnvironmentRead,
18 | 		Exists: datasourceEnvironmentExists,
19 | 
20 | 		Schema: map[string]*schema.Schema{
21 | 			datasourceKeyEnvironmentSlug: &schema.Schema{
22 | 				Type:        schema.TypeString,
23 | 				Required:    true,
24 | 				Description: "The environment slug (last segment of the environment URL).",
25 | 			},
26 | 			datasourceKeyEnvironmentName: &schema.Schema{
27 | 				Type:        schema.TypeString,
28 | 				Computed:    true,
29 | 				Description: "The environment name.",
30 | 			},
31 | 		},
32 | 	}
33 | }
34 | 
35 | // Read a environment data-source.
36 | func datasourceEnvironmentRead(data *schema.ResourceData, provider interface{}) error {
37 | 	slug := data.Get(datasourceKeyEnvironmentSlug).(string)
38 | 
39 | 	log.Printf("Read environment '%s'.", slug)
40 | 
41 | 	client := provider.(*octopus.Client)
42 | 	environment, err := client.GetEnvironment(slug)
43 | 	if err != nil {
44 | 		return err
45 | 	}
46 | 
47 | 	if environment == nil {
48 | 		// Environment has been deleted.
49 | 		data.SetId("")
50 | 
51 | 		return nil
52 | 	}
53 | 
54 | 	data.SetId(environment.ID)
55 | 	data.Set(datasourceKeyEnvironmentName, environment.Name)
56 | 	data.Set(datasourceKeyEnvironmentDescription, environment.Description)
57 | 
58 | 	return nil
59 | }
60 | 
61 | // Determine whether a environment datasource exists.
62 | func datasourceEnvironmentExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
63 | 	id := data.Id()
64 | 
65 | 	log.Printf("Check if environment '%s' exists.", id)
66 | 
67 | 	client := provider.(*octopus.Client)
68 | 
69 | 	var environment *octopus.Environment
70 | 	environment, err = client.GetEnvironment(id)
71 | 	exists = environment != nil
72 | 
73 | 	return
74 | }
75 | 


--------------------------------------------------------------------------------
/datasource_machine.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/helper/schema"
 5 | 	"log"
 6 | 	"octopus"
 7 | )
 8 | 
 9 | const (
10 | 	datasourceKeyMachineSlug       = "slug"
11 | 	datasourceKeyMachineName       = "name"
12 | 	datasourceKeyMachineURI        = "uri"
13 | 	datasourceKeyMachineThumbprint = "thumbprint"
14 | )
15 | 
16 | func datasourceMachine() *schema.Resource {
17 | 	return &schema.Resource{
18 | 		Read:   datasourceMachineRead,
19 | 		Exists: datasourceMachineExists,
20 | 
21 | 		Schema: map[string]*schema.Schema{
22 | 			datasourceKeyMachineSlug: &schema.Schema{
23 | 				Type:        schema.TypeString,
24 | 				Required:    true,
25 | 				Description: "The machine slug (last segment of the machine URL in Octopus UI).",
26 | 			},
27 | 			datasourceKeyMachineName: &schema.Schema{
28 | 				Type:        schema.TypeString,
29 | 				Computed:    true,
30 | 				Description: "The machine name.",
31 | 			},
32 | 			datasourceKeyMachineURI: &schema.Schema{
33 | 				Type:        schema.TypeString,
34 | 				Computed:    true,
35 | 				Description: "The machine URI.",
36 | 			},
37 | 			datasourceKeyMachineThumbprint: &schema.Schema{
38 | 				Type:        schema.TypeString,
39 | 				Computed:    true,
40 | 				Description: "The machine thumbprint.",
41 | 			},
42 | 		},
43 | 	}
44 | }
45 | 
46 | // Read a machine data-source.
47 | func datasourceMachineRead(data *schema.ResourceData, provider interface{}) error {
48 | 	slug := data.Get(datasourceKeyMachineSlug).(string)
49 | 
50 | 	log.Printf("Read machine '%s'.", slug)
51 | 
52 | 	client := provider.(*octopus.Client)
53 | 	machine, err := client.GetMachine(slug)
54 | 	if err != nil {
55 | 		return err
56 | 	}
57 | 
58 | 	if machine == nil {
59 | 		// Machine has been deleted.
60 | 		data.SetId("")
61 | 
62 | 		return nil
63 | 	}
64 | 
65 | 	data.SetId(machine.ID)
66 | 	data.Set(datasourceKeyMachineName, machine.Name)
67 | 	data.Set(datasourceKeyMachineURI, machine.URI)
68 | 	data.Set(datasourceKeyMachineThumbprint, machine.Thumbprint)
69 | 
70 | 	return nil
71 | }
72 | 
73 | // Determine whether a machine datasource exists.
74 | func datasourceMachineExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
75 | 	slug := data.Get(datasourceKeyMachineSlug).(string)
76 | 
77 | 	log.Printf("Check if machine '%s' exists.", slug)
78 | 
79 | 	client := provider.(*octopus.Client)
80 | 
81 | 	var machine *octopus.Machine
82 | 	machine, err = client.GetMachine(slug)
83 | 	exists = machine != nil
84 | 
85 | 	return
86 | }
87 | 


--------------------------------------------------------------------------------
/datasource_project.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/helper/schema"
 5 | 	"log"
 6 | 	"octopus"
 7 | )
 8 | 
 9 | const (
10 | 	datasourceKeyProjectSlug = "slug"
11 | 	datasourceKeyProjectName = "name"
12 | )
13 | 
14 | func datasourceProject() *schema.Resource {
15 | 	return &schema.Resource{
16 | 		Read:   datasourceProjectRead,
17 | 		Exists: datasourceProjectExists,
18 | 
19 | 		Schema: map[string]*schema.Schema{
20 | 			datasourceKeyProjectSlug: &schema.Schema{
21 | 				Type:        schema.TypeString,
22 | 				Required:    true,
23 | 				Description: "The project slug (last segment of the project URL in Octopus UI).",
24 | 			},
25 | 			datasourceKeyProjectName: &schema.Schema{
26 | 				Type:        schema.TypeString,
27 | 				Computed:    true,
28 | 				Description: "The project name.",
29 | 			},
30 | 		},
31 | 	}
32 | }
33 | 
34 | // Read a project data-source.
35 | func datasourceProjectRead(data *schema.ResourceData, provider interface{}) error {
36 | 	slug := data.Get(datasourceKeyProjectSlug).(string)
37 | 
38 | 	log.Printf("Read project '%s'.", slug)
39 | 
40 | 	client := provider.(*octopus.Client)
41 | 	project, err := client.GetProject(slug)
42 | 	if err != nil {
43 | 		return err
44 | 	}
45 | 
46 | 	if project == nil {
47 | 		// Project has been deleted.
48 | 		data.SetId("")
49 | 
50 | 		return nil
51 | 	}
52 | 
53 | 	data.SetId(project.ID)
54 | 	data.Set(datasourceKeyProjectName, project.Name)
55 | 
56 | 	return nil
57 | }
58 | 
59 | // Determine whether a project datasource exists.
60 | func datasourceProjectExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
61 | 	id := data.Id()
62 | 
63 | 	log.Printf("Check if project '%s' exists.", id)
64 | 
65 | 	client := provider.(*octopus.Client)
66 | 
67 | 	var project *octopus.Project
68 | 	project, err = client.GetProject(id)
69 | 	exists = project != nil
70 | 
71 | 	return
72 | }
73 | 


--------------------------------------------------------------------------------
/datasource_variable.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"github.com/hashicorp/terraform/helper/schema"
  6 | 	"log"
  7 | 	"octopus"
  8 | )
  9 | 
 10 | const (
 11 | 	datasourceKeyVariableProjectID = "project"
 12 | 	datasourceKeyVariableName      = "name"
 13 | 	datasourceKeyVariableValue     = "value"
 14 | 	datasourceKeyVariableVariables = "variables"
 15 | 	datasourceKeyVariableRoles     = "roles"
 16 | 	datasourceKeyVariableMachines  = "machines"
 17 | 	datasourceKeyVariableActions   = "actions"
 18 | )
 19 | 
 20 | func datasourceVariable() *schema.Resource {
 21 | 	return &schema.Resource{
 22 | 		Read:   datasourceVariableRead,
 23 | 		Exists: datasourceVariableExists,
 24 | 
 25 | 		Schema: map[string]*schema.Schema{
 26 | 			datasourceKeyVariableProjectID: &schema.Schema{
 27 | 				Type:        schema.TypeString,
 28 | 				Required:    true,
 29 | 				Description: "The variable name.",
 30 | 			},
 31 | 			datasourceKeyVariableName: &schema.Schema{
 32 | 				Type:     schema.TypeString,
 33 | 				Required: true,
 34 | 			},
 35 | 			datasourceKeyVariableValue: &schema.Schema{
 36 | 				Type:     schema.TypeString,
 37 | 				Computed: true,
 38 | 			},
 39 | 			datasourceKeyVariableVariables: &schema.Schema{
 40 | 				Type: schema.TypeList,
 41 | 				Elem: &schema.Schema{
 42 | 					Type: schema.TypeString,
 43 | 				},
 44 | 				Optional: true,
 45 | 			},
 46 | 			datasourceKeyVariableRoles: &schema.Schema{
 47 | 				Type: schema.TypeList,
 48 | 				Elem: &schema.Schema{
 49 | 					Type: schema.TypeString,
 50 | 				},
 51 | 				Optional: true,
 52 | 			},
 53 | 			datasourceKeyVariableMachines: &schema.Schema{
 54 | 				Type: schema.TypeList,
 55 | 				Elem: &schema.Schema{
 56 | 					Type: schema.TypeString,
 57 | 				},
 58 | 				Optional: true,
 59 | 			},
 60 | 			datasourceKeyVariableActions: &schema.Schema{
 61 | 				Type: schema.TypeList,
 62 | 				Elem: &schema.Schema{
 63 | 					Type: schema.TypeString,
 64 | 				},
 65 | 				Optional: true,
 66 | 			},
 67 | 		},
 68 | 	}
 69 | }
 70 | 
 71 | // Read a variable data-source.
 72 | func datasourceVariableRead(data *schema.ResourceData, provider interface{}) error {
 73 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
 74 | 	name := data.Get(resourceKeyVariableName).(string)
 75 | 
 76 | 	propertyHelper := propertyHelper(data)
 77 | 	targetScope := octopus.VariableScopes{
 78 | 		Environments: propertyHelper.GetStringList(resourceKeyVariableEnvironments),
 79 | 		Roles:        propertyHelper.GetStringList(resourceKeyVariableRoles),
 80 | 		Machines:     propertyHelper.GetStringList(resourceKeyVariableMachines),
 81 | 		Actions:      propertyHelper.GetStringList(resourceKeyVariableActions),
 82 | 	}
 83 | 
 84 | 	log.Printf("Read variable '%s' in project '%s', targeting scope %+v", name, projectID, targetScope)
 85 | 
 86 | 	client := provider.(*octopus.Client)
 87 | 
 88 | 	variableSet, err := client.GetProjectVariableSet(projectID)
 89 | 	if err != nil {
 90 | 		return fmt.Errorf("Error retrieving variable set for project '%s': %s", projectID, err.Error())
 91 | 	}
 92 | 	if variableSet == nil {
 93 | 		return fmt.Errorf("Cannot find variable set for project '%s'", projectID)
 94 | 	}
 95 | 
 96 | 	matchingVariables := variableSet.GetVariablesByNameAndScopes(name, targetScope)
 97 | 	if len(matchingVariables) == 0 {
 98 | 		return fmt.Errorf("Cannot find variable '%s' in project '%s' with scope %+v", name, projectID, targetScope)
 99 | 	} else if len(matchingVariables) != 1 {
100 | 		return fmt.Errorf("Multiple variables exactly match name '%s' in project '%s' with scope %+v", name, projectID, targetScope)
101 | 	}
102 | 
103 | 	variable := matchingVariables[0]
104 | 	data.SetId(variable.ID)
105 | 	data.Set(datasourceKeyVariableName, variable.Name)
106 | 
107 | 	return nil
108 | }
109 | 
110 | // Determine whether a variable data-source exists.
111 | func datasourceVariableExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
112 | 	id := data.Id()
113 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
114 | 	name := data.Get(resourceKeyVariableName).(string)
115 | 
116 | 	log.Printf("Check if variable '%s' (name = '%s') exists in project '%s'", id, name, projectID)
117 | 
118 | 	client := provider.(*octopus.Client)
119 | 
120 | 	variableSet, err := client.GetProjectVariableSet(projectID)
121 | 	if err != nil {
122 | 		err = fmt.Errorf("Error retrieving variable set for project '%s': %s", projectID, err.Error())
123 | 
124 | 		return
125 | 	}
126 | 	if variableSet == nil {
127 | 		err = fmt.Errorf("Cannot find variable set for project '%s'", projectID)
128 | 
129 | 		return
130 | 	}
131 | 
132 | 	variable := variableSet.GetVariableByID(id)
133 | 	if variable == nil {
134 | 		log.Printf("Variable '%s' (name = '%s') not found", id, name)
135 | 
136 | 		return false, nil
137 | 	}
138 | 
139 | 	exists = true
140 | 
141 | 	return
142 | }
143 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/plugin"
 5 | )
 6 | 
 7 | // The main program entry-point.
 8 | func main() {
 9 | 	plugin.Serve(&plugin.ServeOpts{
10 | 		ProviderFunc:    Provider,
11 | 		ProvisionerFunc: Provisioner,
12 | 	})
13 | }
14 | 


--------------------------------------------------------------------------------
/provider.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/hashicorp/terraform/helper/schema"
 6 | 	"github.com/hashicorp/terraform/terraform"
 7 | 	"octopus"
 8 | 	"os"
 9 | )
10 | 
11 | // Provider creates the Octopus Deploy resource provider.
12 | func Provider() terraform.ResourceProvider {
13 | 	return &schema.Provider{
14 | 		// Provider settings schema
15 | 		Schema: map[string]*schema.Schema{
16 | 			"server_url": &schema.Schema{
17 | 				Type:        schema.TypeString,
18 | 				Required:    true,
19 | 				Description: "The base URL of the Octopus Deploy server.",
20 | 			},
21 | 			"api_key": &schema.Schema{
22 | 				Type:        schema.TypeString,
23 | 				Optional:    true,
24 | 				Sensitive:   true,
25 | 				Default:     "",
26 | 				Description: "The API key used to authenticate to the Octopus Deploy API (if not specified, then the OCTOPUS_API_KEY environment variable will be used).",
27 | 			},
28 | 		},
29 | 
30 | 		// Provider resource definitions
31 | 		ResourcesMap: map[string]*schema.Resource{
32 | 			"octopus_environment": resourceEnvironment(),
33 | 			"octopus_variable":    resourceVariable(),
34 | 		},
35 | 
36 | 		DataSourcesMap: map[string]*schema.Resource{
37 | 			"octopus_environment": datasourceEnvironment(),
38 | 			"octopus_machine":     datasourceMachine(),
39 | 			"octopus_project":     datasourceProject(),
40 | 			"octopus_variable":    datasourceVariable(),
41 | 		},
42 | 
43 | 		// Provider configuration
44 | 		ConfigureFunc: configureProvider,
45 | 	}
46 | }
47 | 
48 | // Configure the provider.
49 | // Returns the provider's compute API client.
50 | func configureProvider(providerSettings *schema.ResourceData) (interface{}, error) {
51 | 	server := providerSettings.Get("server_url").(string)
52 | 	apiKey := providerSettings.Get("api_key").(string)
53 | 
54 | 	if isEmpty(apiKey) {
55 | 		apiKey = os.Getenv("OCTOPUS_API_KEY")
56 | 	}
57 | 	if isEmpty(apiKey) {
58 | 		return nil, fmt.Errorf("The 'api_key' property was not specified for the 'octopus' provider, and the 'OCTOPUS_API_KEY' environment variable is not present. Please supply either one of these to configure the API key used to authenticate to Octopus Deploy.")
59 | 	}
60 | 
61 | 	var (
62 | 		client *octopus.Client
63 | 		err    error
64 | 	)
65 | 	client, err = octopus.NewClientWithAPIKey(server, apiKey)
66 | 	if err != nil {
67 | 		return nil, err
68 | 	}
69 | 
70 | 	return client, nil
71 | }
72 | 


--------------------------------------------------------------------------------
/provisioner.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/hashicorp/terraform/communicator/winrm"
 6 | 	"github.com/hashicorp/terraform/helper/config"
 7 | 	"github.com/hashicorp/terraform/terraform"
 8 | 	"log"
 9 | )
10 | 
11 | // Provisioner creates the Octopus Deploy resource provisioner.
12 | func Provisioner() terraform.ResourceProvisioner {
13 | 	return &OctopusProvisioner{}
14 | }
15 | 
16 | // OctopusProvisioner represents the Octopus Deploy provisioner.
17 | type OctopusProvisioner struct {
18 | 	// TODO: Decide what state we need to hold for the provisioner.
19 | }
20 | 
21 | // Apply executes provisioner
22 | func (provisioner *OctopusProvisioner) Apply(output terraform.UIOutput, state *terraform.InstanceState, cfg *terraform.ResourceConfig) error {
23 | 	log.Print("Executing Octopus Deploy provisioner.")
24 | 
25 | 	err := ensureConnectionIsWinRM(state)
26 | 	if err != nil {
27 | 		return err
28 | 	}
29 | 
30 | 	communicator, err := winrm.New(state)
31 | 	if err != nil {
32 | 		return err
33 | 	}
34 | 
35 | 	communicator.Connect(output)
36 | 	defer communicator.Disconnect()
37 | 
38 | 	// TODO: Use communicator to upload and execute provisioning script.
39 | 
40 | 	return nil
41 | }
42 | 
43 | // Validate checks if the required arguments are configured for the provisioner.
44 | func (provisioner *OctopusProvisioner) Validate(cfg *terraform.ResourceConfig) (warnings []string, errors []error) {
45 | 	validator := config.Validator{
46 | 		Required: []string{
47 | 		// TODO: List required fields.
48 | 		},
49 | 		Optional: []string{
50 | 		// TODO: List optional fields.
51 | 		},
52 | 	}
53 | 
54 | 	return validator.Validate(cfg)
55 | }
56 | 
57 | func ensureConnectionIsWinRM(state *terraform.InstanceState) error {
58 | 	connectionType := state.Ephemeral.ConnInfo["type"]
59 | 
60 | 	switch connectionType {
61 | 	case "winrm":
62 | 		return nil
63 | 	default:
64 | 		return fmt.Errorf("Connection type '%s' not supported for provisioning Octopus Deploy", connectionType)
65 | 	}
66 | }
67 | 


--------------------------------------------------------------------------------
/resource_environment.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"github.com/hashicorp/terraform/helper/schema"
  5 | 	"log"
  6 | 	"octopus"
  7 | )
  8 | 
  9 | const (
 10 | 	resourceKeyEnvironmentName          = "name"
 11 | 	resourceKeyEnvironmentDescription   = "description"
 12 | 	resourceKeyEnvironmentProjectGroups = "project_groups"
 13 | )
 14 | 
 15 | func resourceEnvironment() *schema.Resource {
 16 | 	return &schema.Resource{
 17 | 		Create: resourceEnvironmentCreate,
 18 | 		Read:   resourceEnvironmentRead,
 19 | 		Update: resourceEnvironmentUpdate,
 20 | 		Delete: resourceEnvironmentDelete,
 21 | 		Exists: resourceEnvironmentExists,
 22 | 
 23 | 		Schema: map[string]*schema.Schema{
 24 | 			resourceKeyEnvironmentName: &schema.Schema{
 25 | 				Type:        schema.TypeString,
 26 | 				Required:    true,
 27 | 				Description: "The environment name.",
 28 | 			},
 29 | 			resourceKeyEnvironmentDescription: &schema.Schema{
 30 | 				Type:        schema.TypeString,
 31 | 				Optional:    true,
 32 | 				Default:     "",
 33 | 				Description: "The environment description.",
 34 | 			},
 35 | 			resourceKeyEnvironmentProjectGroups: &schema.Schema{
 36 | 				Type: schema.TypeList,
 37 | 				Elem: &schema.Schema{
 38 | 					Type: schema.TypeString,
 39 | 				},
 40 | 				Computed:    true,
 41 | 				Optional:    true,
 42 | 				Default:     nil,
 43 | 				Description: "The Ids of project groups associated with the environment.",
 44 | 			},
 45 | 		},
 46 | 	}
 47 | }
 48 | 
 49 | // Create an environment resource.
 50 | func resourceEnvironmentCreate(data *schema.ResourceData, provider interface{}) error {
 51 | 	name := data.Get(resourceKeyEnvironmentName).(string)
 52 | 	description := data.Get(resourceKeyEnvironmentDescription).(string)
 53 | 
 54 | 	log.Printf("Create environment named '%s'.", name)
 55 | 
 56 | 	client := provider.(*octopus.Client)
 57 | 
 58 | 	environment, err := client.CreateEnvironment(name, description, 0)
 59 | 	if err != nil {
 60 | 		return err
 61 | 	}
 62 | 
 63 | 	data.SetId(environment.ID)
 64 | 
 65 | 	return nil
 66 | }
 67 | 
 68 | // Read an environment resource.
 69 | func resourceEnvironmentRead(data *schema.ResourceData, provider interface{}) error {
 70 | 	id := data.Id()
 71 | 	name := data.Get(resourceKeyEnvironmentName).(string)
 72 | 
 73 | 	log.Printf("Read environment '%s' (name = '%s').", id, name)
 74 | 
 75 | 	client := provider.(*octopus.Client)
 76 | 	environment, err := client.GetEnvironment(id)
 77 | 	if err != nil {
 78 | 		return err
 79 | 	}
 80 | 
 81 | 	if environment == nil {
 82 | 		// Environment has been deleted.
 83 | 		data.SetId("")
 84 | 
 85 | 		return nil
 86 | 	}
 87 | 
 88 | 	data.Set(resourceKeyEnvironmentName, environment.Name)
 89 | 	data.Set(resourceKeyEnvironmentDescription, environment.Description)
 90 | 
 91 | 	return nil
 92 | }
 93 | 
 94 | // Update an environment resource.
 95 | func resourceEnvironmentUpdate(data *schema.ResourceData, provider interface{}) error {
 96 | 	id := data.Id()
 97 | 
 98 | 	log.Printf("Update environment '%s'.", id)
 99 | 
100 | 	if !(data.HasChange(resourceKeyEnvironmentName) || data.HasChange(resourceKeyEnvironmentDescription)) {
101 | 		return nil // Nothing to do.
102 | 	}
103 | 
104 | 	client := provider.(*octopus.Client)
105 | 	environment, err := client.GetEnvironment(id)
106 | 	if err != nil {
107 | 		return err
108 | 	}
109 | 	if environment != nil {
110 | 		// Environment has been deleted.
111 | 		data.SetId("")
112 | 
113 | 		return nil
114 | 	}
115 | 
116 | 	if data.HasChange(resourceKeyEnvironmentName) {
117 | 		environment.Name = data.Get(resourceKeyEnvironmentName).(string)
118 | 	}
119 | 
120 | 	if data.HasChange(resourceKeyEnvironmentDescription) {
121 | 		environment.Description = data.Get(resourceKeyEnvironmentDescription).(string)
122 | 	}
123 | 
124 | 	_, err = client.UpdateEnvironment(environment)
125 | 
126 | 	return err
127 | }
128 | 
129 | // Delete an environment resource.
130 | func resourceEnvironmentDelete(data *schema.ResourceData, provider interface{}) error {
131 | 	id := data.Id()
132 | 	name := data.Get(resourceKeyEnvironmentName).(string)
133 | 
134 | 	log.Printf("Delete Environment '%s' (name = '%s').", id, name)
135 | 
136 | 	client := provider.(*octopus.Client)
137 | 
138 | 	return client.DeleteEnvironment(id)
139 | }
140 | 
141 | // Determine whether an environment resource exists.
142 | func resourceEnvironmentExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
143 | 	id := data.Id()
144 | 
145 | 	log.Printf("Check if environment '%s' exists.", id)
146 | 
147 | 	client := provider.(*octopus.Client)
148 | 
149 | 	var environment *octopus.Environment
150 | 	environment, err = client.GetEnvironment(id)
151 | 	exists = environment != nil
152 | 
153 | 	return
154 | }
155 | 


--------------------------------------------------------------------------------
/resource_helper.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/helper/schema"
 5 | )
 6 | 
 7 | // resourcePropertyHelper provides commonly-used functionality for working with Terraform's schema.ResourceData.
 8 | type resourcePropertyHelper struct {
 9 | 	data *schema.ResourceData
10 | }
11 | 
12 | func propertyHelper(data *schema.ResourceData) resourcePropertyHelper {
13 | 	return resourcePropertyHelper{data}
14 | }
15 | 
16 | func (helper resourcePropertyHelper) GetStringList(key string) (elements []string) {
17 | 	value, ok := helper.data.GetOk(key)
18 | 	if !ok {
19 | 		return
20 | 	}
21 | 
22 | 	untypedElements := value.([]interface{})
23 | 	elements = make([]string, len(untypedElements))
24 | 	for index, untypedElement := range untypedElements {
25 | 		elements[index] = untypedElement.(string)
26 | 	}
27 | 
28 | 	return
29 | }
30 | 
31 | func (helper resourcePropertyHelper) SetStringList(key string, elements []string) {
32 | 	untypedElements := make([]interface{}, len(elements))
33 | 	for index, element := range elements {
34 | 		var untypedElement interface{}
35 | 		untypedElement = element
36 | 
37 | 		untypedElements[index] = untypedElement
38 | 	}
39 | 
40 | 	helper.data.Set(key, untypedElements)
41 | }
42 | 
43 | func (helper resourcePropertyHelper) GetOptionalString(key string, allowEmpty bool) *string {
44 | 	value := helper.data.Get(key)
45 | 	switch typedValue := value.(type) {
46 | 	case string:
47 | 		if len(typedValue) > 0 || allowEmpty {
48 | 			return &typedValue
49 | 		}
50 | 	}
51 | 
52 | 	return nil
53 | }
54 | 
55 | func (helper resourcePropertyHelper) GetOptionalInt(key string, allowZero bool) *int {
56 | 	value := helper.data.Get(key)
57 | 	switch typedValue := value.(type) {
58 | 	case int:
59 | 		if typedValue != 0 || allowZero {
60 | 			return &typedValue
61 | 		}
62 | 	}
63 | 
64 | 	return nil
65 | }
66 | 
67 | func (helper resourcePropertyHelper) GetOptionalBool(key string) *bool {
68 | 	value := helper.data.Get(key)
69 | 	switch typedValue := value.(type) {
70 | 	case bool:
71 | 		return &typedValue
72 | 	default:
73 | 		return nil
74 | 	}
75 | }
76 | 


--------------------------------------------------------------------------------
/resource_variable.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"github.com/hashicorp/terraform/helper/schema"
  6 | 	"log"
  7 | 	"octopus"
  8 | )
  9 | 
 10 | const (
 11 | 	resourceKeyVariableProjectID    = "project"
 12 | 	resourceKeyVariableName         = "name"
 13 | 	resourceKeyVariableValue        = "value"
 14 | 	resourceKeyVariableEnvironments = "environments"
 15 | 	resourceKeyVariableRoles        = "roles"
 16 | 	resourceKeyVariableMachines     = "machines"
 17 | 	resourceKeyVariableActions      = "actions"
 18 | )
 19 | 
 20 | func resourceVariable() *schema.Resource {
 21 | 	return &schema.Resource{
 22 | 		Create: resourceVariableCreate,
 23 | 		Read:   resourceVariableRead,
 24 | 		Update: resourceVariableUpdate,
 25 | 		Delete: resourceVariableDelete,
 26 | 
 27 | 		Schema: map[string]*schema.Schema{
 28 | 			resourceKeyVariableProjectID: &schema.Schema{
 29 | 				Type:        schema.TypeString,
 30 | 				Required:    true,
 31 | 				Description: "The variable name.",
 32 | 			},
 33 | 			resourceKeyVariableName: &schema.Schema{
 34 | 				Type:     schema.TypeString,
 35 | 				Required: true,
 36 | 			},
 37 | 			resourceKeyVariableValue: &schema.Schema{
 38 | 				Type:     schema.TypeString,
 39 | 				Optional: true,
 40 | 				Computed: true,
 41 | 				Default:  nil,
 42 | 			},
 43 | 			resourceKeyVariableEnvironments: &schema.Schema{
 44 | 				Type: schema.TypeList,
 45 | 				Elem: &schema.Schema{
 46 | 					Type: schema.TypeString,
 47 | 				},
 48 | 				Optional: true,
 49 | 				Computed: true,
 50 | 			},
 51 | 			resourceKeyVariableRoles: &schema.Schema{
 52 | 				Type: schema.TypeList,
 53 | 				Elem: &schema.Schema{
 54 | 					Type: schema.TypeString,
 55 | 				},
 56 | 				Optional: true,
 57 | 				Computed: true,
 58 | 			},
 59 | 			resourceKeyVariableMachines: &schema.Schema{
 60 | 				Type: schema.TypeList,
 61 | 				Elem: &schema.Schema{
 62 | 					Type: schema.TypeString,
 63 | 				},
 64 | 				Optional: true,
 65 | 				Computed: true,
 66 | 			},
 67 | 			resourceKeyVariableActions: &schema.Schema{
 68 | 				Type: schema.TypeList,
 69 | 				Elem: &schema.Schema{
 70 | 					Type: schema.TypeString,
 71 | 				},
 72 | 				Optional: true,
 73 | 				Computed: true,
 74 | 			},
 75 | 		},
 76 | 	}
 77 | }
 78 | 
 79 | // Create a variable resource.
 80 | func resourceVariableCreate(data *schema.ResourceData, provider interface{}) error {
 81 | 	propertyHelper := propertyHelper(data)
 82 | 
 83 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
 84 | 	name := data.Get(resourceKeyVariableName).(string)
 85 | 
 86 | 	targetScope := octopus.VariableScopes{
 87 | 		Environments: propertyHelper.GetStringList(resourceKeyVariableEnvironments),
 88 | 		Roles:        propertyHelper.GetStringList(resourceKeyVariableRoles),
 89 | 		Machines:     propertyHelper.GetStringList(resourceKeyVariableMachines),
 90 | 		Actions:      propertyHelper.GetStringList(resourceKeyVariableActions),
 91 | 	}
 92 | 
 93 | 	log.Printf("Create variable '%s' for project '%s' (must match scopes: %#v)...", name, projectID, targetScope)
 94 | 
 95 | 	providerClient := provider.(*octopus.Client)
 96 | 
 97 | 	variableSet, err := providerClient.GetProjectVariableSet(projectID)
 98 | 	if err != nil {
 99 | 		return fmt.Errorf("Error retrieving variable set for project '%s': %s", projectID, err.Error())
100 | 	}
101 | 	if variableSet == nil {
102 | 		return fmt.Errorf("Cannot find variable set for project '%s'", projectID)
103 | 	}
104 | 
105 | 	matchingVariables := variableSet.GetVariablesByNameAndScopes(name, targetScope)
106 | 
107 | 	var variable octopus.Variable
108 | 	if len(matchingVariables) == 0 {
109 | 		log.Printf("Create variable '%s' for project '%s' with scope %#v...", name, projectID, targetScope)
110 | 
111 | 		variableSet.Variables = append(variableSet.Variables, octopus.Variable{
112 | 			Name:  name,
113 | 			Scope: targetScope,
114 | 		})
115 | 
116 | 		variableSet, err = providerClient.UpdateVariableSet(variableSet)
117 | 		if err != nil {
118 | 			return err
119 | 		}
120 | 
121 | 		matchingVariables = variableSet.GetVariablesByNameAndScopes(name, targetScope)
122 | 		if len(matchingVariables) != 1 {
123 | 			return fmt.Errorf("Found %d matching variables named '%s' for scope %#v (after attempting to create this variable for that scope).", len(matchingVariables), name, targetScope)
124 | 		}
125 | 	} else if len(matchingVariables) == 1 {
126 | 		log.Printf("Variable '%s' already exists for project '%s' with scope %#v.", name, projectID, targetScope)
127 | 	} else {
128 | 		return fmt.Errorf("Multiple variables exactly match scope %#v for variable '%s'.", name, targetScope)
129 | 	}
130 | 
131 | 	variable = matchingVariables[0]
132 | 	data.SetId(variable.ID)
133 | 	data.Set(resourceKeyVariableValue, variable.Value)
134 | 
135 | 	propertyHelper.SetStringList(resourceKeyVariableEnvironments, variable.Scope.Environments)
136 | 	propertyHelper.SetStringList(resourceKeyVariableRoles, variable.Scope.Roles)
137 | 	propertyHelper.SetStringList(resourceKeyVariableMachines, variable.Scope.Machines)
138 | 	propertyHelper.SetStringList(resourceKeyVariableActions, variable.Scope.Actions)
139 | 
140 | 	return nil
141 | }
142 | 
143 | // Read a variable resource.
144 | func resourceVariableRead(data *schema.ResourceData, provider interface{}) error {
145 | 	id := data.Id()
146 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
147 | 
148 | 	log.Printf("Read variable '%s' (for project '%s').", id, projectID)
149 | 
150 | 	providerClient := provider.(*octopus.Client)
151 | 
152 | 	variableSet, err := providerClient.GetProjectVariableSet(projectID)
153 | 	if err != nil {
154 | 		return err
155 | 	}
156 | 	if variableSet == nil {
157 | 		return fmt.Errorf("Cannot find variable set for project '%s'.", projectID)
158 | 	}
159 | 
160 | 	variable := variableSet.GetVariableByID(id)
161 | 	if variable == nil {
162 | 		// Variable has been deleted.
163 | 		data.SetId("")
164 | 
165 | 		return nil
166 | 	}
167 | 
168 | 	data.Set(resourceKeyVariableValue, variable.Value)
169 | 
170 | 	log.Printf("Variable scope is now %#v", variable.Scope)
171 | 	propertyHelper := propertyHelper(data)
172 | 	propertyHelper.SetStringList(resourceKeyVariableEnvironments, variable.Scope.Environments)
173 | 	propertyHelper.SetStringList(resourceKeyVariableRoles, variable.Scope.Roles)
174 | 	propertyHelper.SetStringList(resourceKeyVariableMachines, variable.Scope.Machines)
175 | 	propertyHelper.SetStringList(resourceKeyVariableActions, variable.Scope.Actions)
176 | 
177 | 	return nil
178 | }
179 | 
180 | // Update a variable resource.
181 | func resourceVariableUpdate(data *schema.ResourceData, provider interface{}) error {
182 | 	id := data.Id()
183 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
184 | 
185 | 	log.Printf("Update variable '%s' (for project '%s').", id, projectID)
186 | 
187 | 	providerClient := provider.(*octopus.Client)
188 | 
189 | 	variableSet, err := providerClient.GetProjectVariableSet(projectID)
190 | 	if err != nil {
191 | 		return err
192 | 	}
193 | 	if variableSet == nil {
194 | 		return fmt.Errorf("Cannot find variable set for project '%s'.", projectID)
195 | 	}
196 | 
197 | 	variable := variableSet.GetVariableByID(id)
198 | 	if variable == nil {
199 | 		// Variable has been deleted.
200 | 		data.SetId("")
201 | 
202 | 		return nil
203 | 	}
204 | 
205 | 	variableSet.UpdateVariable(id, func(variable *octopus.Variable) {
206 | 		if data.HasChange(resourceKeyVariableValue) {
207 | 			value, ok := data.GetOk(resourceKeyVariableValue)
208 | 			if ok {
209 | 				variable.Value = value.(string)
210 | 			} else {
211 | 				data.Set(resourceKeyVariableValue, variable.Value)
212 | 			}
213 | 		}
214 | 
215 | 		// TODO: Propagate scope changes (if any).
216 | 	})
217 | 
218 | 	_, err = providerClient.UpdateVariableSet(variableSet)
219 | 
220 | 	return err
221 | }
222 | 
223 | // Delete a variable resource.
224 | func resourceVariableDelete(data *schema.ResourceData, provider interface{}) error {
225 | 	id := data.Id()
226 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
227 | 
228 | 	log.Printf("Delete variable '%s' (for project '%s').", id, projectID)
229 | 
230 | 	providerClient := provider.(*octopus.Client)
231 | 	providerClient.Reset() // TODO: Replace call to Reset with appropriate API call(s).
232 | 
233 | 	return nil
234 | }
235 | 
236 | // Determine whether a variable resource exists.
237 | func resourceVariableExists(data *schema.ResourceData, provider interface{}) (exists bool, err error) {
238 | 	id := data.Id()
239 | 	projectID := data.Get(resourceKeyVariableProjectID).(string)
240 | 
241 | 	log.Printf("Check if variable '%s' exists.", id)
242 | 
243 | 	client := provider.(*octopus.Client)
244 | 
245 | 	var variableSet *octopus.VariableSet
246 | 	variableSet, err = client.GetProjectVariableSet(projectID)
247 | 	if err != nil {
248 | 		return
249 | 	}
250 | 
251 | 	exists = variableSet.GetVariableByID(id) != nil
252 | 
253 | 	return
254 | }
255 | 


--------------------------------------------------------------------------------
/utilities.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/hashicorp/terraform/helper/schema"
 5 | )
 6 | 
 7 | func newStringSet() *schema.Set {
 8 | 	return &schema.Set{
 9 | 		F: func(item interface{}) int {
10 | 			str := item.(string)
11 | 
12 | 			return schema.HashString(str)
13 | 		},
14 | 	}
15 | }
16 | 
17 | func stringToPtr(value string) *string {
18 | 	return &value
19 | }
20 | 
21 | func isEmpty(value string) bool {
22 | 	return len(value) == 0
23 | }
24 | 


--------------------------------------------------------------------------------