+package nomad++import "github.com/hashicorp/terraform-plugin-sdk/helper/schema"++func getJobFields() map[string]*schema.Schema {+	return map[string]*schema.Schema{+		"namespace": {+			Type:     schema.TypeString,+			Default:  "default",+			Optional: true,+		},+		"priority": {+			Type:     schema.TypeInt,+			Default:  50,+			Optional: true,+		},+		"type": {+			Type:     schema.TypeString,+			Default:  "service",+			Optional: true,+		},+		"region": {+			Type:     schema.TypeString,+			Default:  "global",

+package nomad++import (+	"encoding/json"+	"fmt"+	"reflect"+	"strings"+	"time"++	"github.com/hashicorp/nomad/api"+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"+)++func resourceJobV2() *schema.Resource {+	return &schema.Resource{+		Schema: getJobFields(),+		Create: resourceJobV2Register,+		Update: resourceJobV2Register,+		Read:   resourceJobV2Read,+		Delete: resourceJobV2Deregister,+	}+}++func resourceJobV2Register(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, err := getJob(d)+	if err != nil {+		return fmt.Errorf("Failed to get job definition: %v", err)+	}++	_, _, err = client.Jobs().Register(job, nil)+	if err != nil {+		return fmt.Errorf("Failed to create the job: %v", err)+	}++	d.SetId(d.Get("name").(string))++	return resourceJobV2Read(d, meta)+}++func resourceJobV2Read(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, _, err := client.Jobs().Info(d.Id(), nil)+	if err != nil {+		if strings.Contains(err.Error(), "404") {+			d.SetId("")+			return nil+		}+		return fmt.Errorf("Failed to read the job: %v", err)+	}++	if err = d.Set("namespace", job.Namespace); err != nil {+		return fmt.Errorf("Failed to set 'namespace': %v", err)+	}+	if err = d.Set("priority", job.Priority); err != nil {+		return fmt.Errorf("Failed to set 'priority': %v", err)+	}+	if err = d.Set("type", job.Type); err != nil {+		return fmt.Errorf("Failed to set 'type': %v", err)+	}+	if err = d.Set("region", job.Region); err != nil {+		return fmt.Errorf("Failed to set 'region': %v", err)+	}+	if err = d.Set("meta", job.Meta); err != nil {+		return fmt.Errorf("Failed to set 'meta': %v", err)+	}+	if err = d.Set("all_at_once", job.AllAtOnce); err != nil {+		return fmt.Errorf("Failed to set 'all_at_once': %v", err)+	}+	if err = d.Set("datacenters", job.Datacenters); err != nil {+		return fmt.Errorf("Failed to set 'datacenters': %v", err)+	}+	if err = d.Set("name", job.Name); err != nil {+		return fmt.Errorf("Failed to set 'name': %v", err)+	}+	// if err = d.Set("vault_token", job.VaultToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'vault_token': %v", err)+	// }+	// if err = d.Set("consul_token", job.ConsulToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'consul_token': %v", err)+	// }+	if err = d.Set("constraint", readConstraints(job.Constraints)); err != nil {+		return fmt.Errorf("Failed to set 'constraint': %v", err)+	}+	if err = d.Set("affinity", readAffinities(job.Affinities)); err != nil {+		return fmt.Errorf("Failed to set 'affinity': %v", err)+	}+	if err = d.Set("spread", readSpreads(job.Spreads)); err != nil {+		return fmt.Errorf("Failed to set 'spread': %v", err)+	}+	groups, err := readGroups(d, job.TaskGroups)+	if err != nil {+		return err+	}+	if err = d.Set("group", groups); err != nil {+		return fmt.Errorf("Failed to set 'group': %v", err)+	}++	parameterized := make([]interface{}, 0)+	if job.ParameterizedJob != nil {+		p := map[string]interface{}{+			"meta_optional": job.ParameterizedJob.MetaOptional,+			"meta_required": job.ParameterizedJob.MetaRequired,+			"payload":       job.ParameterizedJob.Payload,+		}+		parameterized = append(parameterized, p)+	}+	if err = d.Set("parameterized", parameterized); err != nil {+		return fmt.Errorf("Failed to set 'parameterized': %v", err)+	}++	periodic := make([]interface{}, 0)+	if job.Periodic != nil {+		p := map[string]interface{}{+			"cron":             job.Periodic.Spec,+			"prohibit_overlap": job.Periodic.ProhibitOverlap,+			"time_zone":        job.Periodic.TimeZone,+		}+		periodic = append(periodic, p)+	}+	if err = d.Set("periodic", periodic); err != nil {+		return fmt.Errorf("Failed to set 'periodic': %v", err)+	}++	update, err := readUpdate(d, job.Update)+	if err != nil {+		return err+	}++	if err = d.Set("update", update); err != nil {+		return fmt.Errorf("Failed to set 'update': %v", err)+	}++	return nil+}++func resourceJobV2Deregister(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client++	_, _, err := client.Jobs().Deregister(d.Id(), true, nil)+	if err != nil {+		return fmt.Errorf("Failed to deregister the job: %v", err)+	}++	d.SetId("")+	return nil+}++// Helpers to covert to representation used by the Nomad API++func strToPtr(s string) *string {+	if s == "" {+		return nil+	}+	return &s+}++func boolToPtr(b bool) *bool {+	return &b+}++func intToPtr(i int) *int {+	return &i+}++func getString(d interface{}, name string) *string {+	if m, ok := d.(map[string]interface{}); ok {+		return strToPtr(m[name].(string))+	}+	return strToPtr(d.(*schema.ResourceData).Get(name).(string))+}++func getBool(d interface{}, name string) *bool {+	if m, ok := d.(map[string]interface{}); ok {+		return boolToPtr(m[name].(bool))+	}+	return boolToPtr(d.(*schema.ResourceData).Get(name).(bool))+}++func getInt(d interface{}, name string) *int {+	if m, ok := d.(map[string]interface{}); ok {+		return intToPtr(m[name].(int))+	}+	return intToPtr(d.(*schema.ResourceData).Get(name).(int))+}++func getMapOfString(d interface{}) map[string]string {+	res := make(map[string]string)+	for key, value := range d.(map[string]interface{}) {+		res[key] = value.(string)+	}+	return res+}++func getDuration(d interface{}) (*time.Duration, error) {+	s := d.(string)++	if s == "" {+		return nil, nil+	}++	duration, err := time.ParseDuration(s)+	if duration.Seconds() == 0 {+		return nil, err+	}+	return &duration, err+}++// Those functions should have a 1 to 1 correspondance with the ones in+// resource_job_v2_fields to make it easy to check we did not forget anything++func getJob(d *schema.ResourceData) (*api.Job, error) {+	datacenters := make([]string, 0)+	for _, dc := range d.Get("datacenters").([]interface{}) {+		datacenters = append(datacenters, dc.(string))+	}++	var parametrizedJob *api.ParameterizedJobConfig+	for _, pj := range d.Get("parameterized").([]interface{}) {+		p := pj.(map[string]interface{})++		metaRequired := make([]string, 0)+		for _, s := range p["meta_required"].([]interface{}) {+			metaRequired = append(metaRequired, s.(string))+		}++		metaOptional := make([]string, 0)+		for _, s := range p["meta_optional"].([]interface{}) {+			metaOptional = append(metaOptional, s.(string))+		}+		parametrizedJob = &api.ParameterizedJobConfig{+			Payload:      p["payload"].(string),+			MetaRequired: metaRequired,+			MetaOptional: metaOptional,+		}+	}++	var periodic *api.PeriodicConfig+	for _, pc := range d.Get("periodic").([]interface{}) {+		p := pc.(map[string]interface{})+		periodic = &api.PeriodicConfig{+			Enabled:         boolToPtr(true),+			Spec:            getString(p, "cron"),+			SpecType:        strToPtr("cron"),+			ProhibitOverlap: getBool(p, "prohibit_overlap"),+			TimeZone:        getString(p, "time_zone"),+		}+	}++	update, err := getUpdate(d.Get("update"))+	if err != nil {+		return nil, err+	}+	taskGroups, err := getTaskGroups(d.Get("group"))+	if err != nil {+		return nil, err+	}++	return &api.Job{+		Namespace:   getString(d, "namespace"),+		Priority:    getInt(d, "priority"),+		Type:        getString(d, "type"),+		Meta:        getMapOfString(d.Get("meta")),+		AllAtOnce:   getBool(d, "all_at_once"),+		Datacenters: datacenters,+		ID:          getString(d, "name"),+		Region:      getString(d, "region"),+		VaultToken:  getString(d, "vault_token"),+		ConsulToken: getString(d, "consul_token"),++		Constraints: getConstraints(d.Get("constraint")),+		Affinities:  getAffinities(d.Get("affinity")),+		Spreads:     getSpreads(d.Get("spread")),+		TaskGroups:  taskGroups,++		ParameterizedJob: parametrizedJob,+		Periodic:         periodic,++		Update: update,+	}, nil+}++func getConstraints(d interface{}) []*api.Constraint {+	constraints := make([]*api.Constraint, 0)++	for _, ct := range d.([]interface{}) {+		c := ct.(map[string]interface{})+		constraints = append(+			constraints,+			api.NewConstraint(+				c["attribute"].(string),+				c["operator"].(string),+				c["value"].(string),+			),+		)+	}++	return constraints+}++func getAffinities(d interface{}) []*api.Affinity {+	affinities := make([]*api.Affinity, 0)++	for _, af := range d.([]interface{}) {+		a := af.(map[string]interface{})+		affinities = append(+			affinities,+			api.NewAffinity(+				a["attribute"].(string),+				a["operator"].(string),+				a["value"].(string),+				int8(a["weight"].(int)),+			),+		)+	}++	return affinities+}++func getSpreads(d interface{}) []*api.Spread {+	spreads := make([]*api.Spread, 0)++	for _, sp := range d.([]interface{}) {+		s := sp.(map[string]interface{})++		targets := make([]*api.SpreadTarget, 0)+		for _, tg := range s["target"].([]interface{}) {+			t := tg.(map[string]interface{})+			targets = append(+				targets,+				&api.SpreadTarget{+					Value:   t["value"].(string),+					Percent: uint8(t["percent"].(int)),+				},+			)+		}++		spreads = append(+			spreads,+			api.NewSpread(+				s["attribute"].(string),+				int8(s["weight"].(int)),+				targets,+			),+		)+	}++	return nil+}++func getTaskGroups(d interface{}) ([]*api.TaskGroup, error) {+	taskGroups := make([]*api.TaskGroup, 0)++	for _, tg := range d.([]interface{}) {+		g := tg.(map[string]interface{})++		migrate, err := getMigrate(g["migrate"])+		if err != nil {+			return nil, err+		}+		reschedule, err := getReschedule(g["reschedule"])+		if err != nil {+			return nil, err+		}++		var ephemeralDisk *api.EphemeralDisk+		for _, ed := range g["ephemeral_disk"].([]interface{}) {+			e := ed.(map[string]interface{})+			ephemeralDisk = &api.EphemeralDisk{+				Sticky:  getBool(e, "sticky"),+				Migrate: getBool(e, "migrate"),+				SizeMB:  getInt(e, "size"),+			}+		}++		var restartPolicy *api.RestartPolicy+		for _, rp := range g["restart"].([]interface{}) {+			r := rp.(map[string]interface{})+			restartPolicy = &api.RestartPolicy{+				Attempts: getInt(r, "attempts"),+				Mode:     getString(r, "mode"),+			}++			var duration *time.Duration+			duration, err = getDuration(r["delay"])+			if err != nil {+				return nil, err+			}+			restartPolicy.Delay = duration++			duration, err = getDuration(r["interval"])+			if err != nil {+				return nil, err+			}+			restartPolicy.Interval = duration+		}+		volumes := make(map[string]*api.VolumeRequest)+		for _, vr := range g["volume"].([]interface{}) {+			v := vr.(map[string]interface{})+			name := v["name"].(string)+			volumes[name] = &api.VolumeRequest{+				Name:     name,+				Type:     v["type"].(string),+				Source:   v["source"].(string),+				ReadOnly: v["read_only"].(bool),+			}+		}++		tasks, err := getTasks(g["task"])+		if err != nil {+			return nil, err+		}++		services, err := getServices(g["service"])+		if err != nil {+			return nil, err+		}++		group := &api.TaskGroup{+			Name:             getString(g, "name"),+			Meta:             getMapOfString(g["meta"]),+			Count:            getInt(g, "count"),+			Constraints:      getConstraints(g["constraint"]),+			Affinities:       getAffinities(g["affinity"]),+			Spreads:          getSpreads(g["spread"]),+			EphemeralDisk:    ephemeralDisk,+			Migrate:          migrate,+			Networks:         getNetworks(g["network"]),+			ReschedulePolicy: reschedule,+			RestartPolicy:    restartPolicy,+			Services:         services,+			Tasks:            tasks,+			Volumes:          volumes,+		}++		var duration *time.Duration+		duration, err = getDuration(g["shutdown_delay"])+		if err != nil {+			return nil, err+		}+		group.ShutdownDelay = duration++		duration, err = getDuration(g["stop_after_client_disconnect"])+		if err != nil {+			return nil, err+		}+		group.StopAfterClientDisconnect = duration++		taskGroups = append(taskGroups, group)+	}++	return taskGroups, nil+}++func getMigrate(d interface{}) (*api.MigrateStrategy, error) {+	for _, mg := range d.([]interface{}) {+		m := mg.(map[string]interface{})++		migrateStrategy := &api.MigrateStrategy{+			MaxParallel: getInt(m, "max_parallel"),+			HealthCheck: getString(m, "health_check"),+		}++		var duration *time.Duration+		duration, err := getDuration(m["min_healthy_time"])+		if err != nil {+			return nil, err+		}+		migrateStrategy.MinHealthyTime = duration++		duration, err = getDuration(m["healthy_deadline"])+		if err != nil {+			return nil, err+		}+		migrateStrategy.HealthyDeadline = duration++		return migrateStrategy, nil+	}++	return nil, nil+}++func getReschedule(d interface{}) (*api.ReschedulePolicy, error) {+	for _, re := range d.([]interface{}) {+		r := re.(map[string]interface{})++		reschedulePolicy := &api.ReschedulePolicy{+			Attempts:      getInt(r, "attempts"),+			DelayFunction: getString(r, "delay_function"),+			Unlimited:     getBool(r, "unlimited"),+		}++		var duration *time.Duration+		duration, err := getDuration(r["interval"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.Interval = duration++		duration, err = getDuration(r["delay"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.Delay = duration++		duration, err = getDuration(r["max_delay"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.MaxDelay = duration++		return reschedulePolicy, nil+	}++	return nil, nil+}++func getUpdate(d interface{}) (*api.UpdateStrategy, error) {+	for _, up := range d.([]interface{}) {+		u := up.(map[string]interface{})++		update := &api.UpdateStrategy{+			MaxParallel: getInt(u, "max_parallel"),+			HealthCheck: getString(u, "health_check"),+			Canary:      getInt(u, "canary"),+			AutoRevert:  getBool(u, "auto_revert"),+			AutoPromote: getBool(u, "auto_promote"),+		}++		var duration *time.Duration+		duration, err := getDuration(u["stagger"])+		if err != nil {+			return nil, err+		}+		update.Stagger = duration++		duration, err = getDuration(u["min_healthy_time"])+		if err != nil {+			return nil, err+		}+		update.MinHealthyTime = duration++		duration, err = getDuration(u["healthy_deadline"])+		if err != nil {+			return nil, err+		}+		update.HealthyDeadline = duration++		duration, err = getDuration(u["progress_deadline"])+		if err != nil {+			return nil, err+		}+		update.ProgressDeadline = duration++		return update, nil+	}+	return nil, nil+}++func getTasks(d interface{}) ([]*api.Task, error) {+	tasks := make([]*api.Task, 0)++	for _, tk := range d.([]interface{}) {+		t := tk.(map[string]interface{})++		artifacts := make([]*api.TaskArtifact, 0)+		for _, af := range t["artifact"].([]interface{}) {+			a := af.(map[string]interface{})++			artifact := &api.TaskArtifact{+				GetterSource:  getString(a, "source"),+				GetterOptions: getMapOfString(a["options"]),+				GetterMode:    getString(a, "mode"),+				RelativeDest:  getString(a, "destination"),+			}++			artifacts = append(artifacts, artifact)+		}++		var dispatchPayloadConfig *api.DispatchPayloadConfig+		for _, dp := range t["dispatch_payload"].([]interface{}) {+			d := dp.(map[string]interface{})++			dispatchPayloadConfig = &api.DispatchPayloadConfig{+				File: d["file"].(string),+			}+		}++		var taskLifecycle *api.TaskLifecycle+		for _, tl := range t["lifecycle"].([]interface{}) {+			l := tl.(map[string]interface{})++			taskLifecycle = &api.TaskLifecycle{+				Hook:    l["hook"].(string),+				Sidecar: l["sidecar"].(bool),+			}+		}++		templates := make([]*api.Template, 0)+		for _, tpl := range t["template"].([]interface{}) {+			tp := tpl.(map[string]interface{})++			template := &api.Template{+				ChangeMode:   getString(tp, "change_mode"),+				ChangeSignal: getString(tp, "change_signal"),+				EmbeddedTmpl: getString(tp, "data"),+				DestPath:     getString(tp, "destination"),+				Envvars:      getBool(tp, "env"),+				LeftDelim:    getString(tp, "left_delimiter"),+				Perms:        getString(tp, "perms"),+				RightDelim:   getString(tp, "right_delimiter"),+				SourcePath:   getString(tp, "source"),+			}++			duration, err := getDuration(tp["splay"])+			if err != nil {+				return nil, err+			}+			template.Splay = duration++			duration, err = getDuration(tp["vault_grace"])+			if err != nil {+				return nil, err+			}+			template.VaultGrace = duration++			templates = append(templates, template)+		}++		volumeMounts := make([]*api.VolumeMount, 0)+		for _, vm := range t["volume_mount"].([]interface{}) {+			v := vm.(map[string]interface{})++			volumeMount := &api.VolumeMount{+				Volume:      getString(v, "volume"),+				Destination: getString(v, "destination"),+				ReadOnly:    getBool(v, "read_only"),+			}++			volumeMounts = append(volumeMounts, volumeMount)+		}++		var config map[string]interface{}+		err := json.Unmarshal([]byte(t["config"].(string)), &config)+		if err != nil {+			return nil, err+		}++		services, err := getServices(t["service"])+		if err != nil {+			return nil, err+		}++		task := &api.Task{+			Name:            t["name"].(string),+			Config:          config,+			Meta:            getMapOfString(t["meta"]),+			Driver:          t["driver"].(string),+			KillSignal:      t["kill_signal"].(string),+			Leader:          t["leader"].(bool),+			User:            t["user"].(string),+			Kind:            t["kind"].(string),+			Artifacts:       artifacts,+			Constraints:     getConstraints(t["constraint"]),+			Affinities:      getAffinities(t["affinity"]),+			DispatchPayload: dispatchPayloadConfig,+			Env:             getMapOfString(t["env"]),+			Lifecycle:       taskLifecycle,+			LogConfig:       getLogConfig(t["logs"]),+			Resources:       getResources(t["resources"]),+			Services:        services,+			Templates:       templates,+			Vault:           getVault(t["vault"]),+			VolumeMounts:    volumeMounts,+		}++		duration, err := getDuration(t["kill_timeout"])+		if err != nil {+			return nil, err+		}+		task.KillTimeout = duration++		duration, err = getDuration(t["shutdown_delay"])+		if err != nil {+			return nil, err+		}+		if duration != nil {+			task.ShutdownDelay = *duration+		}++		tasks = append(tasks, task)+	}++	return tasks, nil+}++func getNetworks(d interface{}) []*api.NetworkResource {+	networks := make([]*api.NetworkResource, 0)++	for _, nr := range d.([]interface{}) {+		n := nr.(map[string]interface{})++		// TODO(remi): find what to do with the ports here

+package nomad++import (+	"encoding/json"+	"fmt"+	"reflect"+	"strings"+	"time"++	"github.com/hashicorp/nomad/api"+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"+)++func resourceJobV2() *schema.Resource {+	return &schema.Resource{+		Schema: getJobFields(),+		Create: resourceJobV2Register,+		Update: resourceJobV2Register,+		Read:   resourceJobV2Read,+		Delete: resourceJobV2Deregister,+	}+}++func resourceJobV2Register(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, err := getJob(d)+	if err != nil {+		return fmt.Errorf("Failed to get job definition: %v", err)+	}++	_, _, err = client.Jobs().Register(job, nil)+	if err != nil {+		return fmt.Errorf("Failed to create the job: %v", err)+	}++	d.SetId(d.Get("name").(string))++	return resourceJobV2Read(d, meta)+}++func resourceJobV2Read(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, _, err := client.Jobs().Info(d.Id(), nil)+	if err != nil {+		if strings.Contains(err.Error(), "404") {+			d.SetId("")+			return nil+		}+		return fmt.Errorf("Failed to read the job: %v", err)+	}++	if err = d.Set("namespace", job.Namespace); err != nil {+		return fmt.Errorf("Failed to set 'namespace': %v", err)+	}+	if err = d.Set("priority", job.Priority); err != nil {+		return fmt.Errorf("Failed to set 'priority': %v", err)+	}+	if err = d.Set("type", job.Type); err != nil {+		return fmt.Errorf("Failed to set 'type': %v", err)+	}+	if err = d.Set("region", job.Region); err != nil {+		return fmt.Errorf("Failed to set 'region': %v", err)+	}+	if err = d.Set("meta", job.Meta); err != nil {+		return fmt.Errorf("Failed to set 'meta': %v", err)+	}+	if err = d.Set("all_at_once", job.AllAtOnce); err != nil {+		return fmt.Errorf("Failed to set 'all_at_once': %v", err)+	}+	if err = d.Set("datacenters", job.Datacenters); err != nil {+		return fmt.Errorf("Failed to set 'datacenters': %v", err)+	}+	if err = d.Set("name", job.Name); err != nil {+		return fmt.Errorf("Failed to set 'name': %v", err)+	}+	// if err = d.Set("vault_token", job.VaultToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'vault_token': %v", err)+	// }+	// if err = d.Set("consul_token", job.ConsulToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'consul_token': %v", err)+	// }+	if err = d.Set("constraint", readConstraints(job.Constraints)); err != nil {+		return fmt.Errorf("Failed to set 'constraint': %v", err)+	}+	if err = d.Set("affinity", readAffinities(job.Affinities)); err != nil {+		return fmt.Errorf("Failed to set 'affinity': %v", err)+	}+	if err = d.Set("spread", readSpreads(job.Spreads)); err != nil {+		return fmt.Errorf("Failed to set 'spread': %v", err)+	}+	groups, err := readGroups(d, job.TaskGroups)+	if err != nil {+		return err+	}+	if err = d.Set("group", groups); err != nil {+		return fmt.Errorf("Failed to set 'group': %v", err)+	}++	parameterized := make([]interface{}, 0)+	if job.ParameterizedJob != nil {+		p := map[string]interface{}{+			"meta_optional": job.ParameterizedJob.MetaOptional,+			"meta_required": job.ParameterizedJob.MetaRequired,+			"payload":       job.ParameterizedJob.Payload,+		}+		parameterized = append(parameterized, p)+	}+	if err = d.Set("parameterized", parameterized); err != nil {+		return fmt.Errorf("Failed to set 'parameterized': %v", err)+	}++	periodic := make([]interface{}, 0)+	if job.Periodic != nil {+		p := map[string]interface{}{+			"cron":             job.Periodic.Spec,+			"prohibit_overlap": job.Periodic.ProhibitOverlap,+			"time_zone":        job.Periodic.TimeZone,+		}+		periodic = append(periodic, p)+	}+	if err = d.Set("periodic", periodic); err != nil {+		return fmt.Errorf("Failed to set 'periodic': %v", err)+	}++	update, err := readUpdate(d, job.Update)+	if err != nil {+		return err+	}++	if err = d.Set("update", update); err != nil {+		return fmt.Errorf("Failed to set 'update': %v", err)+	}++	return nil+}++func resourceJobV2Deregister(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client++	_, _, err := client.Jobs().Deregister(d.Id(), true, nil)+	if err != nil {+		return fmt.Errorf("Failed to deregister the job: %v", err)+	}++	d.SetId("")+	return nil+}++// Helpers to covert to representation used by the Nomad API++func strToPtr(s string) *string {+	if s == "" {+		return nil+	}+	return &s+}++func boolToPtr(b bool) *bool {+	return &b+}++func intToPtr(i int) *int {+	return &i+}++func getString(d interface{}, name string) *string {+	if m, ok := d.(map[string]interface{}); ok {+		return strToPtr(m[name].(string))+	}+	return strToPtr(d.(*schema.ResourceData).Get(name).(string))+}++func getBool(d interface{}, name string) *bool {+	if m, ok := d.(map[string]interface{}); ok {+		return boolToPtr(m[name].(bool))+	}+	return boolToPtr(d.(*schema.ResourceData).Get(name).(bool))+}++func getInt(d interface{}, name string) *int {+	if m, ok := d.(map[string]interface{}); ok {+		return intToPtr(m[name].(int))+	}+	return intToPtr(d.(*schema.ResourceData).Get(name).(int))+}++func getMapOfString(d interface{}) map[string]string {+	res := make(map[string]string)+	for key, value := range d.(map[string]interface{}) {+		res[key] = value.(string)+	}+	return res+}++func getDuration(d interface{}) (*time.Duration, error) {+	s := d.(string)++	if s == "" {+		return nil, nil+	}++	duration, err := time.ParseDuration(s)+	if duration.Seconds() == 0 {+		return nil, err+	}+	return &duration, err+}++// Those functions should have a 1 to 1 correspondance with the ones in+// resource_job_v2_fields to make it easy to check we did not forget anything++func getJob(d *schema.ResourceData) (*api.Job, error) {+	datacenters := make([]string, 0)+	for _, dc := range d.Get("datacenters").([]interface{}) {+		datacenters = append(datacenters, dc.(string))+	}++	var parametrizedJob *api.ParameterizedJobConfig+	for _, pj := range d.Get("parameterized").([]interface{}) {+		p := pj.(map[string]interface{})++		metaRequired := make([]string, 0)+		for _, s := range p["meta_required"].([]interface{}) {+			metaRequired = append(metaRequired, s.(string))+		}++		metaOptional := make([]string, 0)+		for _, s := range p["meta_optional"].([]interface{}) {+			metaOptional = append(metaOptional, s.(string))+		}+		parametrizedJob = &api.ParameterizedJobConfig{+			Payload:      p["payload"].(string),+			MetaRequired: metaRequired,+			MetaOptional: metaOptional,+		}+	}++	var periodic *api.PeriodicConfig+	for _, pc := range d.Get("periodic").([]interface{}) {+		p := pc.(map[string]interface{})+		periodic = &api.PeriodicConfig{+			Enabled:         boolToPtr(true),+			Spec:            getString(p, "cron"),+			SpecType:        strToPtr("cron"),+			ProhibitOverlap: getBool(p, "prohibit_overlap"),+			TimeZone:        getString(p, "time_zone"),+		}+	}++	update, err := getUpdate(d.Get("update"))+	if err != nil {+		return nil, err+	}+	taskGroups, err := getTaskGroups(d.Get("group"))+	if err != nil {+		return nil, err+	}++	return &api.Job{+		Namespace:   getString(d, "namespace"),+		Priority:    getInt(d, "priority"),+		Type:        getString(d, "type"),+		Meta:        getMapOfString(d.Get("meta")),+		AllAtOnce:   getBool(d, "all_at_once"),+		Datacenters: datacenters,+		ID:          getString(d, "name"),+		Region:      getString(d, "region"),+		VaultToken:  getString(d, "vault_token"),+		ConsulToken: getString(d, "consul_token"),++		Constraints: getConstraints(d.Get("constraint")),+		Affinities:  getAffinities(d.Get("affinity")),+		Spreads:     getSpreads(d.Get("spread")),+		TaskGroups:  taskGroups,++		ParameterizedJob: parametrizedJob,+		Periodic:         periodic,++		Update: update,+	}, nil+}++func getConstraints(d interface{}) []*api.Constraint {+	constraints := make([]*api.Constraint, 0)++	for _, ct := range d.([]interface{}) {+		c := ct.(map[string]interface{})+		constraints = append(+			constraints,+			api.NewConstraint(+				c["attribute"].(string),+				c["operator"].(string),+				c["value"].(string),+			),+		)+	}++	return constraints+}++func getAffinities(d interface{}) []*api.Affinity {+	affinities := make([]*api.Affinity, 0)++	for _, af := range d.([]interface{}) {+		a := af.(map[string]interface{})+		affinities = append(+			affinities,+			api.NewAffinity(+				a["attribute"].(string),+				a["operator"].(string),+				a["value"].(string),+				int8(a["weight"].(int)),+			),+		)+	}++	return affinities+}++func getSpreads(d interface{}) []*api.Spread {+	spreads := make([]*api.Spread, 0)++	for _, sp := range d.([]interface{}) {+		s := sp.(map[string]interface{})++		targets := make([]*api.SpreadTarget, 0)+		for _, tg := range s["target"].([]interface{}) {+			t := tg.(map[string]interface{})+			targets = append(+				targets,+				&api.SpreadTarget{+					Value:   t["value"].(string),+					Percent: uint8(t["percent"].(int)),+				},+			)+		}++		spreads = append(+			spreads,+			api.NewSpread(+				s["attribute"].(string),+				int8(s["weight"].(int)),+				targets,+			),+		)+	}++	return nil+}++func getTaskGroups(d interface{}) ([]*api.TaskGroup, error) {+	taskGroups := make([]*api.TaskGroup, 0)++	for _, tg := range d.([]interface{}) {+		g := tg.(map[string]interface{})++		migrate, err := getMigrate(g["migrate"])+		if err != nil {+			return nil, err+		}+		reschedule, err := getReschedule(g["reschedule"])+		if err != nil {+			return nil, err+		}++		var ephemeralDisk *api.EphemeralDisk+		for _, ed := range g["ephemeral_disk"].([]interface{}) {+			e := ed.(map[string]interface{})+			ephemeralDisk = &api.EphemeralDisk{+				Sticky:  getBool(e, "sticky"),+				Migrate: getBool(e, "migrate"),+				SizeMB:  getInt(e, "size"),+			}+		}++		var restartPolicy *api.RestartPolicy+		for _, rp := range g["restart"].([]interface{}) {+			r := rp.(map[string]interface{})+			restartPolicy = &api.RestartPolicy{+				Attempts: getInt(r, "attempts"),+				Mode:     getString(r, "mode"),+			}++			var duration *time.Duration+			duration, err = getDuration(r["delay"])+			if err != nil {+				return nil, err+			}+			restartPolicy.Delay = duration++			duration, err = getDuration(r["interval"])+			if err != nil {+				return nil, err+			}+			restartPolicy.Interval = duration+		}+		volumes := make(map[string]*api.VolumeRequest)+		for _, vr := range g["volume"].([]interface{}) {+			v := vr.(map[string]interface{})+			name := v["name"].(string)+			volumes[name] = &api.VolumeRequest{+				Name:     name,+				Type:     v["type"].(string),+				Source:   v["source"].(string),+				ReadOnly: v["read_only"].(bool),+			}+		}++		tasks, err := getTasks(g["task"])+		if err != nil {+			return nil, err+		}++		services, err := getServices(g["service"])+		if err != nil {+			return nil, err+		}++		group := &api.TaskGroup{+			Name:             getString(g, "name"),+			Meta:             getMapOfString(g["meta"]),+			Count:            getInt(g, "count"),+			Constraints:      getConstraints(g["constraint"]),+			Affinities:       getAffinities(g["affinity"]),+			Spreads:          getSpreads(g["spread"]),+			EphemeralDisk:    ephemeralDisk,+			Migrate:          migrate,+			Networks:         getNetworks(g["network"]),+			ReschedulePolicy: reschedule,+			RestartPolicy:    restartPolicy,+			Services:         services,+			Tasks:            tasks,+			Volumes:          volumes,+		}++		var duration *time.Duration+		duration, err = getDuration(g["shutdown_delay"])+		if err != nil {+			return nil, err+		}+		group.ShutdownDelay = duration++		duration, err = getDuration(g["stop_after_client_disconnect"])+		if err != nil {+			return nil, err+		}+		group.StopAfterClientDisconnect = duration++		taskGroups = append(taskGroups, group)+	}++	return taskGroups, nil+}++func getMigrate(d interface{}) (*api.MigrateStrategy, error) {+	for _, mg := range d.([]interface{}) {+		m := mg.(map[string]interface{})++		migrateStrategy := &api.MigrateStrategy{+			MaxParallel: getInt(m, "max_parallel"),+			HealthCheck: getString(m, "health_check"),+		}++		var duration *time.Duration+		duration, err := getDuration(m["min_healthy_time"])+		if err != nil {+			return nil, err+		}+		migrateStrategy.MinHealthyTime = duration++		duration, err = getDuration(m["healthy_deadline"])+		if err != nil {+			return nil, err+		}+		migrateStrategy.HealthyDeadline = duration++		return migrateStrategy, nil+	}++	return nil, nil+}++func getReschedule(d interface{}) (*api.ReschedulePolicy, error) {+	for _, re := range d.([]interface{}) {+		r := re.(map[string]interface{})++		reschedulePolicy := &api.ReschedulePolicy{+			Attempts:      getInt(r, "attempts"),+			DelayFunction: getString(r, "delay_function"),+			Unlimited:     getBool(r, "unlimited"),+		}++		var duration *time.Duration+		duration, err := getDuration(r["interval"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.Interval = duration++		duration, err = getDuration(r["delay"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.Delay = duration++		duration, err = getDuration(r["max_delay"])+		if err != nil {+			return nil, err+		}+		reschedulePolicy.MaxDelay = duration++		return reschedulePolicy, nil+	}++	return nil, nil+}++func getUpdate(d interface{}) (*api.UpdateStrategy, error) {+	for _, up := range d.([]interface{}) {+		u := up.(map[string]interface{})++		update := &api.UpdateStrategy{+			MaxParallel: getInt(u, "max_parallel"),+			HealthCheck: getString(u, "health_check"),+			Canary:      getInt(u, "canary"),+			AutoRevert:  getBool(u, "auto_revert"),+			AutoPromote: getBool(u, "auto_promote"),+		}++		var duration *time.Duration+		duration, err := getDuration(u["stagger"])+		if err != nil {+			return nil, err+		}+		update.Stagger = duration++		duration, err = getDuration(u["min_healthy_time"])+		if err != nil {+			return nil, err+		}+		update.MinHealthyTime = duration++		duration, err = getDuration(u["healthy_deadline"])+		if err != nil {+			return nil, err+		}+		update.HealthyDeadline = duration++		duration, err = getDuration(u["progress_deadline"])+		if err != nil {+			return nil, err+		}+		update.ProgressDeadline = duration++		return update, nil+	}+	return nil, nil+}++func getTasks(d interface{}) ([]*api.Task, error) {+	tasks := make([]*api.Task, 0)++	for _, tk := range d.([]interface{}) {+		t := tk.(map[string]interface{})++		artifacts := make([]*api.TaskArtifact, 0)+		for _, af := range t["artifact"].([]interface{}) {+			a := af.(map[string]interface{})++			artifact := &api.TaskArtifact{+				GetterSource:  getString(a, "source"),+				GetterOptions: getMapOfString(a["options"]),+				GetterMode:    getString(a, "mode"),+				RelativeDest:  getString(a, "destination"),+			}++			artifacts = append(artifacts, artifact)+		}++		var dispatchPayloadConfig *api.DispatchPayloadConfig+		for _, dp := range t["dispatch_payload"].([]interface{}) {+			d := dp.(map[string]interface{})++			dispatchPayloadConfig = &api.DispatchPayloadConfig{+				File: d["file"].(string),+			}+		}++		var taskLifecycle *api.TaskLifecycle+		for _, tl := range t["lifecycle"].([]interface{}) {+			l := tl.(map[string]interface{})++			taskLifecycle = &api.TaskLifecycle{+				Hook:    l["hook"].(string),+				Sidecar: l["sidecar"].(bool),+			}+		}++		templates := make([]*api.Template, 0)+		for _, tpl := range t["template"].([]interface{}) {+			tp := tpl.(map[string]interface{})++			template := &api.Template{+				ChangeMode:   getString(tp, "change_mode"),+				ChangeSignal: getString(tp, "change_signal"),+				EmbeddedTmpl: getString(tp, "data"),+				DestPath:     getString(tp, "destination"),+				Envvars:      getBool(tp, "env"),+				LeftDelim:    getString(tp, "left_delimiter"),+				Perms:        getString(tp, "perms"),+				RightDelim:   getString(tp, "right_delimiter"),+				SourcePath:   getString(tp, "source"),+			}++			duration, err := getDuration(tp["splay"])+			if err != nil {+				return nil, err+			}+			template.Splay = duration++			duration, err = getDuration(tp["vault_grace"])+			if err != nil {+				return nil, err+			}+			template.VaultGrace = duration++			templates = append(templates, template)+		}++		volumeMounts := make([]*api.VolumeMount, 0)+		for _, vm := range t["volume_mount"].([]interface{}) {+			v := vm.(map[string]interface{})++			volumeMount := &api.VolumeMount{+				Volume:      getString(v, "volume"),+				Destination: getString(v, "destination"),+				ReadOnly:    getBool(v, "read_only"),+			}++			volumeMounts = append(volumeMounts, volumeMount)+		}++		var config map[string]interface{}+		err := json.Unmarshal([]byte(t["config"].(string)), &config)+		if err != nil {+			return nil, err+		}++		services, err := getServices(t["service"])+		if err != nil {+			return nil, err+		}++		task := &api.Task{+			Name:            t["name"].(string),+			Config:          config,+			Meta:            getMapOfString(t["meta"]),+			Driver:          t["driver"].(string),+			KillSignal:      t["kill_signal"].(string),+			Leader:          t["leader"].(bool),+			User:            t["user"].(string),+			Kind:            t["kind"].(string),+			Artifacts:       artifacts,+			Constraints:     getConstraints(t["constraint"]),+			Affinities:      getAffinities(t["affinity"]),+			DispatchPayload: dispatchPayloadConfig,+			Env:             getMapOfString(t["env"]),+			Lifecycle:       taskLifecycle,+			LogConfig:       getLogConfig(t["logs"]),+			Resources:       getResources(t["resources"]),+			Services:        services,+			Templates:       templates,+			Vault:           getVault(t["vault"]),+			VolumeMounts:    volumeMounts,+		}++		duration, err := getDuration(t["kill_timeout"])+		if err != nil {+			return nil, err+		}+		task.KillTimeout = duration++		duration, err = getDuration(t["shutdown_delay"])+		if err != nil {+			return nil, err+		}+		if duration != nil {+			task.ShutdownDelay = *duration+		}++		tasks = append(tasks, task)+	}++	return tasks, nil+}++func getNetworks(d interface{}) []*api.NetworkResource {+	networks := make([]*api.NetworkResource, 0)++	for _, nr := range d.([]interface{}) {+		n := nr.(map[string]interface{})++		// TODO(remi): find what to do with the ports here+		network := &api.NetworkResource{+			Mode:  n["mode"].(string),+			MBits: getInt(n, "mbits"),+		}++		for _, dns := range n["dns"].([]interface{}) {+			d := dns.(map[string]interface{})++			network.DNS = &api.DNSConfig{}++			servers := make([]string, 0)+			for _, s := range d["servers"].([]interface{}) {+				network.DNS.Servers = append(servers, s.(string))+			}+			searches := make([]string, 0)+			for _, s := range d["searches"].([]interface{}) {+				network.DNS.Searches = append(searches, s.(string))+			}+			options := make([]string, 0)+			for _, s := range d["options"].([]interface{}) {+				network.DNS.Options = append(options, s.(string))+			}+		}++		networks = append(networks, network)+	}++	return networks+}++func getServices(d interface{}) ([]*api.Service, error) {+	services := make([]*api.Service, 0)++	for _, svc := range d.([]interface{}) {+		s := svc.(map[string]interface{})++		tags := make([]string, 0)+		for _, t := range s["tags"].([]interface{}) {+			tags = append(tags, t.(string))+		}++		canaryTags := make([]string, 0)+		for _, t := range s["canary_tags"].([]interface{}) {+			canaryTags = append(canaryTags, t.(string))+		}++		checks := make([]api.ServiceCheck, 0)+		for _, cks := range s["check"].([]interface{}) {+			c := cks.(map[string]interface{})++			args := make([]string, 0)+			for _, a := range c["args"].([]interface{}) {+				args = append(args, a.(string))+			}++			var checkRestart *api.CheckRestart+			for _, crt := range c["check_restart"].([]interface{}) {+				cr := crt.(map[string]interface{})++				grace, err := getDuration(cr["grace"])+				if err != nil {+					return nil, err+				}+				checkRestart = &api.CheckRestart{+					Limit:          cr["limit"].(int),+					Grace:          grace,+					IgnoreWarnings: cr["ignore_warnings"].(bool),+				}+			}++			check := api.ServiceCheck{+				AddressMode:            c["address_mode"].(string),+				Args:                   args,+				Command:                c["command"].(string),+				GRPCService:            c["grpc_service"].(string),+				GRPCUseTLS:             c["grpc_use_tls"].(bool),+				InitialStatus:          c["initial_status"].(string),+				SuccessBeforePassing:   c["success_before_passing"].(int),+				FailuresBeforeCritical: c["failures_before_critical"].(int),+				Method:                 c["method"].(string),+				Name:                   c["name"].(string),+				Path:                   c["path"].(string),+				Expose:                 c["expose"].(bool),+				PortLabel:              c["port"].(string),+				Protocol:               c["protocol"].(string),+				TaskName:               c["task"].(string),+				Type:                   c["type"].(string),+				TLSSkipVerify:          c["tls_skip_verify"].(bool),+				CheckRestart:           checkRestart,+			}++			duration, err := getDuration(c["timeout"])+			if err != nil {+				return nil, err+			}+			if duration != nil {+				check.Timeout = *duration+			}++			duration, err = getDuration(c["interval"])+			if err != nil {+				return nil, err+			}+			if duration != nil {+				check.Interval = *duration+			}++			checks = append(checks, check)+		}++		var connect *api.ConsulConnect+		for _, con := range s["connect"].([]interface{}) {+			cn := con.(map[string]interface{})++			var sidecarTask *api.SidecarTask+			for _, stask := range cn["sidecar_task"].([]interface{}) {+				st := stask.(map[string]interface{})++				var config map[string]interface{}+				err := json.Unmarshal([]byte(st["config"].(string)), &d)+				if err != nil {+					return nil, err+				}++				sidecarTask = &api.SidecarTask{+					Meta:       getMapOfString(st["meta"]),+					Name:       st["Name"].(string),+					Driver:     st["Driver"].(string),+					User:       st["User"].(string),+					Config:     config,+					Env:        getMapOfString(st["env"]),+					KillSignal: st["kill_signal"].(string),+					Resources:  getResources(st["resources"]),+					LogConfig:  getLogConfig(st["logs"]),+				}++				sidecarTask.KillTimeout, err = getDuration(st["kill_timeout"])+				if err != nil {+					return nil, err+				}++				sidecarTask.ShutdownDelay, err = getDuration(st["shutdown_delay"])+				if err != nil {+					return nil, err+				}+			}++			var sidecarService *api.ConsulSidecarService+			for _, sservice := range cn["sidecar_service"].([]interface{}) {+				ss := sservice.(map[string]interface{})++				tags := make([]string, 0)+				for _, t := range ss["tags"].([]interface{}) {+					tags = append(tags, t.(string))+				}++				var consulProxy *api.ConsulProxy+				for _, proxy := range ss["proxy"].([]interface{}) {+					p := proxy.(map[string]interface{})++					var config map[string]interface{}+					err := json.Unmarshal([]byte(p["config"].(string)), &config)+					if err != nil {+						return nil, err+					}++					upstreams := make([]*api.ConsulUpstream, 0)+					for _, up := range p["upstreams"].([]interface{}) {+						u := up.(map[string]interface{})++						upstream := &api.ConsulUpstream{+							DestinationName: u["destination_name"].(string),+							LocalBindPort:   u["local_bind_port"].(int),+						}++						upstreams = append(upstreams, upstream)+					}++					var exposeConfig *api.ConsulExposeConfig+					for _, cec := range p["expose"].([]interface{}) {+						ec := cec.(map[string]interface{})++						paths := make([]*api.ConsulExposePath, 0)+						for _, cep := range ec["path"].([]interface{}) {+							p := cep.(map[string]interface{})++							path := &api.ConsulExposePath{+								Path:          p["path"].(string),+								Protocol:      p["protocol"].(string),+								LocalPathPort: p["local_path_port"].(int),+								ListenerPort:  p["listener_port"].(string),+							}++							paths = append(paths, path)+						}++						exposeConfig = &api.ConsulExposeConfig{+							Path: paths,+						}+					}++					consulProxy = &api.ConsulProxy{+						LocalServiceAddress: p["local_service_address"].(string),+						LocalServicePort:    p["local_service_port"].(int),+						ExposeConfig:        exposeConfig,+						Upstreams:           upstreams,+						Config:              config,+					}+				}++				sidecarService = &api.ConsulSidecarService{+					Tags:  tags,+					Port:  ss["port"].(string),+					Proxy: consulProxy,+				}+			}++			connect = &api.ConsulConnect{+				Native:         cn["native"].(bool),+				SidecarService: sidecarService,+				SidecarTask:    sidecarTask,+			}+		}++		service := &api.Service{+			Meta:              getMapOfString(s["meta"]),+			Name:              s["name"].(string),+			PortLabel:         s["port"].(string),+			Tags:              tags,+			CanaryTags:        canaryTags,+			EnableTagOverride: s["enable_tag_override"].(bool),+			AddressMode:       s["address_mode"].(string),+			TaskName:          s["task"].(string),+			Checks:            checks,+			Connect:           connect,+			CanaryMeta:        getMapOfString(s["canary_meta"]),+		}++		services = append(services, service)+	}++	return services, nil+}++func getLogConfig(d interface{}) *api.LogConfig {+	for _, lg := range d.([]interface{}) {+		l := lg.(map[string]interface{})++		return &api.LogConfig{+			MaxFiles:      getInt(l, "max_files"),+			MaxFileSizeMB: getInt(l, "max_file_size"),+		}+	}++	return nil+}++func getResources(d interface{}) *api.Resources {+	for _, rs := range d.([]interface{}) {+		r := rs.(map[string]interface{})++		devices := make([]*api.RequestedDevice, 0)+		for _, dv := range r["device"].([]interface{}) {+			d := dv.(map[string]interface{})++			count := uint64(d["count"].(int))+			device := &api.RequestedDevice{+				Name:        d["name"].(string),+				Count:       &count,+				Constraints: getConstraints(d["constraint"]),+				Affinities:  getAffinities(d["affinity"]),+			}++			devices = append(devices, device)+		}++		return &api.Resources{+			CPU:      getInt(r, "cpu"),+			MemoryMB: getInt(r, "memory"),+			Networks: getNetworks(r["network"]),+			Devices:  devices,+		}+	}++	return nil+}++func getVault(d interface{}) *api.Vault {+	for _, vlt := range d.([]interface{}) {+		v := vlt.(map[string]interface{})++		policies := make([]string, 0)+		for _, p := range v["policies"].([]interface{}) {+			policies = append(policies, p.(string))+		}++		return &api.Vault{+			Policies:     policies,+			Namespace:    getString(v, "namespace"),+			Env:          getBool(v, "env"),+			ChangeMode:   getString(v, "change_mode"),+			ChangeSignal: getString(v, "change_signal"),+		}+	}++	return nil+}++// Readers++func readConstraints(constraints []*api.Constraint) interface{} {+	res := make([]interface{}, 0)++	for _, cn := range constraints {+		constraint := map[string]interface{}{+			"attribute": cn.LTarget,+			"operator":  cn.Operand,+			"value":     cn.RTarget,+		}++		res = append(res, constraint)+	}++	return res+}++func readAffinities(affinities []*api.Affinity) interface{} {+	res := make([]interface{}, 0)++	for _, af := range affinities {+		affinity := map[string]interface{}{+			"attribute": af.LTarget,+			"operator":  af.Operand,+			"value":     af.RTarget,+			"weight":    af.Weight,+		}++		res = append(res, affinity)+	}++	return res+}++func readSpreads(spreads []*api.Spread) interface{} {+	res := make([]interface{}, 0)++	for _, s := range spreads {+		targets := make([]interface{}, 0)++		for _, t := range s.SpreadTarget {+			target := map[string]interface{}{+				"value":   t.Value,+				"percent": t.Percent,+			}++			targets = append(targets, target)+		}++		spread := map[string]interface{}{+			"attribute": s.Attribute,+			"weight":    s.Weight,+			"target":    targets,+		}++		res = append(res, spread)+	}++	return res+}++func readGroups(d *schema.ResourceData, groups []*api.TaskGroup) (interface{}, error) {+	res := make([]interface{}, 0)++	// we have to look for the groups the user created in its configuration as+	// we will need to set the "ephemeral_disk" and "restart" block only if he+	// created one or the value for the block is different from the default one++	groupsConfig := d.Get("group").([]interface{})++	for i, g := range groups {+		currentConfig := groupsConfig[i].(map[string]interface{})++		ephemeralDisk := make([]interface{}, 0)++		if g.EphemeralDisk != nil {+			disk := map[string]interface{}{+				"migrate": *g.EphemeralDisk.Migrate,+				"size":    *g.EphemeralDisk.SizeMB,+				"sticky":  *g.EphemeralDisk.Sticky,+			}++			defaultValue := map[string]interface{}{+				"migrate": false,+				"size":    300,+				"sticky":  false,+			}++			set := currentConfig["ephemeral_disk"].([]interface{})++			if len(set) > 0 || !reflect.DeepEqual(disk, defaultValue) {+				ephemeralDisk = append(ephemeralDisk, disk)+			}+		}++		restart := make([]interface{}, 0)+		if g.RestartPolicy != nil {+			r := map[string]interface{}{+				"attempts": *g.RestartPolicy.Attempts,+				"delay":    g.RestartPolicy.Delay.String(),+				"interval": g.RestartPolicy.Interval.String(),+				"mode":     *g.RestartPolicy.Mode,+			}++			// The default depends on the job type+			var defaultValue map[string]interface{}+			_type := d.Get("type").(string)+			if _type == "service" {+				defaultValue = map[string]interface{}{+					"attempts": 2,+					"delay":    "15s",+					"interval": "30m0s",+					"mode":     "fail",+				}+			} else if _type == "batch" {+				defaultValue = map[string]interface{}{+					"attempts": 3,+					"delay":    "15s",+					"interval": "24h0m0s",+					"mode":     "fail",+				}+			} else if _type == "system" {+				defaultValue = map[string]interface{}{+					"attempts": 2,+					"delay":    "15s",+					"interval": "30m0s",+					"mode":     "fail",+				}

+package nomad++import "github.com/hashicorp/terraform-plugin-sdk/helper/schema"++func getJobFields() map[string]*schema.Schema {+	return map[string]*schema.Schema{+		"namespace": {+			Type:     schema.TypeString,+			Default:  "default",+			Optional: true,+		},+		"priority": {+			Type:     schema.TypeInt,+			Default:  50,+			Optional: true,+		},+		"type": {+			Type:     schema.TypeString,+			Default:  "service",+			Optional: true,+		},+		"region": {+			Type:     schema.TypeString,+			Default:  "global",+			Optional: true,+		},+		"meta": {+			Type:     schema.TypeMap,+			Elem:     &schema.Schema{Type: schema.TypeString},+			Optional: true,+		},+		"all_at_once": {+			Type:     schema.TypeBool,+			Optional: true,+		},+		"datacenters": {+			Type:     schema.TypeList,+			Elem:     &schema.Schema{Type: schema.TypeString},+			Optional: true,+		},+		"name": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"vault_token": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"consul_token": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"constraint": getConstraintFields(),+		"affinity":   getAffinityFields(),+		"spread":     getSpreadFields(),+		"group":      getGroupFields(),+		"parameterized": {+			Type:     schema.TypeList,+			Optional: true,+			MaxItems: 1,+			Elem: &schema.Resource{+				Schema: map[string]*schema.Schema{+					"meta_optional": {+						Type:     schema.TypeList,+						Elem:     &schema.Schema{Type: schema.TypeString},+						Optional: true,+					},+					"meta_required": {+						Type:     schema.TypeList,+						Elem:     &schema.Schema{Type: schema.TypeString},+						Optional: true,+					},+					"payload": {+						Type:     schema.TypeString,+						Optional: true,+					},+				},+			},+		},+		"periodic": {+			Type:     schema.TypeList,+			Optional: true,+			MaxItems: 1,+			Elem: &schema.Resource{+				Schema: map[string]*schema.Schema{+					"cron": {+						Type:     schema.TypeString,+						Optional: true,+					},+					"prohibit_overlap": {+						Type:     schema.TypeBool,+						Optional: true,+					},+					"time_zone": {+						Type:     schema.TypeString,+						Optional: true,+					},+				},+			},+		},+		"update": getUpdateFields(),+	}+}++func getSpreadFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"attribute": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"weight": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"target": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"value": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"percent": {+								Type:     schema.TypeInt,+								Optional: true,+							},+						},+					},+				},+			},+		},+	}+}++func getConstraintFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"attribute": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"operator": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"value": {+					Type:     schema.TypeString,+					Optional: true,+				},+			},+		},+	}+}++func getAffinityFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"attribute": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"operator": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"value": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"weight": {+					Type:     schema.TypeInt,+					Optional: true,+				},+			},+		},+	}+}++func getVaultFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"change_mode": {+					Type:     schema.TypeString,+					Default:  "restart",+					Optional: true,+				},+				"change_signal": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"env": {+					Type:     schema.TypeBool,+					Optional: true,+				},+				"namespace": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"policies": {+					Type:     schema.TypeList,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+			},+		},+	}+}++func getMigrateFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"health_check": {+					Type:     schema.TypeString,+					Default:  "checks",+					Optional: true,+				},+				"healthy_deadline": {+					Type:     schema.TypeString,+					Default:  "5m0s",+					Optional: true,+				},+				"max_parallel": {+					Type:     schema.TypeInt,+					Default:  1,+					Optional: true,+				},+				"min_healthy_time": {+					Type:     schema.TypeString,+					Default:  "10s",+					Optional: true,+				},+			},+		},+	}+}++func getRescheduleFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"attempts": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"interval": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"delay": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"delay_function": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"max_delay": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"unlimited": {+					Type:     schema.TypeBool,+					Optional: true,+				},+			},+		},+	}+}++func getResourcesFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"cpu": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"memory": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"device": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"name": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"count": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"constraint": getConstraintFields(),+							"affinity":   getAffinityFields(),+						},+					},+				},+				"network": getNetworkFields(),+			},+		},+	}+}++func getLogsFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"max_files": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"max_file_size": {+					Type:     schema.TypeInt,+					Optional: true,+				},+			},+		},+	}+}++func getServiceFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"canary_meta": {+					Type:     schema.TypeMap,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"meta": {+					Type:     schema.TypeMap,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"name": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"port": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"tags": {+					Type:     schema.TypeList,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"canary_tags": {+					Type:     schema.TypeList,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"enable_tag_override": {+					Type:     schema.TypeBool,+					Optional: true,+				},+				"address_mode": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"task": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"check": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"address_mode": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"args": {+								Type:     schema.TypeList,+								Elem:     &schema.Schema{Type: schema.TypeString},+								Optional: true,+							},+							"command": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"grpc_service": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"grpc_use_tls": {+								Type:     schema.TypeBool,+								Optional: true,+							},+							"initial_status": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"success_before_passing": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"failures_before_critical": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"interval": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"method": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"name": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"path": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"expose": {+								Type:     schema.TypeBool,+								Optional: true,+							},+							"port": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"protocol": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"task": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"timeout": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"type": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"tls_skip_verify": {+								Type:     schema.TypeBool,+								Optional: true,+							},+							"check_restart": {+								Type:     schema.TypeList,+								Optional: true,+								MaxItems: 1,+								Elem: &schema.Resource{+									Schema: map[string]*schema.Schema{+										"limit": {+											Type:     schema.TypeInt,+											Optional: true,+										},+										"grace": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"ignore_warnings": {+											Type:     schema.TypeBool,+											Optional: true,+										},+									},+								},+							},+						},+					},+				},+				"connect": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"native": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"sidecar_service": {+								Type:     schema.TypeList,+								Optional: true,+								MaxItems: 1,+								Elem: &schema.Resource{+									Schema: map[string]*schema.Schema{+										"tags": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"port": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"proxy": {+											Type:     schema.TypeList,+											Optional: true,+											MaxItems: 1,+											Elem: &schema.Resource{+												Schema: map[string]*schema.Schema{+													"local_service_address": {+														Type:     schema.TypeString,+														Optional: true,+													},+													"local_service_port": {+														Type:     schema.TypeInt,+														Optional: true,+													},+													"config": {+														Type:     schema.TypeMap,+														Elem:     &schema.Schema{Type: schema.TypeString},+														Optional: true,+													},+													"upstreams": {+														Type:     schema.TypeList,+														Optional: true,+														MaxItems: 1,+														Elem: &schema.Resource{+															Schema: map[string]*schema.Schema{+																"destination_name": {+																	Type:     schema.TypeString,+																	Optional: true,+																},+																"local_bind_port": {+																	Type:     schema.TypeString,+																	Optional: true,+																},+															},+														},+													},+													"expose": {+														Type:     schema.TypeList,+														Optional: true,+														MaxItems: 1,+														Elem: &schema.Resource{+															Schema: map[string]*schema.Schema{+																"path": {+																	Type:     schema.TypeList,+																	Optional: true,+																	Elem: &schema.Resource{+																		Schema: map[string]*schema.Schema{+																			"path": {+																				Type:     schema.TypeString,+																				Optional: true,+																			},+																			"protocol": {+																				Type:     schema.TypeString,+																				Optional: true,+																			},+																			"local_path_port": {+																				Type:     schema.TypeInt,+																				Optional: true,+																			},+																			"listener_port": {+																				Type:     schema.TypeString,+																				Optional: true,+																			},+																		},+																	},+																},+															},+														},+													},+												},+											},+										},+									},+								},+							},+							"sidecar_task": {+								Type:     schema.TypeList,+								Optional: true,+								MaxItems: 1,+								Elem: &schema.Resource{+									Schema: map[string]*schema.Schema{+										"meta": {+											Type:     schema.TypeMap,+											Elem:     &schema.Schema{Type: schema.TypeString},+											Optional: true,+										},+										"name": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"driver": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"user": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"config": {+											Type:     schema.TypeMap,+											Elem:     &schema.Schema{Type: schema.TypeString},+											Optional: true,+										},+										"env": {+											Type:     schema.TypeMap,+											Elem:     &schema.Schema{Type: schema.TypeString},+											Optional: true,+										},+										"kill_timeout": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"shutdown_delay": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"kill_signal": {+											Type:     schema.TypeString,+											Optional: true,+										},+										"resources": getResourcesFields(),+										"logs":      getLogsFields(),+									},+								},+							},+						},+					},+				},+			},+		},+	}+}++func getGroupFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Required: true,+		MinItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"name": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"meta": {+					Type:     schema.TypeMap,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"count": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"shutdown_delay": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"stop_after_client_disconnect": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"constraint": getConstraintFields(),+				"affinity":   getAffinityFields(),+				"spread":     getSpreadFields(),+				"ephemeral_disk": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"migrate": {+								Type:     schema.TypeBool,+								Optional: true,+							},+							"size": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"sticky": {+								Type:     schema.TypeBool,+								Optional: true,+							},+						},+					},+				},+				"migrate":    getMigrateFields(),+				"network":    getNetworkFields(),+				"reschedule": getRescheduleFields(),+				"restart": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"attempts": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"delay": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"interval": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"mode": {+								Type:     schema.TypeString,+								Optional: true,+							},+						},+					},+				},+				"service": getServiceFields(),+				"task":    getTaskFields(),+				"volume": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"name": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"type": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"source": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"read_only": {+								Type:     schema.TypeBool,+								Optional: true,+							},+						},+					},+				},+			},+		},+	}+}++func getTaskFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Required: true,+		MinItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"name": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"config": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"kill_timeout": {+					Type:     schema.TypeString,+					Default:  "5s",+					Optional: true,+				},+				"shutdown_delay": {+					Type:     schema.TypeString,+					Default:  "0s",+					Optional: true,+				},+				"env": {+					Type:     schema.TypeMap,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"meta": {+					Type:     schema.TypeMap,+					Elem:     &schema.Schema{Type: schema.TypeString},+					Optional: true,+				},+				"driver": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"kill_signal": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"leader": {+					Type:     schema.TypeBool,+					Optional: true,+				},+				"user": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"kind": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"artifact": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"destination": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"mode": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"options": {+								Type:     schema.TypeMap,+								Elem:     &schema.Schema{Type: schema.TypeString},+								Optional: true,+							},+							"source": {+								Type:     schema.TypeString,+								Optional: true,+							},+						},+					},+				},+				"constraint": getConstraintFields(),+				"affinity":   getAffinityFields(),+				"dispatch_payload": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"file": {+								Type:     schema.TypeString,+								Optional: true,+							},+						},+					},+				},+				"lifecycle": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"hook": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"sidecar": {+								Type:     schema.TypeBool,+								Optional: true,+							},+						},+					},+				},+				"logs":      getLogsFields(),+				"resources": getResourcesFields(),+				"service":   getServiceFields(),+				"template": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"change_mode": {+								Type:     schema.TypeString,+								Default:  "restart",+								Optional: true,+							},+							"change_signal": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"data": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"destination": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"env": {+								Type:     schema.TypeBool,+								Optional: true,+							},+							"left_delimiter": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"perms": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"right_delimiter": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"source": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"splay": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"vault_grace": {+								Type:     schema.TypeString,+								Optional: true,+							},+						},+					},+				},+				"vault": getVaultFields(),+				"volume_mount": {+					Type:     schema.TypeList,+					Optional: true,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"volume": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"destination": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"read_only": {+								Type:     schema.TypeBool,+								Optional: true,+							},+						},+					},+				},+			},+		},+	}+}++func getNetworkFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"mbits": {+					Type:     schema.TypeInt,+					Optional: true,+				},+				"mode": {+					Type:     schema.TypeString,+					Optional: true,+				},+				"port": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"static": {+								Type:     schema.TypeInt,+								Optional: true,+							},+							"to": {+								Type:     schema.TypeString,+								Optional: true,+							},+							"host_network": {+								Type:     schema.TypeString,+								Optional: true,+							},+						},+					},+				},+				"dns": {+					Type:     schema.TypeList,+					Optional: true,+					MaxItems: 1,+					Elem: &schema.Resource{+						Schema: map[string]*schema.Schema{+							"servers": {+								Type:     schema.TypeList,+								Elem:     &schema.Schema{Type: schema.TypeString},+								Optional: true,+							},+							"searches": {+								Type:     schema.TypeList,+								Elem:     &schema.Schema{Type: schema.TypeString},+								Optional: true,+							},+							"options": {+								Type:     schema.TypeList,+								Elem:     &schema.Schema{Type: schema.TypeString},+								Optional: true,+							},+						},+					},+				},+			},+		},+	}+}++func getUpdateFields() *schema.Schema {+	return &schema.Schema{+		Type:     schema.TypeList,+		Optional: true,+		MaxItems: 1,+		Elem: &schema.Resource{+			Schema: map[string]*schema.Schema{+				"healthy_deadline": {+					Type:     schema.TypeString,+					Default:  "0s",+					Optional: true,+				},+				"min_healthy_time": {+					Type:     schema.TypeString,+					Default:  "0s",+					Optional: true,+				},+				"progress_deadline": {+					Type:     schema.TypeString,+					Default:  "0s",+					Optional: true,+				},+				"stagger": {+					Type:     schema.TypeString,+					Default:  "0s",+					Optional: true,+				},

+package nomad++import "github.com/hashicorp/terraform-plugin-sdk/helper/schema"++func getJobFields() map[string]*schema.Schema {+	return map[string]*schema.Schema{+		"namespace": {+			Type:     schema.TypeString,+			Default:  "default",+			Optional: true,+		},+		"priority": {+			Type:     schema.TypeInt,+			Default:  50,

+package nomad++import "github.com/hashicorp/terraform-plugin-sdk/helper/schema"++func getJobFields() map[string]*schema.Schema {+	return map[string]*schema.Schema{+		"namespace": {+			Type:     schema.TypeString,+			Default:  "default",+			Optional: true,+		},+		"priority": {+			Type:     schema.TypeInt,+			Default:  50,+			Optional: true,+		},+		"type": {+			Type:     schema.TypeString,+			Default:  "service",+			Optional: true,+		},+		"region": {+			Type:     schema.TypeString,+			Default:  "global",+			Optional: true,+		},+		"meta": {+			Type:     schema.TypeMap,+			Elem:     &schema.Schema{Type: schema.TypeString},+			Optional: true,+		},+		"all_at_once": {+			Type:     schema.TypeBool,+			Optional: true,+		},+		"datacenters": {+			Type:     schema.TypeList,+			Elem:     &schema.Schema{Type: schema.TypeString},+			Optional: true,+		},+		"name": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"vault_token": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"consul_token": {+			Type:     schema.TypeString,+			Optional: true,+		},+		"constraint": getConstraintFields(),+		"affinity":   getAffinityFields(),+		"spread":     getSpreadFields(),+		"group":      getGroupFields(),+		"parameterized": {+			Type:     schema.TypeList,

+package nomad++import (+	"encoding/json"+	"fmt"+	"reflect"+	"strings"+	"time"++	"github.com/hashicorp/nomad/api"+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"+)++func resourceJobV2() *schema.Resource {+	return &schema.Resource{+		Schema: getJobFields(),+		Create: resourceJobV2Register,+		Update: resourceJobV2Register,+		Read:   resourceJobV2Read,+		Delete: resourceJobV2Deregister,+	}+}++func resourceJobV2Register(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, err := getJob(d)+	if err != nil {+		return fmt.Errorf("Failed to get job definition: %v", err)+	}++	_, _, err = client.Jobs().Register(job, nil)+	if err != nil {+		return fmt.Errorf("Failed to create the job: %v", err)+	}++	d.SetId(d.Get("name").(string))++	return resourceJobV2Read(d, meta)+}++func resourceJobV2Read(d *schema.ResourceData, meta interface{}) error {+	client := meta.(ProviderConfig).client+	job, _, err := client.Jobs().Info(d.Id(), nil)+	if err != nil {+		if strings.Contains(err.Error(), "404") {+			d.SetId("")+			return nil+		}+		return fmt.Errorf("Failed to read the job: %v", err)+	}++	if err = d.Set("namespace", job.Namespace); err != nil {+		return fmt.Errorf("Failed to set 'namespace': %v", err)+	}+	if err = d.Set("priority", job.Priority); err != nil {+		return fmt.Errorf("Failed to set 'priority': %v", err)+	}+	if err = d.Set("type", job.Type); err != nil {+		return fmt.Errorf("Failed to set 'type': %v", err)+	}+	if err = d.Set("region", job.Region); err != nil {+		return fmt.Errorf("Failed to set 'region': %v", err)+	}+	if err = d.Set("meta", job.Meta); err != nil {+		return fmt.Errorf("Failed to set 'meta': %v", err)+	}+	if err = d.Set("all_at_once", job.AllAtOnce); err != nil {+		return fmt.Errorf("Failed to set 'all_at_once': %v", err)+	}+	if err = d.Set("datacenters", job.Datacenters); err != nil {+		return fmt.Errorf("Failed to set 'datacenters': %v", err)+	}+	if err = d.Set("name", job.Name); err != nil {+		return fmt.Errorf("Failed to set 'name': %v", err)+	}+	// if err = d.Set("vault_token", job.VaultToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'vault_token': %v", err)+	// }+	// if err = d.Set("consul_token", job.ConsulToken); err != nil {+	// 	return fmt.Errorf("Failed to set 'consul_token': %v", err)+	// }+	if err = d.Set("constraint", readConstraints(job.Constraints)); err != nil {+		return fmt.Errorf("Failed to set 'constraint': %v", err)+	}+	if err = d.Set("affinity", readAffinities(job.Affinities)); err != nil {+		return fmt.Errorf("Failed to set 'affinity': %v", err)+	}+	if err = d.Set("spread", readSpreads(job.Spreads)); err != nil {+		return fmt.Errorf("Failed to set 'spread': %v", err)+	}