Import functions from Terraform

.circleci/config.yml

@@ -28,29 +28,31 @@ commands:
     steps:
       - run: mkdir ~/goroot && curl https://dl.google.com/go/go<< parameters.GOVERSION >>.windows-amd64.zip --output ~/go<< parameters.GOVERSION >>.windows-amd64.zip
       - run: unzip ~/go<< parameters.GOVERSION >>.windows-amd64.zip -d ~/goroot
-  go-test:
+  go-tests:
     parameters:
-      FOLDER:
-        type: string
       GO:
         type: string
         default: go
     steps:
-      - run: cd << parameters.FOLDER >> && << parameters.GO >> env && << parameters.GO >> test .
-
+      - run: << parameters.GO >> test ./...
+  
 jobs:
   test-linux:
     executor: golang
     working_directory: /go/src/github.com/hashicorp/go-cty-funcs
     steps:
       - checkout
+      - go-tests
+
   test-darwin:
     executor: darwin
     working_directory: ~/go/src/github.com/hashicorp/go-cty-funcs
     steps:
       - checkout
       - install-go-unix:
           GOOS: darwin
+      - go-tests:
+          GO: ~/goroot/go/bin/go
   test-windows:
     executor:
       name: win/vs2019
@@ -59,6 +61,8 @@ jobs:
     steps:
       - checkout
       - install-go-windows
+      - go-tests:
+          GO: ~/goroot/go/bin/go
   check-fmt:
     executor: golang
     steps:

.test.sh

@@ -0,0 +1,13 @@
+set -e
+clear
+go fmt ./... 
+goimports -w */*.go 
+for f in */
+do
+    pushd $f > /dev/null
+    go mod tidy
+    go test .
+    popd > /dev/null
+done
+
+git diff --exit-code --ignore-space-change --ignore-space-at-eol

cidr/host.go

@@ -0,0 +1,49 @@
+package cidr
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/apparentlymart/go-cidr/cidr"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// HostFunc is a function that calculates a full host IP address within a given
+// IP network address prefix.
+var HostFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "prefix",
+			Type: cty.String,
+		},
+		{
+			Name: "hostnum",
+			Type: cty.Number,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		var hostNum int
+		if err := gocty.FromCtyValue(args[1], &hostNum); err != nil {
+			return cty.UnknownVal(cty.String), err
+		}
+		_, network, err := net.ParseCIDR(args[0].AsString())
+		if err != nil {
+			return cty.UnknownVal(cty.String), fmt.Errorf("invalid CIDR expression: %s", err)
+		}
+
+		ip, err := cidr.Host(network, hostNum)
+		if err != nil {
+			return cty.UnknownVal(cty.String), err
+		}
+
+		return cty.StringVal(ip.String()), nil
+	},
+})
+
+// Host calculates a full host IP address within a given IP network address prefix.
+func Host(prefix, hostnum cty.Value) (cty.Value, error) {
+	return HostFunc.Call([]cty.Value{prefix, hostnum})
+}

cidr/host_test.go

@@ -0,0 +1,79 @@
+package cidr
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+func TestHost(t *testing.T) {
+	tests := []struct {
+		Prefix  cty.Value
+		Hostnum cty.Value
+		Want    cty.Value
+		Err     bool
+	}{
+		{
+			cty.StringVal("192.168.1.0/24"),
+			cty.NumberIntVal(5),
+			cty.StringVal("192.168.1.5"),
+			false,
+		},
+		{
+			cty.StringVal("192.168.1.0/24"),
+			cty.NumberIntVal(-5),
+			cty.StringVal("192.168.1.251"),
+			false,
+		},
+		{
+			cty.StringVal("192.168.1.0/24"),
+			cty.NumberIntVal(-256),
+			cty.StringVal("192.168.1.0"),
+			false,
+		},
+		{
+			cty.StringVal("192.168.1.0/30"),
+			cty.NumberIntVal(255),
+			cty.UnknownVal(cty.String),
+			true, // 255 doesn't fit in two bits
+		},
+		{
+			cty.StringVal("192.168.1.0/30"),
+			cty.NumberIntVal(-255),
+			cty.UnknownVal(cty.String),
+			true, // 255 doesn't fit in two bits
+		},
+		{
+			cty.StringVal("not-a-cidr"),
+			cty.NumberIntVal(6),
+			cty.UnknownVal(cty.String),
+			true, // not a valid CIDR mask
+		},
+		{
+			cty.StringVal("10.256.0.0/8"),
+			cty.NumberIntVal(6),
+			cty.UnknownVal(cty.String),
+			true, // can't have an octet >255
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("cidrhost(%#v, %#v)", test.Prefix, test.Hostnum), func(t *testing.T) {
+			got, err := Host(test.Prefix, test.Hostnum)
+
+			if test.Err {
+				if err == nil {
+					t.Fatal("succeeded; want error")
+				}
+				return
+			} else if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+
+			if !got.RawEquals(test.Want) {
+				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
+			}
+		})
+	}
+}

cidr/netmask.go

@@ -0,0 +1,34 @@
+package cidr
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// NetmaskFunc is a function that converts an IPv4 address prefix given in CIDR
+// notation into a subnet mask address.
+var NetmaskFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "prefix",
+			Type: cty.String,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		_, network, err := net.ParseCIDR(args[0].AsString())
+		if err != nil {
+			return cty.UnknownVal(cty.String), fmt.Errorf("invalid CIDR expression: %s", err)
+		}
+
+		return cty.StringVal(net.IP(network.Mask).String()), nil
+	},
+})
+
+// Netmask converts an IPv4 address prefix given in CIDR notation into a subnet mask address.
+func Netmask(prefix cty.Value) (cty.Value, error) {
+	return NetmaskFunc.Call([]cty.Value{prefix})
+}

cidr/netmask_test.go

@@ -0,0 +1,66 @@
+package cidr
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+func TestNetmask(t *testing.T) {
+	tests := []struct {
+		Prefix cty.Value
+		Want   cty.Value
+		Err    bool
+	}{
+		{
+			cty.StringVal("192.168.1.0/24"),
+			cty.StringVal("255.255.255.0"),
+			false,
+		},
+		{
+			cty.StringVal("192.168.1.0/32"),
+			cty.StringVal("255.255.255.255"),
+			false,
+		},
+		{
+			cty.StringVal("0.0.0.0/0"),
+			cty.StringVal("0.0.0.0"),
+			false,
+		},
+		{
+			cty.StringVal("1::/64"),
+			cty.StringVal("ffff:ffff:ffff:ffff::"),
+			false,
+		},
+		{
+			cty.StringVal("not-a-cidr"),
+			cty.UnknownVal(cty.String),
+			true, // not a valid CIDR mask
+		},
+		{
+			cty.StringVal("110.256.0.0/8"),
+			cty.UnknownVal(cty.String),
+			true, // can't have an octet >255
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("cidrnetmask(%#v)", test.Prefix), func(t *testing.T) {
+			got, err := Netmask(test.Prefix)
+
+			if test.Err {
+				if err == nil {
+					t.Fatal("succeeded; want error")
+				}
+				return
+			} else if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+
+			if !got.RawEquals(test.Want) {
+				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
+			}
+		})
+	}
+}

cidr/subnet.go

@@ -0,0 +1,66 @@
+package cidr
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/apparentlymart/go-cidr/cidr"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// SubnetFunc is a function that calculates a subnet address within a given
+// IP network address prefix.
+var SubnetFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "prefix",
+			Type: cty.String,
+		},
+		{
+			Name: "newbits",
+			Type: cty.Number,
+		},
+		{
+			Name: "netnum",
+			Type: cty.Number,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		var newbits int
+		if err := gocty.FromCtyValue(args[1], &newbits); err != nil {
+			return cty.UnknownVal(cty.String), err
+		}
+		var netnum int
+		if err := gocty.FromCtyValue(args[2], &netnum); err != nil {
+			return cty.UnknownVal(cty.String), err
+		}
+
+		_, network, err := net.ParseCIDR(args[0].AsString())
+		if err != nil {
+			return cty.UnknownVal(cty.String), fmt.Errorf("invalid CIDR expression: %s", err)
+		}
+
+		// For portability with 32-bit systems where the subnet number will be
+		// a 32-bit int, we only allow extension of 32 bits in one call even if
+		// we're running on a 64-bit machine. (Of course, this is significant
+		// only for IPv6.)
+		if newbits > 32 {
+			return cty.UnknownVal(cty.String), fmt.Errorf("may not extend prefix by more than 32 bits")
+		}
+
+		newNetwork, err := cidr.Subnet(network, newbits, netnum)
+		if err != nil {
+			return cty.UnknownVal(cty.String), err
+		}
+
+		return cty.StringVal(newNetwork.String()), nil
+	},
+})
+
+// Subnet calculates a subnet address within a given IP network address prefix.
+func Subnet(prefix, newbits, netnum cty.Value) (cty.Value, error) {
+	return SubnetFunc.Call([]cty.Value{prefix, newbits, netnum})
+}