Only interpret vars wrapped in braces

client/driver/env/env_test.go

@@ -61,7 +61,7 @@ func testTaskEnvironment() *TaskEnvironment {
 func TestEnvironment_ParseAndReplace_Env(t *testing.T) {
 	env := testTaskEnvironment()
 
-	input := []string{fmt.Sprintf(`"$%v"!`, envOneKey), fmt.Sprintf("$%s$%s", envOneKey, envTwoKey)}
+	input := []string{fmt.Sprintf(`"${%v}"!`, envOneKey), fmt.Sprintf("${%s}${%s}", envOneKey, envTwoKey)}
 	act := env.ParseAndReplace(input)
 	exp := []string{fmt.Sprintf(`"%s"!`, envOneVal), fmt.Sprintf("%s%s", envOneVal, envTwoVal)}
 
@@ -71,7 +71,7 @@ func TestEnvironment_ParseAndReplace_Env(t *testing.T) {
 }
 
 func TestEnvironment_ParseAndReplace_Meta(t *testing.T) {
-	input := []string{fmt.Sprintf("$%v%v", nodeMetaPrefix, metaKey)}
+	input := []string{fmt.Sprintf("${%v%v}", nodeMetaPrefix, metaKey)}
 	exp := []string{metaVal}
 	env := testTaskEnvironment()
 	act := env.ParseAndReplace(input)
@@ -82,7 +82,7 @@ func TestEnvironment_ParseAndReplace_Meta(t *testing.T) {
 }
 
 func TestEnvironment_ParseAndReplace_Attr(t *testing.T) {
-	input := []string{fmt.Sprintf("$%v%v", nodeAttributePrefix, attrKey)}
+	input := []string{fmt.Sprintf("${%v%v}", nodeAttributePrefix, attrKey)}
 	exp := []string{attrVal}
 	env := testTaskEnvironment()
 	act := env.ParseAndReplace(input)
@@ -93,7 +93,7 @@ func TestEnvironment_ParseAndReplace_Attr(t *testing.T) {
 }
 
 func TestEnvironment_ParseAndReplace_Node(t *testing.T) {
-	input := []string{fmt.Sprintf("$%v", nodeNameKey), fmt.Sprintf("$%v", nodeClassKey)}
+	input := []string{fmt.Sprintf("${%v}", nodeNameKey), fmt.Sprintf("${%v}", nodeClassKey)}
 	exp := []string{nodeName, nodeClass}
 	env := testTaskEnvironment()
 	act := env.ParseAndReplace(input)
@@ -105,9 +105,9 @@ func TestEnvironment_ParseAndReplace_Node(t *testing.T) {
 
 func TestEnvironment_ParseAndReplace_Mixed(t *testing.T) {
 	input := []string{
-		fmt.Sprintf("$%v$%v%v", nodeNameKey, nodeAttributePrefix, attrKey),
-		fmt.Sprintf("$%v$%v%v", nodeClassKey, nodeMetaPrefix, metaKey),
-		fmt.Sprintf("$%v$%v", envTwoKey, nodeClassKey),
+		fmt.Sprintf("${%v}${%v%v}", nodeNameKey, nodeAttributePrefix, attrKey),
+		fmt.Sprintf("${%v}${%v%v}", nodeClassKey, nodeMetaPrefix, metaKey),
+		fmt.Sprintf("${%v}${%v}", envTwoKey, nodeClassKey),
 	}
 	exp := []string{
 		fmt.Sprintf("%v%v", nodeName, attrVal),
@@ -123,7 +123,7 @@ func TestEnvironment_ParseAndReplace_Mixed(t *testing.T) {
 }
 
 func TestEnvironment_ReplaceEnv_Mixed(t *testing.T) {
-	input := fmt.Sprintf("$%v$%v%v", nodeNameKey, nodeAttributePrefix, attrKey)
+	input := fmt.Sprintf("${%v}${%v%v}", nodeNameKey, nodeAttributePrefix, attrKey)
 	exp := fmt.Sprintf("%v%v", nodeName, attrVal)
 	env := testTaskEnvironment()
 	act := env.ReplaceEnv(input)
@@ -193,7 +193,7 @@ func TestEnvironment_ClearEnvvars(t *testing.T) {
 
 func TestEnvironment_Interprolate(t *testing.T) {
 	env := testTaskEnvironment().
-		SetEnvvars(map[string]string{"test": "$node.class", "test2": "$attr.arch"}).
+		SetEnvvars(map[string]string{"test": "${node.class}", "test2": "${attr.arch}"}).
 		Build()
 
 	act := env.EnvList()

client/driver/exec_test.go

@@ -212,7 +212,7 @@ func TestExecDriver_Start_Wait_AllocDir(t *testing.T) {
 			"command": "/bin/bash",
 			"args": []string{
 				"-c",
-				fmt.Sprintf(`sleep 1; echo -n %s > $%s/%s`, string(exp), env.AllocDir, file),
+				fmt.Sprintf(`sleep 1; echo -n %s > ${%s}/%s`, string(exp), env.AllocDir, file),
 			},
 		},
 		Resources: basicResources,

client/driver/raw_exec_test.go

@@ -231,7 +231,7 @@ func TestRawExecDriver_Start_Wait_AllocDir(t *testing.T) {
 	t.Parallel()
 	exp := []byte{'w', 'i', 'n'}
 	file := "output.txt"
-	outPath := fmt.Sprintf(`$%s/%s`, env.AllocDir, file)
+	outPath := fmt.Sprintf(`${%s}/%s`, env.AllocDir, file)
 	task := &structs.Task{
 		Name: "sleep",
 		Config: map[string]interface{}{

command/init.go

@@ -84,7 +84,7 @@ job "example" {
 	# Restrict our job to only linux. We can specify multiple
 	# constraints as needed.
 	constraint {
-		attribute = "$attr.kernel.name"
+		attribute = "${attr.kernel.name}"
 		value = "linux"
 	}
 

helper/args/args.go

@@ -3,19 +3,15 @@ package args
 import "regexp"
 
 var (
-	envRe = regexp.MustCompile(`\$({[a-zA-Z0-9_\.]+}|[a-zA-Z0-9_\.]+)`)
+	envRe = regexp.MustCompile(`\${[a-zA-Z0-9_\.]+}`)
 )
 
 // ReplaceEnv takes an arg and replaces all occurences of environment variables.
 // If the variable is found in the passed map it is replaced, otherwise the
 // original string is returned.
 func ReplaceEnv(arg string, environents ...map[string]string) string {
 	return envRe.ReplaceAllStringFunc(arg, func(arg string) string {
-		stripped := arg[1:]
-		if stripped[0] == '{' {
-			stripped = stripped[1 : len(stripped)-1]
-		}
-
+		stripped := arg[2 : len(arg)-1]
 		for _, env := range environents {
 			if value, ok := env[stripped]; ok {
 				return value

helper/args/args_test.go

@@ -24,8 +24,8 @@ var (
 )
 
 func TestArgs_ReplaceEnv_Invalid(t *testing.T) {
-	input := "$FOO"
-	exp := "$FOO"
+	input := "${FOO}"
+	exp := input
 	act := ReplaceEnv(input, envVars)
 
 	if !reflect.DeepEqual(act, exp) {
@@ -34,7 +34,7 @@ func TestArgs_ReplaceEnv_Invalid(t *testing.T) {
 }
 
 func TestArgs_ReplaceEnv_Valid(t *testing.T) {
-	input := fmt.Sprintf(`"$%v"!`, ipKey)
+	input := fmt.Sprintf(`"${%v}"!`, ipKey)
 	exp := fmt.Sprintf("\"%s\"!", ipVal)
 	act := ReplaceEnv(input, envVars)
 
@@ -44,7 +44,7 @@ func TestArgs_ReplaceEnv_Valid(t *testing.T) {
 }
 
 func TestArgs_ReplaceEnv_Period(t *testing.T) {
-	input := fmt.Sprintf(`"$%v"!`, periodKey)
+	input := fmt.Sprintf(`"${%v}"!`, periodKey)
 	exp := fmt.Sprintf("\"%s\"!", periodVal)
 	act := ReplaceEnv(input, envVars)
 
@@ -54,7 +54,7 @@ func TestArgs_ReplaceEnv_Period(t *testing.T) {
 }
 
 func TestArgs_ReplaceEnv_Chained(t *testing.T) {
-	input := fmt.Sprintf("$%s$%s", ipKey, portKey)
+	input := fmt.Sprintf("${%s}${%s}", ipKey, portKey)
 	exp := fmt.Sprintf("%s%s", ipVal, portVal)
 	act := ReplaceEnv(input, envVars)
 

nomad/mock/mock.go

@@ -67,7 +67,7 @@ func Job() *structs.Job {
 		Datacenters: []string{"dc1"},
 		Constraints: []*structs.Constraint{
 			&structs.Constraint{
-				LTarget: "$attr.kernel.name",
+				LTarget: "${attr.kernel.name}",
 				RTarget: "linux",
 				Operand: "=",
 			},
@@ -145,7 +145,7 @@ func SystemJob() *structs.Job {
 		Datacenters: []string{"dc1"},
 		Constraints: []*structs.Constraint{
 			&structs.Constraint{
-				LTarget: "$attr.kernel.name",
+				LTarget: "${attr.kernel.name}",
 				RTarget: "linux",
 				Operand: "=",
 			},

nomad/structs/node_class.go

@@ -82,11 +82,11 @@ func EscapedConstraints(constraints []*Constraint) []*Constraint {
 // computed node class optimization.
 func constraintTargetEscapes(target string) bool {
 	switch {
-	case strings.HasPrefix(target, "$node.unique."):
+	case strings.HasPrefix(target, "${node.unique."):
 		return true
-	case strings.HasPrefix(target, "$attr.unique."):
+	case strings.HasPrefix(target, "${attr.unique."):
 		return true
-	case strings.HasPrefix(target, "$meta.unique."):
+	case strings.HasPrefix(target, "${meta.unique."):
 		return true
 	default:
 		return false

nomad/structs/node_class_test.go

@@ -172,34 +172,34 @@ func TestNode_ComputedClass_Meta(t *testing.T) {
 func TestNode_EscapedConstraints(t *testing.T) {
 	// Non-escaped constraints
 	ne1 := &Constraint{
-		LTarget: "$attr.kernel.name",
+		LTarget: "${attr.kernel.name}",
 		RTarget: "linux",
 		Operand: "=",
 	}
 	ne2 := &Constraint{
-		LTarget: "$meta.key_foo",
+		LTarget: "${meta.key_foo}",
 		RTarget: "linux",
 		Operand: "<",
 	}
 	ne3 := &Constraint{
-		LTarget: "$node.dc",
+		LTarget: "${node.dc}",
 		RTarget: "test",
 		Operand: "!=",
 	}
 
 	// Escaped constraints
 	e1 := &Constraint{
-		LTarget: "$attr.unique.kernel.name",
+		LTarget: "${attr.unique.kernel.name}",
 		RTarget: "linux",
 		Operand: "=",
 	}
 	e2 := &Constraint{
-		LTarget: "$meta.unique.key_foo",
+		LTarget: "${meta.unique.key_foo}",
 		RTarget: "linux",
 		Operand: "<",
 	}
 	e3 := &Constraint{
-		LTarget: "$unique.node.id",
+		LTarget: "${unique.node.id}",
 		RTarget: "test",
 		Operand: "!=",
 	}

scheduler/context_test.go

@@ -166,22 +166,22 @@ func TestEvalEligibility_TaskGroupStatus(t *testing.T) {
 func TestEvalEligibility_SetJob(t *testing.T) {
 	e := NewEvalEligibility()
 	ne1 := &structs.Constraint{
-		LTarget: "$attr.kernel.name",
+		LTarget: "${attr.kernel.name}",
 		RTarget: "linux",
 		Operand: "=",
 	}
 	e1 := &structs.Constraint{
-		LTarget: "$attr.unique.kernel.name",
+		LTarget: "${attr.unique.kernel.name}",
 		RTarget: "linux",
 		Operand: "=",
 	}
 	e2 := &structs.Constraint{
-		LTarget: "$meta.unique.key_foo",
+		LTarget: "${meta.unique.key_foo}",
 		RTarget: "linux",
 		Operand: "<",
 	}
 	e3 := &structs.Constraint{
-		LTarget: "$meta.unique.key_foo",
+		LTarget: "${meta.unique.key_foo}",
 		RTarget: "Windows",
 		Operand: "<",
 	}

scheduler/feasible.go

@@ -296,25 +296,25 @@ func resolveConstraintTarget(target string, node *structs.Node) (interface{}, bo
 
 	// Handle the interpolations
 	switch {
-	case "$node.unique.id" == target:
+	case "${node.unique.id}" == target:
 		return node.ID, true
 
-	case "$node.datacenter" == target:
+	case "${node.datacenter}" == target:
 		return node.Datacenter, true
 
-	case "$node.unique.name" == target:
+	case "${node.unique.name}" == target:
 		return node.Name, true
 
-	case "$node.class" == target:
+	case "${node.class}" == target:
 		return node.NodeClass, true
 
-	case strings.HasPrefix(target, "$attr."):
-		attr := strings.TrimPrefix(target, "$attr.")
+	case strings.HasPrefix(target, "${attr."):
+		attr := strings.TrimSuffix(strings.TrimPrefix(target, "${attr."), "}")
 		val, ok := node.Attributes[attr]
 		return val, ok
 
-	case strings.HasPrefix(target, "$meta."):
-		meta := strings.TrimPrefix(target, "$meta.")
+	case strings.HasPrefix(target, "${meta."):
+		meta := strings.TrimSuffix(strings.TrimPrefix(target, "${meta."), "}")
 		val, ok := node.Meta[meta]
 		return val, ok
 

scheduler/feasible_test.go

@@ -139,17 +139,17 @@ func TestConstraintChecker(t *testing.T) {
 	constraints := []*structs.Constraint{
 		&structs.Constraint{
 			Operand: "=",
-			LTarget: "$node.datacenter",
+			LTarget: "${node.datacenter}",
 			RTarget: "dc1",
 		},
 		&structs.Constraint{
 			Operand: "is",
-			LTarget: "$attr.kernel.name",
+			LTarget: "${attr.kernel.name}",
 			RTarget: "linux",
 		},
 		&structs.Constraint{
 			Operand: "is",
-			LTarget: "$node.class",
+			LTarget: "${node.class}",
 			RTarget: "large",
 		},
 	}
@@ -189,53 +189,53 @@ func TestResolveConstraintTarget(t *testing.T) {
 	node := mock.Node()
 	cases := []tcase{
 		{
-			target: "$node.unique.id",
+			target: "${node.unique.id}",
 			node:   node,
 			val:    node.ID,
 			result: true,
 		},
 		{
-			target: "$node.datacenter",
+			target: "${node.datacenter}",
 			node:   node,
 			val:    node.Datacenter,
 			result: true,
 		},
 		{
-			target: "$node.unique.name",
+			target: "${node.unique.name}",
 			node:   node,
 			val:    node.Name,
 			result: true,
 		},
 		{
-			target: "$node.class",
+			target: "${node.class}",
 			node:   node,
 			val:    node.NodeClass,
 			result: true,
 		},
 		{
-			target: "$node.foo",
+			target: "${node.foo}",
 			node:   node,
 			result: false,
 		},
 		{
-			target: "$attr.kernel.name",
+			target: "${attr.kernel.name}",
 			node:   node,
 			val:    node.Attributes["kernel.name"],
 			result: true,
 		},
 		{
-			target: "$attr.rand",
+			target: "${attr.rand}",
 			node:   node,
 			result: false,
 		},
 		{
-			target: "$meta.pci-dss",
+			target: "${meta.pci-dss}",
 			node:   node,
 			val:    node.Meta["pci-dss"],
 			result: true,
 		},
 		{
-			target: "$meta.rand",
+			target: "${meta.rand}",
 			node:   node,
 			result: false,
 		},

scheduler/generic_sched_test.go

@@ -238,7 +238,7 @@ func TestServiceSched_JobRegister_FeasibleAndInfeasibleTG(t *testing.T) {
 	job.TaskGroups[0].Count = 2
 	job.TaskGroups[0].Constraints = append(job.Constraints,
 		&structs.Constraint{
-			LTarget: "$node.class",
+			LTarget: "${node.class}",
 			RTarget: "class_0",
 			Operand: "=",
 		},