func dockerLogin(w *worker.Worker, args *map[string]string) (msg string, err error) {
data, err := json.Marshal(args)
reader := bytes.NewReader(data)
req, err := http.NewRequest("POST", api.Action(w.Settings, "credentials").URL.String(), reader)
if err != nil {
return "", err
}
req.Header.Set("Accept", "application/json")
req.Header.Set("Accept-Encoding", "gzip/deflate")
req.Header.Set("Authorization", "OAuth "+w.Settings.Token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", w.Settings.UserAgent)
response, err := http.DefaultClient.Do(req)
if err != nil {
return "", err
}
if err = api.ResponseAsError(response); err != nil {
return "", err
}
var res struct {
Msg string `json:"msg"`
}
err = json.NewDecoder(response.Body).Decode(&res)
return res.Msg, err
}
func main() {
// Create your configuration for iron_worker
// Find these value in credentials
config := config.Config("iron_worker")
config.ProjectId = "your_project_id"
config.Token = "your_token"
// Capture info for this task
taskId := "52b45b17a31186632b00da4c"
// Create your endpoint url for tasks
url := api.Action(config, "tasks", taskId)
log.Printf("Url: %s\n", url.URL.String())
// Post the request to Iron.io
resp, err := url.Request("GET", nil)
defer resp.Body.Close()
if err != nil {
log.Println(err)
return
}
// Check the status code
if resp.StatusCode != 200 {
log.Printf("%v\n", resp)
return
}
// Capture the response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Println(err)
return
}
// Unmarshall to struct
task := &Task{}
err = json.Unmarshal(body, task)
if err != nil {
log.Printf("%v\n", err)
return
}
// Or you can Unmarshall to map
results := map[string]interface{}{}
err = json.Unmarshal(body, &results)
if err != nil {
log.Printf("%v\n", err)
return
}
// Pretty print the response
prettyPrint(task)
}
// Will create a new queue, all fields are optional.
// Queue type cannot be changed.
func ConfigCreateQueue(queueInfo QueueInfo, settings *config.Settings) (QueueInfo, error) {
if queueInfo.Name == "" {
return QueueInfo{}, errors.New("Name of queue is empty")
}
url := api.Action(config.ManualConfig("iron_mq", settings), "queues", queueInfo.Name)
in := struct {
Queue QueueInfo `json:"queue"`
}{
Queue: queueInfo,
}
var out struct {
Queue QueueInfo `json:"queue"`
}
err := url.Req("PUT", in, &out)
return out.Queue, err
}
func main() {
// Create your configuration for iron_worker
// Find these value in credentials
config := config.Config("iron_worker")
config.ProjectId = "your_project_id"
config.Token = "your_token"
// Capture info for this task
taskId := "52b45b17a31186632b00da4c"
// Create your endpoint url for tasks
url := api.Action(config, "tasks", taskId, "log")
log.Printf("Url: %s\n", url.URL.String())
// Post the request to Iron.io
resp, err := url.Request("GET", nil)
defer resp.Body.Close()
if err != nil {
log.Println(err)
return
}
// Check the status code
if resp.StatusCode != 200 {
log.Printf("%v\n", resp)
return
}
// Capture the response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Println(err)
return
}
// Display the log
log.Printf("\n%s\n", string(body))
}
func listQueues(prefix, prev string, perPage int) ([]Queue, error) {
var out struct {
Queues []Queue `json:"queues"`
}
url := api.Action(config.Config("iron_mq"), "queues")
if prev != "" {
url.QueryAdd("previous", "%v", prev)
}
if prefix != "" {
url.QueryAdd("prefix", "%v", prefix)
}
if perPage != 0 {
url.QueryAdd("per_page", "%d", perPage)
}
err := url.Req("GET", nil, &out)
if err != nil {
return nil, err
}
return out.Queues, nil
}
func (w *Worker) schedules(s ...string) *api.URL { return api.Action(w.Settings, "schedules", s...) }
func (w *Worker) tasks(s ...string) *api.URL { return api.Action(w.Settings, "tasks", s...) }
func (w *Worker) codes(s ...string) *api.URL { return api.Action(w.Settings, "codes", s...) }
func (q Queue) queues(s ...string) *api.URL { return api.Action(q.Settings, "queues", s...) }
func (c *Cache) caches(suffix ...string) *api.URL {
return api.Action(c.Settings, "caches", suffix...)
}
// create code package (zip) from parsed .worker info
func pushCodes(zipName string, w *worker.Worker, args worker.Code) (*worker.Code, error) {
// TODO i don't get why i can't write from disk to wire, but I give up
var body bytes.Buffer
mWriter := multipart.NewWriter(&body)
mMetaWriter, err := mWriter.CreateFormField("data")
if err != nil {
return nil, err
}
jEncoder := json.NewEncoder(mMetaWriter)
if err := jEncoder.Encode(args); err != nil {
return nil, err
}
if zipName != "" {
r, err := zip.OpenReader(zipName)
if err != nil {
return nil, err
}
defer r.Close()
mFileWriter, err := mWriter.CreateFormFile("file", "worker.zip")
if err != nil {
return nil, err
}
zWriter := zip.NewWriter(mFileWriter)
for _, f := range r.File {
fWriter, err := zWriter.Create(f.Name)
if err != nil {
return nil, err
}
rc, err := f.Open()
if err != nil {
return nil, err
}
_, err = io.Copy(fWriter, rc)
rc.Close()
if err != nil {
return nil, err
}
}
zWriter.Close()
}
mWriter.Close()
req, err := http.NewRequest("POST", api.Action(w.Settings, "codes").URL.String(), &body)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
req.Header.Set("Accept-Encoding", "gzip/deflate")
req.Header.Set("Authorization", "OAuth "+w.Settings.Token)
req.Header.Set("Content-Type", mWriter.FormDataContentType())
req.Header.Set("User-Agent", w.Settings.UserAgent)
response, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
if err = api.ResponseAsError(response); err != nil {
return nil, err
}
var data worker.Code
err = json.NewDecoder(response.Body).Decode(&data)
return &data, err
}