func (n *Node) UploadPart(part string, r io.Reader, size int64) (err error) {
form := client.NewForm()
form.AddFileReader(part, r, size)
if err = form.Create(); err != nil {
return err
}
headers := client.Header{
"Content-Type": form.ContentType,
"Content-Length": strconv.FormatInt(form.Length, 10),
}
if res, err := client.Do("PUT", conf.Server.Url+"/node/"+n.Id, headers, form.Reader); err == nil {
if res.StatusCode == 200 {
r := WNode{Data: n}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return err
}
} else {
r := Wrapper{}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return errors.New(res.Status + ": " + (*r.Error)[0])
} else {
return errors.New("request error: " + res.Status)
}
}
} else {
return err
}
return nil
}
func (n *Node) aclMod(method, acl, users string) (err error) {
if n.Id == "" {
return errors.New("missing node Id")
}
url := ""
if acl != "owner" {
url = conf.Server.Url + "/node/" + n.Id + "/acl?" + acl + "=" + users
} else {
url = conf.Server.Url + "/node/" + n.Id + "/acl/owner?users=" + users
}
println(method + " : " + url)
res, err := client.Do(method, url, client.Header{}, nil)
if err == nil {
if res.StatusCode == 200 {
r := WAcl{Data: &n.Acl}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return err
}
} else {
r := Wrapper{}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return errors.New(res.Status + ": " + (*r.Error)[0])
} else {
println(err.Error())
return errors.New("request error: " + res.Status)
}
}
} else {
return err
}
return
}
func (sc *ShockClient) Do_request_string(method string, resource string, query url.Values) (jsonstream []byte, err error) {
//logger.Debug(1, fmt.Sprint("string_url: ", sc.Host))
myurl, err := url.ParseRequestURI(sc.Host)
if err != nil {
return
}
(*myurl).Path = resource
(*myurl).RawQuery = query.Encode()
shockurl := myurl.String()
//logger.Debug(1, fmt.Sprint("shock request url: ", shockurl))
if sc.Debug {
fmt.Fprintf(os.Stdout, "Get_request url: %s\n", shockurl)
}
if len(shockurl) < 5 {
return jsonstream, errors.New("could not parse shockurl: " + shockurl)
}
var user *httpclient.Auth
if sc.Token != "" {
user = httpclient.GetUserByTokenAuth(sc.Token)
}
var res *http.Response
res, err = httpclient.Do(method, shockurl, httpclient.Header{}, nil, user)
//res, err = httpclient.Get(shockurl, httpclient.Header{}, nil, user)
if err != nil {
return
}
defer res.Body.Close()
jsonstream, err = ioutil.ReadAll(res.Body)
if sc.Debug {
fmt.Fprintf(os.Stdout, "json response:\n %s\n", string(jsonstream))
}
//logger.Debug(1, string(jsonstream))
if err != nil {
return
}
return jsonstream, nil
}
// authToken validiates token by fetching user information.
func authToken(t string) (*user.User, error) {
url := conf.Conf["mgrast_oauth_url"]
if url == "" {
return nil, errors.New("mgrast_oauth_url not set in configuration")
}
form := client.NewForm()
form.AddParam("token", t)
form.AddParam("action", "credentials")
form.AddParam("groups", "true")
err := form.Create()
if err != nil {
return nil, err
}
headers := client.Header{
"Content-Type": form.ContentType,
"Content-Length": strconv.FormatInt(form.Length, 10),
}
if res, err := client.Do("POST", url, headers, form.Reader); err == nil {
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
}
//shock access functions
func createOrUpdate(opts Opts, host string, nodeid string, token string, nodeattr map[string]interface{}) (node *shock.ShockNode, err error) {
if host == "" {
return nil, errors.New("error: (createOrUpdate) host is not defined")
}
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
}
// deprecated, this is with explicit timeout
func (sc *ShockClient) Do_request_DEPRECATED(method string, resource string, query url.Values, response interface{}) (err error) {
//logger.Debug(1, fmt.Sprint("string_url: ", sc.Host))
myurl, err := url.ParseRequestURI(sc.Host)
if err != nil {
return err
}
(*myurl).Path = resource
(*myurl).RawQuery = query.Encode()
shockurl := myurl.String()
//logger.Debug(1, fmt.Sprint("shock request url: ", shockurl))
if sc.Debug {
fmt.Fprintf(os.Stdout, "Get_request url: %s\n", shockurl)
}
if len(shockurl) < 5 {
return errors.New("could not parse shockurl: " + shockurl)
}
var user *httpclient.Auth
if sc.Token != "" {
user = httpclient.GetUserByTokenAuth(sc.Token)
}
var res *http.Response
c := make(chan int, 1)
go func() {
res, err = httpclient.Do(method, shockurl, httpclient.Header{}, nil, user)
//res, err = httpclient.Get(shockurl, httpclient.Header{}, nil, user)
c <- 1 //we are ending
}()
select {
case <-c:
//go ahead
case <-time.After(SHOCK_TIMEOUT):
return errors.New("timeout when getting node from shock, url=" + shockurl)
}
if err != nil {
return
}
defer res.Body.Close()
jsonstream, err := ioutil.ReadAll(res.Body)
if sc.Debug {
fmt.Fprintf(os.Stdout, "json response:\n %s\n", string(jsonstream))
}
//logger.Debug(1, string(jsonstream))
if err != nil {
return err
}
//response := new(result)
if err := json.Unmarshal(jsonstream, response); err != nil {
return err
}
//if len(response.Errs) > 0 {
// return errors.New(strings.Join(response.Errs, ","))
//}
//node = &response.Data
//if node == nil {
// err = errors.New("empty node got from Shock")
//}
return
}
func (n *Node) createOrUpdate(opts Opts) (err error) {
url := conf.Server.Url + "/node"
method := "POST"
if n.Id != "" {
url += "/" + n.Id
method = "PUT"
}
form := client.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 errors.New("missing file parameter: upload")
}
case "parts":
if opts.HasKey("parts") {
form.AddParam("parts", opts.Value("parts"))
} else {
return 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 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 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 errors.New("missing virtual node parameter: source")
}
}
}
err = form.Create()
if err != nil {
return err
}
headers := client.Header{
"Content-Type": form.ContentType,
"Content-Length": strconv.FormatInt(form.Length, 10),
}
if res, err := client.Do(method, url, headers, form.Reader); err == nil {
if res.StatusCode == 200 {
r := WNode{Data: n}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return err
}
} else {
r := Wrapper{}
body, _ := ioutil.ReadAll(res.Body)
if err = json.Unmarshal(body, &r); err == nil {
return errors.New(res.Status + ": " + (*r.Error)[0])
} else {
return errors.New("request error: " + res.Status)
}
}
} else {
return err
}
return nil
}