CR-5753-registry

client/client.go

@@ -72,7 +72,8 @@ func (client *Client) RequestAPI(opt *RequestOptions) ([]byte, error) {
 		return nil, fmt.Errorf("Failed to read body %v %v", resp.StatusCode, resp.Status)
 	}
 
-	if resp.StatusCode != 200 {
+	// todo: maybe other 2**?
+	if resp.StatusCode != 200 && resp.StatusCode != 201 {
 		return nil, fmt.Errorf("%v, %s", resp.Status, string(body))
 	}
 	return body, nil

client/registry.go

@@ -0,0 +1,146 @@
+package client
+
+import (
+	"fmt"
+	"log"
+	"net/url"
+)
+
+type Registry struct {
+	// common
+	Id               string `json:"_id,omitempty"`
+	Name             string `json:"name,omitempty"`
+	Kind             string `json:"kind,omitempty"`
+	Default          bool   `json:"default,omitempty"`
+	Primary          bool   `json:"primary,omitempty"`
+	BehindFirewall   bool   `json:"behindFirewall,omitempty"`
+	FallbackRegistry string `json:"fallbackRegistry,omitempty"`
+	RepositoryPrefix string `json:"repositoryPrefix,omitempty"`
+	Provider         string `json:"provider,omitempty"`
+
+	// mostly all
+	Domain   string `json:"domain,omitempty"`
+	Username string `json:"username,omitempty"`
+	Password string `json:"password,omitempty"`
+
+	// bintray
+	Token string `json:"token,omitempty"`
+
+	// ecr
+	AccessKeyId     string `json:"accessKeyId,omitempty"`
+	SecretAccessKey string `json:"secretAccessKey,omitempty"`
+	Region          string `json:"region,omitempty"`
+
+	// gcr, gar
+	Keyfile string `json:"keyfile,omitempty"`
+
+	// acr
+	ClientId     string `json:"clientId,omitempty"`
+	ClientSecret string `json:"clientSecret,omitempty"`
+	//DenyCompositeDomain bool   `json:"denyCompositeDomain,omitempty"`
+}
+
+func (registry *Registry) GetID() string {
+	return registry.Id
+}
+
+// GetRegistry identifier is ObjectId or name
+func (client *Client) GetRegistry(identifier string) (*Registry, error) {
+	fullPath := fmt.Sprintf("/registries/%s", url.PathEscape(identifier))
+	opts := RequestOptions{
+		Path:   fullPath,
+		Method: "GET",
+	}
+
+	resp, err := client.RequestAPI(&opts)
+
+	if err != nil {
+		return nil, err
+	}
+	var respRegistry Registry
+	err = DecodeResponseInto(resp, &respRegistry)
+	if err != nil {
+		return nil, err
+	}
+
+	return &respRegistry, nil
+
+}
+
+func (client *Client) CreateRegistry(registry *Registry) (*Registry, error) {
+
+	body, err := EncodeToJSON(registry)
+
+	if err != nil {
+		return nil, err
+	}
+	opts := RequestOptions{
+		Path:   "/registries",
+		Method: "POST",
+		Body:   body,
+	}
+
+	resp, err := client.RequestAPI(&opts)
+
+	if err != nil {
+		log.Printf("[DEBUG] Call to API for registry creation failed with Error = %v for Body %v", err, body)
+		return nil, err
+	}
+
+	var respRegistry Registry
+	err = DecodeResponseInto(resp, &respRegistry)
+	if err != nil {
+		return nil, err
+	}
+
+	return &respRegistry, nil
+
+}
+
+func (client *Client) UpdateRegistry(registry *Registry) (*Registry, error) {
+
+	body, err := EncodeToJSON(registry)
+
+	if err != nil {
+		return nil, err
+	}
+
+	fullPath := fmt.Sprintf("/registries/%s", url.PathEscape(registry.Id))
+	opts := RequestOptions{
+		Path:   fullPath,
+		Method: "PATCH",
+		Body:   body,
+	}
+
+	resp, err := client.RequestAPI(&opts)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var respRegistry Registry
+	err = DecodeResponseInto(resp, &respRegistry)
+	if err != nil {
+		return nil, err
+	}
+
+	return &respRegistry, nil
+
+}
+
+func (client *Client) DeleteRegistry(name string) error {
+
+	fullPath := fmt.Sprintf("/registries/%s", url.PathEscape(name))
+	opts := RequestOptions{
+		Path:   fullPath,
+		Method: "DELETE",
+	}
+
+	_, err := client.RequestAPI(&opts)
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

codefresh/data_registry.go

@@ -0,0 +1,89 @@
+package codefresh
+
+import (
+	"fmt"
+
+	cfClient "github.com/codefresh-io/terraform-provider-codefresh/client"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceRegistry() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceRegistryRead,
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"kind": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"domain": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"registry_provider": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"default": {
+				Type:     schema.TypeBool,
+				Computed: true,
+			},
+			"primary": {
+				Type:     schema.TypeBool,
+				Computed: true,
+			},
+			"fallback_registry": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"repository_prefix": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceRegistryRead(d *schema.ResourceData, meta interface{}) error {
+
+	client := meta.(*cfClient.Client)
+	var registry *cfClient.Registry
+	var err error
+
+	if name, nameOk := d.GetOk("name"); nameOk {
+		registry, err = client.GetRegistry(name.(string))
+	} else {
+		return fmt.Errorf("data.codefresh_registry - must specify name")
+	}
+	if err != nil {
+		return err
+	}
+
+	if registry == nil {
+		return fmt.Errorf("data.codefresh_registry - cannot find registry")
+	}
+
+	return mapDataRegistryToResource(registry, d)
+}
+
+func mapDataRegistryToResource(registry *cfClient.Registry, d *schema.ResourceData) error {
+
+	if registry == nil || registry.Name == "" {
+		return fmt.Errorf("data.codefresh_registry - failed to mapDataRegistryToResource")
+	}
+	d.SetId(registry.Id)
+
+	d.Set("name", registry.Name)
+	d.Set("registry_provider", registry.Provider)
+	d.Set("kind", registry.Kind)
+	d.Set("domain", registry.Domain)
+	d.Set("primary", registry.Primary)
+	d.Set("default", registry.Default)
+	d.Set("fallback_registry", registry.FallbackRegistry)
+	d.Set("repository_prefix", registry.RepositoryPrefix)
+
+	return nil
+}

codefresh/provider.go

@@ -35,12 +35,14 @@ func Provider() *schema.Provider {
 			"codefresh_team":            dataSourceTeam(),
 			"codefresh_user":            dataSourceUser(),
 			"codefresh_users":           dataSourceUsers(),
+			"codefresh_registry":        dataSourceRegistry(),
 		},
 		ResourcesMap: map[string]*schema.Resource{
 			"codefresh_account":        resourceAccount(),
 			"codefresh_account_admins": resourceAccountAdmins(),
 			"codefresh_api_key":        resourceApiKey(),
 			"codefresh_context":        resourceContext(),
+			"codefresh_registry":       resourceRegistry(),
 			"codefresh_idp_accounts":   resourceIDPAccounts(),
 			"codefresh_permission":     resourcePermission(),
 			"codefresh_pipeline":       resourcePipeline(),