Provider based on teraform-framework

.golangci.yaml

@@ -147,7 +147,7 @@ output:
 run:
   timeout: 5m
   issues-exit-code: 1
-  tests: true
+  tests: false
   skip-dirs:
     - bin
     - vendor

Makefile

@@ -62,6 +62,12 @@ go-deps: ##install golang dependencies
 	$(GO) mod verify && \
 	echo -=OK=-
 
+.PHONY: test-tf-provider
+test-tf-provider: ##run tests for tf provider only
+	@echo running tf provider tests... && \
+	$(GO) clean -testcache && \
+	$(GO) test -v ./cmd/sgroups-tf-v2/internal/provider && \
+	echo -=OK=-
 
 .PHONY: test
 test: ##run tests
@@ -122,6 +128,17 @@ sgroups-tf:
 	$(GO) build -ldflags="$(LDFLAGS)" -o $(OUT) $(CURDIR)/cmd/$(APP) &&\
 	echo -=OK=- 
 
+.PHONY: sgroups-tf-v2	
+sgroups-tf-v2: | go-deps ##build SGroups Terraform provider V2 
+sgroups-tf-v2: APP=sgroups-tf-v2
+sgroups-tf-v2: OUT=$(CURDIR)/bin/terraform-provider-sgroups
+sgroups-tf-v2:
+	@echo build \"$(APP)\" for OS/ARCH=\"$(os)/$(arch)\" ... && \
+	echo into \"$(OUT)\" && \
+	env GOOS=$(os) GOARCH=$(arch) CGO_ENABLED=0 \
+	$(GO) build -ldflags="$(LDFLAGS)" -o $(OUT) $(CURDIR)/cmd/$(APP) &&\
+	echo -=OK=- 
+
 
 GOOSE_REPO:=https://github.com/pressly/goose
 GOOSE_LATEST_VERSION:= $(shell git ls-remote --tags --refs --sort='v:refname' $(GOOSE_REPO)|tail -1|egrep -o "v[0-9]+.*")

cmd/sgroups-tf-v2/internal/provider/abstract.go

@@ -0,0 +1,226 @@
+package provider
+
+import (
+	"context"
+	"fmt"
+
+	protos "github.com/H-BF/protos/pkg/api/sgroups"
+	sgAPI "github.com/H-BF/sgroups/internal/api/sgroups"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+type (
+	/*//
+	// KeyOps -
+	KeyOps[T any] interface {
+		String() string
+		FromString(string) error
+	}
+	*/
+
+	SingleResource[T any] interface {
+		ResourceAttributes() map[string]schema.Attribute
+		IsDiffer(T) bool
+	}
+
+	subjectOfSync interface {
+		protos.SyncNetworks |
+			protos.SyncSecurityGroups |
+			protos.SyncSGRules |
+			protos.SyncFqdnRules
+	}
+
+	Description struct {
+		ResourceDescription string
+		ItemsDescription    string
+	}
+
+	CollectionResource[T SingleResource[T], S subjectOfSync] struct {
+		suffix       string
+		description  Description
+		client       *sgAPI.Client
+		toSubjOfSync func(context.Context, map[string]T) (*S, diag.Diagnostics)
+		read         func(context.Context, CollectionResourceModel[T, S], *sgAPI.Client) (CollectionResourceModel[T, S], diag.Diagnostics)
+	}
+)
+
+func (c *CollectionResource[T, S]) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + c.suffix
+}
+
+func (c *CollectionResource[T, S]) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	var sr T
+	resp.Schema = schema.Schema{
+		Description: c.description.ResourceDescription,
+		Attributes: map[string]schema.Attribute{
+			"items": schema.MapNestedAttribute{
+				Description: c.description.ItemsDescription,
+				Required:    true,
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: sr.ResourceAttributes(),
+				},
+			},
+		},
+	}
+}
+
+func (c *CollectionResource[T, S]) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var plan CollectionResourceModel[T, S]
+
+	// Read Terraform plan data into the model
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Convert from Terraform data model into GRPC data model
+	syncReq, diags := plan.toSyncReq(ctx, protos.SyncReq_Upsert, c.toSubjOfSync)
+	if diags.HasError() {
+		resp.Diagnostics.Append(diags...)
+		return
+	}
+
+	// Send GRPC request
+	if _, err := c.client.Sync(ctx, syncReq); err != nil {
+		resp.Diagnostics.AddError(
+			"create "+c.description.ItemsDescription,
+			err.Error())
+		return
+	}
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, plan)...)
+}
+
+func (c *CollectionResource[T, S]) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	var state CollectionResourceModel[T, S]
+
+	// Read Terraform prior state data into the model
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Create GRPC request and convert response to Terraform data model
+	var diags diag.Diagnostics
+	if state, diags = c.read(ctx, state, c.client); diags.HasError() {
+		for _, diagError := range diags.Errors() {
+			resp.Diagnostics.AddError(
+				"read "+c.description.ItemsDescription,
+				diagError.Summary()+":"+diagError.Detail())
+		}
+	}
+
+	// Save updated data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+}
+
+func (c *CollectionResource[T, S]) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+	var plan, state CollectionResourceModel[T, S]
+
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	itemsToDelete := map[string]T{}
+	for name, itemFeatures := range state.Items {
+		if _, ok := plan.Items[name]; !ok {
+			// if item is missing in plan state - delete it
+			itemsToDelete[name] = itemFeatures
+		}
+	}
+
+	if len(itemsToDelete) > 0 {
+		tempModel := CollectionResourceModel[T, S]{
+			Items: itemsToDelete,
+		}
+		delReq, diags := tempModel.toSyncReq(ctx, protos.SyncReq_Delete, c.toSubjOfSync)
+		if diags.HasError() {
+			resp.Diagnostics.Append(diags...)
+			return
+		}
+		if _, err := c.client.Sync(ctx, delReq); err != nil {
+			//c.description.ResourceDescription
+			resp.Diagnostics.AddError(
+				"delete "+c.description.ItemsDescription,
+				err.Error())
+			return
+		}
+	}
+
+	itemsToUpdate := map[string]T{}
+	for name, itemFeatures := range plan.Items {
+		// in plan state can have unchanged items which should be ignored
+		// missing items before and changed items should be updated
+		if oldItemFeatures, ok := state.Items[name]; !ok || itemFeatures.IsDiffer(oldItemFeatures) {
+			itemsToUpdate[name] = itemFeatures
+		}
+	}
+
+	if len(itemsToUpdate) > 0 {
+		tempModel := CollectionResourceModel[T, S]{
+			Items: itemsToUpdate,
+		}
+		updateReq, diags := tempModel.toSyncReq(ctx, protos.SyncReq_Upsert, c.toSubjOfSync)
+		if diags.HasError() {
+			resp.Diagnostics.Append(diags...)
+			return
+		}
+		if _, err := c.client.Sync(ctx, updateReq); err != nil {
+			resp.Diagnostics.AddError(
+				"update "+c.description.ItemsDescription,
+				err.Error())
+			return
+		}
+	}
+
+	resp.Diagnostics.Append(resp.State.Set(ctx, plan)...)
+}
+
+func (c *CollectionResource[T, S]) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	var state CollectionResourceModel[T, S]
+
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	delReq, diags := state.toSyncReq(ctx, protos.SyncReq_Delete, c.toSubjOfSync)
+	if diags.HasError() {
+		resp.Diagnostics.Append(diags...)
+		return
+	}
+
+	if _, err := c.client.Sync(ctx, delReq); err != nil {
+		resp.Diagnostics.AddError(
+			"delete "+c.description.ItemsDescription,
+			err.Error())
+		return
+	}
+}
+
+func (c *CollectionResource[T, S]) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
+	if req.ProviderData == nil {
+		return
+	}
+
+	client, ok := req.ProviderData.(sgAPI.Client)
+	if !ok {
+		resp.Diagnostics.AddError(
+			"unexpected Data Source type",
+			fmt.Sprintf("Expected sgroups client but got: %T.", req.ProviderData),
+		)
+		return
+	}
+	c.client = &client
+}
+
+var (
+	_ resource.Resource              = &CollectionResource[networkItem, protos.SyncNetworks]{}
+	_ resource.ResourceWithConfigure = &CollectionResource[networkItem, protos.SyncNetworks]{}
+)

cmd/sgroups-tf-v2/internal/provider/access-ports.go

@@ -0,0 +1,40 @@
+package provider
+
+import (
+	protos "github.com/H-BF/protos/pkg/api/sgroups"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringdefault"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+type (
+	AccessPorts struct {
+		Source      types.String `tfsdk:"s"`
+		Destination types.String `tfsdk:"d"`
+	}
+)
+
+func (p AccessPorts) ResourceAttributes() map[string]schema.Attribute {
+	return map[string]schema.Attribute{
+		"s": schema.StringAttribute{
+			Description: "source port/ports range",
+			Optional:    true,
+			Computed:    true,
+			Default:     stringdefault.StaticString(""),
+		},
+		"d": schema.StringAttribute{
+			Description: "destination port/ports range",
+			Optional:    true,
+			Computed:    true,
+			Default:     stringdefault.StaticString(""),
+		},
+	}
+}
+
+func (p AccessPorts) toProto() *protos.AccPorts {
+	return &protos.AccPorts{
+		S: p.Source.ValueString(),
+		D: p.Destination.ValueString(),
+	}
+}

cmd/sgroups-tf-v2/internal/provider/collection-resource-model.go

@@ -0,0 +1,40 @@
+package provider
+
+import (
+	"context"
+
+	protos "github.com/H-BF/protos/pkg/api/sgroups"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+)
+
+type (
+	CollectionResourceModel[T any, S subjectOfSync] struct {
+		Items map[string]T `tfsdk:"items"`
+	}
+)
+
+func (model *CollectionResourceModel[T, S]) toSyncReq(
+	ctx context.Context, operation protos.SyncReq_SyncOp,
+	toProto func(context.Context, map[string]T) (*S, diag.Diagnostics),
+) (*protos.SyncReq, diag.Diagnostics) {
+	req := &protos.SyncReq{SyncOp: operation}
+
+	s, diags := toProto(ctx, model.Items)
+	if diags.HasError() {
+		return nil, diags
+	}
+	switch subject := any(s).(type) {
+	case *protos.SyncNetworks:
+		req.Subject = &protos.SyncReq_Networks{Networks: subject}
+	case *protos.SyncSecurityGroups:
+		req.Subject = &protos.SyncReq_Groups{Groups: subject}
+	case *protos.SyncSGRules:
+		req.Subject = &protos.SyncReq_SgRules{SgRules: subject}
+	case *protos.SyncFqdnRules:
+		req.Subject = &protos.SyncReq_FqdnRules{FqdnRules: subject}
+	default:
+		panic("unexpected subject")
+	}
+
+	return req, nil
+}