mitch/versionedTerraform
1
0
Fork 0
Code Issues Pull Requests Projects Releases 7 Wiki Activity

Compare commits

base: mitch:master
Branches Tags
mitch:master
mitch:1.2.3
mitch:1.2.2
mitch:1.2.1
mitch:1.2.0
mitch:1.1.0
mitch:v1.0.1
mitch:v1.0.0
..
compare: mitch:v1.0.1
Branches Tags
mitch:master
mitch:1.2.3
mitch:1.2.2
mitch:1.2.1
mitch:1.2.0
mitch:1.1.0
mitch:v1.0.1
mitch:v1.0.0

No commits in common. "master" and "v1.0.1" have entirely different histories.
master ... v1.0.1

27 changed files with 117 additions and 1204 deletions
Show Stats Expand all files Collapse all files

49
.circleci/config.yml
View File

@ -1,49 +0,0 @@
# Use the latest 2.1 version of CircleCI pipeline process engine.
# See: https://circleci.com/docs/2.0/configuration-reference
version: 2.1
# Define a job to be invoked later in a workflow.
# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
jobs:
build:
resource_class: small
working_directory: ~/repo
# Specify the execution environment. You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
# See: https://circleci.com/docs/2.0/configuration-reference/#docker-machine-macos-windows-executor
docker:
- image: cimg/go:1.17
# Add steps to the job
# See: https://circleci.com/docs/2.0/configuration-reference/#steps
steps:
- checkout
- restore_cache:
keys:
- go-mod-v4-{{ checksum "go.sum" }}
- run:
name: Install Dependencies
command: go mod download
- save_cache:
key: go-mod-v4-{{ checksum "go.sum" }}
paths:
- "/go/pkg/mod"
- run:
name: Run tests
command: |
mkdir -p /tmp/test-reports
mkdir -p /tmp/artifacts
go test -coverprofile=c.out
go tool cover -html=c.out -o coverage.html
mv coverage.html /tmp/artifacts
gotestsum --junitfile /tmp/test-reports/unit-tests.xml
- store_test_results:
path: /tmp/test-reports
- store_artifacts:
path: /tmp/artifacts
# Invoke jobs via workflows
# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
workflows:
build: # This is the name of the workflow, feel free to change it to better match your workflow.
# Inside the workflow, you define the jobs you want to run.
jobs:
- build

14
Makefile
View File

@ -7,12 +7,12 @@ build:
# Clean # Clean
#################################################### ####################################################
clean: clean:
rm -f $(shell go env GOPATH)/bin/versionedTerraform rm -f ~/.local/bin/versionedTerraform
#################################################### ####################################################
# Install # Install
#################################################### ####################################################
install: install:
mv versionedTerraform $(shell go env GOPATH)/bin/ mv versionedTerraform ~/.local/bin/
#################################################### ####################################################
# help feature # help feature
#################################################### ####################################################
@ -20,8 +20,8 @@ help:
@echo '' @echo ''
@echo 'Usage: make [TARGET]' @echo 'Usage: make [TARGET]'
@echo 'Targets:' @echo 'Targets:'
@echo ' build go build -o versionedTerraform ./cmd' @echo ' build go build -o versionedTerraform ./cmd'
@echo ' clean removes installed versionedTerraform file' @echo ' clean removes installed versionedTerraform file'
@echo ' install installs versionedTerraform to bin folder in GOPATH' @echo ' install installs versionedTerraform to local user bin folder'
@echo ' all Nothing to do.' @echo ' all Nothing to do.'
@echo '' @echo ''

13
README.md
View File

@ -1,11 +1,9 @@
[![<ORG_NAME>](https://circleci.com/gh/mitch-thompson/versionedTerraform.svg?style=svg)](<LINK>) #Versioned Terraform
# Versioned Terraform
A wrapper for terraform to detect the expected version of terraform, A wrapper for terraform to detect the expected version of terraform,
download, and execute that version download, and execute that version
## Requirements ## Requirements
- go - go compiler (only tested on go1.17)
## Install ## Install
`make build install` for installation to local user<br> `make build install` for installation to local user<br>
@ -16,12 +14,7 @@ download, and execute that version
All arguments are passed through to terraform All arguments are passed through to terraform
``` ```
## Sample usage ## sample usage
`versionedTerraform version` will display the terraform version executed in a folder `versionedTerraform version` will display the terraform version executed in a folder
## Configuration
A configuration file is created in `~/.versionedTerraform`<br><br>
`StableOnly` boolean values: <b>true</b>/false<br>
This value is used to restrict terraform to release versions only defaults to true
## Known Issues ## Known Issues

64
SemVersion.go
View File

@ -16,7 +16,6 @@ const (
type SemVersion struct { type SemVersion struct {
version string version string
isStable bool
majorVersion int majorVersion int
minorVersion int minorVersion int
patchVersion int patchVersion int
@ -30,7 +29,6 @@ type SemVersionInterface interface {
func NewSemVersion(v string) *SemVersion { func NewSemVersion(v string) *SemVersion {
s := new(SemVersion) s := new(SemVersion)
s.isStable = true
s.version = removeSpacesVersion(v) s.version = removeSpacesVersion(v)
s.setMajorVersion() s.setMajorVersion()
@ -39,14 +37,12 @@ func NewSemVersion(v string) *SemVersion {
return s return s
} }
//setMajorVersion setter for SemVersion.majorVersion
func (s *SemVersion) setMajorVersion() { func (s *SemVersion) setMajorVersion() {
version := s.version version := s.version
majorVersionString := strings.Split(version, ".")[0] majorVersionString := strings.Split(version, ".")[0]
s.majorVersion, _ = strconv.Atoi(majorVersionString) s.majorVersion, _ = strconv.Atoi(majorVersionString)
} }
//setMinorVersion setter for SemVersion.minorVersion
func (s *SemVersion) setMinorVersion() { func (s *SemVersion) setMinorVersion() {
version := s.version version := s.version
minorVersionString := strings.Split(version, ".")[1] minorVersionString := strings.Split(version, ".")[1]
@ -54,30 +50,21 @@ func (s *SemVersion) setMinorVersion() {
} }
//setPatchVersion setter for SemVersion.patchVersion
func (s *SemVersion) setPatchVersion() { func (s *SemVersion) setPatchVersion() {
version := s.version version := s.version
var err error
patchStringSlice := strings.Split(version, ".") patchStringSlice := strings.Split(version, ".")
if len(patchStringSlice) < 3 { if len(patchStringSlice) < 3 {
s.patchVersion = 0 s.patchVersion = 0
return return
} }
s.patchVersion, err = strconv.Atoi(patchStringSlice[2]) s.patchVersion, _ = strconv.Atoi(patchStringSlice[2])
if err != nil {
s.isStable = false
patchStringSlice = strings.Split(patchStringSlice[2], "-")
s.patchVersion, _ = strconv.Atoi(patchStringSlice[0])
}
} }
//ToString returns string of SemVersion
func (s *SemVersion) ToString() string { func (s *SemVersion) ToString() string {
return s.version return s.version
} }
//VersionInSlice iterates through slices of SemVersion to check if version is in slice
//Used by main.go to determine if terraform version is currently installed
func (s *SemVersion) VersionInSlice(sSem []SemVersion) bool { func (s *SemVersion) VersionInSlice(sSem []SemVersion) bool {
for _, ver := range sSem { for _, ver := range sSem {
if ver.ToString() == s.ToString() { if ver.ToString() == s.ToString() {
@ -86,50 +73,3 @@ func (s *SemVersion) VersionInSlice(sSem []SemVersion) bool {
} }
return false return false
} }
func (s *SemVersion) IsEqualTo(s2 SemVersion) bool {
if s.majorVersion == s2.majorVersion && s.minorVersion == s2.minorVersion && s.patchVersion == s2.patchVersion {
return true
}
return false
}
func (s *SemVersion) IsLessThan(s2 SemVersion) bool {
if s2.majorVersion > s.majorVersion {
return true
}
if s2.minorVersion > s.minorVersion && s2.majorVersion == s.majorVersion {
return true
}
if s2.patchVersion > s.patchVersion && s2.majorVersion == s.majorVersion && s2.minorVersion == s.minorVersion {
return true
}
return false
}
func (s *SemVersion) IsGreaterThan(s2 SemVersion) bool {
if s2.majorVersion < s.majorVersion {
return true
}
if s2.minorVersion < s.minorVersion && s2.majorVersion == s.majorVersion {
return true
}
if s2.patchVersion < s.patchVersion && s2.majorVersion == s.majorVersion && s2.minorVersion == s.minorVersion {
return true
}
return false
}
func (s *SemVersion) IsLessOrEqual(s2 SemVersion) bool {
if s.IsLessThan(s2) || s.IsEqualTo(s2) {
return true
}
return false
}
func (s *SemVersion) IsGreaterOrEqual(s2 SemVersion) bool {
if s.IsGreaterThan(s2) || s.IsEqualTo(s2) {
return true
}
return false
}

773
SemVersion_test.go
View File

@ -1,773 +0,0 @@
package versionedTerraform
import "testing"
func TestSemVersion_VersionInSlice_success(t *testing.T) {
want := SemVersion{
version: "1.1.9",
isStable: true,
majorVersion: 1,
minorVersion: 1,
patchVersion: 9,
}
ver1 := SemVersion{
version: "1.1.10",
isStable: true,
majorVersion: 1,
minorVersion: 1,
patchVersion: 10,
}
ver2 := SemVersion{
version: "0.1.9",
isStable: true,
majorVersion: 0,
minorVersion: 1,
patchVersion: 9,
}
ver3 := SemVersion{
version: "1.0.9",
isStable: true,
majorVersion: 1,
minorVersion: 0,
patchVersion: 9,
}
var semArray []SemVersion
semArray = append(semArray, ver1)
semArray = append(semArray, ver2)
semArray = append(semArray, ver3)
semArray = append(semArray, want)
if !want.VersionInSlice(semArray) {
t.Errorf("Expected Sem Version to be found in semArray")
}
}
func TestSemVersion_VersionInSlice_fail(t *testing.T) {
want := SemVersion{
version: "1.1.9",
isStable: true,
majorVersion: 1,
minorVersion: 1,
patchVersion: 9,
}
ver1 := SemVersion{
version: "1.1.10",
isStable: true,
majorVersion: 1,
minorVersion: 1,
patchVersion: 10,
}
ver2 := SemVersion{
version: "0.1.9",
isStable: true,
majorVersion: 0,
minorVersion: 1,
patchVersion: 9,
}
ver3 := SemVersion{
version: "1.0.9",
isStable: true,
majorVersion: 1,
minorVersion: 0,
patchVersion: 9,
}
var semArray []SemVersion
semArray = append(semArray, ver1)
semArray = append(semArray, ver2)
semArray = append(semArray, ver3)
if want.VersionInSlice(semArray) {
t.Errorf("Expected Sem Version to not be found in semArray")
}
}
func TestSemVersion_IsLessThan(t *testing.T) {
cases := []struct {
name string
want bool
s1, s2 SemVersion
}{
{"IsEqualTo",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MinorVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
},
{"PatchVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionGreater",
false,
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
},
{"MinorVersionGreater",
false,
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"PatchVersionGreater",
false,
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
got := c.s1.IsLessThan(c.s2)
if c.want != got {
t.Errorf("Expected %+v got %+v", c.want, got)
}
})
}
}
func TestSemVersion_IsGreaterThan(t *testing.T) {
cases := []struct {
name string
want bool
s1, s2 SemVersion
}{
{"IsEqualTo",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MinorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
},
{"PatchVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionGreater",
true,
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
},
{"MinorVersionGreater",
true,
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"PatchVersionGreater",
true,
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
got := c.s1.IsGreaterThan(c.s2)
if c.want != got {
t.Errorf("Expected %+v got %+v", c.want, got)
}
})
}
}
func TestSemVersion_IsEqualTo(t *testing.T) {
cases := []struct {
name string
want bool
s1, s2 SemVersion
}{
{"IsEqualTo",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MinorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
},
{"PatchVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionGreater",
false,
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
},
{"MinorVersionGreater",
false,
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"PatchVersionGreater",
false,
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
got := c.s1.IsEqualTo(c.s2)
if c.want != got {
t.Errorf("Expected %+v got %+v", c.want, got)
}
})
}
}
func TestSemVersion_IsLessOrEqual(t *testing.T) {
cases := []struct {
name string
want bool
s1, s2 SemVersion
}{
{"IsEqualTo",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MinorVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
},
{"PatchVersionLess",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionGreater",
false,
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
},
{"MinorVersionGreater",
false,
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"PatchVersionGreater",
false,
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
got := c.s1.IsLessOrEqual(c.s2)
if c.want != got {
t.Errorf("Expected %+v got %+v", c.want, got)
}
})
}
}
func TestSemVersion_IsGreaterOrEqual(t *testing.T) {
cases := []struct {
name string
want bool
s1, s2 SemVersion
}{
{"IsEqualTo",
true,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MinorVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
},
{"PatchVersionLess",
false,
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
},
{"MajorVersionGreater",
true,
SemVersion{
version: "2.2.3",
isStable: false,
majorVersion: 2,
minorVersion: 2,
patchVersion: 3,
},
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
},
{"MinorVersionGreater",
true,
SemVersion{
version: "1.3.3",
isStable: false,
majorVersion: 1,
minorVersion: 3,
patchVersion: 3,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
{"PatchVersionGreater",
true,
SemVersion{
version: "1.2.4",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 4,
},
SemVersion{
version: "1.2.3",
isStable: false,
majorVersion: 1,
minorVersion: 2,
patchVersion: 3,
},
},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
got := c.s1.IsGreaterOrEqual(c.s2)
if c.want != got {
t.Errorf("Expected %+v got %+v", c.want, got)
}
})
}
}

2
cmd/examples/example.tf
View File

@ -4,4 +4,4 @@ terraform {
output "hello" { output "hello" {
value = "world" value = "world"
} }

35
cmd/main.go
View File

@ -15,25 +15,20 @@ const (
terraformPrefix = "/terraform_" terraformPrefix = "/terraform_"
) )
var needsStable = true
func main() { func main() {
homeDir, _ := os.UserHomeDir() homeDir, _ := os.UserHomeDir()
configDirString := homeDir + shortConfigDirString configDirString := homeDir + shortConfigDirString
// Create configuration directory if it does not exist
_, err := os.Stat(configDirString) _, err := os.Stat(configDirString)
if os.IsNotExist(err) { if os.IsNotExist(err) {
err = versionedTerraform.CreateConfig(configDirString, configFileLocation) err = versionedTerraform.CreateConfig(configDirString, configFileLocation)
} }
// Create configuration file if it does not exist
_, err = os.Stat(configDirString + "/" + configFileLocation) _, err = os.Stat(configDirString + "/" + configFileLocation)
if os.IsNotExist(err) { if os.IsNotExist(err) {
err = versionedTerraform.CreateConfig(configDirString, configFileLocation) err = versionedTerraform.CreateConfig(configDirString, configFileLocation)
} }
// Let the user know if we couldn't create the config directory or file
if err != nil { if err != nil {
fmt.Printf("Unable to create config directory: %v", err) fmt.Printf("Unable to create config directory: %v", err)
} }
@ -45,28 +40,24 @@ func main() {
flag.Parse() flag.Parse()
args := flag.Args() args := flag.Args()
//Load available versions from configuration file
versionsFromConfig, err = versionedTerraform.LoadVersionsFromConfig(configDir, configFileLocation) versionsFromConfig, err = versionedTerraform.LoadVersionsFromConfig(configDir, configFileLocation)
if err != nil { if err != nil {
fmt.Printf("Unable to read config: %v\n", err) fmt.Printf("Unable to read config: %v", err)
os.Exit(1) os.Exit(1)
} }
//Check if we need to update available versions with terraform's website
//Then update configuration if we do
//todo move this above loading the config
needsUpdate, err := versionedTerraform.NeedToUpdateAvailableVersions(configDir, configFileLocation) needsUpdate, err := versionedTerraform.NeedToUpdateAvailableVersions(configDir, configFileLocation)
if os.ErrNotExist == err { if os.ErrNotExist == err {
fmt.Printf("Unable to update version: %v\n", err) fmt.Println("Unable to update version: %v", err)
} }
fileHandle, _ := os.OpenFile(configDirString+"/"+configFileLocation, os.O_RDWR, 0666)
defer fileHandle.Close()
if needsUpdate { if needsUpdate {
fileHandle, _ := os.OpenFile(configDirString+"/"+configFileLocation, os.O_RDWR, 0666)
defer fileHandle.Close()
versionedTerraform.UpdateConfig(*fileHandle) versionedTerraform.UpdateConfig(*fileHandle)
} }
// Load a slice of versions which have already been installed
installedVersions, err := versionedTerraform.LoadInstalledVersions(configDir) installedVersions, err := versionedTerraform.LoadInstalledVersions(configDir)
if err != nil { if err != nil {
fmt.Printf("Unable to verify installed verisons: %v", err) fmt.Printf("Unable to verify installed verisons: %v", err)
@ -78,14 +69,7 @@ func main() {
vSlice = append(vSlice, v.ToString()) vSlice = append(vSlice, v.ToString())
} }
// Check if stable version of terraform is required ver, err := versionedTerraform.GetVersionFromFile(workingDir, vSlice)
needsStable, err = versionedTerraform.ConfigRequiresStable(*fileHandle)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to open config file, defaulting to stable versions of terraform only")
}
// Load version required from terraform directory
ver, err := versionedTerraform.GetVersionFromFile(workingDir, vSlice, needsStable)
if err != nil { if err != nil {
fmt.Printf("Unable to retrieve terraform version from files: %v", err) fmt.Printf("Unable to retrieve terraform version from files: %v", err)
} }
@ -98,7 +82,6 @@ func main() {
} }
} }
// Execute terraform
terraformFile := configDirString + terraformPrefix + ver.VersionToString() terraformFile := configDirString + terraformPrefix + ver.VersionToString()
argsForTerraform := append([]string{""}, args...) argsForTerraform := append([]string{""}, args...)
cmd := exec.Cmd{ cmd := exec.Cmd{
@ -110,9 +93,5 @@ func main() {
Stdout: os.Stdout, Stdout: os.Stdout,
Stderr: os.Stderr, Stderr: os.Stderr,
} }
if err := cmd.Run(); err != nil { cmd.Run()
if exitError, ok := err.(*exec.ExitError); ok {
os.Exit(exitError.ExitCode())
}
}
} }

54
configManagement.go
View File

@ -12,36 +12,10 @@ import (
) )
type configStruct struct { type configStruct struct {
StableOnly bool
LastUpdate int64 LastUpdate int64
AvailableVersions []string AvailableVersions []string
} }
//ConfigRequiresStable returns bool, error only false if StableOnly: false is set in configuration file
func ConfigRequiresStable(File os.File) (bool, error) {
fileHandle, err := os.Open(File.Name())
if err != nil {
return true, err
}
defer fileHandle.Close()
fileScanner := bufio.NewScanner(fileHandle)
fileScanner.Split(bufio.ScanLines)
for fileScanner.Scan() {
_line := fileScanner.Text()
if strings.Contains(_line, "StableOnly: ") {
isStable := strings.SplitAfter(_line, "StableOnly: ")[1]
if strings.EqualFold(isStable, "false") {
return false, nil
}
}
}
return true, nil
}
//NeedToUpdateAvailableVersions returns bool, error checks if last update was older than 1 day ago
// this prevents us from spamming the list of available terraform versions page
func NeedToUpdateAvailableVersions(fileSystem fs.FS, availableVersions string) (bool, error) { func NeedToUpdateAvailableVersions(fileSystem fs.FS, availableVersions string) (bool, error) {
//todo this is used a lot abstract it? //todo this is used a lot abstract it?
fileHandle, err := fileSystem.Open(availableVersions) fileHandle, err := fileSystem.Open(availableVersions)
@ -71,8 +45,6 @@ func NeedToUpdateAvailableVersions(fileSystem fs.FS, availableVersions string) (
return false, nil return false, nil
} }
//LoadVersionsFromConfig returns slice of SemVersions and an error from AvailableVersions in configuration file
//This is stored from GetVersionList()
func LoadVersionsFromConfig(fileSystem fs.FS, configFile string) ([]SemVersion, error) { func LoadVersionsFromConfig(fileSystem fs.FS, configFile string) ([]SemVersion, error) {
fileHandle, err := fileSystem.Open(configFile) fileHandle, err := fileSystem.Open(configFile)
removeOpenBracket := regexp.MustCompile("\\[") removeOpenBracket := regexp.MustCompile("\\[")
@ -102,7 +74,6 @@ func LoadVersionsFromConfig(fileSystem fs.FS, configFile string) ([]SemVersion,
return nil, nil return nil, nil
} }
//LoadInstalledVersions returns list of SemVersions and an error from the directory listing of the .versionedTerraform
func LoadInstalledVersions(fileSystem fs.FS) ([]SemVersion, error) { func LoadInstalledVersions(fileSystem fs.FS) ([]SemVersion, error) {
dir, err := fs.ReadDir(fileSystem, ".") dir, err := fs.ReadDir(fileSystem, ".")
var installedTerraformVersions []SemVersion var installedTerraformVersions []SemVersion
@ -121,39 +92,24 @@ func LoadInstalledVersions(fileSystem fs.FS) ([]SemVersion, error) {
return installedTerraformVersions, nil return installedTerraformVersions, nil
} }
//UpdateConfig returns an error, and updates configuration file func UpdateConfig(File os.File) error {
// adding:
// a new date to the last updated field
// the available versions listed on terraforms website
// the status of if the user wants only stable releases
func UpdateConfig(File os.File, timeNow ...time.Time) error {
configValues := new(configStruct) configValues := new(configStruct)
configValues.AvailableVersions, _ = GetVersionList() configValues.AvailableVersions, _ = GetVersionList()
configValues.StableOnly, _ = ConfigRequiresStable(File)
var t time.Time timeNow := time.Now()
if len(timeNow) > 0 { configValues.LastUpdate = timeNow.Unix()
t = timeNow[0]
} else {
t = time.Now()
}
configValues.LastUpdate = t.Unix()
File.Truncate(0) File.Truncate(0)
File.Seek(0, 0) File.Seek(0, 0)
lineToByte := []byte(fmt.Sprintf("StableOnly: %+v\n", configValues.StableOnly)) lineToByte := []byte(fmt.Sprintf("LastUpdate: %d\n", configValues.LastUpdate))
File.Write(lineToByte)
lineToByte = []byte(fmt.Sprintf("LastUpdate: %d\n", configValues.LastUpdate))
File.Write(lineToByte) File.Write(lineToByte)
lineToByte = []byte(fmt.Sprintf("AvailableVersions: %+v\n", configValues.AvailableVersions)) lineToByte = []byte(fmt.Sprintf("AvailableVersions: %+v\n", configValues.AvailableVersions))
File.Write(lineToByte) File.Write(lineToByte)
return nil return nil
} }
//CreateConfig returns error, creates a new configuration file
func CreateConfig(directory string, configFile string) error { func CreateConfig(directory string, configFile string) error {
configFileName := directory + "/" + configFile configFileName := directory + "/" + configFile
err := os.MkdirAll(directory, 0755) err := os.MkdirAll(directory, 0755)
@ -164,8 +120,6 @@ func CreateConfig(directory string, configFile string) error {
fileHandler, err := os.Create(configFileName) fileHandler, err := os.Create(configFileName)
defer fileHandler.Close() defer fileHandler.Close()
lineToByte := []byte(fmt.Sprintf("StableOnly: true\n"))
fileHandler.Write(lineToByte)
err = UpdateConfig(*fileHandler) err = UpdateConfig(*fileHandler)
return err return err
} }

119
configManagement_test.go
View File

@ -2,11 +2,8 @@ package versionedTerraform
import ( import (
"fmt" "fmt"
"io"
"os"
"reflect" "reflect"
"sort" "sort"
"strings"
"testing" "testing"
"testing/fstest" "testing/fstest"
"time" "time"
@ -26,26 +23,26 @@ func TestUpdateAvailableVersions(t *testing.T) {
} }
t.Run("Test success last update time", func(t *testing.T) { t.Run("Test success last update time", func(t *testing.T) {
want := false want := true
got, err := NeedToUpdateAvailableVersions(fs, "successConfig.conf") got, err := NeedToUpdateAvailableVersions(fs, "successConfig.conf")
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
if got != want { if got != want {
t.Errorf("updateAvailableVersions had incorrect output expected %v got %v", want, got) t.Errorf("updateAvailableVersions had incorrect output expected %v got %v", got, want)
} }
}) })
t.Run("Test failed last update time", func(t *testing.T) { t.Run("Test failed last update time", func(t *testing.T) {
want := true want := false
got, err := NeedToUpdateAvailableVersions(fs, "failConfig.conf") got, err := NeedToUpdateAvailableVersions(fs, "failConfig.conf")
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
if got != want { if got != want {
t.Errorf("updateAvailableVersions had incorrect output expected %v got %v", want, got) t.Errorf("updateAvailableVersions had incorrect output expected %v got %v", got, want)
} }
}) })
} }
@ -82,27 +79,23 @@ func TestInstalledVersions(t *testing.T) {
} }
fs := fstest.MapFS{ fs := fstest.MapFS{
"terraform_0.12.31": {Data: []byte("")}, "terraform_0.12.31": {Data: []byte("")},
"terraform_0.12.30": {Data: []byte("")}, "terraform_0.12.30": {Data: []byte("")},
"terraform_0.11.10": {Data: []byte("")}, "terraform_0.11.10": {Data: []byte("")},
"terraform_0.11.15": {Data: []byte("")}, "terraform_0.11.15": {Data: []byte("")},
"terraform_1.0.1": {Data: []byte("")}, "terraform_1.0.1": {Data: []byte("")},
"terraform_1.0.12": {Data: []byte("")}, "terraform_1.0.12": {Data: []byte("")},
"terraform_1.2.23-alpha": {Data: []byte("")}, "terraform_1.1.1": {Data: []byte("")},
"terraform_1.1.1": {Data: []byte("")}, "terraform_1.1.2": {Data: []byte("")},
"terraform_1.1.2": {Data: []byte("")}, "terraform_1.1.3": {Data: []byte("")},
"terraform_1.1.3": {Data: []byte("")}, "terraform_1.1.4": {Data: []byte("")},
"terraform_1.1.4": {Data: []byte("")}, "terraform_1.1.5": {Data: []byte("")},
"terraform_1.1.5": {Data: []byte("")}, "terraform_1.1.6": {Data: []byte("")},
"terraform_1.1.6": {Data: []byte("")}, "terraform_1.1.7": {Data: []byte("")},
"terraform_1.1.7": {Data: []byte("")}, "terraform_1.1.8": {Data: []byte("")},
"terraform_1.1.8": {Data: []byte("")}, "terraform_1.1.9": {Data: []byte("")},
"terraform_1.1.9": {Data: []byte("")}, "terraform_1.1.10": {Data: []byte("")},
"terraform_1.1.10": {Data: []byte("")}, "terraform_1.1.11": {Data: []byte("")},
"terraform_1.1.11": {Data: []byte("")},
"terraform_0.14.0": {Data: []byte("")},
"terraform_0.13.1": {Data: []byte("")},
"terraform_0.13.0": {Data: []byte("")},
} }
t.Run("Test installed versions", func(t *testing.T) { t.Run("Test installed versions", func(t *testing.T) {
@ -117,73 +110,3 @@ func TestInstalledVersions(t *testing.T) {
}) })
} }
func TestConfigRequiresStable(t *testing.T) {
availableVersions, _ := GetVersionList()
versions := strings.Join(availableVersions, " ")
cases := []struct {
name, content, want string
timeNow time.Time
}{
{"StableOnly True", "StableOnly: true\n" +
"LastUpdate: 1674481203\n" +
"AvailableVersions: [1.3.7]",
"StableOnly: true\n" +
"LastUpdate: 1286705410\n" +
"AvailableVersions: [" +
versions + "]\n",
time.Date(2010, 10, 10, 10, 10, 10, 10, time.UTC)},
{"StableOnly False", "StableOnly: false\n" +
"LastUpdate: 1674481203\n" +
"AvailableVersions: [1.3.7]",
"StableOnly: false\n" +
"LastUpdate: 1286705410\n" +
"AvailableVersions: [" +
versions + "]\n",
time.Date(2010, 10, 10, 10, 10, 10, 10, time.UTC)},
{"StableOnly not found", "LastUpdate: 1674481203\n" +
"AvailableVersions: [1.3.7]",
"StableOnly: true\n" +
"LastUpdate: 1286705410\n" +
"AvailableVersions: [" +
versions + "]\n",
time.Date(2010, 10, 10, 10, 10, 10, 10, time.UTC)},
}
for _, c := range cases {
t.Run("Test: "+c.name, func(t *testing.T) {
t.Parallel()
tempDir := os.TempDir()
tempFile, err := os.Create(tempDir + "/config")
defer tempFile.Close()
if err != nil {
t.Errorf("Unable to execute test : %v", err)
}
UpdateConfig(*tempFile, c.timeNow)
tempFile.Seek(0, 0)
data := make([]byte, 1024)
var got string
for {
n, err := tempFile.Read(data)
if err == io.EOF {
break
}
if err != nil {
t.Errorf("File reading error : %v", err)
return
}
got += string(data[:n])
}
if !reflect.DeepEqual(got, c.want) {
t.Errorf("%v test failed to meet conditions", c.name)
fmt.Fprintf(os.Stdout, "%v\n", c.want)
fmt.Fprintf(os.Stdout, "%v\n", got)
}
})
}
}

4
darwin_amd64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_darwin_amd64.zip" fileSuffix = "_darwin_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
darwin_arm_64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_darwin_arm64.zip" fileSuffix = "_darwin_arm64.zip"
minVersion = "1.0.2"
alternateSuffix = "_darwin_amd64.zip"
) )

11
fileHandler.go
View File

@ -7,15 +7,9 @@ import (
"strings" "strings"
) )
var needsStable bool
//GetVersionFromFile returns Version pointer and error
//Iterates through files in current directory and sending to parseVersionFromFile
//todo this should be (Version) GetVers... //todo this should be (Version) GetVers...
func GetVersionFromFile(fileSystem fs.FS, versionList []string, needsStableValue bool) (*Version, error) { func GetVersionFromFile(fileSystem fs.FS, versionList []string) (*Version, error) {
needsStable = needsStableValue
var versionFinal Version var versionFinal Version
versionFinal = *NewVersion(">= 0.0.0", versionList)
dir, err := fs.ReadDir(fileSystem, ".") dir, err := fs.ReadDir(fileSystem, ".")
if err != nil { if err != nil {
return &versionFinal, err return &versionFinal, err
@ -35,9 +29,6 @@ func GetVersionFromFile(fileSystem fs.FS, versionList []string, needsStableValue
} }
//todo same here //todo same here
//parseVersionFromFile returns Version pointer, bool, and error
//bool returns true if required_version is found
//if required_version is found sends to NewVersion to determine required version for the application
func parseVersionFromFile(f fs.FS, fileName string, versionList []string) (*Version, bool, error) { func parseVersionFromFile(f fs.FS, fileName string, versionList []string) (*Version, bool, error) {
fileHandle, err := f.Open(fileName) fileHandle, err := f.Open(fileName)
regex := regexp.MustCompile("required_version\\s+?=") regex := regexp.MustCompile("required_version\\s+?=")

30
fileHandler_test.go
View File

@ -5,8 +5,9 @@ import (
"testing/fstest" "testing/fstest"
) )
const ( func TestFileHandler(t *testing.T) {
firstFile = ` const (
firstFile = `
resource "aws_mq_broker" "sample" { resource "aws_mq_broker" "sample" {
depends_on = [aws_security_group.mq] depends_on = [aws_security_group.mq]
broker_name = var.name broker_name = var.name
@ -20,14 +21,13 @@ resource "aws_mq_broker" "sample" {
subnet_ids = ["10.0.0.0/24", "10.0.1.0/24"] subnet_ids = ["10.0.0.0/24", "10.0.1.0/24"]
} }
` `
secondFile = ` secondFile = `
terraform { terraform {
required_version = "~> 0.12.4" required_version = "~> 0.12.4"
} }
` `
) )
func TestFileHandler(t *testing.T) {
want := NewVersion("0.12.31", testVersionList()) want := NewVersion("0.12.31", testVersionList())
fs := fstest.MapFS{ fs := fstest.MapFS{
@ -35,25 +35,7 @@ func TestFileHandler(t *testing.T) {
"versions.tf": {Data: []byte(secondFile)}, "versions.tf": {Data: []byte(secondFile)},
} }
version, err := GetVersionFromFile(fs, testVersionList(), true) version, err := GetVersionFromFile(fs, testVersionList())
if err != nil {
t.Fatal(err)
}
got := *version
if got.Version != want.Version {
t.Errorf("Expected %v, got %v", want.Version, got.Version)
}
}
func TestEmptyTerraformVersion(t *testing.T) {
want := NewVersion("1.1.11", testVersionList())
fs := fstest.MapFS{"main.tf": {Data: []byte(firstFile)}}
version, err := GetVersionFromFile(fs, testVersionList(), true)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)

4
freebsd_386.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_freebsd_386.zip" fileSuffix = "_freebsd_386.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
freebsd_amd_64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_freebsd_amd64.zip" fileSuffix = "_freebsd_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
freebsd_arm.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_freebsd_arm.zip" fileSuffix = "_freebsd_arm.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
linux_386.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_linux_386.zip" fileSuffix = "_linux_386.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
linux_amd_64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_linux_amd64.zip" fileSuffix = "_linux_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
linux_arm.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_linux_arm.zip" fileSuffix = "_linux_arm.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
linux_arm64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_linux_arm64.zip" fileSuffix = "_linux_arm64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
openbsd_386.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_openbsd_386.zip" fileSuffix = "_openbsd_386.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
openbsd_amd64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_openbsd_amd64.zip" fileSuffix = "_openbsd_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
solaris_amd64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_solaris_amd64.zip" fileSuffix = "_solaris_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

98
versionedTerraform.go
View File

@ -5,7 +5,6 @@ import (
"bufio" "bufio"
"bytes" "bytes"
"errors" "errors"
"fmt"
"io" "io"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -14,6 +13,15 @@ import (
"strings" "strings"
) )
func (*Version) latestMajorVersion() {
}
func (*Version) latestMinorVersion() {
}
func (*Version) latestPatchVersion() {
}
type Version struct { type Version struct {
Version SemVersion Version SemVersion
availableVersions []SemVersion availableVersions []SemVersion
@ -26,19 +34,19 @@ const (
versionedTerraformFolder = "/.versionedTerraform" versionedTerraformFolder = "/.versionedTerraform"
) )
// getLatestMajorRelease() returns the latest major release from Version //getLatestMajorRelease() returns the latest major release from Version
func (v *Version) getLatestMajorRelease() { func (v *Version) getLatestMajorRelease() {
//todo clean up
for _, release := range v.availableVersions { for _, release := range v.availableVersions {
if release.majorVersion == v.Version.majorVersion && if release.majorVersion == v.Version.majorVersion &&
release.minorVersion == v.Version.minorVersion && release.minorVersion == v.Version.minorVersion &&
release.patchVersion >= v.Version.patchVersion && release.patchVersion >= v.Version.patchVersion {
(v.Version.isStable || !needsStable) {
v.Version = release v.Version = release
} }
} }
} }
// getGreatestRelease() returns less than release //getGreatestRelease() returns less than release
func (v *Version) getOneLessRelease() { func (v *Version) getOneLessRelease() {
var vSlice []Version var vSlice []Version
@ -61,89 +69,83 @@ func (v *Version) getOneLessRelease() {
} }
} }
// getLatestRelease returns the latest release from Version //getLatestRelease returns the latest release from Version
func (v *Version) getLatestRelease() { func (v *Version) getLatestRelease() {
//todo clean up
for _, release := range v.availableVersions { for _, release := range v.availableVersions {
if release.majorVersion > v.Version.majorVersion && if release.majorVersion > v.Version.majorVersion {
(release.isStable || !needsStable) {
v.Version = release v.Version = release
} }
if release.majorVersion >= v.Version.majorVersion && if release.majorVersion >= v.Version.majorVersion &&
release.minorVersion > v.Version.minorVersion && release.minorVersion > v.Version.minorVersion {
(release.isStable || !needsStable) {
v.Version = release v.Version = release
} }
if release.majorVersion >= v.Version.majorVersion && if release.majorVersion >= v.Version.majorVersion &&
release.minorVersion >= v.Version.minorVersion && release.minorVersion >= v.Version.minorVersion &&
release.patchVersion >= v.Version.patchVersion && release.patchVersion >= v.Version.patchVersion {
(release.isStable || !needsStable) {
v.Version = release v.Version = release
} }
} }
} }
// InstallTerraformVersion installs the defined terraform Version in the application //InstallTerraformVersion installs the defined terraform Version in the application
// configuration directory //configuration directory
func (v *Version) InstallTerraformVersion() error { func (v *Version) InstallTerraformVersion() error {
homeDir, _ := os.UserHomeDir() homeDir, _ := os.UserHomeDir()
suffix := fileSuffix resp, err := http.Get(hashicorpUrl +
minV := NewSemVersion(minVersion)
if v.Version.IsLessThan(*minV) {
suffix = alternateSuffix
}
url := hashicorpUrl +
v.Version.ToString() + v.Version.ToString() +
"/" + terraformPrefix + "/" + terraformPrefix +
v.Version.ToString() + v.Version.ToString() +
suffix fileSuffix)
resp, err := http.Get(url)
if err != nil { if err != nil {
return fmt.Errorf("failed to download Terraform: %v", err) return err
} }
defer resp.Body.Close() defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body) body, err := ioutil.ReadAll(resp.Body)
if err != nil { if err != nil {
return fmt.Errorf("failed to read response body: %v", err) return err
} }
zipReader, err := zip.NewReader(bytes.NewReader(body), int64(len(body))) zipReader, err := zip.NewReader(bytes.NewReader(body), int64(len(body)))
if err != nil { if err != nil {
return fmt.Errorf("failed to create zip reader: %v", err) return err
} }
versionedFileName := homeDir + versionedTerraformFolder + "/" + terraformPrefix + v.Version.ToString() versionedFileName := homeDir + versionedTerraformFolder + "/" + terraformPrefix + v.Version.ToString()
versionedFile, err := os.OpenFile(versionedFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755) versionedFile, err := os.OpenFile(versionedFileName, os.O_WRONLY, 0755)
if os.IsNotExist(err) {
//_, err = os.Create(versionedFileName)
//if err != nil {
// return err
//}
versionedFile, err = os.OpenFile(versionedFileName, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
if err != nil {
return err
}
}
if err != nil { if err != nil {
return fmt.Errorf("failed to create output file: %v", err) return err
} }
defer versionedFile.Close() defer versionedFile.Close()
for _, zipFile := range zipReader.File { for _, zipFIle := range zipReader.File {
if zipFile.Name != "terraform" { zr, err := zipFIle.Open()
continue
}
zr, err := zipFile.Open()
if err != nil { if err != nil {
return fmt.Errorf("failed to open zip file: %v", err) return err
} }
defer zr.Close() unzippedFileBytes, _ := ioutil.ReadAll(zr)
_, err = io.Copy(versionedFile, zr) _, err = versionedFile.Write(unzippedFileBytes)
if err != nil { if err != nil {
return fmt.Errorf("failed to write terraform binary: %v", err) return err
} }
zr.Close()
break
} }
return nil return nil
} }
// NewVersion creates a new Version using sem versioning for determining the //NewVersion creates a new Version using sem versioning for determining the
// latest release //latest release
func NewVersion(_version string, _vList []string) *Version { func NewVersion(_version string, _vList []string) *Version {
v := new(Version) v := new(Version)
v.Version = *NewSemVersion(_version) v.Version = *NewSemVersion(_version)
@ -206,7 +208,7 @@ func NewVersion(_version string, _vList []string) *Version {
return v return v
} }
// GetVersionList returns a list of available versions from hashicorp's release page //GetVersionList returns a list of available versions from hashicorp's release page
func GetVersionList() ([]string, error) { func GetVersionList() ([]string, error) {
var versionList []string var versionList []string
resp, err := http.Get(hashicorpUrl) resp, err := http.Get(hashicorpUrl)
@ -238,7 +240,7 @@ func GetVersionList() ([]string, error) {
return versionList, nil return versionList, nil
} }
// removeSpacesVersion removes spaces from Version string for parsing //removeSpacesVersion removes spaces from Version string for parsing
func removeSpacesVersion(v string) string { func removeSpacesVersion(v string) string {
splitV := strings.Split(v, " ") splitV := strings.Split(v, " ")
var returnString string var returnString string
@ -249,12 +251,12 @@ func removeSpacesVersion(v string) string {
return strings.TrimSpace(returnString) return strings.TrimSpace(returnString)
} }
// VersionToString returns string of a Version //VersionToString returns string of a Version
func (v *Version) VersionToString() string { func (v *Version) VersionToString() string {
return v.Version.ToString() return v.Version.ToString()
} }
// isVersionGreater returns true if v1 is greater than v2 //versionCompare returns true if v1 is greater than v2
func isVersionGreater(v1 Version, v2 Version) bool { func isVersionGreater(v1 Version, v2 Version) bool {
if v1.Version.majorVersion != v2.Version.majorVersion { if v1.Version.majorVersion != v2.Version.majorVersion {
if v1.Version.majorVersion > v2.Version.majorVersion { if v1.Version.majorVersion > v2.Version.majorVersion {

3
versionedTerraform_test.go
View File

@ -6,7 +6,6 @@ import (
func testVersionList() []string { func testVersionList() []string {
return []string{ return []string{
"1.2.23-alpha",
"1.1.11", "1.1.11",
"1.1.10", "1.1.10",
"1.1.9", "1.1.9",
@ -138,7 +137,7 @@ func TestIsVersionGreater(t *testing.T) {
func TestGetVersionList(t *testing.T) { func TestGetVersionList(t *testing.T) {
//todo write test for this //todo write test for this
//response, _ := GetVersionList() //response, _ := getVersionList()
//for _, Version := range response { //for _, Version := range response {
// t.Errorf("%v", Version) // t.Errorf("%v", Version)
//} //}

4
windows_386.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_windows_386.zip" fileSuffix = "_windows_386.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )

4
windows_amd64.go
View File

@ -4,7 +4,5 @@
package versionedTerraform package versionedTerraform
const ( const (
fileSuffix = "_windows_amd64.zip" fileSuffix = "_windows_amd64.zip"
minVersion = "0.0.0"
alternateSuffix = ""
) )