vela

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Build{
	Number:       Int(1),
	Parent:       Int(1),
	Event:        String("push"),
	Status:       String("created"),
	Error:        String(""),
	Enqueued:     Int64(time.Now().UTC().Unix()),
	Created:      Int64(time.Now().UTC().Unix()),
	Started:      Int64(0),
	Finished:     Int64(0),
	Deploy:       String(""),
	Clone:        String("https://github.com/go-vela/server.git"),
	Source:       String("https://github.com/go-vela/server/abcdefghi123456789"),
	Title:        String(""),
	Message:      String(""),
	Commit:       String("abcdefghi123456789"),
	Sender:       String("someone"),
	Author:       String("someone"),
	Email:        String("someone@example.com"),
	Link:         String("https://vela.example.company.com/go-vela/server/1"),
	Branch:       String("main"),
	Ref:          String(""),
	BaseRef:      String(""),
	Host:         String("example.company.com"),
	Runtime:      String("docker"),
	Distribution: String("linux"),
}

// Create the build in the server
build, resp, err := c.Build.Add("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for build %+v", resp.StatusCode, build)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Cancel the build in the server
_, resp, err := c.Build.Cancel("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for github/octocat/1", resp.StatusCode)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a build from the server
build, resp, err := c.Build.Get("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for build %+v", resp.StatusCode, build)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the builds from the server
builds, resp, err := c.Build.GetAll("github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for builds %+v", resp.StatusCode, builds)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get token for a build from the server
token, resp, err := c.Build.GetBuildToken("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for build token %+v", resp.StatusCode, token)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get for a build from the server
logs, resp, err := c.Build.GetLogs("github", "octocat", 1, nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for build logs %+v", resp.StatusCode, logs)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the build in the server
build, resp, err := c.Build.Remove("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, build)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Restart the build in the server
build, resp, err := c.Build.Restart("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, build)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Build{
	Status: String("error"),
	Error:  String(""),
}

// Update the step in the server
build, resp, err := c.Build.Update("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for build %+v", resp.StatusCode, build)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Deployment{
	Commit:      String("48afb5bdc41ad69bf22588491333f7cf71135163"),
	Ref:         String("refs/heads/main"),
	Task:        String("vela-deploy"),
	Target:      String("production"),
	Description: String("Deployment request from Vela"),
}

// Create the deployment in the server
deployment, resp, err := c.Deployment.Add("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for deployment %+v", resp.StatusCode, deployment)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a build from the server
deployment, resp, err := c.Deployment.Get("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for deployment %+v", resp.StatusCode, deployment)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the deployments from the server
deployments, resp, err := c.Deployment.GetAll("github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for deployments %+v", resp.StatusCode, deployments)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Hook{
	Number:   Int(1),
	SourceID: String("c8da1302-07d6-11ea-882f-4893bca275b8"),
	Event:    String("push"),
	Status:   String("created"),
	Error:    String(""),
	Created:  Int64(1563474076),
	Link:     String("https://github.com/github/octocat/settings/hooks/1"),
	Branch:   String("main"),
	Host:     String("github.com"),
}

// Create the hook in the server
hook, resp, err := c.Hook.Add("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for hook %+v", resp.StatusCode, hook)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a hook from the server
hook, resp, err := c.Hook.Get("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for hook %+v", resp.StatusCode, hook)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the hooks from the server
hooks, resp, err := c.Hook.GetAll("github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for hooks %+v", resp.StatusCode, hooks)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the hook in the server
hook, resp, err := c.Hook.Remove("github", "octocat", 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, hook)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Hook{
	Status: String("error"),
	Error:  String(""),
}

// Update the step in the server
hook, resp, err := c.Hook.Update("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for hook %+v", resp.StatusCode, hook)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Log{
	Data: Bytes([]byte("Hello World")),
}

// Create the log in the server
resp, err := c.Log.AddService("github", "octocat", 1, 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d for log", resp.StatusCode)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Log{
	Data: Bytes([]byte("Hello World")),
}

// Create the log in the server
resp, err := c.Log.AddStep("github", "octocat", 1, 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d for log", resp.StatusCode)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a log from the server
log, resp, err := c.Log.GetService("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for log %+v", resp.StatusCode, log)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a log from the server
log, resp, err := c.Log.GetStep("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for log %+v", resp.StatusCode, log)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the log in the server
log, resp, err := c.Log.RemoveService("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for log %+v", resp.StatusCode, log)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the log in the server
log, resp, err := c.Log.RemoveStep("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for log %+v", resp.StatusCode, log)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Log{
	Data: Bytes([]byte("Hello World")),
}

// Update the log in the server
resp, err := c.Log.UpdateService("github", "octocat", 1, 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for log", resp.StatusCode)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Log{
	Data: Bytes([]byte("Hello World")),
}

// Update the log in the server
resp, err := c.Log.UpdateStep("github", "octocat", 1, 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d for log", resp.StatusCode)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Pipeline{
	Commit:  String("48afb5bdc41ad69bf22588491333f7cf71135163"),
	Ref:     String("refs/heads/main"),
	Type:    String("yaml"),
	Version: String("1"),
	Steps:   Bool(true),
}

// Create the pipeline in the server
pipeline, resp, err := c.Pipeline.Add("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// create options for pipeline call
opts := &PipelineOptions{
	Output: "yaml", // default
}

// compile a pipeline from a repo from the server
pipeline, resp, err := c.Pipeline.Compile("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163", opts)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// create options for pipeline call
opts := &PipelineOptions{
	Output: "yaml", // default
}

// expand templates for a pipeline from a repo from the server
pipeline, resp, err := c.Pipeline.Expand("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163", opts)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// get a pipeline from a repo from the server
pipeline, resp, err := c.Pipeline.Get("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the pipelines from the server
pipelines, resp, err := c.Pipeline.GetAll("github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipelines %+v", resp.StatusCode, pipelines)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the pipeline in the server
pipeline, resp, err := c.Pipeline.Remove("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// create options for pipeline call
opts := &PipelineOptions{
	Output: "yaml", // default
}

// get templates for a pipeline from a repo from the server
pipeline, resp, err := c.Pipeline.Templates("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163", opts)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Pipeline{
	Commit: String("48afb5bdc41ad69bf22588491333f7cf71135163"),
	Type:   String("yaml"),
}

// Update the step in the server
pipeline, resp, err := c.Pipeline.Update("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// create options for pipeline call
opts := &PipelineOptions{
	Output: "yaml", // default
}

// get templates for a pipeline from a repo from the server
pipeline, resp, err := c.Pipeline.Validate("github", "octocat", "48afb5bdc41ad69bf22588491333f7cf71135163", opts)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for pipeline %+v", resp.StatusCode, pipeline)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Repo{
	Org:         String("github"),
	Name:        String("octocat"),
	FullName:    String("github/octocat"),
	Link:        String("https://github.com/github/octocat"),
	Clone:       String("https://github.com/github/octocat.git"),
	Branch:      String("main"),
	Timeout:     Int64(60),
	Visibility:  String("public"),
	Private:     Bool(false),
	Trusted:     Bool(false),
	Active:      Bool(true),
	AllowPull:   Bool(true),
	AllowPush:   Bool(true),
	AllowDeploy: Bool(false),
	AllowTag:    Bool(false),
}

// Create the repo in the server
repo, resp, err := c.Repo.Add(&req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Change orgship of the repo in the server
repo, resp, err := c.Repo.Chown("github", "octocat")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a repo from the server
repo, resp, err := c.Repo.Get("github", "octocat")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the repos from the server
repos, resp, err := c.Repo.GetAll(nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repos %+v", resp.StatusCode, repos)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the repo in the server
repo, resp, err := c.Repo.Remove("github", "octocat")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Repair the repo in the server
repo, resp, err := c.Repo.Repair("github", "octocat")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Repo{
	AllowDeploy: Bool(true),
	AllowTag:    Bool(true),
}

// Update the repo in the server
repo, resp, err := c.Repo.Update("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Change orgship of the repo in the server
repo, resp, err := c.SCM.Sync("github", "octocat")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, repo)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Change orgship of the repo in the server
org, resp, err := c.SCM.SyncAll("github")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for repo %+v", resp.StatusCode, org)

Output:

// create a new vela client for interacting with server
c, err := NewClient("http://localhost:8080", "", nil)
if err != nil {
	fmt.Println(err)
}

// set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Schedule{
	Active: Bool(true),
	Name:   String("nightly"),
	Entry:  String("0 0 * * *"),
}

// create the schedule in the server
schedule, resp, err := c.Schedule.Add("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("received response code %d, for schedule %+v", resp.StatusCode, schedule)

Output:

// create a new vela client for interacting with server
c, err := NewClient("http://localhost:8080", "", nil)
if err != nil {
	fmt.Println(err)
}

// set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// get a schedule from a repo in the server
schedule, resp, err := c.Schedule.Get("github", "octocat", "nightly")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("received response code %d, for schedule %+v", resp.StatusCode, schedule)

Output:

// create a new vela client for interacting with server
c, err := NewClient("http://localhost:8080", "", nil)
if err != nil {
	fmt.Println(err)
}

// set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// get all the schedules from a repo in the server
schedules, resp, err := c.Schedule.GetAll("github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("received response code %d, for schedules %+v", resp.StatusCode, schedules)

Output:

// create a new vela client for interacting with server
c, err := NewClient("http://localhost:8080", "", nil)
if err != nil {
	fmt.Println(err)
}

// set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// remove the schedule from the server
schedule, resp, err := c.Schedule.Remove("github", "octocat", "nightly")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("received response code %d, for step %+v", resp.StatusCode, schedule)

Output:

// create a new vela client for interacting with server
c, err := NewClient("http://localhost:8080", "", nil)
if err != nil {
	fmt.Println(err)
}

// set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Schedule{
	Active: Bool(false),
	Name:   String("nightly"),
	Entry:  String("0 0 * * *"),
}

// update the schedule in the server
schedule, resp, err := c.Schedule.Update("github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("received response code %d, for schedule %+v", resp.StatusCode, schedule)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Secret{
	Name:   String("foo"),
	Value:  String("bar"),
	Images: &[]string{"foo", "bar"},
	Events: &[]string{"foo", "bar"},
}

// Create the secret in the server
secret, resp, err := c.Secret.Add("native", "repo", "github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for secret %+v", resp.StatusCode, secret)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get the secret from the server
secret, resp, err := c.Secret.Get("native", "repo", "github", "octocat", "foo")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for secret %+v", resp.StatusCode, secret)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the secrets from the server
secrets, resp, err := c.Secret.GetAll("native", "repo", "github", "octocat", nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for secrets %+v", resp.StatusCode, secrets)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the secret in the server
secret, resp, err := c.Secret.Remove("native", "repo", "github", "octocat", "foo")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for secret %+v", resp.StatusCode, secret)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Secret{
	Name:   String("foo"),
	Value:  String("bar"),
	Events: &[]string{"barf", "foob"},
}

// Update the secret in the server
secret, resp, err := c.Secret.Update("native", "repo", "github", "octocat", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for secret %+v", resp.StatusCode, secret)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Step{
	Number:       Int(1),
	Name:         String("clone"),
	Status:       String("pending"),
	Error:        String(""),
	ExitCode:     Int(0),
	Created:      Int64(time.Now().UTC().Unix()),
	Started:      Int64(0),
	Finished:     Int64(0),
	Host:         String("example.company.com"),
	Runtime:      String("docker"),
	Distribution: String("linux"),
}

// Create the step in the server
step, resp, err := c.Step.Add("github", "octocat", 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, step)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a step from the server
step, resp, err := c.Step.Get("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, step)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the steps from the server
steps, resp, err := c.Step.GetAll("github", "octocat", 1, nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for steps %+v", resp.StatusCode, steps)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the step in the server
step, resp, err := c.Step.Remove("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, step)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Step{
	Status: String("error"),
	Error:  String("Something in the runtime broke"),
}

// Update the step in the server
step, resp, err := c.Step.Update("github", "octocat", 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for step %+v", resp.StatusCode, step)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Service{
	Number:   Int(1),
	Name:     String("clone"),
	Status:   String("pending"),
	Error:    String(""),
	ExitCode: Int(0),
	Created:  Int64(time.Now().UTC().Unix()),
	Started:  Int64(0),
	Finished: Int64(0),
}

// Create the service in the server
service, resp, err := c.Svc.Add("github", "octocat", 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for service %+v", resp.StatusCode, service)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a service from the server
service, resp, err := c.Svc.Get("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for service %+v", resp.StatusCode, service)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the services from the server
services, resp, err := c.Svc.GetAll("github", "octocat", 1, nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for services %+v", resp.StatusCode, services)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the service in the server
service, resp, err := c.Svc.Remove("github", "octocat", 1, 1)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for service %+v", resp.StatusCode, service)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Service{
	Status: String("error"),
	Error:  String("Something in the runtime broke"),
}

// Update the service in the server
service, resp, err := c.Svc.Update("github", "octocat", 1, &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for service %+v", resp.StatusCode, service)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Worker{
	ID:       Int64(1),
	Hostname: String("worker_1"),
	Address:  String("http://vela:8080"),
	Routes: Strings([]string{
		"large",
		"docker",
		"large:docker",
	}),
	Active:        Bool(true),
	LastCheckedIn: Int64(1602612590),
}

// Create the worker in the server
worker, resp, err := c.Worker.Add(&req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for worker %+v", resp.StatusCode, worker)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get a worker from the server
worker, resp, err := c.Worker.Get("worker_1")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for worker %+v", resp.StatusCode, worker)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Get all the workers from the server
workers, resp, err := c.Worker.GetAll(nil)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for workers %+v", resp.StatusCode, workers)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

worker := "worker_1"

// Refresh a worker token with the server
_, resp, err := c.Worker.RefreshAuth(worker)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for worker %+v", resp.StatusCode, worker)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

// Remove the worker in the server
worker, resp, err := c.Worker.Remove("worker_1")
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for worker %+v", resp.StatusCode, worker)

Output:

// Create a new vela client for interacting with server
c, _ := NewClient("http://localhost:8080", "", nil)

// Set new token in existing client
c.Authentication.SetPersonalAccessTokenAuth("token")

req := library.Worker{
	Active: Bool(false),
}

// Update the worker in the server
worker, resp, err := c.Worker.Update("worker_1", &req)
if err != nil {
	fmt.Println(err)
}

fmt.Printf("Received response code %d, for worker %+v", resp.StatusCode, worker)

Output: