func NotifyWorkunitProcessedWithLogs(work *Workunit, perf *WorkPerf, sendstdlogs bool) (err error) {
target_url := fmt.Sprintf("%s/work/%s?status=%s&client=%s&computetime=%d", conf.SERVER_URL, work.Id, work.State, Self.Id, work.ComputeTime)
form := httpclient.NewForm()
hasreport := false
if work.State == WORK_STAT_DONE && perf != nil {
perflog, err := getPerfFilePath(work, perf)
if err == nil {
form.AddFile("perf", perflog)
hasreport = true
}
}
if sendstdlogs { //send stdout and stderr files if specified and existed
stdoutFile, err := getStdOutPath(work)
if err == nil {
form.AddFile("stdout", stdoutFile)
hasreport = true
}
stderrFile, err := getStdErrPath(work)
if err == nil {
form.AddFile("stderr", stderrFile)
hasreport = true
}
worknotesFile, err := getWorkNotesPath(work)
if err == nil {
form.AddFile("worknotes", worknotesFile)
hasreport = true
}
}
if hasreport {
target_url = target_url + "&report"
}
if err := form.Create(); err != nil {
return err
}
var headers httpclient.Header
if conf.CLIENT_GROUP_TOKEN == "" {
headers = httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
}
} else {
headers = httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
"Authorization": []string{"CG_TOKEN " + conf.CLIENT_GROUP_TOKEN},
}
}
res, err := httpclient.Put(target_url, headers, form.Reader, nil)
if err == nil {
defer res.Body.Close()
}
return
}
func RegisterWithAuth(host string, profile *core.Client) (client *core.Client, err error) {
if conf.CLIENT_GROUP_TOKEN == "" {
fmt.Println("clientgroup token not set, register as a public client (can only access public data)")
}
profile_jsonstream, err := json.Marshal(profile)
profile_path := conf.DATA_PATH + "/clientprofile.json"
ioutil.WriteFile(profile_path, []byte(profile_jsonstream), 0644)
form := httpclient.NewForm()
form.AddFile("profile", profile_path)
if err := form.Create(); err != nil {
return nil, err
}
var headers httpclient.Header
if conf.CLIENT_GROUP_TOKEN == "" {
headers = httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
}
} else {
headers = httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
"Authorization": []string{"CG_TOKEN " + conf.CLIENT_GROUP_TOKEN},
}
}
targetUrl := host + "/client"
resp, err := httpclient.Post(targetUrl, headers, form.Reader, nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
jsonstream, err := ioutil.ReadAll(resp.Body)
response := new(ClientResponse)
if err = json.Unmarshal(jsonstream, response); err != nil {
return nil, errors.New("fail to unmashal response:" + string(jsonstream))
}
if len(response.Errs) > 0 {
return nil, errors.New(strings.Join(response.Errs, ","))
}
client = &response.Data
return
}
// authToken validiates token by fetching user information.
func authToken(t string) (*user.User, error) {
url := conf.MGRAST_OAUTH_URL
if url == "" {
return nil, errors.New("mgrast_oauth_url not set in configuration")
}
form := httpclient.NewForm()
form.AddParam("token", t)
form.AddParam("action", "credentials")
form.AddParam("groups", "true")
err := form.Create()
if err != nil {
return nil, err
}
headers := httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
}
if res, err := httpclient.Do("POST", url, headers, form.Reader, &httpclient.Auth{Type: "mgrast", Token: t}); err == nil {
defer res.Body.Close()
if res.StatusCode == 200 {
r := credentials{}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err != nil {
return nil, err
}
return &user.User{Username: r.Uname, Fullname: r.Fname + " " + r.Lname, Email: r.Email, CustomFields: map[string][]string{"groups": r.Groups}}, nil
} else {
r := resErr{}
body, _ := ioutil.ReadAll(res.Body)
fmt.Printf("%s\n", body)
if err = json.Unmarshal(body, &r); err == nil {
return nil, errors.New("request error: " + res.Status)
} else {
return nil, errors.New(res.Status + ": " + r.error)
}
}
}
return nil, nil
}
func RegisterWithAuth(host string, profile *core.Client) (client *core.Client, err error) {
if conf.CLIENT_USERNAME == "public" {
fmt.Println("client username and password not configured, register as a public user (can only access public data)")
}
profile_jsonstream, err := json.Marshal(profile)
profile_path := conf.DATA_PATH + "/clientprofile.json"
ioutil.WriteFile(profile_path, []byte(profile_jsonstream), 0644)
form := httpclient.NewForm()
form.AddFile("profile", profile_path)
if err := form.Create(); err != nil {
return nil, err
}
headers := httpclient.Header{
"Content-Type": form.ContentType,
"Content-Length": strconv.FormatInt(form.Length, 10),
}
user := httpclient.GetUserByBasicAuth(conf.CLIENT_USERNAME, conf.CLIENT_PASSWORD)
targetUrl := host + "/client"
resp, err := httpclient.Post(targetUrl, headers, form.Reader, user)
if err != nil {
return nil, err
}
defer resp.Body.Close()
jsonstream, err := ioutil.ReadAll(resp.Body)
response := new(ClientResponse)
if err = json.Unmarshal(jsonstream, response); err != nil {
return nil, errors.New("fail to unmashal response:" + string(jsonstream))
}
if len(response.Errs) > 0 {
return nil, errors.New(strings.Join(response.Errs, ","))
}
client = &response.Data
return
}
//shock access functions
func createOrUpdate(opts Opts, host string, nodeid string, token string) (node *ShockNode, err error) {
url := host + "/node"
method := "POST"
if nodeid != "" {
url += "/" + nodeid
method = "PUT"
}
form := httpclient.NewForm()
if opts.HasKey("attributes") {
form.AddFile("attributes", opts.Value("attributes"))
}
if opts.HasKey("upload_type") {
switch opts.Value("upload_type") {
case "full":
if opts.HasKey("full") {
form.AddFile("upload", opts.Value("full"))
} else {
return nil, errors.New("missing file parameter: upload")
}
case "parts":
if opts.HasKey("parts") {
form.AddParam("parts", opts.Value("parts"))
} else {
return nil, errors.New("missing partial upload parameter: parts")
}
case "part":
if opts.HasKey("part") && opts.HasKey("file") {
form.AddFile(opts.Value("part"), opts.Value("file"))
} else {
return nil, errors.New("missing partial upload parameter: part or file")
}
case "remote_path":
if opts.HasKey("remote_path") {
form.AddParam("path", opts.Value("remote_path"))
} else {
return nil, errors.New("missing remote path parameter: path")
}
case "virtual_file":
if opts.HasKey("virtual_file") {
form.AddParam("type", "virtual")
form.AddParam("source", opts.Value("virtual_file"))
} else {
return nil, errors.New("missing virtual node parameter: source")
}
case "index":
if opts.HasKey("index_type") {
url += "?index=" + opts.Value("index_type")
} else {
return nil, errors.New("missing index type when creating index")
}
}
}
err = form.Create()
if err != nil {
return
}
headers := httpclient.Header{
"Content-Type": form.ContentType,
"Content-Length": strconv.FormatInt(form.Length, 10),
}
var user *httpclient.Auth
if token != "" {
user = httpclient.GetUserByTokenAuth(token)
}
if res, err := httpclient.Do(method, url, headers, form.Reader, user); err == nil {
defer res.Body.Close()
jsonstream, _ := ioutil.ReadAll(res.Body)
response := new(ShockResponse)
if err := json.Unmarshal(jsonstream, response); err != nil {
return nil, errors.New(fmt.Sprintf("failed to marshal response:\"%s\"", jsonstream))
}
if len(response.Errs) > 0 {
return nil, errors.New(strings.Join(response.Errs, ","))
}
node = &response.Data
} else {
return nil, err
}
return
}
//shock access functions
func createOrUpdate(opts Opts, host string, nodeid string, token string, nodeattr map[string]interface{}) (node *shock.ShockNode, err error) {
url := host + "/node"
method := "POST"
if nodeid != "" {
url += "/" + nodeid
method = "PUT"
}
form := httpclient.NewForm()
if opts.HasKey("attributes") {
form.AddFile("attributes", opts.Value("attributes"))
}
//if opts.HasKey("attributes_str") {
// form.AddParam("attributes_str", opts.Value("attributes_str"))
//}
if len(nodeattr) != 0 {
nodeattr_json, err := json.Marshal(nodeattr)
if err != nil {
return nil, errors.New("error marshalling NodeAttr")
}
form.AddParam("attributes_str", string(nodeattr_json[:]))
}
if opts.HasKey("upload_type") {
switch opts.Value("upload_type") {
case "basic":
if opts.HasKey("file") {
form.AddFile("upload", opts.Value("file"))
}
case "parts":
if opts.HasKey("parts") {
form.AddParam("parts", opts.Value("parts"))
} else {
return nil, errors.New("missing partial upload parameter: parts")
}
if opts.HasKey("file_name") {
form.AddParam("file_name", opts.Value("file_name"))
}
case "part":
if opts.HasKey("part") && opts.HasKey("file") {
form.AddFile(opts.Value("part"), opts.Value("file"))
} else {
return nil, errors.New("missing partial upload parameter: part or file")
}
case "remote_path":
if opts.HasKey("remote_path") {
form.AddParam("path", opts.Value("remote_path"))
} else {
return nil, errors.New("missing remote path parameter: path")
}
case "virtual_file":
if opts.HasKey("virtual_file") {
form.AddParam("type", "virtual")
form.AddParam("source", opts.Value("virtual_file"))
} else {
return nil, errors.New("missing virtual node parameter: source")
}
case "index":
if opts.HasKey("index_type") {
url += "/index/" + opts.Value("index_type")
} else {
return nil, errors.New("missing index type when creating index")
}
case "copy":
if opts.HasKey("parent_node") {
form.AddParam("copy_data", opts.Value("parent_node"))
} else {
return nil, errors.New("missing copy node parameter: parent_node")
}
if opts.HasKey("copy_indexes") {
form.AddParam("copy_indexes", "1")
}
case "subset":
if opts.HasKey("parent_node") && opts.HasKey("parent_index") && opts.HasKey("file") {
form.AddParam("parent_node", opts.Value("parent_node"))
form.AddParam("parent_index", opts.Value("parent_index"))
form.AddFile("subset_indices", opts.Value("file"))
} else {
return nil, errors.New("missing subset node parameter: parent_node or parent_index or file")
}
}
}
err = form.Create()
if err != nil {
return
}
headers := httpclient.Header{
"Content-Type": []string{form.ContentType},
"Content-Length": []string{strconv.FormatInt(form.Length, 10)},
}
var user *httpclient.Auth
if token != "" {
user = httpclient.GetUserByTokenAuth(token)
}
if res, err := httpclient.Do(method, url, headers, form.Reader, user); err == nil {
defer res.Body.Close()
jsonstream, _ := ioutil.ReadAll(res.Body)
response := new(shock.ShockResponse)
if err := json.Unmarshal(jsonstream, response); err != nil {
return nil, errors.New(fmt.Sprintf("failed to marshal response:\"%s\"", jsonstream))
}
if len(response.Errs) > 0 {
return nil, errors.New(strings.Join(response.Errs, ","))
}
node = &response.Data
} else {
return nil, err
}
return
}