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

     1  package oneandone
     2  
     3  import (
     4  	"net/http"
     5  )
     6  
     7  type MonitoringPolicy struct {
     8  	ApiPtr
     9  	idField
    10  	Name         string               `json:"name,omitempty"`
    11  	Description  string               `json:"description,omitempty"`
    12  	State        string               `json:"state,omitempty"`
    13  	Default      *int                 `json:"default,omitempty"`
    14  	CreationDate string               `json:"creation_date,omitempty"`
    15  	Email        string               `json:"email,omitempty"`
    16  	Agent        bool                 `json:"agent"`
    17  	Servers      []Identity           `json:"servers,omitempty"`
    18  	Thresholds   *MonitoringThreshold `json:"thresholds,omitempty"`
    19  	Ports        []MonitoringPort     `json:"ports,omitempty"`
    20  	Processes    []MonitoringProcess  `json:"processes,omitempty"`
    21  }
    22  
    23  type MonitoringThreshold struct {
    24  	Cpu          *MonitoringLevel `json:"cpu,omitempty"`
    25  	Ram          *MonitoringLevel `json:"ram,omitempty"`
    26  	Disk         *MonitoringLevel `json:"disk,omitempty"`
    27  	Transfer     *MonitoringLevel `json:"transfer,omitempty"`
    28  	InternalPing *MonitoringLevel `json:"internal_ping,omitempty"`
    29  }
    30  
    31  type MonitoringLevel struct {
    32  	Warning  *MonitoringValue `json:"warning,omitempty"`
    33  	Critical *MonitoringValue `json:"critical,omitempty"`
    34  }
    35  
    36  type MonitoringValue struct {
    37  	Value int  `json:"value"`
    38  	Alert bool `json:"alert"`
    39  }
    40  
    41  type MonitoringPort struct {
    42  	idField
    43  	Protocol          string `json:"protocol,omitempty"`
    44  	Port              int    `json:"port"`
    45  	AlertIf           string `json:"alert_if,omitempty"`
    46  	EmailNotification bool   `json:"email_notification"`
    47  }
    48  
    49  type MonitoringProcess struct {
    50  	idField
    51  	Process           string `json:"process,omitempty"`
    52  	AlertIf           string `json:"alert_if,omitempty"`
    53  	EmailNotification bool   `json:"email_notification"`
    54  }
    55  
    56  // GET /monitoring_policies
    57  func (api *API) ListMonitoringPolicies(args ...interface{}) ([]MonitoringPolicy, error) {
    58  	url, err := processQueryParams(createUrl(api, monitorPolicyPathSegment), args...)
    59  	if err != nil {
    60  		return nil, err
    61  	}
    62  	result := []MonitoringPolicy{}
    63  	err = api.Client.Get(url, &result, http.StatusOK)
    64  	if err != nil {
    65  		return nil, err
    66  	}
    67  	for index, _ := range result {
    68  		result[index].api = api
    69  	}
    70  	return result, nil
    71  }
    72  
    73  // POST /monitoring_policies
    74  func (api *API) CreateMonitoringPolicy(mp *MonitoringPolicy) (string, *MonitoringPolicy, error) {
    75  	result := new(MonitoringPolicy)
    76  	url := createUrl(api, monitorPolicyPathSegment)
    77  	err := api.Client.Post(url, &mp, &result, http.StatusCreated)
    78  	if err != nil {
    79  		return "", nil, err
    80  	}
    81  	result.api = api
    82  	return result.Id, result, nil
    83  }
    84  
    85  // GET /monitoring_policies/{id}
    86  func (api *API) GetMonitoringPolicy(mp_id string) (*MonitoringPolicy, error) {
    87  	result := new(MonitoringPolicy)
    88  	url := createUrl(api, monitorPolicyPathSegment, mp_id)
    89  	err := api.Client.Get(url, &result, http.StatusOK)
    90  	if err != nil {
    91  		return nil, err
    92  	}
    93  	result.api = api
    94  	return result, nil
    95  }
    96  
    97  // DELETE /monitoring_policies/{id}
    98  func (api *API) DeleteMonitoringPolicy(mp_id string) (*MonitoringPolicy, error) {
    99  	result := new(MonitoringPolicy)
   100  	url := createUrl(api, monitorPolicyPathSegment, mp_id)
   101  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
   102  	if err != nil {
   103  		return nil, err
   104  	}
   105  	result.api = api
   106  	return result, nil
   107  }
   108  
   109  // PUT /monitoring_policies/{id}
   110  func (api *API) UpdateMonitoringPolicy(mp_id string, mp *MonitoringPolicy) (*MonitoringPolicy, error) {
   111  	url := createUrl(api, monitorPolicyPathSegment, mp_id)
   112  	result := new(MonitoringPolicy)
   113  	err := api.Client.Put(url, &mp, &result, http.StatusAccepted)
   114  	if err != nil {
   115  		return nil, err
   116  	}
   117  	result.api = api
   118  	return result, nil
   119  }
   120  
   121  // GET /monitoring_policies/{id}/ports
   122  func (api *API) ListMonitoringPolicyPorts(mp_id string) ([]MonitoringPort, error) {
   123  	result := []MonitoringPort{}
   124  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "ports")
   125  	err := api.Client.Get(url, &result, http.StatusOK)
   126  	if err != nil {
   127  		return nil, err
   128  	}
   129  	return result, nil
   130  }
   131  
   132  // POST /monitoring_policies/{id}/ports
   133  func (api *API) AddMonitoringPolicyPorts(mp_id string, mp_ports []MonitoringPort) (*MonitoringPolicy, error) {
   134  	result := new(MonitoringPolicy)
   135  	data := struct {
   136  		Ports []MonitoringPort `json:"ports"`
   137  	}{mp_ports}
   138  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "ports")
   139  	err := api.Client.Post(url, &data, &result, http.StatusAccepted)
   140  	if err != nil {
   141  		return nil, err
   142  	}
   143  	result.api = api
   144  	return result, nil
   145  }
   146  
   147  // GET /monitoring_policies/{id}/ports/{id}
   148  func (api *API) GetMonitoringPolicyPort(mp_id string, port_id string) (*MonitoringPort, error) {
   149  	result := new(MonitoringPort)
   150  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "ports", port_id)
   151  	err := api.Client.Get(url, &result, http.StatusOK)
   152  	if err != nil {
   153  		return nil, err
   154  	}
   155  	return result, nil
   156  }
   157  
   158  // DELETE /monitoring_policies/{id}/ports/{id}
   159  func (api *API) DeleteMonitoringPolicyPort(mp_id string, port_id string) (*MonitoringPolicy, error) {
   160  	result := new(MonitoringPolicy)
   161  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "ports", port_id)
   162  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
   163  	if err != nil {
   164  		return nil, err
   165  	}
   166  	result.api = api
   167  	return result, nil
   168  }
   169  
   170  // PUT /monitoring_policies/{id}/ports/{id}
   171  func (api *API) ModifyMonitoringPolicyPort(mp_id string, port_id string, mp_port *MonitoringPort) (*MonitoringPolicy, error) {
   172  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "ports", port_id)
   173  	result := new(MonitoringPolicy)
   174  	req := struct {
   175  		Ports *MonitoringPort `json:"ports"`
   176  	}{mp_port}
   177  	err := api.Client.Put(url, &req, &result, http.StatusAccepted)
   178  	if err != nil {
   179  		return nil, err
   180  	}
   181  	result.api = api
   182  	return result, nil
   183  }
   184  
   185  // GET /monitoring_policies/{id}/processes
   186  func (api *API) ListMonitoringPolicyProcesses(mp_id string) ([]MonitoringProcess, error) {
   187  	result := []MonitoringProcess{}
   188  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "processes")
   189  	err := api.Client.Get(url, &result, http.StatusOK)
   190  	if err != nil {
   191  		return nil, err
   192  	}
   193  	return result, nil
   194  }
   195  
   196  // POST /monitoring_policies/{id}/processes
   197  func (api *API) AddMonitoringPolicyProcesses(mp_id string, mp_procs []MonitoringProcess) (*MonitoringPolicy, error) {
   198  	result := new(MonitoringPolicy)
   199  	request := struct {
   200  		Processes []MonitoringProcess `json:"processes"`
   201  	}{mp_procs}
   202  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "processes")
   203  	err := api.Client.Post(url, &request, &result, http.StatusAccepted)
   204  	if err != nil {
   205  		return nil, err
   206  	}
   207  	result.api = api
   208  	return result, nil
   209  }
   210  
   211  // GET /monitoring_policies/{id}/processes/{id}
   212  func (api *API) GetMonitoringPolicyProcess(mp_id string, proc_id string) (*MonitoringProcess, error) {
   213  	result := new(MonitoringProcess)
   214  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "processes", proc_id)
   215  	err := api.Client.Get(url, &result, http.StatusOK)
   216  	if err != nil {
   217  		return nil, err
   218  	}
   219  	return result, nil
   220  }
   221  
   222  // DELETE /monitoring_policies/{id}/processes/{id}
   223  func (api *API) DeleteMonitoringPolicyProcess(mp_id string, proc_id string) (*MonitoringPolicy, error) {
   224  	result := new(MonitoringPolicy)
   225  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "processes", proc_id)
   226  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
   227  	if err != nil {
   228  		return nil, err
   229  	}
   230  	result.api = api
   231  	return result, nil
   232  }
   233  
   234  // PUT /monitoring_policies/{id}/processes/{id}
   235  func (api *API) ModifyMonitoringPolicyProcess(mp_id string, proc_id string, mp_proc *MonitoringProcess) (*MonitoringPolicy, error) {
   236  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "processes", proc_id)
   237  	result := new(MonitoringPolicy)
   238  	req := struct {
   239  		Processes *MonitoringProcess `json:"processes"`
   240  	}{mp_proc}
   241  	err := api.Client.Put(url, &req, &result, http.StatusAccepted)
   242  	if err != nil {
   243  		return nil, err
   244  	}
   245  	result.api = api
   246  	return result, nil
   247  }
   248  
   249  // GET /monitoring_policies/{id}/servers
   250  func (api *API) ListMonitoringPolicyServers(mp_id string) ([]Identity, error) {
   251  	result := []Identity{}
   252  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "servers")
   253  	err := api.Client.Get(url, &result, http.StatusOK)
   254  	if err != nil {
   255  		return nil, err
   256  	}
   257  	return result, nil
   258  }
   259  
   260  // POST /monitoring_policies/{id}/servers
   261  func (api *API) AttachMonitoringPolicyServers(mp_id string, sids []string) (*MonitoringPolicy, error) {
   262  	result := new(MonitoringPolicy)
   263  	request := servers{
   264  		Servers: sids,
   265  	}
   266  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "servers")
   267  	err := api.Client.Post(url, &request, &result, http.StatusAccepted)
   268  	if err != nil {
   269  		return nil, err
   270  	}
   271  	result.api = api
   272  	return result, nil
   273  }
   274  
   275  // GET /monitoring_policies/{id}/servers/{id}
   276  func (api *API) GetMonitoringPolicyServer(mp_id string, ser_id string) (*Identity, error) {
   277  	result := new(Identity)
   278  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "servers", ser_id)
   279  	err := api.Client.Get(url, &result, http.StatusOK)
   280  	if err != nil {
   281  		return nil, err
   282  	}
   283  	return result, nil
   284  }
   285  
   286  // DELETE /monitoring_policies/{id}/servers/{id}
   287  func (api *API) RemoveMonitoringPolicyServer(mp_id string, ser_id string) (*MonitoringPolicy, error) {
   288  	result := new(MonitoringPolicy)
   289  	url := createUrl(api, monitorPolicyPathSegment, mp_id, "servers", ser_id)
   290  	err := api.Client.Delete(url, nil, &result, http.StatusAccepted)
   291  	if err != nil {
   292  		return nil, err
   293  	}
   294  	result.api = api
   295  	return result, nil
   296  }
   297  
   298  func (mp *MonitoringPolicy) GetState() (string, error) {
   299  	in, err := mp.api.GetMonitoringPolicy(mp.Id)
   300  	if in == nil {
   301  		return "", err
   302  	}
   303  	return in.State, err
   304  }