4.10.1

internal/service/sdn/segments/decort_sdn_get_status.go

@@ -0,0 +1,70 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package segments
+
+import (
+	"context"
+
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceSegmentGetStatusRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	status, err := utilitySegmentGetStatusCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	if d.Id() == "" {
+		d.SetId(d.Get("segment_id").(string))
+	}
+
+	d.Set("status", status)
+	return nil
+}
+
+func DataSourceSegmentGetStatus() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceSegmentGetStatusRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+		Schema: dataSourceSegmentGetStatusSchemaMake(),
+	}
+}

internal/service/sdn/segments/decort_sdn_segment.go

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package segments
+
+import (
+	"context"
+
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceSegmentRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	segment, err := utilitySegmentCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenSegment(d, segment)
+	d.SetId(segment.ID)
+	return nil
+}
+
+func DataSourceSegment() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceSegmentRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+		Schema: dataSourceSegmentSchemaMake(),
+	}
+}

internal/service/sdn/segments/decort_sdn_segment_list.go

@@ -0,0 +1,70 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package segments
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceSegmentListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	segmentList, err := utilitySegmentListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenSegmentList(segmentList))
+
+	return nil
+}
+
+func DataSourceSegmentList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceSegmentListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceSegmentListSchemaMake(),
+	}
+}

internal/service/sdn/segments/flattens.go

@@ -0,0 +1,117 @@
+package segments
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/segments"
+)
+
+func flattenSegment(d *schema.ResourceData, segmentRecord *segments.SegmentResponse) {
+	d.Set("access_group_id", segmentRecord.AccessGroupID)
+	d.Set("access_group_name", segmentRecord.AccessGroupName)
+	d.Set("created_at", segmentRecord.CreatedAt.String())
+	d.Set("description", segmentRecord.Description)
+	d.Set("dhcp_v4", flattenDHCPv4(segmentRecord.DHCPv4))
+	d.Set("dhcp_v6", flattenDHCPv6(segmentRecord.DHCPv6))
+	d.Set("display_name", segmentRecord.DisplayName)
+	d.Set("enabled", segmentRecord.Enabled)
+	d.Set("logical_ports_info", flattenEntity(segmentRecord.LogicalPortsInfo))
+	d.Set("routers_info", flattenEntity(segmentRecord.RoutersInfo))
+	d.Set("status", flattenStatus(segmentRecord.Status))
+	d.Set("subnet_v4", segmentRecord.SubnetV4)
+	d.Set("subnet_v6", segmentRecord.SubnetV6)
+	d.Set("updated_at", segmentRecord.UpdatedAt.String())
+	d.Set("version_id", segmentRecord.VersionID)
+}
+
+func flattenStatus(s segments.Status) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"common":      s.Common,
+		"hypervisors": flattenHypervisors(s.Hypervisors),
+	}
+	res = append(res, temp)
+	return res
+}
+
+func flattenHypervisors(hv []segments.HypervisorStatus) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(hv))
+	for _, v := range hv {
+		temp := map[string]interface{}{
+			"status":            v.Status,
+			"name":              v.Name,
+			"display_name":      v.DisplayName,
+			"hypervisor_status": v.HypervisorStatus,
+			"synced_at":         v.SyncedAt.String(),
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenEntity(ei []segments.EntityInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(ei))
+	for _, v := range ei {
+		temp := map[string]interface{}{
+			"display_name": v.DisplayName,
+			"id":           v.ID,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenDHCPv4(dchp segments.DHCPv4Config) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"dns":                     dchp.DNS,
+		"excluded_address_ranges": dchp.ExcludedAddressRanges,
+		"gateway":                 dchp.Gateway,
+		"id":                      dchp.ID,
+		"lease_time":              dchp.LeaseTime,
+		"server_ip":               dchp.ServerIP,
+		"server_mac":              dchp.ServerMAC,
+		"enabled":                 dchp.Enabled,
+	}
+	res = append(res, temp)
+	return res
+}
+
+func flattenDHCPv6(dchp segments.DHCPv6Config) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"dns":            dchp.DNS,
+		"address_prefix": dchp.AddressPrefix,
+		"id":             dchp.ID,
+		"lease_time":     dchp.LeaseTime,
+		"server_mac":     dchp.ServerMAC,
+		"enabled":        dchp.Enabled,
+	}
+	res = append(res, temp)
+	return res
+}
+
+func flattenSegmentList(sl *segments.ListSegment) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(*sl))
+	for _, v := range *sl {
+		temp := map[string]interface{}{
+			"access_group_id":    v.AccessGroupID,
+			"access_group_name":  v.AccessGroupName,
+			"created_at":         v.CreatedAt.String(),
+			"description":        v.Description,
+			"dhcp_v4":            flattenDHCPv4(v.DHCPv4),
+			"dhcp_v6":            flattenDHCPv6(v.DHCPv6),
+			"display_name":       v.DisplayName,
+			"enabled":            v.Enabled,
+			"logical_ports_info": flattenEntity(v.LogicalPortsInfo),
+			"routers_info":       flattenEntity(v.RoutersInfo),
+			"status":             flattenStatus(v.Status),
+			"id":                 v.ID,
+			"subnet_v4":          v.SubnetV4,
+			"subnet_v6":          v.SubnetV6,
+			"updated_at":         v.UpdatedAt.String(),
+			"version_id":         v.VersionID,
+		}
+		res = append(res, temp)
+	}
+	return res
+}

internal/service/sdn/segments/resource_sdn_segment.go

@@ -0,0 +1,357 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package segments
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/segments"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func resourceSegmentCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceSegmentCreate: called segment with name %s",
+		d.Get("display_name").(string))
+	c := m.(*controller.ControllerCfg)
+
+	subnetV4, v4ok := d.GetOk("subnet_v4")
+	subnetV6, v6ok := d.GetOk("subnet_v6")
+
+	if !v4ok && !v6ok {
+		return diag.Errorf("resourceSegmentCreate: either subnet_v4 or subnet_v6 must be specified")
+	}
+
+	req := segments.CreateRequest{
+		AccessGroupID: d.Get("access_group_id").(string),
+		Description:   d.Get("description").(string),
+		DisplayName:   d.Get("display_name").(string),
+		Enabled:       d.Get("enabled").(bool),
+	}
+
+	if v4ok {
+		req.SubnetV4 = subnetV4.(string)
+	}
+
+	if v6ok {
+		req.SubnetV6 = subnetV6.(string)
+	}
+
+	if dhcpV4, ok := d.GetOk("dhcp_v4"); ok {
+		dhcpV4 := dhcpV4.([]interface{})[0]
+		dhcpV4Map := dhcpV4.(map[string]interface{})
+		dhcpReq := segments.DHCPv4ConfigRequest{
+			Gateway:  dhcpV4Map["gateway"].(string),
+			ServerIP: dhcpV4Map["server_ip"].(string),
+			Enabled:  dhcpV4Map["enabled"].(bool),
+		}
+		serverMAC, sMAC := dhcpV4Map["server_mac"]
+		if sMAC {
+			dhcpReq.ServerMAC = serverMAC.(string)
+		}
+
+		leaseTime, lTime := dhcpV4Map["lease_time"]
+		if lTime {
+			dhcpReq.LeaseTime = uint64(leaseTime.(int))
+		}
+
+		dns, dnsOk := dhcpV4Map["dns"]
+		if dnsOk {
+			dnsArr := make([]string, 0)
+			for _, v := range dns.([]interface{}) {
+				dnsArr = append(dnsArr, v.(string))
+			}
+			dhcpReq.DNS = dnsArr
+		}
+
+		adrRanges, earOK := dhcpV4Map["excluded_address_ranges"]
+		if earOK {
+			earArr := make([]string, 0)
+			for _, v := range adrRanges.([]interface{}) {
+				earArr = append(earArr, v.(string))
+			}
+			dhcpReq.ExcludedAddressRanges = earArr
+		}
+		req.DHCPv4 = &dhcpReq
+	}
+
+	if dhcpV6, ok := d.GetOk("dhcp_v6"); ok {
+		dhcpV6 := dhcpV6.([]interface{})[0]
+		dhcpV6Map := dhcpV6.(map[string]interface{})
+		dhcpReq := segments.DHCPv6ConfigRequest{
+			AddressPrefix: dhcpV6Map["address_prefix"].(string),
+			Enabled:       dhcpV6Map["enabled"].(bool),
+		}
+		serverMAC, sMAC := dhcpV6Map["server_mac"]
+		if sMAC {
+			dhcpReq.ServerMAC = serverMAC.(string)
+		}
+
+		leaseTime, lTime := dhcpV6Map["lease_time"]
+		if lTime {
+			dhcpReq.LeaseTime = uint64(leaseTime.(int))
+		}
+
+		dns, dnsOk := dhcpV6Map["dns"]
+		if dnsOk {
+			dnsArr := make([]string, 0)
+			for _, v := range dns.([]interface{}) {
+				dnsArr = append(dnsArr, v.(string))
+			}
+			dhcpReq.DNS = dnsArr
+		}
+		req.DHCPv6 = &dhcpReq
+	}
+
+	segmentData, err := c.SDN().Segments().Create(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	d.SetId(segmentData.ID)
+	d.Set("segment_id", segmentData.ID)
+
+	return append(resourceSegmentRead(ctx, d, m))
+}
+
+func resourceSegmentRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceSegmentRead: called segment with name %s",
+		d.Get("display_name").(string))
+
+	segmentData, err := utilitySegmentCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenSegment(d, segmentData)
+
+	return nil
+}
+
+func resourceSegmentUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceSegmentUpdate: called segment with name %s",
+		d.Get("display_name").(string))
+
+	c := m.(*controller.ControllerCfg)
+
+	segmentData, err := utilitySegmentCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	subnetV4, v4ok := d.GetOk("subnet_v4")
+	subnetV6, v6ok := d.GetOk("subnet_v6")
+
+	if !v4ok && !v6ok {
+		return diag.Errorf("resourceSegmentCreate: either subnet_v4 or subnet_v6 must be specified")
+	}
+
+	needUpdate := false
+
+	req := segments.UpdateRequest{
+		SegmentID:     segmentData.ID,
+		VersionID:     segmentData.VersionID,
+		AccessGroupID: d.Get("access_group_id").(string),
+		Description:   d.Get("description").(string),
+		DisplayName:   d.Get("display_name").(string),
+		Enabled:       d.Get("enabled").(bool),
+	}
+
+	if d.HasChanges("access_group_id", "description", "display_name", "enabled") {
+		needUpdate = true
+	}
+
+	if v4ok {
+		req.SubnetV4 = subnetV4.(string)
+	}
+
+	if v6ok {
+		req.SubnetV6 = subnetV6.(string)
+	}
+
+	if d.HasChange("dhcp_v4") {
+		if dhcpV4, ok := d.GetOk("dhcp_v4"); ok {
+			dhcpV4 := dhcpV4.([]interface{})[0]
+			dhcpV4Map := dhcpV4.(map[string]interface{})
+			dhcpReq := segments.DHCPv4ConfigRequest{
+				Gateway:  dhcpV4Map["gateway"].(string),
+				ServerIP: dhcpV4Map["server_ip"].(string),
+				Enabled:  dhcpV4Map["enabled"].(bool),
+			}
+			serverMAC, sMAC := dhcpV4Map["server_mac"]
+			if sMAC {
+				dhcpReq.ServerMAC = serverMAC.(string)
+			}
+
+			leaseTime, lTime := dhcpV4Map["lease_time"]
+			if lTime {
+				dhcpReq.LeaseTime = uint64(leaseTime.(int))
+			}
+
+			dns, dnsOk := dhcpV4Map["dns"]
+			if dnsOk {
+				dnsArr := make([]string, 0)
+				for _, v := range dns.([]interface{}) {
+					dnsArr = append(dnsArr, v.(string))
+				}
+				dhcpReq.DNS = dnsArr
+			}
+
+			adrRanges, earOK := dhcpV4Map["excluded_address_ranges"]
+			if earOK {
+				earArr := make([]string, 0)
+				for _, v := range adrRanges.([]interface{}) {
+					earArr = append(earArr, v.(string))
+				}
+				dhcpReq.ExcludedAddressRanges = earArr
+			}
+			req.DHCPv4 = &dhcpReq
+		}
+
+		needUpdate = true
+	}
+
+	if d.HasChange("dhcp_v6") {
+		if dhcpV6, ok := d.GetOk("dhcp_v6"); ok {
+			dhcpV6 := dhcpV6.([]interface{})[0]
+			dhcpV6Map := dhcpV6.(map[string]interface{})
+			dhcpReq := segments.DHCPv6ConfigRequest{
+				AddressPrefix: dhcpV6Map["address_prefix"].(string),
+				Enabled:       dhcpV6Map["enabled"].(bool),
+			}
+			serverMAC, sMAC := dhcpV6Map["server_mac"]
+			if sMAC {
+				dhcpReq.ServerMAC = serverMAC.(string)
+			}
+
+			leaseTime, lTime := dhcpV6Map["lease_time"]
+			if lTime {
+				dhcpReq.LeaseTime = uint64(leaseTime.(int))
+			}
+
+			dns, dnsOk := dhcpV6Map["dns"]
+			if dnsOk {
+				dnsArr := make([]string, 0)
+				for _, v := range dns.([]interface{}) {
+					dnsArr = append(dnsArr, v.(string))
+				}
+				dhcpReq.DNS = dnsArr
+			}
+			req.DHCPv6 = &dhcpReq
+		}
+		needUpdate = true
+	}
+
+	if needUpdate {
+		segmentData, err = c.SDN().Segments().Update(ctx, req)
+	}
+
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	d.SetId(segmentData.ID)
+	d.Set("segment_id", segmentData.ID)
+
+	return append(resourceSegmentRead(ctx, d, m))
+}
+
+func resourceSegmentDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceSegmentUpdate: called segment with name %s",
+		d.Get("display_name").(string))
+
+	segmentData, err := utilitySegmentCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	req := segments.DeleteRequest{
+		SegmentID: segmentData.ID,
+		VersionID: segmentData.VersionID,
+	}
+
+	if force, ok := d.GetOk("force"); ok {
+		req.Force = force.(bool)
+	}
+
+	c := m.(*controller.ControllerCfg)
+	err = c.SDN().Segments().Delete(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func ResourceSegment() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CreateContext: resourceSegmentCreate,
+		ReadContext:   resourceSegmentRead,
+		UpdateContext: resourceSegmentUpdate,
+		DeleteContext: resourceSegmentDelete,
+
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		CustomizeDiff: func(ctx context.Context, diff *schema.ResourceDiff, i interface{}) error {
+			changedKeys := diff.GetChangedKeysPrefix("")
+			if len(changedKeys) > 0 {
+				diff.SetNewComputed("updated_at")
+				diff.SetNewComputed("version_id")
+			}
+			return nil
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create:  &constants.Timeout600s,
+			Read:    &constants.Timeout300s,
+			Update:  &constants.Timeout600s,
+			Delete:  &constants.Timeout900s,
+			Default: &constants.Timeout300s,
+		},
+
+		Schema: resourceSegmentSchemaMake(),
+	}
+}

internal/service/sdn/segments/schema.go

@@ -0,0 +1,731 @@
+package segments
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+)
+
+func dataSourceSegmentSchemaMake() map[string]*schema.Schema {
+	sch := map[string]*schema.Schema{
+		"segment_id": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"access_group_id": {
+			Type:     schema.TypeString,
+			Optional: true,
+			Computed: true,
+		},
+		"access_group_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_at": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"description": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"dhcp_v4": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"dns": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"excluded_address_ranges": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"gateway": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"lease_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"server_ip": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"server_mac": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"enabled": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"dhcp_v6": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"address_prefix": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"dns": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"lease_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"server_mac": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"enabled": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"display_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"enabled": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"logical_ports_info": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"display_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"routers_info": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"display_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"status": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"common": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"hypervisors": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"status": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"display_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"hypervisor_status": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"synced_at": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		"subnet_v4": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"subnet_v6": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_at": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"version_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return sch
+}
+
+func dataSourceSegmentListSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"page": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Page number",
+		},
+		"per_page": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Items per page",
+		},
+		"sort_by": {
+			Type:         schema.TypeString,
+			Optional:     true,
+			ValidateFunc: validation.StringInSlice([]string{"display_name", "subnet", "created_at", "updated_at"}, false),
+			Description:  "sort by one of supported fields",
+		},
+		"sort_order": {
+			Type:         schema.TypeString,
+			Optional:     true,
+			ValidateFunc: validation.StringInSlice([]string{"asc", "dec"}, false),
+			Description:  "sort order",
+		},
+		"enabled": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "find by enabled status",
+		},
+		"is_synced": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "does core currently believe that its data is synchronized with the data in the OVN?",
+		},
+		"display_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by display name",
+		},
+		"subnet": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "IPv4 or IPv6 subnet for the current segment",
+		},
+		"access_group_id": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by access group id",
+		},
+		"created_from": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by created date",
+		},
+		"created_to": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by created date",
+		},
+		"updated_from": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by updated date",
+		},
+		"updated_to": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by updated date",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"access_group_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"access_group_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"created_at": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"description": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"dhcp_v4": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"dns": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Schema{
+										Type: schema.TypeString,
+									},
+								},
+								"excluded_address_ranges": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Schema{
+										Type: schema.TypeString,
+									},
+								},
+								"gateway": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"lease_time": {
+									Type:     schema.TypeInt,
+									Computed: true,
+								},
+								"server_ip": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"server_mac": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"enabled": {
+									Type:     schema.TypeBool,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"dhcp_v6": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"address_prefix": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"dns": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Schema{
+										Type: schema.TypeString,
+									},
+								},
+								"id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"lease_time": {
+									Type:     schema.TypeInt,
+									Computed: true,
+								},
+								"server_mac": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"enabled": {
+									Type:     schema.TypeBool,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"display_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"enabled": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"logical_ports_info": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"display_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"routers_info": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"display_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"status": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"common": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"hypervisors": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Resource{
+										Schema: map[string]*schema.Schema{
+											"status": {
+												Type:     schema.TypeString,
+												Computed: true,
+											},
+											"name": {
+												Type:     schema.TypeString,
+												Computed: true,
+											},
+											"display_name": {
+												Type:     schema.TypeString,
+												Computed: true,
+											},
+											"hypervisor_status": {
+												Type:     schema.TypeString,
+												Computed: true,
+											},
+											"synced_at": {
+												Type:     schema.TypeString,
+												Computed: true,
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+					"subnet_v4": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"subnet_v6": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"updated_at": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"version_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "entry count",
+		},
+	}
+	return res
+}
+
+func dataSourceSegmentGetStatusSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"segment_id": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"version_id": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"detailed": {
+			Type:     schema.TypeBool,
+			Optional: true,
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func resourceSegmentSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"access_group_id": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"description": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"display_name": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"enabled": {
+			Type:     schema.TypeBool,
+			Required: true,
+		},
+		"force": {
+			Type:     schema.TypeBool,
+			Optional: true,
+		},
+		"subnet_v4": {
+			Type:     schema.TypeString,
+			Optional: true,
+			Computed: true,
+		},
+		"subnet_v6": {
+			Type:     schema.TypeString,
+			Optional: true,
+			Computed: true,
+		},
+		"dhcp_v4": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			MaxItems: 1,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"dns": {
+						Type:     schema.TypeList,
+						Optional: true,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"excluded_address_ranges": {
+						Type:     schema.TypeList,
+						Optional: true,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"gateway": {
+						Type:     schema.TypeString,
+						Required: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"lease_time": {
+						Type:     schema.TypeInt,
+						Optional: true,
+						Computed: true,
+					},
+					"server_ip": {
+						Type:     schema.TypeString,
+						Required: true,
+					},
+					"server_mac": {
+						Type:     schema.TypeString,
+						Optional: true,
+						Computed: true,
+					},
+					"enabled": {
+						Type:     schema.TypeBool,
+						Required: true,
+					},
+				},
+			},
+		},
+		"dhcp_v6": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			MaxItems: 1,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"address_prefix": {
+						Type:     schema.TypeString,
+						Required: true,
+					},
+					"dns": {
+						Type:     schema.TypeList,
+						Optional: true,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"lease_time": {
+						Type:     schema.TypeInt,
+						Optional: true,
+						Computed: true,
+					},
+					"server_mac": {
+						Type:     schema.TypeString,
+						Optional: true,
+						Computed: true,
+					},
+					"enabled": {
+						Type:     schema.TypeBool,
+						Required: true,
+					},
+				},
+			},
+		},
+		"access_group_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_at": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"logical_ports_info": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"display_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"routers_info": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"display_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"status": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"common": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"hypervisors": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"status": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"display_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"hypervisor_status": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"synced_at": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		"updated_at": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"version_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}

internal/service/sdn/segments/utility_segment.go

@@ -0,0 +1,28 @@
+package segments
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/segments"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilitySegmentCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*segments.SegmentResponse, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := segments.GetRequest{}
+
+	if d.Id() != "" {
+		req.SegmentID = d.Id()
+	} else {
+		req.SegmentID = d.Get("segment_id").(string)
+	}
+
+	segment, err := c.SDN().Segments().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return segment, nil
+}

internal/service/sdn/segments/utility_segment_get_status.go

@@ -0,0 +1,36 @@
+package segments
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/segments"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilitySegmentGetStatusCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (string, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := segments.GetStatusRequest{}
+
+	if d.Id() != "" {
+		req.SegmentID = d.Id()
+	} else {
+		req.SegmentID = d.Get("segment_id").(string)
+	}
+
+	if version, ok := d.GetOk("version"); ok {
+		req.VersionID = uint64(version.(int))
+	}
+
+	if detailed, ok := d.GetOk("detailed"); ok {
+		req.Detailed = detailed.(bool)
+	}
+
+	segment, err := c.SDN().Segments().GetStatus(ctx, req)
+	if err != nil {
+		return "", err
+	}
+
+	return segment, nil
+}

internal/service/sdn/segments/utility_segment_list.go

@@ -0,0 +1,63 @@
+package segments
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/segments"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilitySegmentListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*segments.ListSegment, error) {
+	c := m.(*controller.ControllerCfg)
+	req := segments.ListRequest{}
+
+	if page, ok := d.GetOk("page"); ok {
+		req.Page = uint64(page.(int))
+	}
+	if perPage, ok := d.GetOk("per_page"); ok {
+		req.PerPage = uint64(perPage.(int))
+	}
+	if sortBy, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = sortBy.(string)
+	}
+	if sortOrder, ok := d.GetOk("sort_order"); ok {
+		req.SortOrder = sortOrder.(string)
+	}
+	if enabled, ok := d.GetOk("enabled"); ok {
+		req.Enabled = enabled.(bool)
+	}
+	if isSynced, ok := d.GetOk("is_synced"); ok {
+		req.Enabled = isSynced.(bool)
+	}
+	if displayName, ok := d.GetOk("display_name"); ok {
+		req.DisplayName = displayName.(string)
+	}
+	if subnet, ok := d.GetOk("subnet"); ok {
+		req.Subnet = subnet.(string)
+	}
+	if accessGroupID, ok := d.GetOk("access_group_id"); ok {
+		req.AccessGroupID = accessGroupID.(string)
+	}
+	if createdFrom, ok := d.GetOk("created_from"); ok {
+		req.CreatedFrom = createdFrom.(string)
+	}
+	if createdTo, ok := d.GetOk("created_to"); ok {
+		req.CreatedTo = createdTo.(string)
+	}
+	if updatedFrom, ok := d.GetOk("updated_from"); ok {
+		req.UpdatedTo = updatedFrom.(string)
+	}
+	if updatedTo, ok := d.GetOk("updated_to"); ok {
+		req.UpdatedTo = updatedTo.(string)
+	}
+	
+	log.Debugf("utilitySegmentListCheckPresence")
+	segmentList, err := c.SDN().Segments().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &segmentList, nil
+}