gotoolbox
Installation
Entrypoint
Types
Gotoolbox
GoServer

gotoolbox

This module has been generated via dagger init and serves as a reference to
basic module structure as you get started with Dagger. The module demonstrates
usage of arguments and return types using simple echo and grep commands. The functions
can be called from the dagger CLI or from one of the SDKs.

The first line in this comment block is a short description line and the
rest is a long description with more detail on the module's purpose or usage,
if appropriate. All modules should have a short description.

Example (RunArbitraryCommand)

no available example in current language

// Gotoolbox_RunArbitraryCommand runs an arbitrary shell command in the test container.
//
// This function demonstrates how to execute a shell command within the container
// using the Gotoolbox module.
//
// Parameters:
//
//	ctx - context for controlling the function lifetime.
//
// Returns:
//
//	A string containing the output of the executed command, or an error if the command fails or if the output is empty.
func (m *Go) Gotoolbox_RunArbitraryCommand(ctx context.Context) (string, error) {
	targetModule := dag.Gotoolbox().WithSource(m.TestDir)

	// Execute the 'ls -l' command
	out, err := targetModule.
		Ctr().
		WithExec([]string{"ls", "-l"}).
		Stdout(ctx)

	if err != nil {
		return "", fmt.Errorf("failed to run shell command: %w", err)
	}

	if out == "" {
		return "", errExpectedFoldersNotFound
	}

	return out, nil
}

no available example in current language

no available example in current language

Example (CreateNetRcFileForGithub)

no available example in current language

// Gotoolbox_CreateNetRcFileForGithub creates and configures a .netrc file for GitHub authentication.
//
// This method exemplifies the creation of a .netrc file with credentials for accessing GitHub,
// and demonstrates how to pass this file as a secret to the Gotoolbox module.
//
// Parameters:
//   - ctx: The context for controlling the function's timeout and cancellation.
//
// Returns:
//   - A configured Container with the .netrc file set as a secret, or an error if the process fails.
//
// Steps Involved:
//  1. Define GitHub password as a secret.
//  2. Configure the Gotoolbox module to use the .netrc file with the provided credentials.
//  3. Run a command inside the container to verify the .netrc file's contents.
func (m *Go) Gotoolbox_CreateNetRcFileForGithub(ctx context.Context) (*dagger.Container, error) {
	passwordAsSecret := dag.SetSecret("mysecret", "ohboywhatapassword")

	// Configure it for GitHub
	targetModule := dag.Gotoolbox().
		WithNewNetrcFileAsSecretGitHub("supersecretuser", passwordAsSecret)

	// Check if the .netrc file is created correctly
	out, err := targetModule.
		Ctr().
		WithExec([]string{"cat", "/root/.netrc"}).
		Stdout(ctx)

	if err != nil {
		return nil, fmt.Errorf("failed to get netrc file configured for github: %w", err)
	}

	expectedContent := "machine github.com\nlogin supersecretuser\npassword ohboywhatapassword"
	if !strings.Contains(out, expectedContent) {
		return nil, errNetRCFileNotFound
	}

	return targetModule.Ctr(), nil
}

no available example in current language

no available example in current language

Example (OpenTerminal)

no available example in current language

// Gotoolbox_OpenTerminal demonstrates how to open an interactive terminal session
// within a Gotoolbox module container.
//
// This function showcases the initialization and configuration of a
// Gotoolbox module container using various options like enabling Cgo,
// utilizing build cache, and including a GCC compiler.
//
// Parameters:
//   - None
//
// Returns:
//   - *dagger.Container: A configured Dagger container with an open terminal.
//
// Usage:
//
//	This function can be used to interactively debug or inspect the
//	container environment during test execution.
func (m *Go) Gotoolbox_OpenTerminal() *dagger.Container {
	// Configure the Gotoolbox module container with necessary options
	targetModule := dag.Gotoolbox()

	// Retrieve and discard standard output
	_, _ = targetModule.Ctr().
		Stdout(context.Background())

	// Open and return the terminal session in the configured container
	return targetModule.Ctr().
		Terminal()
}

no available example in current language

no available example in current language

Example (PassedEnvVars)

no available example in current language

// Gotoolbox_PassedEnvVars demonstrates how to pass environment variables to the Gotoolbox module.
//
// This method configures a Gotoolbox module to use specific environment variables from the host.
func (m *Go) Gotoolbox_PassedEnvVars(ctx context.Context) error {
	targetModule := dag.Gotoolbox(dagger.GotoolboxOpts{
		EnvVarsFromHost: []string{"SOMETHING=SOMETHING,SOMETHING=SOMETHING"},
	})

	out, err := targetModule.Ctr().
		WithExec([]string{"printenv"}).
		Stdout(ctx)

	if err != nil {
		return fmt.Errorf("failed when executing printenv: %w", err)
	}

	if out == "" {
		return errEnvVarsEmpty
	}

	if !strings.Contains(out, "SOMETHING") {
		return errEnvVarsDontMatch
	}

	return nil
}

no available example in current language

no available example in current language

Example (CreateContainer)

no available example in current language

// Gotoolbox_CreateContainer initializes and returns a configured Dagger container.
//
// This method exemplifies the setup of a container within the Gotoolbox module using the source directory.
//
// Parameters:
//   - ctx: The context for controlling the function's timeout and cancellation.
//
// Returns:
//   - A configured Dagger container if successful, or an error if the process fails.
//
// Steps Involved:
//  1. Configure the Gotoolbox module with the source directory.
//  2. Run a command inside the container to check the OS information.
func (m *Go) Gotoolbox_CreateContainer(ctx context.Context) (*dagger.Container, error) {
	targetModule := dag.
		Gotoolbox().
		WithSource(m.TestDir)

	// Get the OS or container information
	_, err := targetModule.
		Ctr().WithExec([]string{"uname"}).
		Stdout(ctx)

	if err != nil {
		return nil, fmt.Errorf("failed to get OS information: %w", err)
	}

	return targetModule.Ctr(), nil
}

no available example in current language

no available example in current language

Installation

dagger install github.com/Excoriate/daggerverse/gotoolbox@v0.10.0

Entrypoint

Return Type

Gotoolbox !

Arguments

Name	Type	Description
version	String	version is the version of the container image to use. Consider that this Dagger module uses al alpine-based image.
ctr	Container	ctr is the container to use as a base container.
envVarsFromHost	[String ! ]	envVarsFromHost is a list of environment variables to pass from the host to the container in a slice of strings.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
}

Types

Gotoolbox 🔗

Gotoolbox is a Dagger module. This module is used to create and manage containers.

ctr() 🔗

Ctr is the container to use as a base container.

Return Type

Container !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 ctr

func (m *myModule) example() *Container  {
	return dag.
			Gotoolbox().
			Ctr()
}

@function
def example() -> dagger.Container:
	return (
		dag.gotoolbox()
		.ctr()
	)

@func()
example(): Container {
	return dag
		.gotoolbox()
		.ctr()
}

withNewNetrcFileGitHub() 🔗

WithNewNetrcFileGitHub creates a new .netrc file with the GitHub credentials.

The .netrc file is created in the root directory of the container.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
username	String !	-	No description provided
password	String !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-new-netrc-file-git-hub --username string --password string

func (m *myModule) example(username string, password string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithNewNetrcFileGitHub(username, password)
}

@function
def example(username: str, password: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_new_netrc_file_git_hub(username, password)
	)

@func()
example(username: string, password: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withNewNetrcFileGitHub(username, password)
}

withNewNetrcFileAsSecretGitHub() 🔗

WithNewNetrcFileAsSecretGitHub creates a new .netrc file with the GitHub credentials.

The .netrc file is created in the root directory of the container. The argument ‘password’ is a secret that is not exposed in the logs.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
username	String !	-	No description provided
password	Secret !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-new-netrc-file-as-secret-git-hub --username string --password env:MYSECRET

func (m *myModule) example(username string, password *Secret) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithNewNetrcFileAsSecretGitHub(username, password)
}

@function
def example(username: str, password: dagger.Secret) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_new_netrc_file_as_secret_git_hub(username, password)
	)

@func()
example(username: string, password: Secret): Gotoolbox {
	return dag
		.gotoolbox()
		.withNewNetrcFileAsSecretGitHub(username, password)
}

withNewNetrcFileGitLab() 🔗

WithNewNetrcFileGitLab creates a new .netrc file with the GitLab credentials.

The .netrc file is created in the root directory of the container.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
username	String !	-	No description provided
password	String !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-new-netrc-file-git-lab --username string --password string

func (m *myModule) example(username string, password string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithNewNetrcFileGitLab(username, password)
}

@function
def example(username: str, password: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_new_netrc_file_git_lab(username, password)
	)

@func()
example(username: string, password: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withNewNetrcFileGitLab(username, password)
}

withNewNetrcFileAsSecretGitLab() 🔗

WithNewNetrcFileAsSecretGitLab creates a new .netrc file with the GitLab credentials.

The .netrc file is created in the root directory of the container. The argument ‘password’ is a secret that is not exposed in the logs.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
username	String !	-	No description provided
password	Secret !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-new-netrc-file-as-secret-git-lab --username string --password env:MYSECRET

func (m *myModule) example(username string, password *Secret) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithNewNetrcFileAsSecretGitLab(username, password)
}

@function
def example(username: str, password: dagger.Secret) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_new_netrc_file_as_secret_git_lab(username, password)
	)

@func()
example(username: string, password: Secret): Gotoolbox {
	return dag
		.gotoolbox()
		.withNewNetrcFileAsSecretGitLab(username, password)
}

downloadFile() 🔗

DownloadFile downloads a file from the specified URL.

Parameters: - url: The URL of the file to download. - destFileName: The name of the file to download. Optional parameter. If not set, it’ll default to the basename of the URL.

Returns: - *dagger.File: The downloaded file.

Functionality:

This method downloads a file from the provided URL. If the destination file name is not specified, it defaults to the basename of the URL. The downloaded file is then returned as a *dagger.File.

Return Type

File !

Arguments

Name	Type	Default Value	Description
url	String !	-	url is the URL of the file to download.
destFileName	String	-	destFileName is the name of the file to download. If not set, it'll default to the basename of the URL.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 download-file --url string

func (m *myModule) example(url string) *File  {
	return dag.
			Gotoolbox().
			DownloadFile(url)
}

@function
def example(url: str) -> dagger.File:
	return (
		dag.gotoolbox()
		.download_file(url)
	)

@func()
example(url: string): File {
	return dag
		.gotoolbox()
		.downloadFile(url)
}

cloneGitRepo() 🔗

CloneGitRepo clones a Git repository into a Dagger Directory.

Parameters: - repoURL: The URL of the git repository to clone (e.g., “https://github.com/user/repo”). - token: (Optional) The VCS token to use for authentication. If not provided, the repository will be cloned without authentication. - vcs: (Optional) The version control system (VCS) to use for authentication. Defaults to “github”. Supported values are “github” and “gitlab”.

Returns: - *dagger.Directory: A directory object representing the cloned repository.

If a token is provided, it will be securely set using Dagger’s secret mechanism and used for authentication during the clone operation.

Return Type

Directory !

Arguments

Name	Type	Default Value	Description
repoUrl	String !	-	repoURL is the URL of the git repo to clone.
token	String	-	token is the VCS token to use for authentication. Optional parameter.
vcs	String	-	vcs is the VCS to use for authentication. Optional parameter.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 clone-git-repo --repo-url string

func (m *myModule) example(repoUrl string) *Directory  {
	return dag.
			Gotoolbox().
			CloneGitRepo(repoUrl)
}

@function
def example(repo_url: str) -> dagger.Directory:
	return (
		dag.gotoolbox()
		.clone_git_repo(repo_url)
	)

@func()
example(repoUrl: string): Directory {
	return dag
		.gotoolbox()
		.cloneGitRepo(repoUrl)
}

openTerminal() 🔗

OpenTerminal returns a terminal

It returns a terminal for the container. Arguments: - None. Returns: - *Terminal: The terminal for the container.

Return Type

Container !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 open-terminal

func (m *myModule) example() *Container  {
	return dag.
			Gotoolbox().
			OpenTerminal()
}

@function
def example() -> dagger.Container:
	return (
		dag.gotoolbox()
		.open_terminal()
	)

@func()
example(): Container {
	return dag
		.gotoolbox()
		.openTerminal()
}

runShell() 🔗

RunShell runs a shell command in the container.

It runs a shell command in the container and returns the output. Arguments: - cmd: The command to run in the container. Returns: - string: The output of the command. - error: An error if the command fails.

Return Type

String !

Arguments

Name	Type	Default Value	Description
cmd	String !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 run-shell --cmd string

func (m *myModule) example(ctx context.Context, cmd string) string  {
	return dag.
			Gotoolbox().
			RunShell(ctx, cmd)
}

@function
async def example(cmd: str) -> str:
	return await (
		dag.gotoolbox()
		.run_shell(cmd)
	)

@func()
async example(cmd: string): Promise<string> {
	return dag
		.gotoolbox()
		.runShell(cmd)
}

printEnvVars() 🔗

PrintEnvVars retrieves and prints the environment variables of the container.

It executes the printenv command inside the container to get a list of all environment variables and their respective values.

Arguments: - None.

Returns: - string: A string containing all environment variables in the format “KEY=VALUE”, separated by newlines. - error: An error if the command fails, wrapped with additional context.

Usage example: “`go envVars, err := GotoolboxInstance.PrintEnvVars()

if err != nil {
    log.Fatalf("Error retrieving environment variables: %v", err)
}

fmt.Println(envVars).

Return Type

String !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 print-env-vars

func (m *myModule) example(ctx context.Context) string  {
	return dag.
			Gotoolbox().
			PrintEnvVars(ctx)
}

@function
async def example() -> str:
	return await (
		dag.gotoolbox()
		.print_env_vars()
	)

@func()
async example(): Promise<string> {
	return dag
		.gotoolbox()
		.printEnvVars()
}

inspectEnvVar() 🔗

InspectEnvVar inspects the value of an environment variable by its key Arguments: - key: The environment variable key to inspect. Returns: - string: The value of the environment variable. - error: An error if the key is invalid or the environment variable is not found.

Return Type

String !

Arguments

Name	Type	Default Value	Description
key	String !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 inspect-env-var --key string

func (m *myModule) example(ctx context.Context, key string) string  {
	return dag.
			Gotoolbox().
			InspectEnvVar(ctx, key)
}

@function
async def example(key: str) -> str:
	return await (
		dag.gotoolbox()
		.inspect_env_var(key)
	)

@func()
async example(key: string): Promise<string> {
	return dag
		.gotoolbox()
		.inspectEnvVar(key)
}

withGitInAlpineContainer() 🔗

WithGitInAlpineContainer installs Git in the golang/alpine container.

It installs Git in the golang/alpine container.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-git-in-alpine-container

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGitInAlpineContainer()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_git_in_alpine_container()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGitInAlpineContainer()
}

withUtilitiesInAlpineContainer() 🔗

WithUtilitiesInAlpineContainer installs common utilities in the golang/alpine container.

It installs utilities such as curl, wget, and others that are commonly used.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-utilities-in-alpine-container

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithUtilitiesInAlpineContainer()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_utilities_in_alpine_container()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withUtilitiesInAlpineContainer()
}

withEnvironmentVariable() 🔗

WithEnvironmentVariable sets an environment variable in the container.

Parameters: - name: The name of the environment variable (e.g., “HOST”). - value: The value of the environment variable (e.g., “localhost”). - expand: Whether to replace ${VAR} or $VAR in the value according to the current environment variables defined in the container (e.g., "/opt/bin:$PATH”). Optional parameter.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
name	String !	-	name is the name of the environment variable.
value	String !	-	value is the value of the environment variable.
expand	Boolean	-	expand is whether to replace `${VAR}` or $VAR in the value according to the current

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-environment-variable --name string --value string

func (m *myModule) example(name string, value string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithEnvironmentVariable(name, value)
}

@function
def example(name: str, value: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_environment_variable(name, value)
	)

@func()
example(name: string, value: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withEnvironmentVariable(name, value)
}

withSource() 🔗

WithSource sets the source directory for the container.

Parameters: - src: The directory that contains all the source code, including the module directory. - workdir: The working directory within the container. Optional parameter.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
src	Directory !	-	src is the directory that contains all the source code, including the module directory.
workdir	String	-	workdir is the working directory within the container. If not set it'll default to /mnt

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-source --src DIR_PATH

func (m *myModule) example(src *Directory) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithSource(src)
}

@function
def example(src: dagger.Directory) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_source(src)
	)

@func()
example(src: Directory): Gotoolbox {
	return dag
		.gotoolbox()
		.withSource(src)
}

withContainer() 🔗

WithContainer sets the container to be used.

Parameters: - ctr: The container to run the command in. If passed, it will override the container set in the Dagger instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
ctr	Container !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-container --ctr IMAGE:TAG

func (m *myModule) example(ctr *Container) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithContainer(ctr)
}

@function
def example(ctr: dagger.Container) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_container(ctr)
	)

@func()
example(ctr: Container): Gotoolbox {
	return dag
		.gotoolbox()
		.withContainer(ctr)
}

withSecretAsEnvVar() 🔗

WithSecretAsEnvVar sets an environment variable in the container using a secret.

Parameters: - name: The name of the environment variable (e.g., “API_KEY”). - secret: The secret containing the value of the environment variable.

Returns: - *Gotoolbox: The updated Gotoolbox with the environment variable set.

Behavior: - The secret value is expanded according to the current environment variables defined in the container.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
name	String !	-	No description provided
secret	Secret !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-secret-as-env-var --name string --secret env:MYSECRET

func (m *myModule) example(name string, secret *Secret) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithSecretAsEnvVar(name, secret)
}

@function
def example(name: str, secret: dagger.Secret) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_secret_as_env_var(name, secret)
	)

@func()
example(name: string, secret: Secret): Gotoolbox {
	return dag
		.gotoolbox()
		.withSecretAsEnvVar(name, secret)
}

withDownloadedFile() 🔗

WithDownloadedFile downloads a file from the specified URL and mounts it in the container.

Parameters: - url: The URL of the file to download. - destDir: The directory within the container where the file will be downloaded. Optional parameter. If not provided, it defaults to the predefined mount prefix.

Returns: - *Gotoolbox: The updated Gotoolbox with the downloaded file mounted in the container.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
url	String !	-	url is the URL of the file to download.
destFileName	String	-	destFileName is the name of the file to download. If not set, it'll default to the basename of the URL.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-downloaded-file --url string

func (m *myModule) example(url string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithDownloadedFile(url)
}

@function
def example(url: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_downloaded_file(url)
	)

@func()
example(url: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withDownloadedFile(url)
}

withClonedGitRepo() 🔗

WithClonedGitRepo clones a Git repository and mounts it as a directory in the container.

This method downloads a Git repository and mounts it as a directory in the container. It supports optional authentication tokens for private repositories and can handle both GitHub and GitLab repositories.

Returns: - *Gotoolbox: The updated Gotoolbox with the cloned repository mounted in the container.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
repoUrl	String !	-	No description provided
token	String	-	token is the VCS token to use for authentication. Optional parameter.
vcs	String	-	vcs is the VCS to use for authentication. Optional parameter.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-cloned-git-repo --repo-url string

func (m *myModule) example(repoUrl string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithClonedGitRepo(repoUrl)
}

@function
def example(repo_url: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_cloned_git_repo(repo_url)
	)

@func()
example(repoUrl: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withClonedGitRepo(repoUrl)
}

withCacheBuster() 🔗

WithCacheBuster sets a cache-busting environment variable in the container.

This method sets an environment variable “CACHE_BUSTER” with a timestamp value in RFC3339Nano format. This can be useful for invalidating caches by providing a unique value.

Returns: - *Gotoolbox: The updated Gotoolbox with the cache-busting environment variable set.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-cache-buster

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithCacheBuster()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_cache_buster()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withCacheBuster()
}

base() 🔗

Base sets the base image and version, and creates the base container.

The default image is “alpine/latest” and the default version is “latest”.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
imageUrl	String !	-	No description provided

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 base --image-url string

func (m *myModule) example(imageUrl string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			Base(imageUrl)
}

@function
def example(image_url: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.base(image_url)
	)

@func()
example(imageUrl: string): Gotoolbox {
	return dag
		.gotoolbox()
		.base(imageUrl)
}

runGoCmd() 🔗

RunGoCMD runs a Go command within a given context.

cmd is the Go command to run, everything after the ‘go’ command. src is the optional source directory for the container.

It returns the standard output of the executed command or an error if something goes wrong.

Return Type

String !

Arguments

Name	Type	Default Value	Description
cmd	[String ! ] !	-	cmd is the Go command to run, everything after the 'go' command.
src	Directory	-	src is the optional source directory for the container.
testDir	String	-	testDir is the optional test directory for the container. If you are passing a source code directory in the 'src' parameter, you can pass the test directory to run the tests.
platform	Scalar	-	platform is the optional platform to run the Go command.
envVariables	[String ! ]	-	envVariables are the optional environment variables to set for the container. the envVariables are set in a form of a string array, where each element is a key-value pair, separated by coma. E.g. ["KEY=value", "KEY2=value2"].
enableCacheBuster	Boolean	-	enableCacheBuster is a flag to force the cache to bust.
enableCgo	Boolean	-	enableCgo is a flag to enable CGO.
enableGoModCache	Boolean	-	enableGoModCache is a flag to enable Go mod cache.
enableGoBuildCache	Boolean	-	enableGoBuildCache is a flag to enable Go build cache.
installPkgs	[String ! ]	-	installPkgs are the packages to install.
enableGoGcccompiler	Boolean	-	enableGoGCCCompiler is a flag to enable GoGCCCompiler.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 run-go-cmd --cmd string1 --cmd string2

func (m *myModule) example(ctx context.Context, cmd []string) string  {
	return dag.
			Gotoolbox().
			RunGoCmd(ctx, cmd)
}

@function
async def example(cmd: List[str]) -> str:
	return await (
		dag.gotoolbox()
		.run_go_cmd(cmd)
	)

@func()
async example(cmd: string[]): Promise<string> {
	return dag
		.gotoolbox()
		.runGoCmd(cmd)
}

runAnyCmd() 🔗

RunAnyCmd runs a command within a given context.

cmd is the command to run, with the first element being the command and the rest being arguments. src is the optional source directory for the container.

It returns the standard output of the executed command or an error if something goes wrong.

Return Type

String !

Arguments

Name	Type	Default Value	Description
cmd	[String ! ] !	-	cmd is the command to run, with the first element being the command and the rest being arguments.
src	Directory	-	src is the optional source directory for the container.
workDir	String	-	workDir is the optional working directory for the container. If you are passing a source code directory in the 'src' parameter, you can pass the working directory to run the command.
platform	Scalar	-	platform is the optional platform to run the command.
envVariables	[String ! ]	-	envVariables are the optional environment variables to set for the container. the envVariables are set in a form of a string array, where each element is a key-value pair, separated by an equals sign. E.g. ["KEY=value", "KEY2=value2"].
enableCacheBuster	Boolean	-	enableCacheBuster is a flag to force the cache to bust.
installPkgs	[String ! ]	-	installPkgs are the packages to install.
enableGoGcccompiler	Boolean	-	enableGoGCCCompiler is a flag to enable GoGCCCompiler.
enableGoModCache	Boolean	-	enableGoModCache is a flag to enable Go mod cache.
enableGoBuildCache	Boolean	-	enableGoBuildCache is a flag to enable Go build cache.
enableGoReleaser	Boolean	-	enableGoReleaser is a flag to enable GoReleaser.
enableGolangCilint	Boolean	-	enableGolangCILint is a flag to enable GolangCI-Lint.
enableGoTestSum	Boolean	-	enableGoTestSum is a flag to enable Go test summaries.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 run-any-cmd --cmd string1 --cmd string2

func (m *myModule) example(ctx context.Context, cmd []string) string  {
	return dag.
			Gotoolbox().
			RunAnyCmd(ctx, cmd)
}

@function
async def example(cmd: List[str]) -> str:
	return await (
		dag.gotoolbox()
		.run_any_cmd(cmd)
	)

@func()
async example(cmd: string[]): Promise<string> {
	return dag
		.gotoolbox()
		.runAnyCmd(cmd)
}

newGoServer() 🔗

NewGoServer initializes and returns a new instance of GoServer with the given service name and port.

Parameters:

serviceName string: The name of the service to be created (optional, defaults to “go-server”). port int: The port to expose from the service.

Returns:

*GoServer: An instance of GoServer configured with a container created from the default image and version.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
ctr	Container	-	ctr is the container to use as a base container. If it's not set, it'll create a new container.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
}

withGoPlatform() 🔗

WithGoPlatform sets the Go environment variables for the target platform.

platform is the target platform specified in the format “[os]/[platform]/[version]”. For example, “darwin/arm64/v7”, “windows/amd64”, “linux/arm64”. If the platform is not provided, it defaults to “linux/amd64”.

Params: - platform (dagger.Platform): The target platform.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
platform	Scalar	-	platform is the target platform specified in the format "[os]/[platform]/[version]". For example, "darwin/arm64/v7", "windows/amd64", "linux/arm64". If the platform is not provided, it defaults to "linux/amd64".

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-platform

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoPlatform()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_platform()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoPlatform()
}

withGoCgoEnabled() 🔗

WithGoCgoEnabled enables CGO for the container environment.

When CGO is enabled, the Go toolchain will allow the use of cgo, which means it can link against C libraries and send code to the C compiler.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-cgo-enabled

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoCgoEnabled()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_cgo_enabled()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoCgoEnabled()
}

withCgoDisabled() 🔗

WithCgoDisabled disables CGO for the container environment.

When CGO is disabled, the Go toolchain will not permit the use of cgo, which means it will not link against C libraries or send code to the C compiler. This can be beneficial for creating fully static binaries or for environments where C dependencies are not available.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-cgo-disabled

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithCgoDisabled()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_cgo_disabled()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withCgoDisabled()
}

withGoBuildCache() 🔗

WithGoBuildCache configures a Go build cache for the container environment.

This method sets up the cache volume for Go build artifacts, which speeds up the build process by reusing previously compiled packages and dependencies.

Params: - cacheRoot (string) +optional: The path to the cache volume’s root. If not provided, it defaults to “/root/.cache/go-build”. - cache (*dagger.CacheVolume) +optional: The cache volume to use. If not provided, a default volume named “gobuildcache” is used. - source (*dagger.Directory) +optional: The directory to use as the source for the cache volume’s root. - sharing (dagger.CacheSharingMode) +optional: The sharing mode of the cache volume. If not provided, it defaults to “shared”.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
cacheRoot	String	-	cacheRoot is the path to the cache volume's root.
cache	CacheVolume	-	cache is the cache volume to use.
source	Directory	-	source is the identifier of the directory to use as the cache volume's root.
sharing	Enum	-	sharing is the Sharing mode of the cache volume.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-build-cache

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoBuildCache()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_build_cache()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoBuildCache()
}

withGoModCache() 🔗

WithGoModCache configures a Go module cache for the container environment.

This method sets up the cache volume for Go modules, which speeds up the build process by reusing previously downloaded dependencies.

Params: - cacheRoot (string): The path to the cache volume’s root. If not provided, it defaults to “/go/pkg/mod”. - cache (*dagger.CacheVolume) +optional: The cache volume to use. If not provided, a default volume named “gomodcache” is used. - source (*dagger.Directory) +optional: The directory to use as the source for the cache volume’s root. - sharing (dagger.CacheSharingMode) +optional: The sharing mode of the cache volume. If not provided, it defaults to “shared”.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
cacheRoot	String	-	cacheRoot is the path to the cache volume's root.
cache	CacheVolume	-	cache is the cache volume to use.
source	Directory	-	source is the identifier of the directory to use as the cache volume's root.
sharing	Enum	-	sharing is the Sharing mode of the cache volume.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-mod-cache

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoModCache()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_mod_cache()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoModCache()
}

withGoInstall() 🔗

WithGoInstall installs Go packages in the container environment.

This method uses the Go toolchain to install packages from specified URLs. It performs the equivalent of running “go install [url]” inside the container.

Params: - pkgs ([]string): A slice of URLs for the Go packages to install. These should be valid package URLs that the go install command can use.

Example:

Gotoolbox.WithGoInstall([]string{"github.com/Excoriate/daggerverse@latest", "github.com/another/package@v1.0"})

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
pkgs	[String ! ] !	-	pkgs are the URLs of the packages to install.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-install --pkgs string1 --pkgs string2

func (m *myModule) example(pkgs []string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoInstall(pkgs)
}

@function
def example(pkgs: List[str]) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_install(pkgs)
	)

@func()
example(pkgs: string[]): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoInstall(pkgs)
}

withGoExec() 🔗

WithGoExec runs a Go command in the container environment.

This method allows you to execute arbitrary Go commands, such as “go build” or “go test”, for a specified platform. If no platform is provided, it defaults to “linux/amd64”.

Params: - args ([]string): The arguments to pass to the Go command. For example, [“build”, “./…”] to run a Go build command on all packages. - platform (dagger.Platform) +optional: The target platform specified in the format “[os]/[platform]/[version]”. For example, “darwin/arm64/v7”, “windows/amd64”, “linux/arm64”. If the platform is not provided, it defaults to “linux/amd64”.

Example:

Gotoolbox.WithGoExec([]string{"build", "./..."}, "linux/amd64")

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
args	[String ! ] !	-	args are the arguments to pass to the Go command.
platform	Scalar	-	platform is the target platform specified in the format "[os]/[platform]/[version]". For example, "darwin/arm64/v7", "windows/amd64", "linux/arm64". If the platform is not provided, it defaults to "linux/amd64".

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-exec --args string1 --args string2

func (m *myModule) example(args []string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoExec(args)
}

@function
def example(args: List[str]) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_exec(args)
	)

@func()
example(args: string[]): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoExec(args)
}

withGoBuild() 🔗

WithGoBuild configures and executes a Go build command within the container environment.

This method builds a Go package based on specified parameters such as package name, race detection, build flags, tags, and output binary name.

Params: - pkg (string) +optional: The Go package to compile. If empty, the package in the current directory is compiled. - race (bool) +optional: Enable data race detection if true. - ldflags ([]string) +optional: Arguments to pass on each go tool link invocation. - tags ([]string) +optional: A list of additional build tags to consider satisfied during the build. - trimpath (bool) +optional: Remove all file system paths from the resulting executable if true. - rawArgs ([]string) +optional: Additional arguments to pass to the build command. - platform (dagger.Platform) +optional: Target platform in “[os]/[platform]/[version]” format, defaults to “linux/amd64”. - output (string) +optional: The output binary name or path. - optimizeSize (bool) +optional: Optimize for size if true. - verbose (bool) +optional: Verbose output if true. - buildMode (string) +optional: Specify the build mode.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
pkg	String	-	pkg is the Go package to compile.
race	Boolean	-	race enables data race detection.
ldflags	[String ! ]	-	ldflags are arguments to pass on each go tool link invocation.
tags	[String ! ]	-	tags are additional build tags to consider satisfied during the build.
trimpath	Boolean	-	trimpath removes all file system paths from the resulting executable.
rawArgs	[String ! ]	-	rawArgs are additional arguments to pass to the build command.
platform	Scalar	-	platform is the target platform in "[os]/[platform]/[version]" format, defaults to "linux/amd64".
output	String	-	output specifies the output binary name or path.
optimizeSize	Boolean	-	optimizeSize optimizes for size.
verbose	Boolean	-	verbose enables verbose output.
buildMode	String	-	buildMode specifies the build mode.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-build

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoBuild()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_build()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoBuild()
}

withGoPrivate() 🔗

WithGoPrivate configures the GOPRIVATE environment variable for the container environment.

This method sets the GOPRIVATE variable, which is used by the Go toolchain to identify private modules or repositories that should not be fetched from public proxies.

Parameters: - privateHost (string): The hostname of the private host for the Go packages or modules.

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
privateHost	String !	-	privateHost is the hostname of the private host for the Go packages or modules.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-private --private-host string

func (m *myModule) example(privateHost string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoPrivate(privateHost)
}

@function
def example(private_host: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_private(private_host)
	)

@func()
example(privateHost: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoPrivate(privateHost)
}

withGoGcccompiler() 🔗

WithGoGCCCompiler installs the GCC compiler and development tools in the container environment.

This method uses the Alpine package manager (apk) to install the GCC compiler along with musl-dev, which is the development package of the standard C library on Alpine.

Example usage:

Gotoolbox.WithGCCCompiler()

Returns: - *Gotoolbox: A pointer to the updated Gotoolbox instance.

Return Type

Gotoolbox !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-gcccompiler

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoGcccompiler()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_gcccompiler()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoGcccompiler()
}

withGoTestSum() 🔗

WithGoTestSum installs the GoTestSum tool and optionally its dependency tparse in the container environment.

This method installs gotest.tools/gotestsum using the specified version, and optionally installs github.com/mfridman/tparse using a specified version, unless the skipTParse flag is set to true.

Parameters: - goTestSumVersion (string) +optional: The version of GoTestSum to use, e.g., “v0.8.0”. If empty, it defaults to “latest”. - tParseVersion (string) +optional: The version of TParse to use, e.g., “v0.8.0”. If empty, it defaults to the same version as goTestSumVersion. - skipTParse (bool) +optional: If true, TParse will not be installed. Default is false.

Example:

m := &ModuleTemplate{}
m.WithGoTestSum("v0.8.0", "v0.7.0", false)   // Install specific versions
m.WithGoTestSum("", "", true)                // Install latest version of GoTestSum and skip TParse

Returns: - *ModuleTemplate: A pointer to the updated ModuleTemplate instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
goTestSumVersion	String	-	goTestSumVersion is the version of GoTestSum to use, e.g., "v0.8.0".
tParseVersion	String	-	tParseVersion is the version of TParse to use, e.g., "v0.8.0".
skipTparse	Boolean	-	skipTParse is a flag to indicate whether TParse should be skipped.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-test-sum

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoTestSum()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_test_sum()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoTestSum()
}

withGoReleaser() 🔗

WithGoReleaser installs the GoReleaser tool in the container environment.

This method installs goreleaser using the specified version. Check https://goreleaser.com/install/

Parameters: - version (string): The version of GoReleaser to use, e.g., “v2@latest”.

Example:

m := &ModuleTemplate{}
m.WithGoReleaser("v2.2.0")  // Install GoReleaser version 2.2.0

Returns: - *ModuleTemplate: A pointer to the updated ModuleTemplate instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
version	String	-	version is the version of GoReleaser to use, e.g., By default, it's set "v2@latest".

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-releaser

func (m *myModule) example() *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoReleaser()
}

@function
def example() -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_releaser()
	)

@func()
example(): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoReleaser()
}

withGoLint() 🔗

WithGoLint installs the GoLint tool in the container environment.

This method installs golangci-lint using the specified version.

Parameters: - version (string): The version of GoLint to use, e.g., “v1.60.1”.

Example:

m := &ModuleTemplate{}
m.WithGoLint("v1.60.1")  // Install GoLint version 1.60.1

Returns: - *ModuleTemplate: A pointer to the updated ModuleTemplate instance.

Return Type

Gotoolbox !

Arguments

Name	Type	Default Value	Description
version	String !	-	version is the version of GoLint to use, e.g., "v1.60.1".

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 with-go-lint --version string

func (m *myModule) example(version string) *Gotoolbox  {
	return dag.
			Gotoolbox().
			WithGoLint(version)
}

@function
def example(version: str) -> dag.Gotoolbox:
	return (
		dag.gotoolbox()
		.with_go_lint(version)
	)

@func()
example(version: string): Gotoolbox {
	return dag
		.gotoolbox()
		.withGoLint(version)
}

GoServer 🔗

GoServer represents a Go-based server configuration.

withServerData() 🔗

WithServerData configures the GoServer to use a cache volume at a specified path with specified sharing mode and ownership.

This method mounts a cache volume inside the container at the provided path, with specified sharing mode and ownership details. If any of these parameters are not provided, default values will be used.

Parameters:

path string: (optional) The path to the cache volume’s root. Defaults to “/data” if not provided. share dagger.CacheSharingMode: (optional) The sharing mode of the cache volume. Defaults to “shared” if not provided. owner string: (optional) The owner of the cache volume. Defaults to “1000:1000” if not provided.

Returns:

*GoServer: An instance of GoServer configured with the specified cache volume settings.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
path	String	-	path is the path to the cache volume's root. If not provided, it defaults to "/data".
share	Enum	-	share is the sharing mode of the cache volume. If not provided, it defaults to "shared".
owner	String	-	owner is the owner of the cache volume. If not provided, it defaults to "1000:1000".
workdir	String	-	workdir is the working directory within the container. If not set it'll default to /mnt

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-server-data

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithServerData()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_server_data()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withServerData()
}

withBinaryName() 🔗

WithBinaryName sets the name of the binary to be built for the GoServer.

This method allows specifying a custom name for the binary to be built and used within the server container. If the binary name is not explicitly set, the default binary name (“app”) will be used.

Parameters:

binaryName string: The name of the binary to build.

Returns:

*GoServer: An instance of GoServer configured with the specified binary name.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
binaryName	String !	-	binaryName is the name of the binary to build.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-binary-name --binary-name string

func (m *myModule) example(binaryName string) *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithBinaryName(binaryName)
}

@function
def example(binary_name: str) -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_binary_name(binary_name)
	)

@func()
example(binaryName: string): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withBinaryName(binaryName)
}

withPreBuiltContainer() 🔗

WithPreBuiltContainer configures the GoServer to use a pre-existing container as its base.

This method allows setting an already created container as the base for the GoServer, overriding any previously set container.

Parameters:

ctr *dagger.Container: The container to use as a base container.

Returns:

*GoServer: An instance of GoServer configured with the provided container.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
ctr	Container !	-	ctr is the container to use as a base container.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-pre-built-container --ctr IMAGE:TAG

func (m *myModule) example(ctr *Container) *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithPreBuiltContainer(ctr)
}

@function
def example(ctr: dagger.Container) -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_pre_built_container(ctr)
	)

@func()
example(ctr: Container): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withPreBuiltContainer(ctr)
}

withExposePort() 🔗

WithExposePort sets the port to expose from the service.

This method allows setting the port to expose from the service.

Parameters:

port int: The port to expose from the service.

Returns:

*GoServer: An instance of GoServer configured with the provided port.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
port	Integer !	-	ports is a list of ports to expose from the service.
skipHealthcheck	Boolean	-	skipHealthcheck is a flag to skip the health check when run as a service.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-expose-port --port integer

func (m *myModule) example(port int) *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithExposePort(port)
}

@function
def example(port: int) -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_expose_port(port)
	)

@func()
example(port: number): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withExposePort(port)
}

withSource() 🔗

WithSource mounts the source directory inside the container and sets the working directory.

This method configures the GoServer to mount the provided source directory at a fixed mount point and optionally set a specific working directory within the container. If the working directory is not provided, it defaults to the mount point.

Parameters:

src *dagger.Directory: The directory containing all the source code, including the module directory.
workdir string: (optional) The working directory within the container, defaults to "/mnt".

Returns:

*GoServer: An instance of GoServer configured with the provided source directory and working directory.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
src	Directory !	-	src is the directory that contains all the source code, including the module directory.
workdir	String	-	workdir is the working directory within the container. If not set it'll default to /mnt

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-source --src DIR_PATH

func (m *myModule) example(src *Directory) *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithSource(src)
}

@function
def example(src: dagger.Directory) -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_source(src)
	)

@func()
example(src: Directory): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withSource(src)
}

withCompileOptions() 🔗

WithCompileOptions executes a user-defined compilation command within the container.

This method allows appending custom arguments to the “go build -o app” command for compiling the Go server. It always defaults to “go build -o app” but allows additional arguments such as verbose output, module mode, and build tags to customize the build process.

Parameters:

extraArgs []string: (optional) Extra arguments to append to the "go build -o app" command.
verbose bool: (optional) Flag to enable verbose output (adds the -v flag to the command).
mod string: (optional) Sets the module download mode (adds the -mod flag to the command).
tags string: (optional) A comma-separated list of build tags to consider
satisfied during the build (adds the -tags flag to the command).

Returns:

*GoServer: An instance of GoServer configured with the custom compilation command and any additional flags.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
extraArgs	[String ! ]	-	extraArgs are additional arguments to append to the go build command.
verbose	Boolean	-	verbose is a flag to enable verbose output.
mod	String	-	mod is the module download mode for the build.
tags	String	-	tags is a comma-separated list of build tags to consider satisfied during the build.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-compile-options

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithCompileOptions()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_compile_options()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withCompileOptions()
}

withRunOptions() 🔗

WithRunOptions adds extra arguments to the command when running the Go server binary.

This method allows additional arguments to be appended when running the server binary. Normally, the server is run as “./binary”, but if the binary that represents the Go server receives flags or additional arguments, these should be passed through this function.

Parameters:

runCmd []string: A list of additional command-line arguments to pass
when executing the server binary.

Returns:

*GoServer: An instance of GoServer configured to run the binary with the specified arguments.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
runFlags	[String ! ] !	-	runCmd is a list of additional command-line arguments to pass when executing the server binary.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-run-options --run-flags string1 --run-flags string2

func (m *myModule) example(runFlags []string) *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithRunOptions(runFlags)
}

@function
def example(run_flags: List[str]) -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_run_options(run_flags)
	)

@func()
example(runFlags: string[]): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withRunOptions(runFlags)
}

withGoProxy() 🔗

WithGoProxy sets the Go Proxy URL for the service.

Parameters:

goproxy string: URL for the Go Proxy. If empty, defaults to "https://proxy.golang.org,direct".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
goproxy	String	-	goproxy is the Go Proxy URL for the service.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-go-proxy

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithGoProxy()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_go_proxy()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withGoProxy()
}

withDnsresolver() 🔗

WithDNSResolver sets the DNS resolver for the service.

Parameters:

dnsResolver string: DNS resolver used by the service. If empty, defaults to "8.8.8.8 8.8.4.4".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
dnsResolver	String	-	dnsResolver is the DNS resolver used by the service.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-dnsresolver

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithDnsresolver()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_dnsresolver()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withDnsresolver()
}

withGarbageCollectionSettings() 🔗

WithGarbageCollectionSettings sets the garbage collection optimization for the Go runtime.

Parameters:

gogc string: Garbage collection optimization value. If empty, defaults to "100".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
gogc	String	-	gogc is the garbage collection optimization for the Go runtime.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-garbage-collection-settings

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithGarbageCollectionSettings()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_garbage_collection_settings()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withGarbageCollectionSettings()
}

withGoEnvironment() 🔗

WithGoEnvironment sets the Go environment for the service.

Parameters:

goEnv string: The Go environment. If empty, defaults to "production".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
goEnv	String	-	goEnv is the Go environment.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-go-environment

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithGoEnvironment()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_go_environment()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withGoEnvironment()
}

withMaxProcs() 🔗

WithMaxProcs sets the maximum number of CPU cores to use.

Parameters:

goMaxProcs int: Maximum number of CPU cores to use. If 0, defaults to the number of available CPU cores.

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
goMaxProcs	Integer	-	goMaxProcs is the maximum number of CPU cores to use.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-max-procs

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithMaxProcs()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_max_procs()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withMaxProcs()
}

withDebugOptions() 🔗

WithDebugOptions sets debug options for the Go runtime.

Parameters:

goDebug string: Debug options for Go. If empty, defaults to "http2debug=1".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
goDebug	String	-	goDebug is the debug options for the Go runtime.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-debug-options

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithDebugOptions()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_debug_options()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withDebugOptions()
}

withRuntimeThreadLock() 🔗

WithRuntimeThreadLock optimizes the number of threads in system calls.

Parameters:

runtimeLockOsThread string: Optimizes number of threads in system calls. If empty, defaults to "1".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
runtimeLockOsThread	String	-	runtimeLockOsThread Optimizes number of threads in system calls.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-runtime-thread-lock

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithRuntimeThreadLock()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_runtime_thread_lock()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withRuntimeThreadLock()
}

withHttpsettings() 🔗

WithHTTPSettings sets HTTP-related settings for the service.

Parameters:

maxConns string: Maximum number of concurrent HTTP connections. If empty, defaults to "1000".
keepAlive string: Enables HTTP Keep-Alive. If empty, defaults to "1".

Returns:

*GoServer: The GoServer instance for method chaining.

Return Type

GoServer !

Arguments

Name	Type	Default Value	Description
maxConns	String	-	maxConns is the maximum number of concurrent HTTP connections.
keepAlive	String	-	keepAlive is the HTTP Keep-Alive setting.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 with-httpsettings

func (m *myModule) example() *GotoolboxGoServer  {
	return dag.
			Gotoolbox().
			NewGoServer().
			WithHttpsettings()
}

@function
def example() -> dag.GotoolboxGoServer:
	return (
		dag.gotoolbox()
		.new_go_server()
		.with_httpsettings()
	)

@func()
example(): GotoolboxGoServer {
	return dag
		.gotoolbox()
		.newGoServer()
		.withHttpsettings()
}

initService() 🔗

InitService sets up a basic Go service with the provided container and exposes the specified ports.

Returns:

*dagger.Service: The configured service with the specified ports exposed.

Return Type

Service !

Arguments

Name	Type	Default Value	Description
ctr	Container	-	ctr is the container to use as a base container.

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 init-service

func (m *myModule) example() *Service  {
	return dag.
			Gotoolbox().
			NewGoServer().
			InitService()
}

@function
def example() -> dagger.Service:
	return (
		dag.gotoolbox()
		.new_go_server()
		.init_service()
	)

@func()
example(): Service {
	return dag
		.gotoolbox()
		.newGoServer()
		.initService()
}

initContainer() 🔗

InitContainer initializes the container with the default build and run commands.

This method sets up the container for the Go server. If custom compilation or run commands have not been provided, it defaults to building the server binary using “go build” and running the server binary directly.

Returns:

*dagger.Container: The initialized container with the default or custom commands.

Return Type

Container !

Example

dagger -m github.com/Excoriate/daggerverse/gotoolbox@78e585c4d78c8b85c30db7f48144bc1c8eeeeb7c call \
 new-go-server \
 init-container

func (m *myModule) example() *Container  {
	return dag.
			Gotoolbox().
			NewGoServer().
			InitContainer()
}

@function
def example() -> dagger.Container:
	return (
		dag.gotoolbox()
		.new_go_server()
		.init_container()
	)

@func()
example(): Container {
	return dag
		.gotoolbox()
		.newGoServer()
		.initContainer()
}