// addNodeHandler can provide an machine and/or register a node address.
// If register flag is true, it will just register a node.
// It checks if node address is valid and accessible.
func addNodeHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
params, err := unmarshal(r.Body)
if err != nil {
return err
}
if templateName, ok := params["template"]; ok {
params, err = iaas.ExpandTemplate(templateName)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
}
}
pool := params["pool"]
if pool == "" {
w.WriteHeader(http.StatusBadRequest)
return json.NewEncoder(w).Encode(map[string]string{"error": "pool is required"})
}
if !permission.Check(t, permission.PermNodeCreate, permission.Context(permission.CtxPool, pool)) {
return permission.ErrUnauthorized
}
isRegister, _ := strconv.ParseBool(r.URL.Query().Get("register"))
if !isRegister {
canCreateMachine := permission.Check(t, permission.PermMachineCreate,
permission.Context(permission.CtxIaaS, params["iaas"]))
if !canCreateMachine {
return permission.ErrUnauthorized
}
}
response, err := mainDockerProvisioner.addNodeForParams(params, isRegister)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
response["error"] = err.Error()
}
return json.NewEncoder(w).Encode(response)
}
// addNodeHandler can provide an machine and/or register a node address.
// If register flag is true, it will just register a node.
// It checks if node address is valid and accessible.
func addNodeHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
params, err := unmarshal(r.Body)
if err != nil {
return err
}
if templateName, ok := params["template"]; ok {
params, err = iaas.ExpandTemplate(templateName)
if err != nil {
return &errors.HTTP{Code: http.StatusBadRequest, Message: err.Error()}
}
}
pool := params["pool"]
if pool == "" {
return &errors.HTTP{Code: http.StatusBadRequest, Message: "pool is required"}
}
if !permission.Check(t, permission.PermNodeCreate, permission.Context(permission.CtxPool, pool)) {
return permission.ErrUnauthorized
}
isRegister, _ := strconv.ParseBool(r.URL.Query().Get("register"))
if !isRegister {
canCreateMachine := permission.Check(t, permission.PermMachineCreate,
permission.Context(permission.CtxIaaS, params["iaas"]))
if !canCreateMachine {
return permission.ErrUnauthorized
}
}
keepAliveWriter := tsuruIo.NewKeepAliveWriter(w, 15*time.Second, "")
defer keepAliveWriter.Stop()
writer := &tsuruIo.SimpleJsonMessageEncoderWriter{Encoder: json.NewEncoder(keepAliveWriter)}
response, err := mainDockerProvisioner.addNodeForParams(params, isRegister)
if err != nil {
writer.Encode(tsuruIo.SimpleJsonMessage{
Error: fmt.Sprintf("%s\n\n%s", err, response["description"]),
})
}
return nil
}
// title: add node
// path: /{provisioner}/node
// method: POST
// consume: application/x-www-form-urlencoded
// produce: application/x-json-stream
// responses:
// 201: Ok
// 401: Unauthorized
// 404: Not found
func addNodeHandler(w http.ResponseWriter, r *http.Request, t auth.Token) (err error) {
err = r.ParseForm()
if err != nil {
return &tsuruErrors.HTTP{Code: http.StatusBadRequest, Message: err.Error()}
}
var params provision.AddNodeOptions
dec := form.NewDecoder(nil)
dec.IgnoreUnknownKeys(true)
err = dec.DecodeValues(¶ms, r.Form)
if err != nil {
return &tsuruErrors.HTTP{Code: http.StatusBadRequest, Message: err.Error()}
}
if templateName, ok := params.Metadata["template"]; ok {
params.Metadata, err = iaas.ExpandTemplate(templateName, params.Metadata)
if err != nil {
return &tsuruErrors.HTTP{Code: http.StatusBadRequest, Message: err.Error()}
}
}
poolName := params.Metadata["pool"]
if poolName == "" {
return &tsuruErrors.HTTP{Code: http.StatusBadRequest, Message: "pool is required"}
}
if !permission.Check(t, permission.PermNodeCreate, permission.Context(permission.CtxPool, poolName)) {
return permission.ErrUnauthorized
}
if !params.Register {
canCreateMachine := permission.Check(t, permission.PermMachineCreate,
permission.Context(permission.CtxIaaS, params.Metadata["iaas"]))
if !canCreateMachine {
return permission.ErrUnauthorized
}
}
evt, err := event.New(&event.Opts{
Target: event.Target{Type: event.TargetTypeNode},
Kind: permission.PermNodeCreate,
Owner: t,
CustomData: event.FormToCustomData(r.Form),
DisableLock: true,
Allowed: event.Allowed(permission.PermPoolReadEvents, permission.Context(permission.CtxPool, poolName)),
})
if err != nil {
return err
}
defer func() { evt.Done(err) }()
pool, err := provision.GetPoolByName(poolName)
if err != nil {
return err
}
prov, err := pool.GetProvisioner()
if err != nil {
return err
}
nodeProv, ok := prov.(provision.NodeProvisioner)
if !ok {
return provision.ProvisionerNotSupported{Prov: prov, Action: "node operations"}
}
w.Header().Set("Content-Type", "application/x-json-stream")
w.WriteHeader(http.StatusCreated)
keepAliveWriter := tsuruIo.NewKeepAliveWriter(w, 15*time.Second, "")
defer keepAliveWriter.Stop()
addr, response, err := addNodeForParams(nodeProv, params)
evt.Target.Value = addr
if err != nil {
if desc := response["description"]; desc != "" {
return errors.Wrapf(err, "Instructions:\n%s", desc)
}
return err
}
return nil
}