// UpdateVersion updates a specific version of a cookbook.
func (cbv *CookbookVersion) UpdateVersion(cbvData map[string]interface{}, force string) util.Gerror {
/* Allow force to update a frozen cookbook */
if cbv.IsFrozen == true && force != "true" {
err := util.Errorf("The cookbook %s at version %s is frozen. Use the 'force' option to override.", cbv.CookbookName, cbv.Version)
err.SetStatus(http.StatusConflict)
return err
}
fhashes := cbv.fileHashes()
_, nerr := util.ValidateAsString(cbvData["cookbook_name"])
if nerr != nil {
if nerr.Error() == "Field 'name' missing" {
nerr = util.Errorf("Field 'cookbook_name' missing")
} else {
nerr = util.Errorf("Field 'cookbook_name' invalid")
}
return nerr
}
/* Validation, validation, all is validation. */
validElements := []string{"cookbook_name", "name", "version", "json_class", "chef_type", "definitions", "libraries", "attributes", "recipes", "providers", "resources", "templates", "root_files", "files", "frozen?", "metadata", "force"}
ValidElem:
for k := range cbvData {
for _, i := range validElements {
if k == i {
continue ValidElem
}
}
err := util.Errorf("Invalid key %s in request body", k)
return err
}
var verr util.Gerror
cbvData["chef_type"], verr = util.ValidateAsFieldString(cbvData["chef_type"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
cbvData["chef_type"] = cbv.ChefType
} else {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
} else {
// Wait, what was I doing here?
// if !util.ValidateEnvName(cbvData["chef_type"].(string)) {
if cbvData["chef_type"].(string) != "cookbook_version" {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
}
cbvData["json_class"], verr = util.ValidateAsFieldString(cbvData["json_class"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
cbvData["json_class"] = cbv.JSONClass
} else {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
} else {
if cbvData["json_class"].(string) != "Chef::CookbookVersion" {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
}
cbvData["version"], verr = util.ValidateAsVersion(cbvData["version"])
if verr != nil {
verr = util.Errorf("Field 'version' invalid")
return verr
}
if cbvData["version"].(string) == "0.0.0" && cbv.Version != "" {
cbvData["version"] = cbv.Version
}
divs := []string{"definitions", "libraries", "attributes", "recipes", "providers", "resources", "templates", "root_files", "files"}
for _, d := range divs {
cbvData[d], verr = util.ValidateCookbookDivision(d, cbvData[d])
if verr != nil {
return verr
}
}
cbvData["metadata"], verr = util.ValidateCookbookMetadata(cbvData["metadata"])
if verr != nil {
return verr
}
cbvData["frozen?"], verr = util.ValidateAsBool(cbvData["frozen?"])
if verr != nil {
return verr
}
/* Basic sanity checking */
if cbvData["cookbook_name"].(string) != cbv.CookbookName {
err := util.Errorf("Field 'cookbook_name' invalid")
return err
}
if cbvData["name"].(string) != cbv.Name {
err := util.Errorf("Field 'name' invalid")
return err
}
if cbvData["version"].(string) != cbv.Version && cbvData["version"] != "0.0.0" {
err := util.Errorf("Field 'version' invalid")
return err
}
/* Update the data */
/* With these next two, should we test for existence before setting? */
cbv.ChefType = cbvData["chef_type"].(string)
cbv.JSONClass = cbvData["json_class"].(string)
cbv.Definitions = convertToCookbookDiv(cbvData["definitions"])
cbv.Libraries = convertToCookbookDiv(cbvData["libraries"])
cbv.Attributes = convertToCookbookDiv(cbvData["attributes"])
cbv.Recipes = cbvData["recipes"].([]map[string]interface{})
cbv.Providers = convertToCookbookDiv(cbvData["providers"])
cbv.Resources = convertToCookbookDiv(cbvData["resources"])
cbv.Templates = convertToCookbookDiv(cbvData["templates"])
cbv.RootFiles = convertToCookbookDiv(cbvData["root_files"])
cbv.Files = convertToCookbookDiv(cbvData["files"])
if cbv.IsFrozen != true {
cbv.IsFrozen = cbvData["frozen?"].(bool)
}
cbv.Metadata = cbvData["metadata"].(map[string]interface{})
/* If we're using SQL, update this version in the DB. */
if config.UsingDB() {
if err := cbv.updateCookbookVersionSQL(); err != nil {
return err
}
}
/* Clean cookbook hashes */
if len(fhashes) > 0 {
// Get our parent. Bravely assuming that if it exists we exist.
cbook, _ := Get(cbv.CookbookName)
cbook.Versions[cbv.Version] = cbv
cbook.deleteHashes(fhashes)
}
return nil
}
// UpdateFromJSON updates an existing node with the uploaded JSON.
func (n *Node) UpdateFromJSON(jsonNode map[string]interface{}) util.Gerror {
/* It's actually totally legitimate to save a node with a different
* name than you started with, but we need to get/create a new node for
* it is all. */
nodeName, nerr := util.ValidateAsString(jsonNode["name"])
if nerr != nil {
return nerr
}
if n.Name != nodeName {
err := util.Errorf("Node name %s and %s from JSON do not match.", n.Name, nodeName)
return err
}
/* Validations */
/* Look for invalid top level elements. *We* don't have to worry about
* them, but chef-pedant cares (probably because Chef <=10 stores
* json objects directly, dunno about Chef 11). */
validElements := []string{"name", "json_class", "chef_type", "chef_environment", "run_list", "override", "normal", "default", "automatic"}
ValidElem:
for k := range jsonNode {
for _, i := range validElements {
if k == i {
continue ValidElem
}
}
err := util.Errorf("Invalid key %s in request body", k)
return err
}
var verr util.Gerror
jsonNode["run_list"], verr = util.ValidateRunList(jsonNode["run_list"])
if verr != nil {
return verr
}
attrs := []string{"normal", "automatic", "default", "override"}
for _, a := range attrs {
jsonNode[a], verr = util.ValidateAttributes(a, jsonNode[a])
if verr != nil {
return verr
}
}
jsonNode["chef_environment"], verr = util.ValidateAsFieldString(jsonNode["chef_environment"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonNode["chef_environment"] = n.ChefEnvironment
} else {
return verr
}
} else {
if !util.ValidateEnvName(jsonNode["chef_environment"].(string)) {
verr = util.Errorf("Field 'chef_environment' invalid")
return verr
}
}
jsonNode["json_class"], verr = util.ValidateAsFieldString(jsonNode["json_class"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonNode["json_class"] = n.JSONClass
} else {
return verr
}
} else {
if jsonNode["json_class"].(string) != "Chef::Node" {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
}
jsonNode["chef_type"], verr = util.ValidateAsFieldString(jsonNode["chef_type"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonNode["chef_type"] = n.ChefType
} else {
return verr
}
} else {
if jsonNode["chef_type"].(string) != "node" {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
}
/* and setting */
n.ChefEnvironment = jsonNode["chef_environment"].(string)
n.ChefType = jsonNode["chef_type"].(string)
n.JSONClass = jsonNode["json_class"].(string)
n.RunList = jsonNode["run_list"].([]string)
n.Normal = jsonNode["normal"].(map[string]interface{})
n.Automatic = jsonNode["automatic"].(map[string]interface{})
n.Default = jsonNode["default"].(map[string]interface{})
n.Override = jsonNode["override"].(map[string]interface{})
return nil
}
// UpdateFromJSON updates an existing environment from JSON uploaded to the
// server.
func (e *ChefEnvironment) UpdateFromJSON(jsonEnv map[string]interface{}) util.Gerror {
if e.Name != jsonEnv["name"].(string) {
err := util.Errorf("Environment name %s and %s from JSON do not match", e.Name, jsonEnv["name"].(string))
return err
} else if e.Name == "_default" {
err := util.Errorf("The '_default' environment cannot be modified.")
err.SetStatus(http.StatusMethodNotAllowed)
return err
}
/* Validations */
validElements := []string{"name", "chef_type", "json_class", "description", "default_attributes", "override_attributes", "cookbook_versions"}
ValidElem:
for k := range jsonEnv {
for _, i := range validElements {
if k == i {
continue ValidElem
}
}
err := util.Errorf("Invalid key %s in request body", k)
return err
}
var verr util.Gerror
attrs := []string{"default_attributes", "override_attributes"}
for _, a := range attrs {
jsonEnv[a], verr = util.ValidateAttributes(a, jsonEnv[a])
if verr != nil {
return verr
}
}
jsonEnv["json_class"], verr = util.ValidateAsFieldString(jsonEnv["json_class"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonEnv["json_class"] = e.JSONClass
} else {
return verr
}
} else {
if jsonEnv["json_class"].(string) != "Chef::Environment" {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
}
jsonEnv["chef_type"], verr = util.ValidateAsFieldString(jsonEnv["chef_type"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonEnv["chef_type"] = e.ChefType
} else {
return verr
}
} else {
if jsonEnv["chef_type"].(string) != "environment" {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
}
jsonEnv["cookbook_versions"], verr = util.ValidateAttributes("cookbook_versions", jsonEnv["cookbook_versions"])
if verr != nil {
return verr
}
for k, v := range jsonEnv["cookbook_versions"].(map[string]interface{}) {
if !util.ValidateEnvName(k) || k == "" {
merr := util.Errorf("Cookbook name %s invalid", k)
merr.SetStatus(http.StatusBadRequest)
return merr
}
if v == nil {
verr = util.Errorf("Invalid version number")
return verr
}
_, verr = util.ValidateAsConstraint(v)
if verr != nil {
/* try validating as a version */
v, verr = util.ValidateAsVersion(v)
if verr != nil {
return verr
}
}
}
jsonEnv["description"], verr = util.ValidateAsString(jsonEnv["description"])
if verr != nil {
if verr.Error() == "Field 'name' missing" {
jsonEnv["description"] = ""
} else {
return verr
}
}
e.ChefType = jsonEnv["chef_type"].(string)
e.JSONClass = jsonEnv["json_class"].(string)
e.Description = jsonEnv["description"].(string)
e.Default = jsonEnv["default_attributes"].(map[string]interface{})
e.Override = jsonEnv["override_attributes"].(map[string]interface{})
/* clear out, then loop over the cookbook versions */
e.CookbookVersions = make(map[string]string, len(jsonEnv["cookbook_versions"].(map[string]interface{})))
for c, v := range jsonEnv["cookbook_versions"].(map[string]interface{}) {
e.CookbookVersions[c] = v.(string)
}
return nil
}
// UpdateFromJSON updates an existing role with the uploaded JSON.
func (r *Role) UpdateFromJSON(jsonRole map[string]interface{}) util.Gerror {
/* TODO - this and node.UpdateFromJSON may be generalizeable with
* reflect - look into it. */
if r.Name != jsonRole["name"] {
err := util.Errorf("Role name %s and %s from JSON do not match.", r.Name, jsonRole["name"])
return err
}
/* Validations */
/* Look for invalid top level elements. See node/node.go for more
* information. */
validElements := []string{"name", "json_class", "chef_type", "run_list", "env_run_lists", "default_attributes", "override_attributes", "description"}
ValidElem:
for k := range jsonRole {
for _, i := range validElements {
if k == i {
continue ValidElem
}
}
err := util.Errorf("Invalid key %s in request body", k)
return err
}
var verr util.Gerror
if jsonRole["run_list"], verr = util.ValidateRunList(jsonRole["run_list"]); verr != nil {
return verr
}
if _, erlExists := jsonRole["env_run_lists"]; erlExists {
for k, v := range jsonRole["env_run_lists"].(map[string][]string) {
if jsonRole["env_run_lists"].(map[string][]string)[k], verr = util.ValidateRunList(v); verr != nil {
return verr
}
}
} else {
jsonRole["env_run_lists"] = make(map[string][]string)
}
attrs := []string{"default_attributes", "override_attributes"}
for _, a := range attrs {
jsonRole[a], verr = util.ValidateAttributes(a, jsonRole[a])
if verr != nil {
return verr
}
}
jsonRole["json_class"], verr = util.ValidateAsFieldString(jsonRole["json_class"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonRole["json_class"] = r.JSONClass
} else {
return verr
}
} else {
if jsonRole["json_class"].(string) != "Chef::Role" {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
}
// Roles can be empty, just force it into being a string
jsonRole["description"], _ = util.ValidateAsString(jsonRole["description"])
jsonRole["chef_type"], verr = util.ValidateAsFieldString(jsonRole["chef_type"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonRole["chef_type"] = r.ChefType
} else {
return verr
}
} else {
if jsonRole["chef_type"].(string) != "role" {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
}
r.ChefType = jsonRole["chef_type"].(string)
r.JSONClass = jsonRole["json_class"].(string)
r.Description = jsonRole["description"].(string)
r.RunList = jsonRole["run_list"].([]string)
r.EnvRunLists = jsonRole["env_run_lists"].(map[string][]string)
r.Default = jsonRole["default_attributes"].(map[string]interface{})
r.Override = jsonRole["override_attributes"].(map[string]interface{})
return nil
}
// UpdateFromJSON updates a client/user from a json object. Does a bunch of
// validations inside rather than in the handler.
func (c *Client) UpdateFromJSON(jsonActor map[string]interface{}) util.Gerror {
actorName, nerr := util.ValidateAsString(jsonActor["name"])
if nerr != nil {
return nerr
}
if c.Name != actorName {
err := util.Errorf("Client name %s and %s from JSON do not match", c.Name, actorName)
return err
}
/* Validations. */
/* Invalid top level elements */
validElements := []string{"name", "json_class", "chef_type", "validator", "org_name", "orgname", "public_key", "private_key", "admin", "certificate", "password", "node_name"}
ValidElem:
for k := range jsonActor {
for _, i := range validElements {
if k == i {
continue ValidElem
}
}
err := util.Errorf("Invalid key %s in request body", k)
return err
}
var verr util.Gerror
jsonActor["json_class"], verr = util.ValidateAsFieldString(jsonActor["json_class"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonActor["json_class"] = c.JSONClass
} else {
return verr
}
} else {
if jsonActor["json_class"].(string) != "Chef::ApiClient" {
verr = util.Errorf("Field 'json_class' invalid")
return verr
}
}
jsonActor["chef_type"], verr = util.ValidateAsFieldString(jsonActor["chef_type"])
if verr != nil {
if verr.Error() == "Field 'name' nil" {
jsonActor["chef_type"] = c.ChefType
} else {
return verr
}
} else {
if jsonActor["chef_type"].(string) != "client" {
verr = util.Errorf("Field 'chef_type' invalid")
return verr
}
}
var ab, vb bool
if adminVal, ok := jsonActor["admin"]; ok {
if ab, verr = util.ValidateAsBool(adminVal); verr != nil {
// NOTE: may need to tweak this error message depending
// if this is a user or a client
verr = util.Errorf("Field 'admin' invalid")
return verr
} else if c.Admin && !ab {
if c.isLastAdmin() {
verr = util.Errorf("Cannot remove admin status from the last admin")
verr.SetStatus(http.StatusForbidden)
return verr
}
}
}
if validatorVal, ok := jsonActor["validator"]; ok {
if vb, verr = util.ValidateAsBool(validatorVal); verr != nil {
return verr
}
}
if ab && vb {
verr = util.Errorf("Client can be either an admin or a validator, but not both.")
verr.SetStatus(http.StatusBadRequest)
return verr
}
c.Admin = ab
c.Validator = vb
c.ChefType = jsonActor["chef_type"].(string)
c.JSONClass = jsonActor["json_class"].(string)
return nil
}