func (self *Service) DescribeInstances(id *aws.Signer, filter http.Values, ic chan Instance) (err os.Error) { if filter == nil { filter = http.Values{} } filter.Set("Action", "DescribeInstances") req := aws.NewRequest(self.URL, "GET", nil, filter) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) if err != nil { return } resp, err := self.conn.Request(req) if err == nil { defer resp.Body.Close() xresp := describeInstancesResponse{} err := xml.Unmarshal(resp.Body, &xresp) if err == nil { log.Printf("XRESP == %+v", xresp) } else { log.Printf("XERR == %+v", err) } ob, _ := http.DumpResponse(resp, true) os.Stdout.Write(ob) } return }
// Users note: amazon will only return an error if the request is bad, // thus an error will not be raised when deleting a non-existent LB. func (self *Service) DeleteLoadBalancer(id *aws.Signer, name string) (err os.Error) { parms := http.Values{} parms.Set("Action", "DeleteLoadBalancer") parms.Set("LoadBalancerName", name) req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 0) if err != nil { return } resp, err := self.conn.Request(req) if err != nil { return } defer resp.Body.Close() if resp.StatusCode != 200 { err = aws.CodeToError(resp.StatusCode) } qr := LoadBalancerQueryResult{} err = xml.Unmarshal(resp.Body, &qr) if err == nil { if qr.ErrorCode != "" { err = os.NewError(qr.ErrorCode) } } return }
func (self *Domain) GetAttribute(s *aws.Signer, item string, attrs AttributeList, consist bool) (a []Attribute, err os.Error) { var resp *http.Response vl := attrs.Values(ATTRIBUTE_LIST) vl.Set("Action", "GetAttributes") vl.Set("DomainName", self.Name) vl.Set("ItemName", item) if consist { vl.Set("ConsistentRead", "true") } req := aws.NewRequest(self.URL, "GET", nil, vl) err = s.SignRequestV2(req, aws.Canonicalize, DEFAULT_API_VERSION, 0) if err == nil { resp, err = self.conn.Request(req) } if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } if err == nil { var response getattributesresponse ob, _ := http.DumpResponse(resp, true) os.Stdout.Write(ob) err = xml.Unmarshal(resp.Body, &response) if err == nil { a = response.Attributes } } return }
func (self *Service) ListQueues(id *aws.Signer, prefix string) (mq []string, err os.Error) { var resp *http.Response parms := http.Values{} parms.Set("Action", "ListQueues") if prefix != "" { parms.Set("QueueNamePrefix", prefix) } req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) resp, err = self.conn.Request(req) if err == nil { defer resp.Body.Close() xresp := listQueuesResponse{} if resp.StatusCode == http.StatusOK { err = xml.Unmarshal(resp.Body, &xresp) } else { err = os.NewError("Unexpected response code") } if err == nil { mq = xresp.QueueURL } } return }
// Note: 0 is a valid timeout!! func (self *Queue) Peek(id *aws.Signer, vt int) (body []byte, msgid string, err os.Error) { var resp *http.Response parms := http.Values{} parms.Set("Action", "ReceiveMessage") if vt >= 0 { parms.Set("VisibilityTimeout", strconv.Itoa(vt)) } req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) if err == nil { resp, err = self.conn.Request(req) if err == nil { defer resp.Body.Close() } if err == nil && resp.StatusCode != http.StatusOK { err = os.NewError("Unexpected response") } if err == nil { msg := message{} err = xml.Unmarshal(resp.Body, &msg) if err == nil { body, msgid = msg.Body, msg.ReceiptHandle } } } return }
// Create a queue, returning the Queue object. func (self *Service) CreateQueue(id *aws.Signer, name string, dvtimeout int) (mq *Queue, err os.Error) { var resp *http.Response parms := http.Values{} parms.Set("Action", "CreateQueue") parms.Set("QueueName", name) parms.Set("DefaultVisibilityTimeout", strconv.Itoa(dvtimeout)) req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) if err == nil { resp, err = self.conn.Request(req) if err == nil { defer resp.Body.Close() if resp.StatusCode == http.StatusOK { xmlresp := createQueueResponse{} err = xml.Unmarshal(resp.Body, &xmlresp) if err == nil { var qrl *http.URL qrl, err = http.ParseURL(xmlresp.QueueURL) if err == nil { mq = NewQueue(qrl) } } } else { err = os.NewError("Unexpected response") } } } return }
// Performs a HEAD request on the bucket and returns the response object. // The body is CLOSED, and it is an error to try and read from it. func (self *Bucket) HeadKey(id *aws.Signer, key string) (resp *http.Response, err os.Error) { hreq := aws.NewRequest(self.key_url(key), "HEAD", nil, nil) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) } if err == nil { resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } return }
func (self *Bucket) PutKeyBytes(id *aws.Signer, key string, buff []byte, hdr http.Header) (err os.Error) { var resp *http.Response hreq := aws.NewRequest(self.key_url(key), "PUT", hdr, nil) hreq.ContentLength = int64(len(buff)) hreq.Body = ioutil.NopCloser(bytes.NewBuffer(buff)) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } } return }
// Note: 0 is a valid timeout!! func (self *Queue) Delete(id *aws.Signer, mid string) (err os.Error) { var resp *http.Response parms := http.Values{} parms.Set("Action", "DeleteMessage") parms.Set("ReceiptHandle", mid) req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) if err == nil { resp, err = self.conn.Request(req) if err == nil { defer resp.Body.Close() } if resp.StatusCode != http.StatusOK { err = os.NewError("Unexpected response") } } return }
func (self *Queue) Push(id *aws.Signer, body []byte) (err os.Error) { var resp *http.Response parms := http.Values{} parms.Set("Action", "SendMessage") parms.Set("MessageBody", string(body)) req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15) if err == nil { resp, err = self.conn.Request(req) if err == nil { defer resp.Body.Close() if resp.StatusCode != http.StatusOK { err = os.NewError("Unexpected response") } } } return }
func (self *Domain) Select(id *aws.Signer, what, where string, consist bool, items chan<- Item) (err os.Error) { var resp *http.Response vl := http.Values{} vl.Set("Action", "Select") if where != "" { where = " where " + where } vl.Set("SelectExpression", fmt.Sprintf("select %s from %s%s", what, self.Name, where)) if consist { vl.Set("ConsistentRead", "true") } done := false nextToken := "" for err == nil && !done { vl.Del("NextToken") if nextToken != "" { vl.Set("NextToken", nextToken) } req := aws.NewRequest(self.URL, "GET", nil, vl) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_API_VERSION, 0) if err == nil { resp, err = self.conn.Request(req) } if err == nil { ob, _ := http.DumpResponse(resp, true) os.Stdout.Write(ob) xresp := selectresponse{} err = xml.Unmarshal(resp.Body, &xresp) if err == nil { fmt.Printf("XML == %+v", xresp) for i := range xresp.Items { items <- xresp.Items[i] } nextToken = xresp.NextToken done = (nextToken == "") } resp.Body.Close() } } return }
// NB: Length is required as we do not buffer the reader // NB(2): We do NOT close your reader (hence the io.Reader), // we wrap it with a NopCloser. func (self *Bucket) PutKeyReader(id *aws.Signer, key string, r io.Reader, l int64, hdr http.Header) (err os.Error) { var resp *http.Response hreq := aws.NewRequest(self.key_url(key), "PUT", hdr, nil) hreq.ContentLength = l hreq.Body = ioutil.NopCloser(io.LimitReader(r, l)) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } if err == aws.ErrorUnexpectedResponse { ob, _ := http.DumpResponse(resp, true) os.Stdout.Write(ob) } } return }
// Deletes the named key from the bucket. To delete a bucket, see *Service.DeleteBucket() func (self *Bucket) Delete(id *aws.Signer, key string) (err os.Error) { var resp *http.Response if key == "" { return os.NewError("Key cannot be empty!") } hreq := aws.NewRequest(self.key_url(key), "DELETE", nil, nil) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) } if err == nil { defer resp.Body.Close() if resp.StatusCode != http.StatusNoContent { err = aws.CodeToError(resp.StatusCode) } } return }
// Walks a bucket and writes the resulting strings to the channel. // * There is currently NO (correct) way to abort a running walk. func (self *Bucket) ListKeys(id *aws.Signer, prefix, delim, marker string, out chan<- string) (err os.Error) { var done bool var resp *http.Response var last string form := http.Values{"prefix": []string{prefix}, "delimeter": []string{delim}, "marker": []string{marker}} for err == nil && !done { result := listBucketResult{} result.Prefix = prefix result.Marker = marker if last != "" { form.Set("marker", last) } hreq := aws.NewRequest(self.key_url("/"), "GET", nil, form) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) } if err == nil { err = aws.CodeToError(resp.StatusCode) if err == nil { err = xml.Unmarshal(resp.Body, &result) if err == nil { for i := range result.Contents { out <- result.Contents[i].Key } if len(result.Contents) > 0 { last = result.Contents[len(result.Contents)-1].Key } done = !result.IsTruncated } } resp.Body.Close() } } close(out) return }
// Opens the named key and copys it to the named io.Writer IFF the response.Status is 200. // Also returns the http headers for convenience (regardless of status code, as long as a resp is generated). func (self *Bucket) GetKey(id *aws.Signer, key string, w io.Writer) (hdr http.Header, err os.Error) { var resp *http.Response hreq := aws.NewRequest(self.key_url(key), "GET", nil, nil) err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) } if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) hdr = resp.Header if err == nil { _, err2 := io.Copy(w, resp.Body) if err == nil { err = err2 } } } return }
func (self *Service) DescribeLoadBalancers(id *aws.Signer) (lbs []LoadBalancerDescription, err os.Error) { parms := http.Values{} parms.Set("Action", "DescribeLoadBalancers") req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 0) if err != nil { return } resp, err := self.conn.Request(req) if err == nil { qr := LoadBalancerQueryResult{} defer resp.Body.Close() err = xml.Unmarshal(resp.Body, &qr) if err == nil { lbs = qr.LoadBalancerDescription } } return }
// Will put an open file descriptor to the named key. Size is determined // by statting the fd (so a partially read file will not work). // TODO: ACL's & content-type/headers support func (self *Bucket) PutFile(id *aws.Signer, key string, fp *os.File) (err os.Error) { var resp *http.Response if fp == nil { return os.NewError("invalid file descriptor") } fi, err := fp.Stat() if err == nil { fsize := fi.Size hdr := http.Header{} hreq := aws.NewRequest(self.key_url(key), "PUT", hdr, nil) hreq.ContentLength = fsize hreq.Body = fp err = id.SignRequestV1(hreq, aws.CanonicalizeS3, 15) if err == nil { resp, err = self.conn.Request(hreq) if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } } } return }
func (self *Domain) DeleteAttribute(s *aws.Signer, item string, attrs, expected AttributeList) (err os.Error) { var resp *http.Response vl := attrs.Values(ATTRIBUTE_LIST) for k, v := range expected.Values(EXPECTED_LIST) { vl[k] = v } vl.Set("Action", "DeleteAttribute") vl.Set("DomainName", self.Name) vl.Set("ItemName", item) req := aws.NewRequest(self.URL, "GET", nil, vl) err = s.SignRequestV2(req, aws.Canonicalize, DEFAULT_API_VERSION, 0) if err == nil { resp, err = self.conn.Request(req) } if err == nil { defer resp.Body.Close() err = aws.CodeToError(resp.StatusCode) } return }
func (self *Service) CreateLoadBalancer(id *aws.Signer, name string, zones []string, listeners []Listener) (err os.Error) { parms := http.Values{} parms.Set("Action", "CreateLoadBalancer") parms.Set("LoadBalancerName", name) for zi := range zones { parms.Set(Sprintf("AvailabilityZones.members.%d", zi+1), zones[zi]) } for li := range listeners { listeners[li].SetValues(parms, li+1) } req := aws.NewRequest(self.URL, "GET", nil, parms) err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 0) if err != nil { return } resp, err := self.conn.Request(req) if err == nil { defer resp.Body.Close() ob, _ := http.DumpResponse(resp, true) os.Stdout.Write(ob) } return }