func ReadAsMap(args intf.Command) (resultMap map[string]interface{}, err error) { subs := args.Subs() ci := AntiAbbreviate(subs[0]) body, err := http.Read("/repository/ci/" + ci) if err != nil { return } return xml2CleanMap(body) }
func permissions(args intf.Command) (result string, err error) { body, err := http.Read("/metadata/permissions") if err != nil { return } list := PermissionsList{} err = xml.Unmarshal(body, &list) for _, el := range list.Permissions { fmt.Println(eq(el.Name, 20), eq(el.Level, 8), el.Root) } return "", nil }
func displayStatus(taskId string) { timer := time.Tick(100 * time.Millisecond) previousStep := -1 for _ = range timer { // TODO support parallel deployments body, err := http.Read("/task/" + taskId + "/step") if err != nil { return } task := Task{} err = xml.Unmarshal(body, &task) if err != nil { return } currentStep := task.CurrentStep for i, step := range task.Steps { // Fix current step - sometimes it is one too high if step.State == "EXECUTING" { currentStep = i } if i > previousStep && i <= currentStep { fmt.Printf("%d/%d - "+step.Description+"\n", i+1, task.TotalSteps) } } previousStep = currentStep if task.State == "EXECUTED" { break } else if task.State == "FAILED" { // TODO throw error on deployment FAILED // TODO show logs on deployment error // can we simulate an error? break } } }
func list(args intf.Command) (result string, err error) { subs := args.Subs() arguments := make([]string, 0) if len(subs) > 0 { if strings.HasSuffix(subs[0], "*") { arguments = append(arguments, "ancestor="+url.QueryEscape(AntiAbbreviate(strings.Replace(subs[0], "*", "", -1)))) } else { arguments = append(arguments, "parent="+url.QueryEscape(AntiAbbreviate(subs[0]))) } } extra := args.Arguments() for _, el := range extra { name := el.Name() switch name { case "type": arguments = append(arguments, "type="+url.QueryEscape(el.Value())) case "like": arguments = append(arguments, "namePattern="+url.QueryEscape(el.Value())) case "before": //TODO lastModifiedBefore case "after": //TODO lastModifiedAfter case "page": arguments = append(arguments, "page="+url.QueryEscape(el.Value())) case "pagesize": arguments = append(arguments, "resultsPerPage="+url.QueryEscape(el.Value())) } } body, err := http.Read("/repository/query?" + strings.Join(arguments, "&")) list, err := readCiList(body) if err != nil { return "error", err } for _, el := range list.CIs { fmt.Println(el.CiRef) } return "", err }
func types(args intf.Command) (result string, err error) { body, err := http.Read("/metadata/type") if err != nil { return } list := List{} err = xml.Unmarshal(body, &list) if err != nil { return } for _, ciType := range list.CITypes { fmt.Println(ciType.Type) } return "", nil }
// TODO Make this a util? func AntiAbbreviate(ciName string) string { prefix := strings.SplitN(ciName, "/", 2) longer := shorthand[prefix[0]] remainder := "" if len(prefix) > 1 { remainder = prefix[1] } if longer != "" { ciName = longer + "/" + remainder } if strings.HasSuffix(ciName, "latest") { searchFor := ciName[:len(ciName)-len("latest")] body, err := http.Read("/repository/query?parent=" + searchFor) list, err := readCiList(body) if err != nil || len(list.CIs) == 0 { // TODO ERROR return "error" } splitter := regexp.MustCompile("[\\.?\\-?_?]+") versions := make([][]string, 0) ciMap := make(map[string]Ci) for _, el := range list.CIs { version := el.CiRef[len(searchFor):] split := splitter.Split(version, -1) ciMap[strings.Join(split, ".")] = el versions = append(versions, split) } sort.Sort(ByVersion(versions)) ciName = ciMap[strings.Join(versions[len(versions)-1], ".")].CiRef } return ciName }
func Type(typeName string) (retType *CIType, err error) { long := shorthand[typeName] if long != "" { typeName = long } body, err := http.Read("/metadata/type/" + typeName) if err != nil { return } ciType := CIType{} err = xml.Unmarshal(body, &ciType) if err == io.EOF { return nil, errors.New("Type " + typeName + " not found") } else if err != nil { return } return &ciType, nil }
func plan(args intf.Command, depType string) (result string, err error) { result, err = prepare(args, depType) body, err := http.Read("/task/" + result + "/step") if err != nil { return } task := Task{} err = xml.Unmarshal(body, &task) if err != nil { return "error", err } fmt.Println("Plan", task.Description) for i, step := range task.Steps { fmt.Printf("%d/%d - "+step.Description+"\n", i+1, task.TotalSteps) } return "", err }
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 }
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 }