Esempio n. 1
0
func undeploy(args intf.Command) (result string, err error) {
	subs := args.Subs()
	appToUndeploy := repo.AntiAbbreviate(subs[0])
	body, err := http.Read("/deployment/prepare/undeploy?deployedApplication=" + appToUndeploy)
	if err != nil {
		return
	}

	body, err = http.Create("/deployment", bytes.NewBuffer(body))
	if err != nil {
		return
	}

	taskId := string(body)

	body, err = http.Create("/task/"+string(body)+"/start", nil)
	if err != nil {
		return
	}

	displayStatus(taskId)

	return string(body), err
}
Esempio n. 2
0
func grant(args intf.Command) (result string, err error) {
	subs := args.Subs()

	ci := subs[0]
	roleToChange := subs[1]
	perms := subs[2:]

	// Get current permissions
	// (already works for global keyword :) )
	body, err := http.Read("/internal/security/roles/permissions/" + repo.AntiAbbreviate(ci))
	if err != nil {
		return
	}

	values, err := x2j.XmlToMap(body)
	if err != nil {
		return
	}

	arr := arrayFromMap(values["collection"], "rolePermissions")
	changed := false

	for _, elMap := range arr {
		role := elMap["role"].(map[string]interface{})
		if role["-name"] == roleToChange {

			oldPerms := elMap["permissions"].([]interface{})
			for _, el := range perms {
				oldPerms = append(oldPerms, el)
			}
			elMap["permissions"], changed = oldPerms, true
		}
	}

	if !changed {
		roleMap := map[string]string{"-id": strconv.Itoa(len(arr)), "-role": roleToChange}
		fmt.Println("Need to add it.... :( ", roleMap)
		fullMap := map[string]interface{}{"permissions": perms, "role": roleMap}
		arr = append(arr, fullMap)
		values["collection"].(map[string]interface{})["rolePermissions"] = arr
	}

	// TODO Make this a util?
	json, _ := j2x.MapToJson(values)
	xml, _ := j2x.JsonToXml(json)

	fmt.Println("modified(?) response = ", string(xml))

	/*
		body, err = http.Update("/internal/security/roles/permissions/" +
			repo.AntiAbbreviate(ci),
			bytes.NewBuffer(xml))
		if err != nil {
			return
		}

		fmt.Println("modified(?) response = ", body)
		//*/

	//fmt.Println("permset = ", permSet)

	// decode XML to ... JSON or marshall to objects?

	// is role already in there?
	// if not: add role

	// is permission already in there? -> ignore

	// add permission

	// encode as XML

	// post to http
	return
}
Esempio n. 3
0
func prepare(args intf.Command, depType string) (result string, err error) {
	subs := args.Subs()
	appVersion := repo.AntiAbbreviate(subs[0])
	targetEnv := repo.AntiAbbreviate(subs[1])

	parts := strings.Split(appVersion, "/")

	app := parts[len(parts)-2]

	targetDeployed := targetEnv + "/" + app

	if depType == "*" {
		statusCode, _, err := http.Get("/repository/ci/" + targetDeployed)
		if err != nil {
			return "error", err
		} else if statusCode == 200 {
			depType = "UPDATE"
		} else if statusCode == 404 {
			depType = "INITIAL"
		} else {
			return "error", errors.New("Unexpected http status code " + strconv.Itoa(statusCode) + " while checking the existance of " + targetDeployed)
		}
	}

	deployedApplication := map[string]interface{}{
		"-id": targetDeployed,
		"version": map[string]interface{}{
			"-ref": appVersion,
		},
		"environment": map[string]interface{}{
			"-ref": targetEnv,
		},
		"optimizePlan": "true",
	}

	deployment := map[string]interface{}{
		"deployment": map[string]interface{}{
			"-type": depType,
			"application": map[string]interface{}{
				"udm.DeployedApplication": deployedApplication,
			},
		},
	}

	for _, arg := range args.Arguments() {
		if arg.Name() == "orchestrator" {
			deployedApplication["orchestrator"] =
				repo.MapSetOfStrings(arg.Values())
		}
	}

	// TODO Make this a util?
	json, _ := j2x.MapToJson(deployment)
	xml, _ := j2x.JsonToXml(json)

	body, err := http.Create("/deployment/prepare/deployeds", bytes.NewBuffer(xml))
	if err != nil {
		return "error", err
	}

	body, err = http.Create("/deployment", bytes.NewBuffer(body))

	return string(body), err
}