github.com/akamai/AkamaiOPEN-edgegrid-golang/v8@v8.1.0/pkg/gtm/datacenter.go (about)

     1  package gtm
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"net/http"
     7  
     8  	"strconv"
     9  )
    10  
    11  // Datacenters contains operations available on a Datacenter resource.
    12  type Datacenters interface {
    13  	// ListDatacenters retrieves all Datacenters.
    14  	//
    15  	// See: https://techdocs.akamai.com/gtm/reference/get-datacenters
    16  	ListDatacenters(context.Context, string) ([]*Datacenter, error)
    17  	// GetDatacenter retrieves a Datacenter with the given name. NOTE: Id arg is int!
    18  	//
    19  	// See: https://techdocs.akamai.com/gtm/reference/get-datacenter
    20  	GetDatacenter(context.Context, int, string) (*Datacenter, error)
    21  	// CreateDatacenter creates the datacenter identified by the receiver argument in the specified domain.
    22  	//
    23  	// See: https://techdocs.akamai.com/gtm/reference/post-datacenter
    24  	CreateDatacenter(context.Context, *Datacenter, string) (*DatacenterResponse, error)
    25  	// DeleteDatacenter deletes the datacenter identified by the receiver argument from the domain specified.
    26  	//
    27  	// See: https://techdocs.akamai.com/gtm/reference/delete-datacenter
    28  	DeleteDatacenter(context.Context, *Datacenter, string) (*ResponseStatus, error)
    29  	// UpdateDatacenter updates the datacenter identified in the receiver argument in the provided domain.
    30  	//
    31  	// See: https://techdocs.akamai.com/gtm/reference/put-datacenter
    32  	UpdateDatacenter(context.Context, *Datacenter, string) (*ResponseStatus, error)
    33  	// CreateMapsDefaultDatacenter creates Default Datacenter for Maps.
    34  	CreateMapsDefaultDatacenter(context.Context, string) (*Datacenter, error)
    35  	// CreateIPv4DefaultDatacenter creates Default Datacenter for IPv4 Selector.
    36  	CreateIPv4DefaultDatacenter(context.Context, string) (*Datacenter, error)
    37  	// CreateIPv6DefaultDatacenter creates Default Datacenter for IPv6 Selector.
    38  	CreateIPv6DefaultDatacenter(context.Context, string) (*Datacenter, error)
    39  }
    40  
    41  // Datacenter represents a GTM datacenter
    42  type Datacenter struct {
    43  	City                          string      `json:"city,omitempty"`
    44  	CloneOf                       int         `json:"cloneOf,omitempty"`
    45  	CloudServerHostHeaderOverride bool        `json:"cloudServerHostHeaderOverride"`
    46  	CloudServerTargeting          bool        `json:"cloudServerTargeting"`
    47  	Continent                     string      `json:"continent,omitempty"`
    48  	Country                       string      `json:"country,omitempty"`
    49  	DefaultLoadObject             *LoadObject `json:"defaultLoadObject,omitempty"`
    50  	Latitude                      float64     `json:"latitude,omitempty"`
    51  	Links                         []*Link     `json:"links,omitempty"`
    52  	Longitude                     float64     `json:"longitude,omitempty"`
    53  	Nickname                      string      `json:"nickname,omitempty"`
    54  	PingInterval                  int         `json:"pingInterval,omitempty"`
    55  	PingPacketSize                int         `json:"pingPacketSize,omitempty"`
    56  	DatacenterID                  int         `json:"datacenterId,omitempty"`
    57  	ScorePenalty                  int         `json:"scorePenalty,omitempty"`
    58  	ServermonitorLivenessCount    int         `json:"servermonitorLivenessCount,omitempty"`
    59  	ServermonitorLoadCount        int         `json:"servermonitorLoadCount,omitempty"`
    60  	ServermonitorPool             string      `json:"servermonitorPool,omitempty"`
    61  	StateOrProvince               string      `json:"stateOrProvince,omitempty"`
    62  	Virtual                       bool        `json:"virtual"`
    63  }
    64  
    65  // DatacenterList contains a list of Datacenters
    66  type DatacenterList struct {
    67  	DatacenterItems []*Datacenter `json:"items"`
    68  }
    69  
    70  func (g *gtm) ListDatacenters(ctx context.Context, domainName string) ([]*Datacenter, error) {
    71  	logger := g.Log(ctx)
    72  	logger.Debug("ListDatacenters")
    73  
    74  	getURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters", domainName)
    75  	req, err := http.NewRequestWithContext(ctx, http.MethodGet, getURL, nil)
    76  	if err != nil {
    77  		return nil, fmt.Errorf("failed to create ListDatacenters request: %w", err)
    78  	}
    79  	setVersionHeader(req, schemaVersion)
    80  
    81  	var result DatacenterList
    82  	resp, err := g.Exec(req, &result)
    83  	if err != nil {
    84  		return nil, fmt.Errorf("ListDatacenters request failed: %w", err)
    85  	}
    86  
    87  	if resp.StatusCode != http.StatusOK {
    88  		return nil, g.Error(resp)
    89  	}
    90  
    91  	return result.DatacenterItems, nil
    92  }
    93  
    94  func (g *gtm) GetDatacenter(ctx context.Context, dcID int, domainName string) (*Datacenter, error) {
    95  	logger := g.Log(ctx)
    96  	logger.Debug("GetDatacenter")
    97  
    98  	getURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dcID))
    99  	req, err := http.NewRequestWithContext(ctx, http.MethodGet, getURL, nil)
   100  	if err != nil {
   101  		return nil, fmt.Errorf("failed to create GetDatacenter request: %w", err)
   102  	}
   103  	setVersionHeader(req, schemaVersion)
   104  
   105  	var result Datacenter
   106  	resp, err := g.Exec(req, &result)
   107  	if err != nil {
   108  		return nil, fmt.Errorf("GetDatacenter request failed: %w", err)
   109  	}
   110  
   111  	if resp.StatusCode != http.StatusOK {
   112  		return nil, g.Error(resp)
   113  	}
   114  
   115  	return &result, nil
   116  }
   117  
   118  func (g *gtm) CreateDatacenter(ctx context.Context, dc *Datacenter, domainName string) (*DatacenterResponse, error) {
   119  	logger := g.Log(ctx)
   120  	logger.Debug("CreateDatacenter")
   121  
   122  	postURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters", domainName)
   123  	req, err := http.NewRequestWithContext(ctx, http.MethodPost, postURL, nil)
   124  	if err != nil {
   125  		return nil, fmt.Errorf("failed to create Datacenter request: %w", err)
   126  	}
   127  	setVersionHeader(req, schemaVersion)
   128  
   129  	var result DatacenterResponse
   130  	resp, err := g.Exec(req, &result, dc)
   131  	if err != nil {
   132  		return nil, fmt.Errorf("CreateDatacenter request failed: %w", err)
   133  	}
   134  	if resp.StatusCode != http.StatusCreated {
   135  		return nil, g.Error(resp)
   136  	}
   137  
   138  	return &result, nil
   139  }
   140  
   141  var (
   142  	// MapDefaultDC is a default Datacenter ID for Maps
   143  	MapDefaultDC = 5400
   144  	// Ipv4DefaultDC is a default Datacenter ID for IPv4
   145  	Ipv4DefaultDC = 5401
   146  	// Ipv6DefaultDC is a default Datacenter ID for IPv6
   147  	Ipv6DefaultDC = 5402
   148  )
   149  
   150  func (g *gtm) CreateMapsDefaultDatacenter(ctx context.Context, domainName string) (*Datacenter, error) {
   151  	logger := g.Log(ctx)
   152  	logger.Debug("CreateMapsDefaultDatacenter")
   153  
   154  	return createDefaultDC(ctx, g, MapDefaultDC, domainName)
   155  }
   156  
   157  func (g *gtm) CreateIPv4DefaultDatacenter(ctx context.Context, domainName string) (*Datacenter, error) {
   158  	logger := g.Log(ctx)
   159  	logger.Debug("CreateIPv4DefaultDatacenter")
   160  
   161  	return createDefaultDC(ctx, g, Ipv4DefaultDC, domainName)
   162  }
   163  
   164  func (g *gtm) CreateIPv6DefaultDatacenter(ctx context.Context, domainName string) (*Datacenter, error) {
   165  	logger := g.Log(ctx)
   166  	logger.Debug("CreateIPv6DefaultDatacenter")
   167  
   168  	return createDefaultDC(ctx, g, Ipv6DefaultDC, domainName)
   169  }
   170  
   171  // createDefaultDC is worker function used to create Default Datacenter identified id in the specified domain.
   172  func createDefaultDC(ctx context.Context, g *gtm, defaultID int, domainName string) (*Datacenter, error) {
   173  	if defaultID != MapDefaultDC && defaultID != Ipv4DefaultDC && defaultID != Ipv6DefaultDC {
   174  		return nil, fmt.Errorf("invalid default datacenter id provided for creation")
   175  	}
   176  	// check if already exists
   177  	dc, err := g.GetDatacenter(ctx, defaultID, domainName)
   178  	if err == nil {
   179  		return dc, err
   180  	}
   181  	apiError, ok := err.(*Error)
   182  	if !ok || apiError.StatusCode != http.StatusNotFound {
   183  		return nil, err
   184  	}
   185  
   186  	defaultURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/", domainName)
   187  	switch defaultID {
   188  	case MapDefaultDC:
   189  		defaultURL += "default-datacenter-for-maps"
   190  	case Ipv4DefaultDC:
   191  		defaultURL += "datacenter-for-ip-version-selector-ipv4"
   192  	case Ipv6DefaultDC:
   193  		defaultURL += "datacenter-for-ip-version-selector-ipv6"
   194  	}
   195  
   196  	req, err := http.NewRequestWithContext(ctx, http.MethodPost, defaultURL, nil)
   197  	if err != nil {
   198  		return nil, fmt.Errorf("failed to create Default Datacenter request: %w", err)
   199  	}
   200  
   201  	setVersionHeader(req, schemaVersion)
   202  	var result DatacenterResponse
   203  	resp, err := g.Exec(req, &result, "")
   204  	if err != nil {
   205  		return nil, fmt.Errorf("DefaultDatacenter request failed: %w", err)
   206  	}
   207  	if resp.StatusCode != http.StatusCreated {
   208  		return nil, g.Error(resp)
   209  	}
   210  
   211  	return result.Resource, nil
   212  }
   213  
   214  func (g *gtm) UpdateDatacenter(ctx context.Context, dc *Datacenter, domainName string) (*ResponseStatus, error) {
   215  	logger := g.Log(ctx)
   216  	logger.Debug("UpdateDatacenter")
   217  
   218  	putURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dc.DatacenterID))
   219  	req, err := http.NewRequestWithContext(ctx, http.MethodPut, putURL, nil)
   220  	if err != nil {
   221  		return nil, fmt.Errorf("failed to create Update Datacenter request: %w", err)
   222  	}
   223  
   224  	setVersionHeader(req, schemaVersion)
   225  	var result DatacenterResponse
   226  	resp, err := g.Exec(req, &result, dc)
   227  	if err != nil {
   228  		return nil, fmt.Errorf("UpdateDatacenter request failed: %w", err)
   229  	}
   230  	if resp.StatusCode != http.StatusOK {
   231  		return nil, g.Error(resp)
   232  	}
   233  
   234  	return result.Status, nil
   235  }
   236  
   237  func (g *gtm) DeleteDatacenter(ctx context.Context, dc *Datacenter, domainName string) (*ResponseStatus, error) {
   238  	logger := g.Log(ctx)
   239  	logger.Debug("DeleteDatacenter")
   240  
   241  	delURL := fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dc.DatacenterID))
   242  	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, delURL, nil)
   243  	if err != nil {
   244  		return nil, fmt.Errorf("failed to create Delete Datacenter request: %w", err)
   245  	}
   246  	setVersionHeader(req, schemaVersion)
   247  
   248  	var result DatacenterResponse
   249  	resp, err := g.Exec(req, &result)
   250  	if err != nil {
   251  		return nil, fmt.Errorf("DeleteDatacenter request failed: %w", err)
   252  	}
   253  	if resp.StatusCode != http.StatusOK {
   254  		return nil, g.Error(resp)
   255  	}
   256  
   257  	return result.Status, nil
   258  }