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