291 lines
8.4 KiB
Go
291 lines
8.4 KiB
Go
package cfclient
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type DomainsResponse struct {
|
|
Count int `json:"total_results"`
|
|
Pages int `json:"total_pages"`
|
|
NextUrl string `json:"next_url"`
|
|
Resources []DomainResource `json:"resources"`
|
|
}
|
|
|
|
type SharedDomainsResponse struct {
|
|
Count int `json:"total_results"`
|
|
Pages int `json:"total_pages"`
|
|
NextUrl string `json:"next_url"`
|
|
Resources []SharedDomainResource `json:"resources"`
|
|
}
|
|
|
|
type DomainResource struct {
|
|
Meta Meta `json:"metadata"`
|
|
Entity Domain `json:"entity"`
|
|
}
|
|
|
|
type SharedDomainResource struct {
|
|
Meta Meta `json:"metadata"`
|
|
Entity SharedDomain `json:"entity"`
|
|
}
|
|
|
|
type Domain struct {
|
|
Guid string `json:"guid"`
|
|
Name string `json:"name"`
|
|
CreatedAt string `json:"created_at"`
|
|
UpdatedAt string `json:"updated_at"`
|
|
OwningOrganizationGuid string `json:"owning_organization_guid"`
|
|
OwningOrganizationUrl string `json:"owning_organization_url"`
|
|
SharedOrganizationsUrl string `json:"shared_organizations_url"`
|
|
c *Client
|
|
}
|
|
|
|
type SharedDomain struct {
|
|
Guid string `json:"guid"`
|
|
Name string `json:"name"`
|
|
CreatedAt string `json:"created_at"`
|
|
UpdatedAt string `json:"updated_at"`
|
|
RouterGroupGuid string `json:"router_group_guid"`
|
|
RouterGroupType string `json:"router_group_type"`
|
|
Internal bool `json:"internal"`
|
|
c *Client
|
|
}
|
|
|
|
func (c *Client) ListDomainsByQuery(query url.Values) ([]Domain, error) {
|
|
var domains []Domain
|
|
requestUrl := "/v2/private_domains?" + query.Encode()
|
|
for {
|
|
var domainResp DomainsResponse
|
|
r := c.NewRequest("GET", requestUrl)
|
|
resp, err := c.DoRequest(r)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error requesting domains")
|
|
}
|
|
resBody, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error reading domains request")
|
|
}
|
|
|
|
err = json.Unmarshal(resBody, &domainResp)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error unmarshaling domains")
|
|
}
|
|
for _, domain := range domainResp.Resources {
|
|
domain.Entity.Guid = domain.Meta.Guid
|
|
domain.Entity.CreatedAt = domain.Meta.CreatedAt
|
|
domain.Entity.UpdatedAt = domain.Meta.UpdatedAt
|
|
domain.Entity.c = c
|
|
domains = append(domains, domain.Entity)
|
|
}
|
|
requestUrl = domainResp.NextUrl
|
|
if requestUrl == "" {
|
|
break
|
|
}
|
|
}
|
|
return domains, nil
|
|
}
|
|
|
|
func (c *Client) ListDomains() ([]Domain, error) {
|
|
return c.ListDomainsByQuery(nil)
|
|
}
|
|
|
|
func (c *Client) ListSharedDomainsByQuery(query url.Values) ([]SharedDomain, error) {
|
|
var domains []SharedDomain
|
|
requestUrl := "/v2/shared_domains?" + query.Encode()
|
|
for {
|
|
var domainResp SharedDomainsResponse
|
|
r := c.NewRequest("GET", requestUrl)
|
|
resp, err := c.DoRequest(r)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error requesting shared domains")
|
|
}
|
|
resBody, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error reading shared domains request")
|
|
}
|
|
|
|
err = json.Unmarshal(resBody, &domainResp)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Error unmarshaling shared domains")
|
|
}
|
|
for _, domain := range domainResp.Resources {
|
|
domain.Entity.Guid = domain.Meta.Guid
|
|
domain.Entity.CreatedAt = domain.Meta.CreatedAt
|
|
domain.Entity.UpdatedAt = domain.Meta.UpdatedAt
|
|
domain.Entity.c = c
|
|
domains = append(domains, domain.Entity)
|
|
}
|
|
requestUrl = domainResp.NextUrl
|
|
if requestUrl == "" {
|
|
break
|
|
}
|
|
}
|
|
return domains, nil
|
|
}
|
|
|
|
func (c *Client) ListSharedDomains() ([]SharedDomain, error) {
|
|
return c.ListSharedDomainsByQuery(nil)
|
|
}
|
|
|
|
func (c *Client) GetSharedDomainByGuid(guid string) (SharedDomain, error) {
|
|
r := c.NewRequest("GET", "/v2/shared_domains/"+guid)
|
|
resp, err := c.DoRequest(r)
|
|
if err != nil {
|
|
return SharedDomain{}, errors.Wrap(err, "Error requesting shared domain")
|
|
}
|
|
defer resp.Body.Close()
|
|
retval, err := c.handleSharedDomainResp(resp)
|
|
return *retval, err
|
|
}
|
|
|
|
func (c *Client) CreateSharedDomain(name string, internal bool, router_group_guid string) (*SharedDomain, error) {
|
|
req := c.NewRequest("POST", "/v2/shared_domains")
|
|
params := map[string]interface{}{
|
|
"name": name,
|
|
"internal": internal,
|
|
}
|
|
|
|
if strings.TrimSpace(router_group_guid) != "" {
|
|
params["router_group_guid"] = router_group_guid
|
|
}
|
|
|
|
req.obj = params
|
|
|
|
resp, err := c.DoRequest(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode != http.StatusCreated {
|
|
return nil, errors.Wrapf(err, "Error creating shared domain %s, response code: %d", name, resp.StatusCode)
|
|
}
|
|
return c.handleSharedDomainResp(resp)
|
|
}
|
|
|
|
func (c *Client) DeleteSharedDomain(guid string, async bool) error {
|
|
resp, err := c.DoRequest(c.NewRequest("DELETE", fmt.Sprintf("/v2/shared_domains/%s?async=%t", guid, async)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (async && (resp.StatusCode != http.StatusAccepted)) || (!async && (resp.StatusCode != http.StatusNoContent)) {
|
|
return errors.Wrapf(err, "Error deleting organization %s, response code: %d", guid, resp.StatusCode)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) GetDomainByName(name string) (Domain, error) {
|
|
q := url.Values{}
|
|
q.Set("q", "name:"+name)
|
|
domains, err := c.ListDomainsByQuery(q)
|
|
if err != nil {
|
|
return Domain{}, errors.Wrapf(err, "Error during domain lookup %s", name)
|
|
}
|
|
if len(domains) == 0 {
|
|
return Domain{}, fmt.Errorf("Unable to find domain %s", name)
|
|
}
|
|
return domains[0], nil
|
|
}
|
|
|
|
func (c *Client) GetSharedDomainByName(name string) (SharedDomain, error) {
|
|
q := url.Values{}
|
|
q.Set("q", "name:"+name)
|
|
domains, err := c.ListSharedDomainsByQuery(q)
|
|
if err != nil {
|
|
return SharedDomain{}, errors.Wrapf(err, "Error during shared domain lookup %s", name)
|
|
}
|
|
if len(domains) == 0 {
|
|
return SharedDomain{}, fmt.Errorf("Unable to find shared domain %s", name)
|
|
}
|
|
return domains[0], nil
|
|
}
|
|
|
|
func (c *Client) CreateDomain(name, orgGuid string) (*Domain, error) {
|
|
req := c.NewRequest("POST", "/v2/private_domains")
|
|
req.obj = map[string]interface{}{
|
|
"name": name,
|
|
"owning_organization_guid": orgGuid,
|
|
}
|
|
resp, err := c.DoRequest(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode != http.StatusCreated {
|
|
return nil, errors.Wrapf(err, "Error creating domain %s, response code: %d", name, resp.StatusCode)
|
|
}
|
|
return c.handleDomainResp(resp)
|
|
}
|
|
|
|
func (c *Client) DeleteDomain(guid string) error {
|
|
resp, err := c.DoRequest(c.NewRequest("DELETE", fmt.Sprintf("/v2/private_domains/%s", guid)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if resp.StatusCode != http.StatusNoContent {
|
|
return errors.Wrapf(err, "Error deleting domain %s, response code: %d", guid, resp.StatusCode)
|
|
}
|
|
return nil
|
|
}
|
|
func (c *Client) handleDomainResp(resp *http.Response) (*Domain, error) {
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
defer resp.Body.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var domainResource DomainResource
|
|
err = json.Unmarshal(body, &domainResource)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return c.mergeDomainResource(domainResource), nil
|
|
}
|
|
|
|
func (c *Client) handleSharedDomainResp(resp *http.Response) (*SharedDomain, error) {
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
defer resp.Body.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var domainResource SharedDomainResource
|
|
err = json.Unmarshal(body, &domainResource)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return c.mergeSharedDomainResource(domainResource), nil
|
|
}
|
|
|
|
func (c *Client) getDomainsResponse(requestUrl string) (DomainsResponse, error) {
|
|
var domainResp DomainsResponse
|
|
r := c.NewRequest("GET", requestUrl)
|
|
resp, err := c.DoRequest(r)
|
|
if err != nil {
|
|
return DomainsResponse{}, errors.Wrap(err, "Error requesting domains")
|
|
}
|
|
resBody, err := ioutil.ReadAll(resp.Body)
|
|
defer resp.Body.Close()
|
|
if err != nil {
|
|
return DomainsResponse{}, errors.Wrap(err, "Error reading domains request")
|
|
}
|
|
err = json.Unmarshal(resBody, &domainResp)
|
|
if err != nil {
|
|
return DomainsResponse{}, errors.Wrap(err, "Error unmarshalling org")
|
|
}
|
|
return domainResp, nil
|
|
}
|
|
|
|
func (c *Client) mergeDomainResource(domainResource DomainResource) *Domain {
|
|
domainResource.Entity.Guid = domainResource.Meta.Guid
|
|
domainResource.Entity.c = c
|
|
return &domainResource.Entity
|
|
}
|
|
|
|
func (c *Client) mergeSharedDomainResource(domainResource SharedDomainResource) *SharedDomain {
|
|
domainResource.Entity.Guid = domainResource.Meta.Guid
|
|
domainResource.Entity.c = c
|
|
return &domainResource.Entity
|
|
}
|