Merge pull request #6 from benzaita/lx-899-split-og-and-indexing-status

Lx 899 split og and indexing status

Author: kzonov

Makefile

@@ -4,7 +4,7 @@ NAMESPACE=benzaita
 NAME=chaossearch
 BINARY=terraform-provider-${NAME}
 VERSION=0.6.0
-OS_ARCH=linux_amd64
+OS_ARCH=darwin_amd64
 
 default: install
 

chaossearch/client/client.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"time"
+	"encoding/json"
 
 	"github.com/aws/aws-sdk-go/aws/credentials"
 	v4 "github.com/aws/aws-sdk-go/aws/signer/v4"
@@ -93,9 +94,9 @@ func (client *Client) unmarshalJSONBody(bodyReader io.Reader, v interface{}) err
 		return fmt.Errorf("Failed to read body: %s", err)
 	}
 
-	if err :=json.Unmarshal(bodyAsBytes, v); err != nil {
+	if err := json.Unmarshal(bodyAsBytes, v); err != nil {
 		return fmt.Errorf("Failed to unmarshal JSON: %s", err)
 	}
 
 	return nil
-}
+}

chaossearch/client/model.go

@@ -26,7 +26,6 @@ type ReadObjectGroupResponse struct {
 	PartitionBy      string
 	SourceBucket     string
 	IndexRetention   int
-	Active           bool
 }
 
 type CreateObjectGroupRequest struct {
@@ -41,7 +40,7 @@ type CreateObjectGroupRequest struct {
 	IndexRetention   int
 }
 
-type SetActiveRequest struct {
+type UpdateIndexingStateRequest struct {
 	ObjectGroupName string
 	Active          bool
 }
@@ -54,3 +53,17 @@ type UpdateObjectGroupRequest struct {
 	Name           string
 	IndexRetention int
 }
+
+type ReadIndexingStateRequest struct {
+	ObjectGroupName string
+}
+
+type readBucketMetadataRequest struct {
+	BucketName string `json:"BucketName"`
+	Stats bool `json:"Stats"`
+}
+
+type IndexingState struct {
+	ObjectGroupName string
+	Active          bool
+}

chaossearch/client/operation_read_indexing_state.go

@@ -0,0 +1,71 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+
+// There are other nested structures that we don't marshal here because we don't need to.
+//  Feel free to add them in the future when needed
+type readBucketMetadataResponse struct {
+	Bucket string `json:"Bucket"`
+	State  string `json:"State"`
+}
+
+// For documentation see: https://docs.chaossearch.io/reference#bucketmodel
+func (client *Client) ReadIndexingState(ctx context.Context, req *ReadIndexingStateRequest) (*IndexingState, error) {
+	method := "POST"
+	body := &readBucketMetadataRequest{
+		BucketName: req.ObjectGroupName,
+		Stats: false,
+	}
+
+	response, err := makeGetBucketMetadataRequest(method, client, ctx, body)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %s", err)
+	}
+
+	bucketMetadata := &IndexingState{
+		ObjectGroupName: response.Bucket,
+		Active: false,
+	}
+
+	if response.State == "Active" || response.State == "Idle" {
+		bucketMetadata.Active = true
+	}
+
+	return bucketMetadata, nil
+}
+
+func makeGetBucketMetadataRequest(method string, client *Client, ctx context.Context, body *readBucketMetadataRequest) (*readBucketMetadataResponse, error) {
+	url := fmt.Sprintf("%s/Bucket/metadata", client.config.URL)
+
+	jsonedBody, err := json.Marshal(body)
+	if err != nil {
+		return nil, fmt.Errorf("cannot marshal request body: %s", err)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(jsonedBody))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %s", err)
+	}
+
+	httpResp, err := client.signAndDo(httpReq, jsonedBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to %s to %s: %s", method, url, err)
+	}
+	defer httpResp.Body.Close()
+
+
+	var response readBucketMetadataResponse
+	err = client.unmarshalJSONBody(httpResp.Body, &response)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %s", err)
+	}
+
+	return &response, nil
+}

chaossearch/client/operation_read_object_group.go

@@ -105,10 +105,6 @@ func mapBucketTaggingToResponse(tagging *s3.GetBucketTaggingOutput, v *ReadObjec
 		return err
 	}
 
-	if err := readJSONTagValue(tagging, "cs3.modeled", &v.Active); err != nil {
-		return err
-	}
-
 	var filterObject struct {
 		Type string `json:"_type"`
 		Pattern string `json:"pattern"`

…aossearch/client/operation_set_active.go …lient/operation_update_indexing_state.gochaossearch/client/operation_set_active.go renamed to chaossearch/client/operation_update_indexing_state.go chaossearch/client/operation_set_active.go renamed to chaossearch/client/operation_update_indexing_state.go

@@ -8,11 +8,12 @@ import (
 	"net/http"
 )
 
-func (client *Client) SetActive(ctx context.Context, req *SetActiveRequest) error {
+// For documentation see: https://docs.chaossearch.io/reference#bucketmodel
+func (client *Client) UpdateIndexingState(ctx context.Context, req *UpdateIndexingStateRequest) error {
 	method := "POST"
 	url := fmt.Sprintf("%s/Bucket/model", client.config.URL)
 
-	bodyAsBytes, err := marshalSetActiveRequest(req)
+	bodyAsBytes, err := marshalUpdateIndexingStateRequest(req)
 	if err != nil {
 		return err
 	}
@@ -31,7 +32,7 @@ func (client *Client) SetActive(ctx context.Context, req *SetActiveRequest) erro
 	return nil
 }
 
-func marshalSetActiveRequest(req *SetActiveRequest) ([]byte, error) {
+func marshalUpdateIndexingStateRequest(req *UpdateIndexingStateRequest) ([]byte, error) {
 	var modelMode int
 
 	if req.Active {

chaossearch/provider.go

@@ -41,6 +41,7 @@ func Provider() *schema.Provider {
 		},
 		ResourcesMap: map[string]*schema.Resource{
 			"chaossearch_object_group": resourceObjectGroup(),
+			"chaossearch_indexing_state": resourceIndexingState(),
 		},
 		DataSourcesMap: map[string]*schema.Resource{
 			"chaossearch_object_groups": dataSourceObjectGroups(),

chaossearch/resource_indexing_state.go

@@ -0,0 +1,101 @@
+package chaossearch
+
+import (
+	"context"
+	"terraform-provider-chaossearch/chaossearch/client"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func resourceIndexingState() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceIndexingStateCreate,
+		ReadContext:   resourceIndexingStateRead,
+		UpdateContext: resourceIndexingStateUpdate,
+		DeleteContext: resourceIndexingStateDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Schema: map[string]*schema.Schema{
+			"object_group_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"active": {
+				Type:        schema.TypeBool,
+				Description: "Whether the live indexing should be running or not",
+				Required:    true,
+				ForceNew:    false,
+			},
+		},
+	}
+}
+
+func resourceIndexingStateCreate(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	c := meta.(*ProviderMeta).Client
+
+	updateIndexingStateRequest := &client.UpdateIndexingStateRequest{
+		ObjectGroupName: data.Get("object_group_name").(string),
+		Active:          data.Get("active").(bool),
+	}
+
+	if err := c.UpdateIndexingState(ctx, updateIndexingStateRequest); err != nil {
+		return diag.FromErr(err)
+	}
+
+	data.SetId(data.Get("object_group_name").(string))
+
+	return resourceIndexingStateRead(ctx, data, meta)
+}
+
+func resourceIndexingStateRead(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	diags := diag.Diagnostics{}
+
+	c := meta.(*ProviderMeta).Client
+
+	readIndexingStateRequest := &client.ReadIndexingStateRequest{
+		ObjectGroupName: data.Get("object_group_name").(string),
+	}
+
+	resp, err := c.ReadIndexingState(ctx, readIndexingStateRequest)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	data.SetId(resp.ObjectGroupName)
+	data.Set("active", resp.Active)
+
+	return diags
+}
+
+func resourceIndexingStateUpdate(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	c := meta.(*ProviderMeta).Client
+
+	updateIndexingStateRequest := &client.UpdateIndexingStateRequest{
+		ObjectGroupName: data.Get("object_group_name").(string),
+		Active:          data.Get("active").(bool),
+	}
+	if err := c.UpdateIndexingState(ctx, updateIndexingStateRequest); err != nil {
+		return diag.FromErr(err)
+	}
+
+	return resourceIndexingStateRead(ctx, data, meta)
+}
+
+func resourceIndexingStateDelete(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	c := meta.(*ProviderMeta).Client
+
+	stopIndexingRequest := &client.UpdateIndexingStateRequest{
+		ObjectGroupName: data.Get("object_group_name").(string),
+		Active:          false,
+	}
+	if err := c.UpdateIndexingState(ctx, stopIndexingRequest); err != nil {
+		return diag.FromErr(err)
+	}
+
+	data.SetId("")
+
+	return nil
+}

chaossearch/resource_object_group.go

@@ -77,12 +77,6 @@ func resourceObjectGroup() *schema.Resource {
 				Optional:    true,
 				ForceNew:    false,
 			},
-			"active": {
-				Type:        schema.TypeBool,
-				Description: "Whether the live indexing should be running or not",
-				Required:    true,
-				ForceNew:    false,
-			},
 
 			// Workaround. Otherwise Terraform fails with "All fields are ForceNew or Computed w/out Optional, Update is superfluous"
 			"description": {
@@ -113,15 +107,6 @@ func resourceObjectGroupCreate(ctx context.Context, data *schema.ResourceData, m
 		return diag.FromErr(err)
 	}
 
-	setActiveRequest := &client.SetActiveRequest{
-		ObjectGroupName: data.Get("name").(string),
-		Active:          data.Get("active").(bool),
-	}
-
-	if err := c.SetActive(ctx, setActiveRequest); err != nil {
-		return diag.FromErr(err)
-	}
-
 	data.SetId(data.Get("name").(string))
 
 	return resourceObjectGroupRead(ctx, data, meta)
@@ -145,7 +130,6 @@ func resourceObjectGroupRead(ctx context.Context, data *schema.ResourceData, met
 	data.Set("format", resp.Format)
 	data.Set("live_events_sqs_arn", resp.LiveEventsSqsArn)
 	data.Set("index_retention", resp.IndexRetention)
-	data.Set("active", resp.Active)
 
 	// When the object in an Object Group use no compression, you need to create it with
 	// `compression = ""`. However, when querying an Object Group whose object are not
@@ -167,14 +151,6 @@ func resourceObjectGroupRead(ctx context.Context, data *schema.ResourceData, met
 func resourceObjectGroupUpdate(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	c := meta.(*ProviderMeta).Client
 
-	setActiveRequest := &client.SetActiveRequest{
-		ObjectGroupName: data.Get("name").(string),
-		Active:          data.Get("active").(bool),
-	}
-	if err := c.SetActive(ctx, setActiveRequest); err != nil {
-		return diag.FromErr(err)
-	}
-
 	updateObjectGroupRequest := &client.UpdateObjectGroupRequest{
 		Name:           data.Get("name").(string),
 		IndexRetention: data.Get("index_retention").(int),
@@ -190,14 +166,6 @@ func resourceObjectGroupUpdate(ctx context.Context, data *schema.ResourceData, m
 func resourceObjectGroupDelete(ctx context.Context, data *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	c := meta.(*ProviderMeta).Client
 
-	stopIndexingRequest := &client.SetActiveRequest{
-		ObjectGroupName: data.Get("name").(string),
-		Active:          false,
-	}
-	if err := c.SetActive(ctx, stopIndexingRequest); err != nil {
-		return diag.FromErr(err)
-	}
-
 	deleteObjectGroupRequest := &client.DeleteObjectGroupRequest{
 		Name: data.Get("name").(string),
 	}

examples/main.tf

@@ -1,18 +1,23 @@
 terraform {
   required_providers {
     chaossearch = {
-      versions = ["0.2"]
+      versions = ["0.6.0"]
       source = "benzaita/chaossearch"
     }
   }
 }
 
-provider "chaossearch" {}
+provider "chaossearch" {
+    url               = "http://example.com"
+    access_key_id     = "chaossearch_access_key_id"
+    secret_access_key = "chaossearch_secret_access_key"
+    region            = "eu-west-1"
+}
 
 resource "chaossearch_object_group" "my-object-group" {
   name = "my-object-group"
   source_bucket = "<s3 bucket name>"
-  live_events_sqs_arn ="<sqs arn>"
+  live_events_sqs_arn ="arn:aws:sqs:sqs_sqs"
 
   filter_json = jsonencode({
     AND = [
@@ -28,3 +33,8 @@ resource "chaossearch_object_group" "my-object-group" {
 
   partition_by = "<regex>"
 }
+
+resource "chaossearch_indexing_state" "my-object-group" {
+  object_group_name = chaossearch_object_group.my-object-group.name
+  active = true
+}