// get a server hardware with filters
func (c *OVClient) GetServerHardwareList(filters []string, sort string) (ServerHardwareList, error) {
var (
uri = "/rest/server-hardware"
q map[string]interface{}
serverlist ServerHardwareList
)
q = make(map[string]interface{})
if len(filters) > 0 {
q["filter"] = filters
}
if sort != "" {
q["sort"] = sort
}
// refresh login
c.RefreshLogin()
c.SetAuthHeaderOptions(c.GetAuthHeaderMap())
// Setup query
if len(q) > 0 {
c.SetQueryString(q)
}
data, err := c.RestAPICall(rest.GET, uri, nil)
// parse the url and setup any query strings
var Url *url.URL
Url, err = url.Parse(utils.Sanatize(c.Endpoint))
if err != nil {
return serverlist, err
}
Url.Path += uri
c.GetQueryString(Url)
log.Debugf("GetServerHardwareList %s", data)
if err := json.Unmarshal([]byte(data), &serverlist); err != nil {
return serverlist, err
}
return serverlist, nil
}
// RestAPICall - general rest method caller
func (c *Client) RestAPICall(method Method, path string, options interface{}) ([]byte, error) {
log.Debugf("RestAPICall %s - %s%s", method, utils.Sanatize(c.Endpoint), path)
var (
Url *url.URL
err error
req *http.Request
)
Url, err = url.Parse(utils.Sanatize(c.Endpoint))
if err != nil {
return nil, err
}
Url.Path += path
// Manage the query string
c.GetQueryString(Url)
log.Debugf("*** url => %s", Url.String())
log.Debugf("*** method => %s", method.String())
// parse url
reqUrl, err := url.Parse(Url.String())
if err != nil {
return nil, fmt.Errorf("Error with request: %v - %q", Url, err)
}
// handle options
if options != nil {
OptionsJSON, err := json.Marshal(options)
if err != nil {
return nil, err
}
log.Debugf("*** options => %+v", bytes.NewBuffer(OptionsJSON))
req, err = http.NewRequest(method.String(), reqUrl.String(), bytes.NewBuffer(OptionsJSON))
} else {
req, err = http.NewRequest(method.String(), reqUrl.String(), nil)
}
if err != nil {
return nil, fmt.Errorf("Error with request: %v - %q", Url, err)
}
// setup proxy
proxyUrl, err := http.ProxyFromEnvironment(req)
if err != nil {
return nil, fmt.Errorf("Error with proxy: %v - %q", proxyUrl, err)
}
if proxyUrl != nil {
tr.Proxy = http.ProxyURL(proxyUrl)
log.Debugf("*** proxy => %+v", tr.Proxy)
}
// build the auth headerU
for k, v := range c.Option.Headers {
log.Debugf("Headers -> %s -> %+v\n", k, v)
req.Header.Add(k, v)
}
// req.SetBasicAuth(c.User, c.APIKey)
req.Method = fmt.Sprintf("%s", method.String())
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// TODO: CLeanup Later
// DEBUGGING WHILE WE WORK
// DEBUGGING WHILE WE WORK
// fmt.Printf("METHOD --> %+v\n",method)
log.Debugf("REQ --> %+v\n", req)
log.Debugf("RESP --> %+v\n", resp)
log.Debugf("ERROR --> %+v\n", err)
// DEBUGGING WHILE WE WORK
data, err := ioutil.ReadAll(resp.Body)
if !c.isOkStatus(resp.StatusCode) {
type apiErr struct {
Err string `json:"details"`
}
var outErr apiErr
json.Unmarshal(data, &outErr)
return nil, fmt.Errorf("Error in response: %s\n Response Status: %s", outErr.Err, resp.Status)
}
if err != nil {
return nil, err
}
return data, nil
}