script

package
v0.5.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 5, 2020 License: Apache-2.0 Imports: 22 Imported by: 2

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExpandColonDelimitedStringListWithEnv 

func ExpandColonDelimitedStringListWithEnv(arr []string) []string
Example 
package main

import (
	"fmt"
	"os"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
)

func main() {
	os.Setenv("FOO", "1")
	val := []string{
		"$FOO:$FOO",
	}
	fmt.Println(script.ExpandColonDelimitedStringListWithEnv(val))
}

Output:

[1:$FOO]

func ExpandColonDelimitedStringWithEnv 

func ExpandColonDelimitedStringWithEnv(s string) string
Example 
package main

import (
	"fmt"
	"os"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
)

func main() {
	os.Setenv("FOO", "2")
	val := "$FOO:$FOO"
	fmt.Println(script.ExpandColonDelimitedStringWithEnv(val))
}

Output:

2:$FOO

func ExpandEnv 

func ExpandEnv(str string) string
Example 
package main

import (
	"fmt"
	"os"
	"strconv"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
)

func main() {
	os.Setenv("FOO_BAR_1", "1")
	// expand env
	fmt.Println(script.ExpandEnv("$FOO_BAR_1"))
	fmt.Println(script.ExpandEnv("${FOO_BAR_1}"))
	fmt.Println(script.ExpandEnv(strconv.Quote("$FOO_BAR_1")))
	fmt.Println(script.ExpandEnv(strconv.Quote("${FOO_BAR_1}")))

	// expand env in string
	fmt.Println(script.ExpandEnv("#$FOO_BAR_1#"))
	fmt.Println(script.ExpandEnv("#${FOO_BAR_1}#"))
	fmt.Println(script.ExpandEnv("#\"$FOO_BAR_1\"#"))
	fmt.Println(script.ExpandEnv("#\"${FOO_BAR_1}\"#"))

	// special environment
	fmt.Println(script.ExpandEnv("$PWD"))
	fmt.Println(script.ExpandEnv("${PWD}"))
	fmt.Println(script.ExpandEnv("##$PWD##"))
	fmt.Println(script.ExpandEnv("##${PWD}##"))

	// no expand env
	fmt.Println(script.ExpandEnv("'$FOO_BAR_1'"))
	fmt.Println(script.ExpandEnv("`echo $FOO_BAR_1`"))
	fmt.Println(script.ExpandEnv("$(echo $FOO_BAR_1)"))
	fmt.Println(script.ExpandEnv("$@")) // not expand shell special variables

	// empty
	fmt.Println(script.ExpandEnv("$"))
	fmt.Println(script.ExpandEnv("${}"))
	fmt.Println(script.ExpandEnv("\"\""))
	fmt.Println(script.ExpandEnv("''"))
	fmt.Println(script.ExpandEnv("``"))
	fmt.Println(script.ExpandEnv("$()"))

	// broken pair
	fmt.Println(script.ExpandEnv("${"))
	fmt.Println(script.ExpandEnv("\""))
	fmt.Println(script.ExpandEnv("'"))
	fmt.Println(script.ExpandEnv("`"))
	fmt.Println(script.ExpandEnv("$("))
	fmt.Println(script.ExpandEnv("${ABC"))
	fmt.Println(script.ExpandEnv("${..."))
	fmt.Println(script.ExpandEnv("\"..."))
	fmt.Println(script.ExpandEnv("'..."))
	fmt.Println(script.ExpandEnv("`..."))
	fmt.Println(script.ExpandEnv("$(..."))

}

Output:

1
1
"1"
"1"
#1#
#1#
#"1"#
#"1"#
${ALIASES_PWD:-$PWD}
${ALIASES_PWD:-$PWD}
##${ALIASES_PWD:-$PWD}##
##${ALIASES_PWD:-$PWD}##
'$FOO_BAR_1'
`echo $FOO_BAR_1`
$(echo $FOO_BAR_1)
$@
$
${}
""
''
``
$()
${
"
'
`
$(
${ABC
${...
"...
'...
`...
$(...

func ExpandStringKeyMapWithEnv 

func ExpandStringKeyMapWithEnv(m map[string]string) map[string]string
Example 
package main

import (
	"fmt"
	"os"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
)

func main() {
	os.Setenv("FOO", "1")
	val := map[string]string{
		"$FOO": "$FOO",
	}
	fmt.Println(script.ExpandStringKeyMapWithEnv(val))
}

Output:

map[1:$FOO]

Types

type DockerBinaryAdapter 

type DockerBinaryAdapter yaml.Option

DockerBinaryAdapter adapts binary information from spec to a form that can be used in aliases.

func (*DockerBinaryAdapter) Command 

func (adpt *DockerBinaryAdapter) Command(client *docker.Client) *posix.Cmd

Command returns a command to download the docker binary.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"

	"github.com/k-kinzal/aliases/pkg/docker"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleDockerBinaryAdapter_Command"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleDockerBinaryAdapter_Command"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
		},
	}
	bin := script.AdaptDockerBinary(spec)
	fmt.Println(bin.Command(client).String())
}

Output:

docker run --entrypoint "" --volume "/tmp/aliases/ExampleDockerBinaryAdapter_Command/docker:/share" docker:18.09.0 sh -c 'cp -av $(which docker) /share/docker-18-09-0'

func (*DockerBinaryAdapter) FileName 

func (adpt *DockerBinaryAdapter) FileName() string

FileName returns filename of docker binary.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
		},
	}
	bin := script.AdaptDockerBinary(spec)
	fmt.Println(bin.FileName())
}

Output:

docker-18-09-0

func (*DockerBinaryAdapter) Image 

func (adpt *DockerBinaryAdapter) Image() string

Image returns image of docker binary.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
		},
	}
	bin := script.AdaptDockerBinary(spec)
	fmt.Println(bin.Image())
}

Output:

docker

func (*DockerBinaryAdapter) Tag 

func (adpt *DockerBinaryAdapter) Tag() string

Tag returns tag of docker binary.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
		},
	}
	bin := script.AdaptDockerBinary(spec)
	fmt.Println(bin.Tag())
}

Output:

18.09.0

type DockerRunAdapter 

type DockerRunAdapter yaml.Option

DockerRunAdapter adapts docker run information from spec to a form that can be used in aliases.

func (*DockerRunAdapter) Args 

func (adpt *DockerRunAdapter) Args() []string

Args returns arguments of docker run.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
	}
	runner := script.AdaptDockerRun(spec)
	fmt.Println(runner.Args())
}

Output:

[-c]

func (*DockerRunAdapter) Command 

func (adpt *DockerRunAdapter) Command(client *docker.Client, overrideArgs []string, overrideOption docker.RunOption) *posix.Cmd

Command returns a command to download the docker run.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleDockerRunAdapter_Command"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleDockerRunAdapter_Command"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
	}
	runner := script.AdaptDockerRun(spec)
	cmd := runner.Command(client, []string{"-c", "echo 1"}, docker.RunOption{
		Entrypoint: (func(str string) *string { return &str })("bash"),
	})
	fmt.Println(cmd.String())
}

Output:

docker run --entrypoint "bash" alpine:${._VERSION:-"latest"} -c "echo 1"

func (*DockerRunAdapter) Image 

func (adpt *DockerRunAdapter) Image() string

Image returns image of docker run.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
	}
	runner := script.AdaptDockerRun(spec)
	fmt.Println(runner.Image())
}

Output:

alpine:${._VERSION:-"latest"}

func (*DockerRunAdapter) Option 

func (adpt *DockerRunAdapter) Option() *docker.RunOption

Option returns option of docker run.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
)

func main() {
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
	}
	runner := script.AdaptDockerRun(spec)
	fmt.Println(*runner.Option().Entrypoint)
}

Output:

sh

type Script 

type Script struct {
	// contains filtered or unexported fields
}

Script is the actual of command alises.

func NewScript 

func NewScript(spec yaml.Option) *Script

NewScript creates a new Script.

func (*Script) Alias 

func (script *Script) Alias(client *docker.Client) (*posix.Cmd, error)

Alias returns the command of alias.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleScript_Alias"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleScript_Alias/export"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image: "alpine",
			Tag:   "latest",
			Args:  []string{"-c"},
		},
		Path: yaml.SpecPath("/path/to/command"),
	}

	cmd, err := script.NewScript(spec).Alias(client)
	if err != nil {
		panic(err)
	}
	fmt.Println(cmd.String())
}

Output:

alias command='/tmp/aliases/ExampleScript_Alias/export/command'

func (*Script) Run 

func (script *Script) Run(client *docker.Client, overrideArgs []string, overrideOption docker.RunOption) error

Run aliases script.

Example 
package main

import (
	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleScript_Alias"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleScript_Alias/export"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:   "alpine",
			Tag:     "latest",
			Command: (func(s string) *string { return &s })("sh"),
			Args:    []string{"-c"},
		},
		Path: yaml.SpecPath("/path/to/command"),
	}

	if err := script.NewScript(spec).Run(client, []string{"-c", "echo 1"}, docker.RunOption{}); err != nil {
		panic(err)
	}
}

Output:

1

func (*Script) Write 

func (script *Script) Write(client *docker.Client) error

Write exports aliases script to a file.

Example 
package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleScript_Write"); err != nil {
		panic(err)
	}

	file, err := os.Create("/tmp/aliases.yaml")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	if err := context.ChangeConfPath(file.Name()); err != nil {
		panic(err)
	}

	if err := context.ChangeExportPath("/tmp/aliases/ExampleScript_Write/export"); err != nil {
		panic(err)
	}

	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image: "alpine",
			Tag:   "latest",
			Args:  []string{"-c"},
		},
		Path: yaml.SpecPath("/path/to/command"),
	}

	if err := script.NewScript(spec).Write(client); err != nil {
		panic(err)
	}

	fileinfo, _ := ioutil.ReadDir(context.ExportPath())
	for _, file := range fileinfo {
		content, _ := ioutil.ReadFile(filepath.Join(context.ExportPath(), file.Name()))
		fmt.Printf("%s:\n", file.Name())
		fmt.Println(string(content))
	}
}

Output:

command:
#!/bin/sh

if [ -p /dev/stdin ]; then
  cat - | docker run alpine:${COMMAND_VERSION:-"latest"} -c "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run alpine:${COMMAND_VERSION:-"latest"} -c "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run alpine:${COMMAND_VERSION:-"latest"} -c "$@"
  exit $?
else
  echo "" >/dev/null | docker run alpine:${COMMAND_VERSION:-"latest"} -c "$@"
  exit $?
fi

func (*Script) WriteWithOverride 

func (script *Script) WriteWithOverride(client *docker.Client, overrideArgs []string, overrideOption docker.RunOption) error

WriteWithOverride exports aliases script to a file with override docker option.

Example 
package main

import (
	"fmt"
	"io/ioutil"
	"path/filepath"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleScript_WriteWithOverride"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleScript_WriteWithOverride/export"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
			Image: "alpine",
			Tag:   "latest",
			Args:  []string{"-c"},
		},
		Path: yaml.SpecPath("/path/to/command1"),
		Dependencies: []*yaml.Option{
			{
				OptionSpec: &yaml.OptionSpec{
					Image: "alpine",
					Tag:   "latest",
					Args:  []string{"-c"},
				},
				Path: yaml.SpecPath("/path/to/command2"),
			},
		},
	}

	entrypoint := "bash"
	if err := script.NewScript(spec).WriteWithOverride(client, []string{"--posix", "-c"}, docker.RunOption{Entrypoint: &entrypoint}); err != nil {
		panic(err)
	}

	fileinfo, _ := ioutil.ReadDir(context.ExportPath())
	for _, file := range fileinfo {
		content, _ := ioutil.ReadFile(filepath.Join(context.ExportPath(), file.Name()))
		fmt.Printf("%s:\n", file.Name())
		fmt.Println(string(content))
	}
}

Output:

command1:
#!/bin/sh

DOCKER_BINARY_PATH="/tmp/aliases/ExampleScript_WriteWithOverride/docker/docker-18-09-0"
if [ ! -f "${DOCKER_BINARY_PATH}" ]; then
  docker run --entrypoint "" --volume "/tmp/aliases/ExampleScript_WriteWithOverride/docker:/share" docker:18.09.0 sh -c 'cp -av $(which docker) /share/docker-18-09-0' >/dev/null
fi
if [ -p /dev/stdin ]; then
  cat - | docker run --entrypoint "bash" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleScript_WriteWithOverride:/tmp/aliases/ExampleScript_WriteWithOverride" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" --volume "/tmp/aliases/ExampleScript_WriteWithOverride/export/command2:/path/to/command2" alpine:${COMMAND1_VERSION:-"latest"} --posix -c "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run --entrypoint "bash" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleScript_WriteWithOverride:/tmp/aliases/ExampleScript_WriteWithOverride" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" --volume "/tmp/aliases/ExampleScript_WriteWithOverride/export/command2:/path/to/command2" alpine:${COMMAND1_VERSION:-"latest"} --posix -c "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run --entrypoint "bash" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleScript_WriteWithOverride:/tmp/aliases/ExampleScript_WriteWithOverride" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" --volume "/tmp/aliases/ExampleScript_WriteWithOverride/export/command2:/path/to/command2" alpine:${COMMAND1_VERSION:-"latest"} --posix -c "$@"
  exit $?
else
  echo "" >/dev/null | docker run --entrypoint "bash" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleScript_WriteWithOverride:/tmp/aliases/ExampleScript_WriteWithOverride" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" --volume "/tmp/aliases/ExampleScript_WriteWithOverride/export/command2:/path/to/command2" alpine:${COMMAND1_VERSION:-"latest"} --posix -c "$@"
  exit $?
fi

command2:
#!/bin/sh

if [ -p /dev/stdin ]; then
  cat - | docker run alpine:${COMMAND2_VERSION:-"latest"} -c "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run alpine:${COMMAND2_VERSION:-"latest"} -c "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run alpine:${COMMAND2_VERSION:-"latest"} -c "$@"
  exit $?
else
  echo "" >/dev/null | docker run alpine:${COMMAND2_VERSION:-"latest"} -c "$@"
  exit $?
fi

type ShellAdapter 

type ShellAdapter yaml.Option

ShellAdapter adapts shell script from spec to a form that can be used in aliases.

func (*ShellAdapter) Command 

func (adpt *ShellAdapter) Command(client *docker.Client, overrideArgs []string, overrideOption docker.RunOption, debug bool) (*posix.ShellScript, error)

Command returns a command to aliases script.

Example 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleShellAdapter_Command"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleShellAdapter_Command"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
	}
	runner := script.AdaptShell(spec)
	cmd, err := runner.Command(client, []string{"-c", "echo 1"}, docker.RunOption{
		Entrypoint: (func(str string) *string { return &str })("bash"),
	}, false)
	if err != nil {
		panic(err)
	}
	fmt.Println(cmd.String())
}

Output:

if [ -p /dev/stdin ]; then
  cat - | docker run --entrypoint "bash" alpine:${._VERSION:-"latest"} -c "echo 1" "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run --entrypoint "bash" alpine:${._VERSION:-"latest"} -c "echo 1" "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run --entrypoint "bash" alpine:${._VERSION:-"latest"} -c "echo 1" "$@"
  exit $?
else
  echo "" >/dev/null | docker run --entrypoint "bash" alpine:${._VERSION:-"latest"} -c "echo 1" "$@"
  exit $?
fi
Example (HasDependencies) 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleShellAdapter_Command_HasDependencies"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleShellAdapter_Command_HasDependencies"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Docker: &yaml.DockerSpec{
				Image: "docker",
				Tag:   "18.09.0",
			},
			Image:      "alpine",
			Tag:        "latest",
			Entrypoint: (func(str string) *string { return &str })("sh"),
			Args:       []string{"-c"},
		},
		Dependencies: []*yaml.Option{
			{
				OptionSpec: &yaml.OptionSpec{
					Image: "alpine",
					Tag:   "latest",
				},
			},
		},
	}
	runner := script.AdaptShell(spec)
	cmd, err := runner.Command(client, []string{}, docker.RunOption{}, false)
	if err != nil {
		panic(err)
	}
	fmt.Println(cmd.String())
}

Output:

DOCKER_BINARY_PATH="/tmp/aliases/ExampleShellAdapter_Command_HasDependencies/docker/docker-18-09-0"
if [ ! -f "${DOCKER_BINARY_PATH}" ]; then
  docker run --entrypoint "" --volume "/tmp/aliases/ExampleShellAdapter_Command_HasDependencies/docker:/share" docker:18.09.0 sh -c 'cp -av $(which docker) /share/docker-18-09-0' >/dev/null
fi
if [ -p /dev/stdin ]; then
  cat - | docker run --entrypoint "sh" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleShellAdapter_Command_HasDependencies:/tmp/aliases/ExampleShellAdapter_Command_HasDependencies" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run --entrypoint "sh" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleShellAdapter_Command_HasDependencies:/tmp/aliases/ExampleShellAdapter_Command_HasDependencies" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" alpine:${._VERSION:-"latest"} -c "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run --entrypoint "sh" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleShellAdapter_Command_HasDependencies:/tmp/aliases/ExampleShellAdapter_Command_HasDependencies" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
else
  echo "" >/dev/null | docker run --entrypoint "sh" --env ALIASES_PWD="${ALIASES_PWD:-$PWD}" --privileged --volume "/tmp/aliases/ExampleShellAdapter_Command_HasDependencies:/tmp/aliases/ExampleShellAdapter_Command_HasDependencies" --volume "${DOCKER_BINARY_PATH}:/usr/local/bin/docker" --volume "/var/run/docker.sock:/var/run/docker.sock" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
fi
Example (UseExtendEntrypoint) 
package main

import (
	"fmt"

	"github.com/k-kinzal/aliases/pkg/aliases/context"
	"github.com/k-kinzal/aliases/pkg/aliases/script"
	"github.com/k-kinzal/aliases/pkg/aliases/yaml"
	"github.com/k-kinzal/aliases/pkg/docker"
)

func main() {
	if err := context.ChangeHomePath("/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint"); err != nil {
		panic(err)
	}
	if err := context.ChangeExportPath("/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint"); err != nil {
		panic(err)
	}
	client, err := docker.NewClient()
	if err != nil {
		panic(err)
	}
	spec := yaml.Option{
		OptionSpec: &yaml.OptionSpec{
			Image: "alpine",
			Tag:   "latest",
			Entrypoint: (func(str string) *string { return &str })(`
				#!/bin/sh
				sh -c "$@"
			`),
			Args: []string{"-c"},
		},
	}
	runner := script.AdaptShell(spec)
	cmd, err := runner.Command(client, []string{}, docker.RunOption{}, false)
	if err != nil {
		panic(err)
	}
	fmt.Println(cmd.String())
}

Output:

if [ -p /dev/stdin ]; then
  cat - | docker run --entrypoint "/b82c6c95fa559f017ac62344f961e206" --volume "/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint/entrypoint/b82c6c95fa559f017ac62344f961e206:/b82c6c95fa559f017ac62344f961e206" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
elif [ -f /dev/stdin ]; then
  docker run --entrypoint "/b82c6c95fa559f017ac62344f961e206" --volume "/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint/entrypoint/b82c6c95fa559f017ac62344f961e206:/b82c6c95fa559f017ac62344f961e206" alpine:${._VERSION:-"latest"} -c "$@" </dev/stdin
  exit $?
elif [ -t 0 ]; then
  docker run --entrypoint "/b82c6c95fa559f017ac62344f961e206" --volume "/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint/entrypoint/b82c6c95fa559f017ac62344f961e206:/b82c6c95fa559f017ac62344f961e206" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
else
  echo "" >/dev/null | docker run --entrypoint "/b82c6c95fa559f017ac62344f961e206" --volume "/tmp/aliases/ExampleShellAdapter_Command_UseExtendEntrypoint/entrypoint/b82c6c95fa559f017ac62344f961e206:/b82c6c95fa559f017ac62344f961e206" alpine:${._VERSION:-"latest"} -c "$@"
  exit $?
fi

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.