github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/configgtm/datacenter.go (about)

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