func main() { var repo = drone.Repo{} var build = drone.Build{} var vargs = struct { Urls []string `json:"urls"` }{} plugin.Param("repo", &repo) plugin.Param("build", &build) plugin.Param("vargs", &vargs) plugin.Parse() // data structure data := struct { Repo drone.Repo `json:"repo"` Build drone.Build `json:"build"` }{repo, build} // json payload that will be posted payload, err := json.Marshal(&data) if err != nil { os.Exit(1) } // post payload to each url for _, url := range vargs.Urls { resp, err := http.Post(url, "application/json", bytes.NewBuffer(payload)) if err != nil { os.Exit(1) } resp.Body.Close() } }
func main() { fmt.Printf("\nDrone Bintray plugin version %s %s\n", version, buildDate) var workspace = drone.Workspace{} plugin.Param("workspace", &workspace) plugin.Param("vargs", &bintray) if err := plugin.Parse(); err != nil { fmt.Printf("ERROR Can't parse yaml config: %s", err.Error()) os.Exit(1) } if bintray.Host == "" { bintray.Host = defaultHost } if bintray.Debug { saveApikey := bintray.APIKey bintray.APIKey = "******" fmt.Printf("DEBUG plugin input:\n%#v\n%#v\n", workspace, bintray) bintray.APIKey = saveApikey } if len(bintray.Branch) == 0 || bintray.Branch == "master" { fmt.Printf("\nPublishing %d artifacts to Bintray for user %s\n", len(bintray.Artifacts), bintray.Username) } else { fmt.Printf("\nPublishing %d artifacts on branch %s to Bintray for user %s\n", len(bintray.Artifacts), bintray.Branch, bintray.Username) } for i, artifact := range bintray.Artifacts { artifact.Version = fmt.Sprintf("%v", artifact.Versioni) fmt.Printf("\nUploading file %d %s to %s\n", i+1, artifact.File, artifact.getEndpoint()) artifact.Upload(workspace.Path) } }
func main() { var ( repo = new(drone.Repo) build = new(drone.Build) sys = new(drone.System) workspace = new(drone.Workspace) vargs = new(Vargs) ) plugin.Param("build", build) plugin.Param("repo", repo) plugin.Param("system", sys) plugin.Param("workspace", workspace) plugin.Param("vargs", vargs) err := plugin.Parse() if err != nil { log.Fatal(err) } vargs.TerraformVarsFile = strings.Join([]string{vargs.TerraformVarsFile, "\nbuild_number = \"", strconv.Itoa(build.Number), "\""}, "") err = CheckDeploy(vargs) if err != nil { log.Fatal(err) os.Exit(1) } else { os.Exit(0) } }
func main() { repo := drone.Repo{} build := drone.Build{} workspace := drone.Workspace{} vargs := Nonstop{} plugin.Param("build", &build) plugin.Param("repo", &repo) plugin.Param("workspace", &workspace) plugin.Param("vargs", &vargs) // parse the parameters if err := plugin.Parse(); err != nil { fmt.Println(err.Error()) os.Exit(1) } // check for required parameters if len(vargs.Index) == 0 { fmt.Println("Index Host/IP not provided") os.Exit(1) } if len(vargs.Port) == 0 { fmt.Println("Index Port not provided") os.Exit(1) } if len(vargs.Token) == 0 { fmt.Println("Index Auth Token not provided") os.Exit(1) } if len(vargs.Url) == 0 { fmt.Println("Index Url not provided") os.Exit(1) } //set up commands var cmd *exec.Cmd cmd = publishCommand(vargs) cmd.Dir = workspace.Path cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if vargs.Secure { c := []string{"ns", "upload", "--latest", "--secure", "--index", vargs.Index, "--port", vargs.Port, "--url", vargs.Url, "--token", "***********"} fmt.Println("$", strings.Join(c, " ")) } else { c := []string{"ns", "upload", "--latest", "--index", vargs.Index, "--port", vargs.Port, "--url", vargs.Url, "--token", "***********"} fmt.Println("$", strings.Join(c, " ")) } err := cmd.Run() if err != nil { os.Exit(1) } }
func main() { w := new(drone.Workspace) v := new(Rsync) plugin.Param("workspace", w) plugin.Param("vargs", v) if err := plugin.Parse(); err != nil { fmt.Println("Rsync: unable to parse invalid plugin input.") os.Exit(1) } // write the rsa private key if provided if err := writeKey(w); err != nil { fmt.Println(err) os.Exit(1) } // default values if v.Port == 0 { v.Port = 22 } if len(v.User) == 0 { v.User = "******" } if len(v.Source) == 0 { v.Source = "./" } // execute for each host for _, host := range v.Hosts.Slice() { // sync the files on the remote machine rs := v.buildRsync(host, w.Path) rs.Stderr = os.Stderr rs.Stdout = os.Stdout trace(rs) err := rs.Run() if err != nil { os.Exit(1) return } // continue if no commands if len(v.Commands) == 0 { continue } // execute commands on remote server (reboot instance, etc) if err := v.run(w.Keys, host); err != nil { os.Exit(1) return } } }
func main() { w := new(drone.Workspace) v := new(Rsync) plugin.Param("workspace", w) plugin.Param("vargs", v) if err := plugin.Parse(); err != nil { fmt.Println("Rsync: unable to parse invalid plugin input.") os.Exit(1) } if err := rsync(w, v); err != nil { fmt.Printf("Rsync: %s\n", err) os.Exit(1) } }
func main() { // plugin settings repo := drone.Repo{} build := drone.Build{} system := drone.System{} vargs := HipChat{} // set plugin parameters plugin.Param("build", &build) plugin.Param("repo", &repo) plugin.Param("system", &system) plugin.Param("vargs", &vargs) // parse the parameters if err := plugin.Parse(); err != nil { fmt.Println(err) os.Exit(1) } // create the HipChat client client := NewClient(vargs.Room.String(), vargs.Token) // build the HipChat message msg := Message{ From: vargs.From, Notify: vargs.Notify, Color: Color(&build), Message: BuildMessage(&repo, &build, &system), } // sends the HipChat message if err := client.Send(&msg); err != nil { fmt.Println(err) os.Exit(1) } }
func main() { vargs := Rancher{StartFirst: true} plugin.Param("vargs", &vargs) err := plugin.Parse() if err != nil { fmt.Println(err) os.Exit(1) } if len(vargs.Url) == 0 || len(vargs.AccessKey) == 0 || len(vargs.SecretKey) == 0 || len(vargs.Service) == 0 { return } if !strings.HasPrefix(vargs.Image, "docker:") { vargs.Image = fmt.Sprintf("docker:%s", vargs.Image) } var wantedService, wantedStack string if strings.Contains(vargs.Service, "/") { parts := strings.SplitN(vargs.Service, "/", 2) wantedStack = parts[0] wantedService = parts[1] } else { wantedService = vargs.Service } rancher, err := client.NewRancherClient(&client.ClientOpts{ Url: vargs.Url, AccessKey: vargs.AccessKey, SecretKey: vargs.SecretKey, }) if err != nil { fmt.Printf("Failed to create rancher client: %s\n", err) os.Exit(1) } var stackId string if wantedStack != "" { environments, err := rancher.Environment.List(&client.ListOpts{}) if err != nil { fmt.Printf("Failed to list rancher environments: %s\n", err) os.Exit(1) } for _, env := range environments.Data { if env.Name == wantedStack { stackId = env.Id } } if stackId == "" { fmt.Printf("Unable to find stack %s\n", wantedStack) os.Exit(1) } } services, err := rancher.Service.List(&client.ListOpts{}) if err != nil { fmt.Printf("Failed to list rancher services: %s\n", err) os.Exit(1) } found := false var service client.Service for _, svc := range services.Data { if svc.Name == wantedService && ((wantedStack != "" && svc.EnvironmentId == stackId) || wantedStack == "") { service = svc found = true } } if !found { fmt.Printf("Unable to find service %s\n", vargs.Service) os.Exit(1) } service.LaunchConfig.ImageUuid = vargs.Image upgrade := &client.ServiceUpgrade{} upgrade.InServiceStrategy = &client.InServiceUpgradeStrategy{ LaunchConfig: service.LaunchConfig, SecondaryLaunchConfigs: service.SecondaryLaunchConfigs, StartFirst: vargs.StartFirst, } upgrade.ToServiceStrategy = &client.ToServiceUpgradeStrategy{} _, err = rancher.Service.ActionUpgrade(&service, upgrade) if err != nil { fmt.Printf("Unable to upgrade service %s\n", vargs.Service) os.Exit(1) } fmt.Printf("Upgraded %s to %s\n", vargs.Service, vargs.Image) }