github.com/1and1/oneandone-cloudserver-sdk-go@v1.4.1/privatenetworks.go (about)

     1  package oneandone
     2  
     3  import (
     4  	"net/http"
     5  )
     6  
     7  type PrivateNetwork struct {
     8  	Identity
     9  	descField
    10  	NetworkAddress string      `json:"network_address,omitempty"`
    11  	SubnetMask     string      `json:"subnet_mask,omitempty"`
    12  	State          string      `json:"state,omitempty"`
    13  	SiteId         string      `json:"site_id,omitempty"`
    14  	CreationDate   string      `json:"creation_date,omitempty"`
    15  	Servers        []Identity  `json:"servers,omitempty"`
    16  	Datacenter     *Datacenter `json:"datacenter,omitempty"`
    17  	ApiPtr
    18  }
    19  
    20  type PrivateNetworkRequest struct {
    21  	Name           string `json:"name,omitempty"`
    22  	Description    string `json:"description,omitempty"`
    23  	DatacenterId   string `json:"datacenter_id,omitempty"`
    24  	NetworkAddress string `json:"network_address,omitempty"`
    25  	SubnetMask     string `json:"subnet_mask,omitempty"`
    26  }
    27  
    28  // GET /private_networks
    29  func (api *API) ListPrivateNetworks(args ...interface{}) ([]PrivateNetwork, error) {
    30  	url, err := processQueryParams(createUrl(api, privateNetworkPathSegment), args...)
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  	result := []PrivateNetwork{}
    35  	err = api.Client.Get(url, &result, http.StatusOK)
    36  	if err != nil {
    37  		return nil, err
    38  	}
    39  	for index, _ := range result {
    40  		result[index].api = api
    41  	}
    42  	return result, nil
    43  }
    44  
    45  // POST /private_networks
    46  func (api *API) CreatePrivateNetwork(request *PrivateNetworkRequest) (string, *PrivateNetwork, error) {
    47  	result := new(PrivateNetwork)
    48  	url := createUrl(api, privateNetworkPathSegment)
    49  	err := api.Client.Post(url, &request, &result, http.StatusAccepted)
    50  	if err != nil {
    51  		return "", nil, err
    52  	}
    53  	result.api = api
    54  	return result.Id, result, nil
    55  }
    56  
    57  // GET /private_networks/{id}
    58  func (api *API) GetPrivateNetwork(pn_id string) (*PrivateNetwork, error) {
    59  	result := new(PrivateNetwork)
    60  	url := createUrl(api, privateNetworkPathSegment, pn_id)
    61  	err := api.Client.Get(url, &result, http.StatusOK)
    62  	if err != nil {
    63  		return nil, err
    64  	}
    65  	result.api = api
    66  	return result, nil
    67  }
    68  
    69  // PUT /private_networks/{id}
    70  func (api *API) UpdatePrivateNetwork(pn_id string, request *PrivateNetworkRequest) (*PrivateNetwork, error) {
    71  	result := new(PrivateNetwork)
    72  	url := createUrl(api, privateNetworkPathSegment, pn_id)
    73  	err := api.Client.Put(url, &request, &result, http.StatusOK)
    74  	if err != nil {
    75  		return nil, err
    76  	}
    77  	result.api = api
    78  	return result, nil
    79  }
    80  
    81  // DELETE /private_networks/{id}
    82  func (api *API) DeletePrivateNetwork(pn_id string) (*PrivateNetwork, error) {
    83  	result := new(PrivateNetwork)
    84  	url := createUrl(api, privateNetworkPathSegment, pn_id)
    85  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  	result.api = api
    90  	return result, nil
    91  }
    92  
    93  // GET /private_networks/{id}/servers
    94  func (api *API) ListPrivateNetworkServers(pn_id string) ([]Identity, error) {
    95  	result := []Identity{}
    96  	url := createUrl(api, privateNetworkPathSegment, pn_id, "servers")
    97  	err := api.Client.Get(url, &result, http.StatusOK)
    98  	if err != nil {
    99  		return nil, err
   100  	}
   101  	return result, nil
   102  }
   103  
   104  // POST /private_networks/{id}/servers
   105  func (api *API) AttachPrivateNetworkServers(pn_id string, sids []string) (*PrivateNetwork, error) {
   106  	result := new(PrivateNetwork)
   107  	req := servers{
   108  		Servers: sids,
   109  	}
   110  	url := createUrl(api, privateNetworkPathSegment, pn_id, "servers")
   111  	err := api.Client.Post(url, &req, &result, http.StatusAccepted)
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  	result.api = api
   116  	return result, nil
   117  }
   118  
   119  // GET /private_networks/{id}/servers/{id}
   120  func (api *API) GetPrivateNetworkServer(pn_id string, server_id string) (*Identity, error) {
   121  	result := new(Identity)
   122  	url := createUrl(api, privateNetworkPathSegment, pn_id, "servers", server_id)
   123  	err := api.Client.Get(url, &result, http.StatusOK)
   124  	if err != nil {
   125  		return nil, err
   126  	}
   127  	return result, nil
   128  }
   129  
   130  // DELETE /private_networks/{id}/servers/{id}
   131  func (api *API) DetachPrivateNetworkServer(pn_id string, pns_id string) (*PrivateNetwork, error) {
   132  	result := new(PrivateNetwork)
   133  	url := createUrl(api, privateNetworkPathSegment, pn_id, "servers", pns_id)
   134  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
   135  	if err != nil {
   136  		return nil, err
   137  	}
   138  	result.api = api
   139  	return result, nil
   140  }
   141  
   142  func (pn *PrivateNetwork) GetState() (string, error) {
   143  	in, err := pn.api.GetPrivateNetwork(pn.Id)
   144  	if in == nil {
   145  		return "", err
   146  	}
   147  	return in.State, err
   148  }