id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
165,100 | hashicorp/packer | helper/ssh/key_pair.go | authorizedKeysLine | func authorizedKeysLine(key gossh.PublicKey, comment string) []byte {
marshaledPublicKey := gossh.MarshalAuthorizedKey(key)
// Remove the mandatory unix new line. Awful, but the go
// ssh library automatically appends a unix new line.
// We remove it so a key comment can be safely appended to the
// end of the string.
marshaledPublicKey = bytes.TrimSpace(marshaledPublicKey)
if len(strings.TrimSpace(comment)) > 0 {
marshaledPublicKey = append(marshaledPublicKey, ' ')
marshaledPublicKey = append(marshaledPublicKey, comment...)
}
return marshaledPublicKey
} | go | func authorizedKeysLine(key gossh.PublicKey, comment string) []byte {
marshaledPublicKey := gossh.MarshalAuthorizedKey(key)
// Remove the mandatory unix new line. Awful, but the go
// ssh library automatically appends a unix new line.
// We remove it so a key comment can be safely appended to the
// end of the string.
marshaledPublicKey = bytes.TrimSpace(marshaledPublicKey)
if len(strings.TrimSpace(comment)) > 0 {
marshaledPublicKey = append(marshaledPublicKey, ' ')
marshaledPublicKey = append(marshaledPublicKey, comment...)
}
return marshaledPublicKey
} | [
"func",
"authorizedKeysLine",
"(",
"key",
"gossh",
".",
"PublicKey",
",",
"comment",
"string",
")",
"[",
"]",
"byte",
"{",
"marshaledPublicKey",
":=",
"gossh",
".",
"MarshalAuthorizedKey",
"(",
"key",
")",
"\n\n",
"// Remove the mandatory unix new line. Awful, but the... | // authorizedKeysLine serializes key for inclusion in an OpenSSH
// authorized_keys file. The return value ends without newline so
// a comment can be appended to the end. | [
"authorizedKeysLine",
"serializes",
"key",
"for",
"inclusion",
"in",
"an",
"OpenSSH",
"authorized_keys",
"file",
".",
"The",
"return",
"value",
"ends",
"without",
"newline",
"so",
"a",
"comment",
"can",
"be",
"appended",
"to",
"the",
"end",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/helper/ssh/key_pair.go#L243-L258 |
165,101 | hashicorp/packer | template/template.go | Raw | func (t *Template) Raw() (*rawTemplate, error) {
var out rawTemplate
out.MinVersion = t.MinVersion
out.Description = t.Description
for k, v := range t.Comments {
out.Comments = append(out.Comments, map[string]string{k: v})
}
for _, b := range t.Builders {
out.Builders = append(out.Builders, b)
}
for _, p := range t.Provisioners {
out.Provisioners = append(out.Provisioners, p)
}
for _, pp := range t.PostProcessors {
out.PostProcessors = append(out.PostProcessors, pp)
}
for _, v := range t.SensitiveVariables {
out.SensitiveVariables = append(out.SensitiveVariables, v.Key)
}
for k, v := range t.Variables {
if out.Variables == nil {
out.Variables = make(map[string]interface{})
}
out.Variables[k] = v
}
if t.Push.Name != "" {
b, _ := json.Marshal(t.Push)
var m map[string]interface{}
_ = json.Unmarshal(b, &m)
out.Push = m
}
return &out, nil
} | go | func (t *Template) Raw() (*rawTemplate, error) {
var out rawTemplate
out.MinVersion = t.MinVersion
out.Description = t.Description
for k, v := range t.Comments {
out.Comments = append(out.Comments, map[string]string{k: v})
}
for _, b := range t.Builders {
out.Builders = append(out.Builders, b)
}
for _, p := range t.Provisioners {
out.Provisioners = append(out.Provisioners, p)
}
for _, pp := range t.PostProcessors {
out.PostProcessors = append(out.PostProcessors, pp)
}
for _, v := range t.SensitiveVariables {
out.SensitiveVariables = append(out.SensitiveVariables, v.Key)
}
for k, v := range t.Variables {
if out.Variables == nil {
out.Variables = make(map[string]interface{})
}
out.Variables[k] = v
}
if t.Push.Name != "" {
b, _ := json.Marshal(t.Push)
var m map[string]interface{}
_ = json.Unmarshal(b, &m)
out.Push = m
}
return &out, nil
} | [
"func",
"(",
"t",
"*",
"Template",
")",
"Raw",
"(",
")",
"(",
"*",
"rawTemplate",
",",
"error",
")",
"{",
"var",
"out",
"rawTemplate",
"\n\n",
"out",
".",
"MinVersion",
"=",
"t",
".",
"MinVersion",
"\n",
"out",
".",
"Description",
"=",
"t",
".",
"D... | // Raw converts a Template struct back into the raw Packer template structure | [
"Raw",
"converts",
"a",
"Template",
"struct",
"back",
"into",
"the",
"raw",
"Packer",
"template",
"structure"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L35-L79 |
165,102 | hashicorp/packer | template/template.go | MarshalJSON | func (b *Builder) MarshalJSON() ([]byte, error) {
// Avoid recursion
type Builder_ Builder
out, _ := json.Marshal(Builder_(*b))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range b.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | go | func (b *Builder) MarshalJSON() ([]byte, error) {
// Avoid recursion
type Builder_ Builder
out, _ := json.Marshal(Builder_(*b))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range b.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Avoid recursion",
"type",
"Builder_",
"Builder",
"\n",
"out",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"Builder_",
"(",
"*",
"b",
... | // MarshalJSON conducts the necessary flattening of the Builder struct
// to provide valid Packer template JSON | [
"MarshalJSON",
"conducts",
"the",
"necessary",
"flattening",
"of",
"the",
"Builder",
"struct",
"to",
"provide",
"valid",
"Packer",
"template",
"JSON"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L90-L106 |
165,103 | hashicorp/packer | template/template.go | MarshalJSON | func (p *PostProcessor) MarshalJSON() ([]byte, error) {
// Early exit for simple definitions
if len(p.Config) == 0 && len(p.OnlyExcept.Only) == 0 && len(p.OnlyExcept.Except) == 0 && p.KeepInputArtifact == nil {
return json.Marshal(p.Type)
}
// Avoid recursion
type PostProcessor_ PostProcessor
out, _ := json.Marshal(PostProcessor_(*p))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range p.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | go | func (p *PostProcessor) MarshalJSON() ([]byte, error) {
// Early exit for simple definitions
if len(p.Config) == 0 && len(p.OnlyExcept.Only) == 0 && len(p.OnlyExcept.Except) == 0 && p.KeepInputArtifact == nil {
return json.Marshal(p.Type)
}
// Avoid recursion
type PostProcessor_ PostProcessor
out, _ := json.Marshal(PostProcessor_(*p))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range p.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | [
"func",
"(",
"p",
"*",
"PostProcessor",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Early exit for simple definitions",
"if",
"len",
"(",
"p",
".",
"Config",
")",
"==",
"0",
"&&",
"len",
"(",
"p",
".",
"OnlyExcept",... | // MarshalJSON conducts the necessary flattening of the PostProcessor struct
// to provide valid Packer template JSON | [
"MarshalJSON",
"conducts",
"the",
"necessary",
"flattening",
"of",
"the",
"PostProcessor",
"struct",
"to",
"provide",
"valid",
"Packer",
"template",
"JSON"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L120-L141 |
165,104 | hashicorp/packer | template/template.go | MarshalJSON | func (p *Provisioner) MarshalJSON() ([]byte, error) {
// Avoid recursion
type Provisioner_ Provisioner
out, _ := json.Marshal(Provisioner_(*p))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range p.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | go | func (p *Provisioner) MarshalJSON() ([]byte, error) {
// Avoid recursion
type Provisioner_ Provisioner
out, _ := json.Marshal(Provisioner_(*p))
var m map[string]json.RawMessage
_ = json.Unmarshal(out, &m)
// Flatten Config
delete(m, "config")
for k, v := range p.Config {
out, _ = json.Marshal(v)
m[k] = out
}
return json.Marshal(m)
} | [
"func",
"(",
"p",
"*",
"Provisioner",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Avoid recursion",
"type",
"Provisioner_",
"Provisioner",
"\n",
"out",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"Provisioner_",
"(",... | // MarshalJSON conducts the necessary flattening of the Provisioner struct
// to provide valid Packer template JSON | [
"MarshalJSON",
"conducts",
"the",
"necessary",
"flattening",
"of",
"the",
"Provisioner",
"struct",
"to",
"provide",
"valid",
"Packer",
"template",
"JSON"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L156-L172 |
165,105 | hashicorp/packer | template/template.go | Skip | func (o *OnlyExcept) Skip(n string) bool {
if len(o.Only) > 0 {
for _, v := range o.Only {
if v == n {
return false
}
}
return true
}
if len(o.Except) > 0 {
for _, v := range o.Except {
if v == n {
return true
}
}
return false
}
return false
} | go | func (o *OnlyExcept) Skip(n string) bool {
if len(o.Only) > 0 {
for _, v := range o.Only {
if v == n {
return false
}
}
return true
}
if len(o.Except) > 0 {
for _, v := range o.Except {
if v == n {
return true
}
}
return false
}
return false
} | [
"func",
"(",
"o",
"*",
"OnlyExcept",
")",
"Skip",
"(",
"n",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"o",
".",
"Only",
")",
">",
"0",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"o",
".",
"Only",
"{",
"if",
"v",
"==",
"n",
"{",
"return",... | // Skip says whether or not to skip the build with the given name. | [
"Skip",
"says",
"whether",
"or",
"not",
"to",
"skip",
"the",
"build",
"with",
"the",
"given",
"name",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L264-L286 |
165,106 | hashicorp/packer | template/template.go | Validate | func (o *OnlyExcept) Validate(t *Template) error {
if len(o.Only) > 0 && len(o.Except) > 0 {
return errors.New("only one of 'only' or 'except' may be specified")
}
var err error
for _, n := range o.Only {
if _, ok := t.Builders[n]; !ok {
err = multierror.Append(err, fmt.Errorf(
"'only' specified builder '%s' not found", n))
}
}
for _, n := range o.Except {
if _, ok := t.Builders[n]; !ok {
err = multierror.Append(err, fmt.Errorf(
"'except' specified builder '%s' not found", n))
}
}
return err
} | go | func (o *OnlyExcept) Validate(t *Template) error {
if len(o.Only) > 0 && len(o.Except) > 0 {
return errors.New("only one of 'only' or 'except' may be specified")
}
var err error
for _, n := range o.Only {
if _, ok := t.Builders[n]; !ok {
err = multierror.Append(err, fmt.Errorf(
"'only' specified builder '%s' not found", n))
}
}
for _, n := range o.Except {
if _, ok := t.Builders[n]; !ok {
err = multierror.Append(err, fmt.Errorf(
"'except' specified builder '%s' not found", n))
}
}
return err
} | [
"func",
"(",
"o",
"*",
"OnlyExcept",
")",
"Validate",
"(",
"t",
"*",
"Template",
")",
"error",
"{",
"if",
"len",
"(",
"o",
".",
"Only",
")",
">",
"0",
"&&",
"len",
"(",
"o",
".",
"Except",
")",
">",
"0",
"{",
"return",
"errors",
".",
"New",
"... | // Validate validates that the OnlyExcept settings are correct for a thing. | [
"Validate",
"validates",
"that",
"the",
"OnlyExcept",
"settings",
"are",
"correct",
"for",
"a",
"thing",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/template.go#L289-L309 |
165,107 | hashicorp/packer | builder/vmware/iso/config.go | validateVMXTemplatePath | func (c *Config) validateVMXTemplatePath() error {
f, err := os.Open(c.VMXTemplatePath)
if err != nil {
return err
}
defer f.Close()
data, err := ioutil.ReadAll(f)
if err != nil {
return err
}
return interpolate.Validate(string(data), &c.ctx)
} | go | func (c *Config) validateVMXTemplatePath() error {
f, err := os.Open(c.VMXTemplatePath)
if err != nil {
return err
}
defer f.Close()
data, err := ioutil.ReadAll(f)
if err != nil {
return err
}
return interpolate.Validate(string(data), &c.ctx)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"validateVMXTemplatePath",
"(",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"c",
".",
"VMXTemplatePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer"... | // Make sure custom vmx template exists and that data can be read from it | [
"Make",
"sure",
"custom",
"vmx",
"template",
"exists",
"and",
"that",
"data",
"can",
"be",
"read",
"from",
"it"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/iso/config.go#L245-L258 |
165,108 | hashicorp/packer | post-processor/vagrant/util.go | CopyContents | func CopyContents(dst, src string) error {
srcF, err := os.Open(src)
if err != nil {
return err
}
defer srcF.Close()
dstDir, _ := filepath.Split(dst)
if dstDir != "" {
err := os.MkdirAll(dstDir, 0755)
if err != nil {
return err
}
}
dstF, err := os.Create(dst)
if err != nil {
return err
}
defer dstF.Close()
if _, err := io.Copy(dstF, srcF); err != nil {
return err
}
return nil
} | go | func CopyContents(dst, src string) error {
srcF, err := os.Open(src)
if err != nil {
return err
}
defer srcF.Close()
dstDir, _ := filepath.Split(dst)
if dstDir != "" {
err := os.MkdirAll(dstDir, 0755)
if err != nil {
return err
}
}
dstF, err := os.Create(dst)
if err != nil {
return err
}
defer dstF.Close()
if _, err := io.Copy(dstF, srcF); err != nil {
return err
}
return nil
} | [
"func",
"CopyContents",
"(",
"dst",
",",
"src",
"string",
")",
"error",
"{",
"srcF",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"srcF",
".",
"Close",
"(",
... | // Copies a file by copying the contents of the file to another place. | [
"Copies",
"a",
"file",
"by",
"copying",
"the",
"contents",
"of",
"the",
"file",
"to",
"another",
"place",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/post-processor/vagrant/util.go#L26-L52 |
165,109 | hashicorp/packer | post-processor/vagrant/util.go | DirToBox | func DirToBox(dst, dir string, ui packer.Ui, level int) error {
log.Printf("Turning dir into box: %s => %s", dir, dst)
// Make the containing directory, if it does not already exist
err := os.MkdirAll(filepath.Dir(dst), 0755)
if err != nil {
return err
}
dstF, err := os.Create(dst)
if err != nil {
return err
}
defer dstF.Close()
var dstWriter io.WriteCloser = dstF
if level != flate.NoCompression {
log.Printf("Compressing with gzip compression level: %d", level)
gzipWriter, err := makePgzipWriter(dstWriter, level)
if err != nil {
return err
}
defer gzipWriter.Close()
dstWriter = gzipWriter
}
tarWriter := tar.NewWriter(dstWriter)
defer tarWriter.Close()
// This is the walk func that tars each of the files in the dir
tarWalk := func(path string, info os.FileInfo, prevErr error) error {
// If there was a prior error, return it
if prevErr != nil {
return prevErr
}
// Skip directories
if info.IsDir() {
log.Printf("Skipping directory '%s' for box '%s'", path, dst)
return nil
}
log.Printf("Box add: '%s' to '%s'", path, dst)
f, err := os.Open(path)
if err != nil {
return err
}
defer f.Close()
header, err := tar.FileInfoHeader(info, "")
if err != nil {
return err
}
// go >=1.10 wants to use GNU tar format to workaround issues in
// libarchive < 3.3.2
setHeaderFormat(header)
// We have to set the Name explicitly because it is supposed to
// be a relative path to the root. Otherwise, the tar ends up
// being a bunch of files in the root, even if they're actually
// nested in a dir in the original "dir" param.
header.Name, err = filepath.Rel(dir, path)
if err != nil {
return err
}
if ui != nil {
ui.Message(fmt.Sprintf("Compressing: %s", header.Name))
}
if err := tarWriter.WriteHeader(header); err != nil {
return err
}
if _, err := io.Copy(tarWriter, f); err != nil {
return err
}
return nil
}
// Tar.gz everything up
return filepath.Walk(dir, tarWalk)
} | go | func DirToBox(dst, dir string, ui packer.Ui, level int) error {
log.Printf("Turning dir into box: %s => %s", dir, dst)
// Make the containing directory, if it does not already exist
err := os.MkdirAll(filepath.Dir(dst), 0755)
if err != nil {
return err
}
dstF, err := os.Create(dst)
if err != nil {
return err
}
defer dstF.Close()
var dstWriter io.WriteCloser = dstF
if level != flate.NoCompression {
log.Printf("Compressing with gzip compression level: %d", level)
gzipWriter, err := makePgzipWriter(dstWriter, level)
if err != nil {
return err
}
defer gzipWriter.Close()
dstWriter = gzipWriter
}
tarWriter := tar.NewWriter(dstWriter)
defer tarWriter.Close()
// This is the walk func that tars each of the files in the dir
tarWalk := func(path string, info os.FileInfo, prevErr error) error {
// If there was a prior error, return it
if prevErr != nil {
return prevErr
}
// Skip directories
if info.IsDir() {
log.Printf("Skipping directory '%s' for box '%s'", path, dst)
return nil
}
log.Printf("Box add: '%s' to '%s'", path, dst)
f, err := os.Open(path)
if err != nil {
return err
}
defer f.Close()
header, err := tar.FileInfoHeader(info, "")
if err != nil {
return err
}
// go >=1.10 wants to use GNU tar format to workaround issues in
// libarchive < 3.3.2
setHeaderFormat(header)
// We have to set the Name explicitly because it is supposed to
// be a relative path to the root. Otherwise, the tar ends up
// being a bunch of files in the root, even if they're actually
// nested in a dir in the original "dir" param.
header.Name, err = filepath.Rel(dir, path)
if err != nil {
return err
}
if ui != nil {
ui.Message(fmt.Sprintf("Compressing: %s", header.Name))
}
if err := tarWriter.WriteHeader(header); err != nil {
return err
}
if _, err := io.Copy(tarWriter, f); err != nil {
return err
}
return nil
}
// Tar.gz everything up
return filepath.Walk(dir, tarWalk)
} | [
"func",
"DirToBox",
"(",
"dst",
",",
"dir",
"string",
",",
"ui",
"packer",
".",
"Ui",
",",
"level",
"int",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"dir",
",",
"dst",
")",
"\n\n",
"// Make the containing directory, if it does not alre... | // DirToBox takes the directory and compresses it into a Vagrant-compatible
// box. This function does not perform checks to verify that dir is
// actually a proper box. This is an expected precondition. | [
"DirToBox",
"takes",
"the",
"directory",
"and",
"compresses",
"it",
"into",
"a",
"Vagrant",
"-",
"compatible",
"box",
".",
"This",
"function",
"does",
"not",
"perform",
"checks",
"to",
"verify",
"that",
"dir",
"is",
"actually",
"a",
"proper",
"box",
".",
"... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/post-processor/vagrant/util.go#L74-L159 |
165,110 | hashicorp/packer | post-processor/vagrant/util.go | WriteMetadata | func WriteMetadata(dir string, contents interface{}) error {
if _, err := os.Stat(filepath.Join(dir, "metadata.json")); os.IsNotExist(err) {
f, err := os.Create(filepath.Join(dir, "metadata.json"))
if err != nil {
return err
}
defer f.Close()
enc := json.NewEncoder(f)
return enc.Encode(contents)
}
return nil
} | go | func WriteMetadata(dir string, contents interface{}) error {
if _, err := os.Stat(filepath.Join(dir, "metadata.json")); os.IsNotExist(err) {
f, err := os.Create(filepath.Join(dir, "metadata.json"))
if err != nil {
return err
}
defer f.Close()
enc := json.NewEncoder(f)
return enc.Encode(contents)
}
return nil
} | [
"func",
"WriteMetadata",
"(",
"dir",
"string",
",",
"contents",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
")",
";",
"os",
".",
"IsNotE... | // WriteMetadata writes the "metadata.json" file for a Vagrant box. | [
"WriteMetadata",
"writes",
"the",
"metadata",
".",
"json",
"file",
"for",
"a",
"Vagrant",
"box",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/post-processor/vagrant/util.go#L162-L175 |
165,111 | hashicorp/packer | common/uuid/uuid.go | TimeOrderedUUID | func TimeOrderedUUID() string {
unix := uint32(time.Now().UTC().Unix())
b := make([]byte, 12)
n, err := rand.Read(b)
if n != len(b) {
err = fmt.Errorf("Not enough entropy available")
}
if err != nil {
panic(err)
}
return fmt.Sprintf("%08x-%04x-%04x-%04x-%04x%08x",
unix, b[0:2], b[2:4], b[4:6], b[6:8], b[8:])
} | go | func TimeOrderedUUID() string {
unix := uint32(time.Now().UTC().Unix())
b := make([]byte, 12)
n, err := rand.Read(b)
if n != len(b) {
err = fmt.Errorf("Not enough entropy available")
}
if err != nil {
panic(err)
}
return fmt.Sprintf("%08x-%04x-%04x-%04x-%04x%08x",
unix, b[0:2], b[2:4], b[4:6], b[6:8], b[8:])
} | [
"func",
"TimeOrderedUUID",
"(",
")",
"string",
"{",
"unix",
":=",
"uint32",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Unix",
"(",
")",
")",
"\n\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"12",
")",
"\n",
"n",
",",... | // Generates a time ordered UUID. Top 32 bits are a timestamp,
// bottom 96 are random. | [
"Generates",
"a",
"time",
"ordered",
"UUID",
".",
"Top",
"32",
"bits",
"are",
"a",
"timestamp",
"bottom",
"96",
"are",
"random",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/common/uuid/uuid.go#L11-L24 |
165,112 | hashicorp/packer | template/interpolate/funcs.go | Funcs | func Funcs(ctx *Context) template.FuncMap {
result := make(map[string]interface{})
for k, v := range FuncGens {
result[k] = v(ctx)
}
if ctx != nil {
for k, v := range ctx.Funcs {
result[k] = v
}
}
return template.FuncMap(result)
} | go | func Funcs(ctx *Context) template.FuncMap {
result := make(map[string]interface{})
for k, v := range FuncGens {
result[k] = v(ctx)
}
if ctx != nil {
for k, v := range ctx.Funcs {
result[k] = v
}
}
return template.FuncMap(result)
} | [
"func",
"Funcs",
"(",
"ctx",
"*",
"Context",
")",
"template",
".",
"FuncMap",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"FuncGens",
"{",
"result",
"[",
"k",
... | // Funcs returns the functions that can be used for interpolation given
// a context. | [
"Funcs",
"returns",
"the",
"functions",
"that",
"can",
"be",
"used",
"for",
"interpolation",
"given",
"a",
"context",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/interpolate/funcs.go#L56-L68 |
165,113 | hashicorp/packer | common/retry/retry.go | Run | func (cfg Config) Run(ctx context.Context, fn func(context.Context) error) error {
retryDelay := func() time.Duration { return 2 * time.Second }
if cfg.RetryDelay != nil {
retryDelay = cfg.RetryDelay
}
shouldRetry := func(error) bool { return true }
if cfg.ShouldRetry != nil {
shouldRetry = cfg.ShouldRetry
}
var startTimeout <-chan time.Time // nil chans never unlock !
if cfg.StartTimeout != 0 {
startTimeout = time.After(cfg.StartTimeout)
}
var err error
for try := 0; ; try++ {
if cfg.Tries != 0 && try == cfg.Tries {
return &RetryExhaustedError{err}
}
if err = fn(ctx); err == nil {
return nil
}
if !shouldRetry(err) {
return err
}
log.Print(fmt.Errorf("Retryable error: %s", err))
select {
case <-ctx.Done():
return err
case <-startTimeout:
return err
default:
time.Sleep(retryDelay())
}
}
} | go | func (cfg Config) Run(ctx context.Context, fn func(context.Context) error) error {
retryDelay := func() time.Duration { return 2 * time.Second }
if cfg.RetryDelay != nil {
retryDelay = cfg.RetryDelay
}
shouldRetry := func(error) bool { return true }
if cfg.ShouldRetry != nil {
shouldRetry = cfg.ShouldRetry
}
var startTimeout <-chan time.Time // nil chans never unlock !
if cfg.StartTimeout != 0 {
startTimeout = time.After(cfg.StartTimeout)
}
var err error
for try := 0; ; try++ {
if cfg.Tries != 0 && try == cfg.Tries {
return &RetryExhaustedError{err}
}
if err = fn(ctx); err == nil {
return nil
}
if !shouldRetry(err) {
return err
}
log.Print(fmt.Errorf("Retryable error: %s", err))
select {
case <-ctx.Done():
return err
case <-startTimeout:
return err
default:
time.Sleep(retryDelay())
}
}
} | [
"func",
"(",
"cfg",
"Config",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"fn",
"func",
"(",
"context",
".",
"Context",
")",
"error",
")",
"error",
"{",
"retryDelay",
":=",
"func",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"2",
... | // Run fn until context is cancelled up until StartTimeout time has passed. | [
"Run",
"fn",
"until",
"context",
"is",
"cancelled",
"up",
"until",
"StartTimeout",
"time",
"has",
"passed",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/common/retry/retry.go#L40-L77 |
165,114 | hashicorp/packer | builder/azure/arm/tempname.go | generatePassword | func generatePassword() string {
var s string
for i := 0; i < 100; i++ {
s := random.AlphaNum(32)
if !strings.ContainsAny(s, random.PossibleNumbers) {
continue
}
if !strings.ContainsAny(s, random.PossibleLowerCase) {
continue
}
if !strings.ContainsAny(s, random.PossibleUpperCase) {
continue
}
return s
}
// if an acceptable password cannot be generated in 100 tries, give up
return s
} | go | func generatePassword() string {
var s string
for i := 0; i < 100; i++ {
s := random.AlphaNum(32)
if !strings.ContainsAny(s, random.PossibleNumbers) {
continue
}
if !strings.ContainsAny(s, random.PossibleLowerCase) {
continue
}
if !strings.ContainsAny(s, random.PossibleUpperCase) {
continue
}
return s
}
// if an acceptable password cannot be generated in 100 tries, give up
return s
} | [
"func",
"generatePassword",
"(",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"++",
"{",
"s",
":=",
"random",
".",
"AlphaNum",
"(",
"32",
")",
"\n",
"if",
"!",
"strings",
".",
"ContainsAny... | // generate a password that is acceptable to Azure
// Three of the four items must be met.
// 1. Contains an uppercase character
// 2. Contains a lowercase character
// 3. Contains a numeric digit
// 4. Contains a special character | [
"generate",
"a",
"password",
"that",
"is",
"acceptable",
"to",
"Azure",
"Three",
"of",
"the",
"four",
"items",
"must",
"be",
"met",
".",
"1",
".",
"Contains",
"an",
"uppercase",
"character",
"2",
".",
"Contains",
"a",
"lowercase",
"character",
"3",
".",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/arm/tempname.go#L50-L71 |
165,115 | hashicorp/packer | post-processor/vsphere-template/step_mark_as_template.go | unregisterPreviousVM | func unregisterPreviousVM(cli *govmomi.Client, folder *object.Folder, name string) error {
si := object.NewSearchIndex(cli.Client)
fullPath := path.Join(folder.InventoryPath, name)
ref, err := si.FindByInventoryPath(context.Background(), fullPath)
if err != nil {
return err
}
if ref != nil {
if vm, ok := ref.(*object.VirtualMachine); ok {
return vm.Unregister(context.Background())
} else {
return fmt.Errorf("an object name '%v' already exists", name)
}
}
return nil
} | go | func unregisterPreviousVM(cli *govmomi.Client, folder *object.Folder, name string) error {
si := object.NewSearchIndex(cli.Client)
fullPath := path.Join(folder.InventoryPath, name)
ref, err := si.FindByInventoryPath(context.Background(), fullPath)
if err != nil {
return err
}
if ref != nil {
if vm, ok := ref.(*object.VirtualMachine); ok {
return vm.Unregister(context.Background())
} else {
return fmt.Errorf("an object name '%v' already exists", name)
}
}
return nil
} | [
"func",
"unregisterPreviousVM",
"(",
"cli",
"*",
"govmomi",
".",
"Client",
",",
"folder",
"*",
"object",
".",
"Folder",
",",
"name",
"string",
")",
"error",
"{",
"si",
":=",
"object",
".",
"NewSearchIndex",
"(",
"cli",
".",
"Client",
")",
"\n",
"fullPath... | // If in the target folder a virtual machine or template already exists
// it will be removed to maintain consistency | [
"If",
"in",
"the",
"target",
"folder",
"a",
"virtual",
"machine",
"or",
"template",
"already",
"exists",
"it",
"will",
"be",
"removed",
"to",
"maintain",
"consistency"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/post-processor/vsphere-template/step_mark_as_template.go#L150-L169 |
165,116 | hashicorp/packer | builder/hyperv/common/step_create_external_switch.go | Run | func (s *StepCreateExternalSwitch) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
vmName := state.Get("vmName").(string)
errorMsg := "Error creating external switch: %s"
var err error
ui.Say("Creating external switch...")
packerExternalSwitchName := "paes_" + uuid.TimeOrderedUUID()
// CreateExternalVirtualSwitch checks for an existing external switch,
// creating one if required, and connects the VM to it
err = driver.CreateExternalVirtualSwitch(vmName, packerExternalSwitchName)
if err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
s.SwitchName = ""
return multistep.ActionHalt
}
switchName, err := driver.GetVirtualMachineSwitchName(vmName)
if err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if len(switchName) == 0 {
err := fmt.Errorf(errorMsg, err)
state.Put("error", "Can't get the VM switch name")
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say("External switch name is: '" + switchName + "'")
if switchName != packerExternalSwitchName {
s.SwitchName = ""
} else {
s.SwitchName = packerExternalSwitchName
s.oldSwitchName = state.Get("SwitchName").(string)
}
// Set the final name in the state bag so others can use it
state.Put("SwitchName", switchName)
return multistep.ActionContinue
} | go | func (s *StepCreateExternalSwitch) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
vmName := state.Get("vmName").(string)
errorMsg := "Error creating external switch: %s"
var err error
ui.Say("Creating external switch...")
packerExternalSwitchName := "paes_" + uuid.TimeOrderedUUID()
// CreateExternalVirtualSwitch checks for an existing external switch,
// creating one if required, and connects the VM to it
err = driver.CreateExternalVirtualSwitch(vmName, packerExternalSwitchName)
if err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
s.SwitchName = ""
return multistep.ActionHalt
}
switchName, err := driver.GetVirtualMachineSwitchName(vmName)
if err != nil {
err := fmt.Errorf(errorMsg, err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if len(switchName) == 0 {
err := fmt.Errorf(errorMsg, err)
state.Put("error", "Can't get the VM switch name")
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say("External switch name is: '" + switchName + "'")
if switchName != packerExternalSwitchName {
s.SwitchName = ""
} else {
s.SwitchName = packerExternalSwitchName
s.oldSwitchName = state.Get("SwitchName").(string)
}
// Set the final name in the state bag so others can use it
state.Put("SwitchName", switchName)
return multistep.ActionContinue
} | [
"func",
"(",
"s",
"*",
"StepCreateExternalSwitch",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"state",
"multistep",
".",
"StateBag",
")",
"multistep",
".",
"StepAction",
"{",
"driver",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
... | // Run runs the step required to create an external switch. Depending on
// the connectivity of the host machine, the external switch will allow the
// build VM to connect to the outside world. | [
"Run",
"runs",
"the",
"step",
"required",
"to",
"create",
"an",
"external",
"switch",
".",
"Depending",
"on",
"the",
"connectivity",
"of",
"the",
"host",
"machine",
"the",
"external",
"switch",
"will",
"allow",
"the",
"build",
"VM",
"to",
"connect",
"to",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/hyperv/common/step_create_external_switch.go#L24-L75 |
165,117 | hashicorp/packer | common/step_create_floppy.go | removeBase | func removeBase(base string, path string) (string, error) {
var idx int
var err error
if res, err := filepath.Abs(path); err == nil {
path = res
}
path = filepath.Clean(path)
if base, err = filepath.Abs(base); err != nil {
return path, err
}
c1, c2 := strings.Split(base, string(os.PathSeparator)), strings.Split(path, string(os.PathSeparator))
for idx = 0; idx < len(c1); idx++ {
if len(c1[idx]) == 0 && len(c2[idx]) != 0 {
break
}
if c1[idx] != c2[idx] {
return "", fmt.Errorf("Path %s is not prefixed by Base %s", path, base)
}
}
return strings.Join(c2[idx:], string(os.PathSeparator)), nil
} | go | func removeBase(base string, path string) (string, error) {
var idx int
var err error
if res, err := filepath.Abs(path); err == nil {
path = res
}
path = filepath.Clean(path)
if base, err = filepath.Abs(base); err != nil {
return path, err
}
c1, c2 := strings.Split(base, string(os.PathSeparator)), strings.Split(path, string(os.PathSeparator))
for idx = 0; idx < len(c1); idx++ {
if len(c1[idx]) == 0 && len(c2[idx]) != 0 {
break
}
if c1[idx] != c2[idx] {
return "", fmt.Errorf("Path %s is not prefixed by Base %s", path, base)
}
}
return strings.Join(c2[idx:], string(os.PathSeparator)), nil
} | [
"func",
"removeBase",
"(",
"base",
"string",
",",
"path",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"idx",
"int",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"res",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"path",
")",
";",
... | // removeBase will take a regular os.PathSeparator-separated path and remove the
// prefix directory base from it. Both paths are converted to their absolute
// formats before the stripping takes place. | [
"removeBase",
"will",
"take",
"a",
"regular",
"os",
".",
"PathSeparator",
"-",
"separated",
"path",
"and",
"remove",
"the",
"prefix",
"directory",
"base",
"from",
"it",
".",
"Both",
"paths",
"are",
"converted",
"to",
"their",
"absolute",
"formats",
"before",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/common/step_create_floppy.go#L311-L334 |
165,118 | hashicorp/packer | builder/parallels/common/driver.go | NewDriver | func NewDriver() (Driver, error) {
var drivers map[string]Driver
var prlctlPath string
var prlsrvctlPath string
var supportedVersions []string
DHCPLeaseFile := "/Library/Preferences/Parallels/parallels_dhcp_leases"
if runtime.GOOS != "darwin" {
return nil, fmt.Errorf(
"Parallels builder works only on \"darwin\" platform!")
}
if prlctlPath == "" {
var err error
prlctlPath, err = exec.LookPath("prlctl")
if err != nil {
return nil, err
}
}
log.Printf("prlctl path: %s", prlctlPath)
if prlsrvctlPath == "" {
var err error
prlsrvctlPath, err = exec.LookPath("prlsrvctl")
if err != nil {
return nil, err
}
}
log.Printf("prlsrvctl path: %s", prlsrvctlPath)
drivers = map[string]Driver{
"11": &Parallels11Driver{
Parallels9Driver: Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
},
"10": &Parallels10Driver{
Parallels9Driver: Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
},
"9": &Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
}
for v, d := range drivers {
version, _ := d.Version()
if strings.HasPrefix(version, v) {
if err := d.Verify(); err != nil {
return nil, err
}
return d, nil
}
supportedVersions = append(supportedVersions, v)
}
latestDriver := 11
version, _ := drivers[strconv.Itoa(latestDriver)].Version()
majVer, _ := strconv.Atoi(strings.SplitN(version, ".", 2)[0])
log.Printf("Parallels version: %s", version)
if majVer > latestDriver {
log.Printf("Your version of Parallels Desktop for Mac is %s, Packer will use driver for version %d.", version, latestDriver)
return drivers[strconv.Itoa(latestDriver)], nil
}
return nil, fmt.Errorf(
"Unable to initialize any driver. Supported Parallels Desktop versions: "+
"%s\n", strings.Join(supportedVersions, ", "))
} | go | func NewDriver() (Driver, error) {
var drivers map[string]Driver
var prlctlPath string
var prlsrvctlPath string
var supportedVersions []string
DHCPLeaseFile := "/Library/Preferences/Parallels/parallels_dhcp_leases"
if runtime.GOOS != "darwin" {
return nil, fmt.Errorf(
"Parallels builder works only on \"darwin\" platform!")
}
if prlctlPath == "" {
var err error
prlctlPath, err = exec.LookPath("prlctl")
if err != nil {
return nil, err
}
}
log.Printf("prlctl path: %s", prlctlPath)
if prlsrvctlPath == "" {
var err error
prlsrvctlPath, err = exec.LookPath("prlsrvctl")
if err != nil {
return nil, err
}
}
log.Printf("prlsrvctl path: %s", prlsrvctlPath)
drivers = map[string]Driver{
"11": &Parallels11Driver{
Parallels9Driver: Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
},
"10": &Parallels10Driver{
Parallels9Driver: Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
},
"9": &Parallels9Driver{
PrlctlPath: prlctlPath,
PrlsrvctlPath: prlsrvctlPath,
dhcpLeaseFile: DHCPLeaseFile,
},
}
for v, d := range drivers {
version, _ := d.Version()
if strings.HasPrefix(version, v) {
if err := d.Verify(); err != nil {
return nil, err
}
return d, nil
}
supportedVersions = append(supportedVersions, v)
}
latestDriver := 11
version, _ := drivers[strconv.Itoa(latestDriver)].Version()
majVer, _ := strconv.Atoi(strings.SplitN(version, ".", 2)[0])
log.Printf("Parallels version: %s", version)
if majVer > latestDriver {
log.Printf("Your version of Parallels Desktop for Mac is %s, Packer will use driver for version %d.", version, latestDriver)
return drivers[strconv.Itoa(latestDriver)], nil
}
return nil, fmt.Errorf(
"Unable to initialize any driver. Supported Parallels Desktop versions: "+
"%s\n", strings.Join(supportedVersions, ", "))
} | [
"func",
"NewDriver",
"(",
")",
"(",
"Driver",
",",
"error",
")",
"{",
"var",
"drivers",
"map",
"[",
"string",
"]",
"Driver",
"\n",
"var",
"prlctlPath",
"string",
"\n",
"var",
"prlsrvctlPath",
"string",
"\n",
"var",
"supportedVersions",
"[",
"]",
"string",
... | // NewDriver returns a new driver implementation for this version of Parallels
// Desktop, or an error if the driver couldn't be initialized. | [
"NewDriver",
"returns",
"a",
"new",
"driver",
"implementation",
"for",
"this",
"version",
"of",
"Parallels",
"Desktop",
"or",
"an",
"error",
"if",
"the",
"driver",
"couldn",
"t",
"be",
"initialized",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver.go#L66-L143 |
165,119 | hashicorp/packer | packer/rpc/ui_progress_tracking.go | TrackProgress | func (u *Ui) TrackProgress(src string, currentSize, totalSize int64, stream io.ReadCloser) io.ReadCloser {
pl := &TrackProgressParameters{
Src: src,
CurrentSize: currentSize,
TotalSize: totalSize,
}
var trackingID string
if err := u.client.Call("Ui.NewTrackProgress", pl, &trackingID); err != nil {
log.Printf("Error in Ui.NewTrackProgress RPC call: %s", err)
return stream
}
cli := &ProgressTrackingClient{
id: trackingID,
client: u.client,
stream: stream,
}
return cli
} | go | func (u *Ui) TrackProgress(src string, currentSize, totalSize int64, stream io.ReadCloser) io.ReadCloser {
pl := &TrackProgressParameters{
Src: src,
CurrentSize: currentSize,
TotalSize: totalSize,
}
var trackingID string
if err := u.client.Call("Ui.NewTrackProgress", pl, &trackingID); err != nil {
log.Printf("Error in Ui.NewTrackProgress RPC call: %s", err)
return stream
}
cli := &ProgressTrackingClient{
id: trackingID,
client: u.client,
stream: stream,
}
return cli
} | [
"func",
"(",
"u",
"*",
"Ui",
")",
"TrackProgress",
"(",
"src",
"string",
",",
"currentSize",
",",
"totalSize",
"int64",
",",
"stream",
"io",
".",
"ReadCloser",
")",
"io",
".",
"ReadCloser",
"{",
"pl",
":=",
"&",
"TrackProgressParameters",
"{",
"Src",
":"... | // TrackProgress starts a pair of ProgressTrackingClient and ProgressProgressTrackingServer
// that will send the size of each read bytes of stream.
// In order to track an operation on the terminal side. | [
"TrackProgress",
"starts",
"a",
"pair",
"of",
"ProgressTrackingClient",
"and",
"ProgressProgressTrackingServer",
"that",
"will",
"send",
"the",
"size",
"of",
"each",
"read",
"bytes",
"of",
"stream",
".",
"In",
"order",
"to",
"track",
"an",
"operation",
"on",
"th... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/packer/rpc/ui_progress_tracking.go#L14-L31 |
165,120 | hashicorp/packer | builder/amazon/common/ssh.go | SSHHost | func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (string, error) {
return func(state multistep.StateBag) (string, error) {
const tries = 2
// <= with current structure to check result of describing `tries` times
for j := 0; j <= tries; j++ {
var host string
i := state.Get("instance").(*ec2.Instance)
if sshInterface != "" {
switch sshInterface {
case "public_ip":
if i.PublicIpAddress != nil {
host = *i.PublicIpAddress
}
case "private_ip":
if i.PrivateIpAddress != nil {
host = *i.PrivateIpAddress
}
case "public_dns":
if i.PublicDnsName != nil {
host = *i.PublicDnsName
}
case "private_dns":
if i.PrivateDnsName != nil {
host = *i.PrivateDnsName
}
default:
panic(fmt.Sprintf("Unknown interface type: %s", sshInterface))
}
} else if i.VpcId != nil && *i.VpcId != "" {
if i.PublicIpAddress != nil && *i.PublicIpAddress != "" {
host = *i.PublicIpAddress
} else if i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
host = *i.PrivateIpAddress
}
} else if i.PublicDnsName != nil && *i.PublicDnsName != "" {
host = *i.PublicDnsName
}
if host != "" {
return host, nil
}
r, err := e.DescribeInstances(&ec2.DescribeInstancesInput{
InstanceIds: []*string{i.InstanceId},
})
if err != nil {
return "", err
}
if len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
return "", fmt.Errorf("instance not found: %s", *i.InstanceId)
}
state.Put("instance", r.Reservations[0].Instances[0])
time.Sleep(sshHostSleepDuration)
}
return "", errors.New("couldn't determine address for instance")
}
} | go | func SSHHost(e ec2Describer, sshInterface string) func(multistep.StateBag) (string, error) {
return func(state multistep.StateBag) (string, error) {
const tries = 2
// <= with current structure to check result of describing `tries` times
for j := 0; j <= tries; j++ {
var host string
i := state.Get("instance").(*ec2.Instance)
if sshInterface != "" {
switch sshInterface {
case "public_ip":
if i.PublicIpAddress != nil {
host = *i.PublicIpAddress
}
case "private_ip":
if i.PrivateIpAddress != nil {
host = *i.PrivateIpAddress
}
case "public_dns":
if i.PublicDnsName != nil {
host = *i.PublicDnsName
}
case "private_dns":
if i.PrivateDnsName != nil {
host = *i.PrivateDnsName
}
default:
panic(fmt.Sprintf("Unknown interface type: %s", sshInterface))
}
} else if i.VpcId != nil && *i.VpcId != "" {
if i.PublicIpAddress != nil && *i.PublicIpAddress != "" {
host = *i.PublicIpAddress
} else if i.PrivateIpAddress != nil && *i.PrivateIpAddress != "" {
host = *i.PrivateIpAddress
}
} else if i.PublicDnsName != nil && *i.PublicDnsName != "" {
host = *i.PublicDnsName
}
if host != "" {
return host, nil
}
r, err := e.DescribeInstances(&ec2.DescribeInstancesInput{
InstanceIds: []*string{i.InstanceId},
})
if err != nil {
return "", err
}
if len(r.Reservations) == 0 || len(r.Reservations[0].Instances) == 0 {
return "", fmt.Errorf("instance not found: %s", *i.InstanceId)
}
state.Put("instance", r.Reservations[0].Instances[0])
time.Sleep(sshHostSleepDuration)
}
return "", errors.New("couldn't determine address for instance")
}
} | [
"func",
"SSHHost",
"(",
"e",
"ec2Describer",
",",
"sshInterface",
"string",
")",
"func",
"(",
"multistep",
".",
"StateBag",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"func",
"(",
"state",
"multistep",
".",
"StateBag",
")",
"(",
"string",
",",... | // SSHHost returns a function that can be given to the SSH communicator
// for determining the SSH address based on the instance DNS name. | [
"SSHHost",
"returns",
"a",
"function",
"that",
"can",
"be",
"given",
"to",
"the",
"SSH",
"communicator",
"for",
"determining",
"the",
"SSH",
"address",
"based",
"on",
"the",
"instance",
"DNS",
"name",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/amazon/common/ssh.go#L23-L82 |
165,121 | hashicorp/packer | packer/rpc/mux_broker.go | Run | func (m *muxBroker) Run() {
for {
stream, err := m.session.AcceptStream()
if err != nil {
// Once we receive an error, just exit
break
}
// Read the stream ID from the stream
var id uint32
if err := binary.Read(stream, binary.LittleEndian, &id); err != nil {
stream.Close()
continue
}
// Initialize the waiter
p := m.getStream(id)
select {
case p.ch <- stream:
default:
}
// Wait for a timeout
go m.timeoutWait(id, p)
}
} | go | func (m *muxBroker) Run() {
for {
stream, err := m.session.AcceptStream()
if err != nil {
// Once we receive an error, just exit
break
}
// Read the stream ID from the stream
var id uint32
if err := binary.Read(stream, binary.LittleEndian, &id); err != nil {
stream.Close()
continue
}
// Initialize the waiter
p := m.getStream(id)
select {
case p.ch <- stream:
default:
}
// Wait for a timeout
go m.timeoutWait(id, p)
}
} | [
"func",
"(",
"m",
"*",
"muxBroker",
")",
"Run",
"(",
")",
"{",
"for",
"{",
"stream",
",",
"err",
":=",
"m",
".",
"session",
".",
"AcceptStream",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Once we receive an error, just exit",
"break",
"\n",
"}"... | // Run starts the brokering and should be executed in a goroutine, since it
// blocks forever, or until the session closes. | [
"Run",
"starts",
"the",
"brokering",
"and",
"should",
"be",
"executed",
"in",
"a",
"goroutine",
"since",
"it",
"blocks",
"forever",
"or",
"until",
"the",
"session",
"closes",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/packer/rpc/mux_broker.go#L124-L149 |
165,122 | hashicorp/packer | common/iochan/iochan.go | LineReader | func LineReader(r io.Reader) <-chan string {
ch := make(chan string)
go func() {
scanner := bufio.NewScanner(r)
defer close(ch)
for scanner.Scan() {
ch <- scanner.Text()
}
}()
return ch
} | go | func LineReader(r io.Reader) <-chan string {
ch := make(chan string)
go func() {
scanner := bufio.NewScanner(r)
defer close(ch)
for scanner.Scan() {
ch <- scanner.Text()
}
}()
return ch
} | [
"func",
"LineReader",
"(",
"r",
"io",
".",
"Reader",
")",
"<-",
"chan",
"string",
"{",
"ch",
":=",
"make",
"(",
"chan",
"string",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"r",
")",
"\n",
"defer",
... | // LineReader takes an io.Reader and produces the contents of the reader on the
// returned channel. Internally bufio.NewScanner is used, io.ScanLines parses
// lines and returns them without carriage return. Scan can panic if the split
// function returns too many empty tokens without advancing the input.
//
// The channel will be closed either by reaching the end of the input or an
// error. | [
"LineReader",
"takes",
"an",
"io",
".",
"Reader",
"and",
"produces",
"the",
"contents",
"of",
"the",
"reader",
"on",
"the",
"returned",
"channel",
".",
"Internally",
"bufio",
".",
"NewScanner",
"is",
"used",
"io",
".",
"ScanLines",
"parses",
"lines",
"and",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/common/iochan/iochan.go#L15-L28 |
165,123 | hashicorp/packer | builder/azure/common/devicelogin.go | tokenFromFile | func tokenFromFile(say func(string), oauthCfg adal.OAuthConfig, tokenPath, clientID, resource string,
callback adal.TokenRefreshCallback) (*adal.ServicePrincipalToken, error) {
say(fmt.Sprintf("Loading auth token from file: %s", tokenPath))
if _, err := os.Stat(tokenPath); err != nil {
if os.IsNotExist(err) { // file not found
return nil, nil
}
return nil, err
}
token, err := adal.LoadToken(tokenPath)
if err != nil {
return nil, fmt.Errorf("Failed to load token from file: %v", err)
}
spt, err := adal.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token, callback)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token: %v", err)
}
return spt, nil
} | go | func tokenFromFile(say func(string), oauthCfg adal.OAuthConfig, tokenPath, clientID, resource string,
callback adal.TokenRefreshCallback) (*adal.ServicePrincipalToken, error) {
say(fmt.Sprintf("Loading auth token from file: %s", tokenPath))
if _, err := os.Stat(tokenPath); err != nil {
if os.IsNotExist(err) { // file not found
return nil, nil
}
return nil, err
}
token, err := adal.LoadToken(tokenPath)
if err != nil {
return nil, fmt.Errorf("Failed to load token from file: %v", err)
}
spt, err := adal.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token, callback)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token: %v", err)
}
return spt, nil
} | [
"func",
"tokenFromFile",
"(",
"say",
"func",
"(",
"string",
")",
",",
"oauthCfg",
"adal",
".",
"OAuthConfig",
",",
"tokenPath",
",",
"clientID",
",",
"resource",
"string",
",",
"callback",
"adal",
".",
"TokenRefreshCallback",
")",
"(",
"*",
"adal",
".",
"S... | // tokenFromFile returns a token from the specified file if it is found, otherwise
// returns nil. Any error retrieving or creating the token is returned as an error. | [
"tokenFromFile",
"returns",
"a",
"token",
"from",
"the",
"specified",
"file",
"if",
"it",
"is",
"found",
"otherwise",
"returns",
"nil",
".",
"Any",
"error",
"retrieving",
"or",
"creating",
"the",
"token",
"is",
"returned",
"as",
"an",
"error",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/devicelogin.go#L99-L119 |
165,124 | hashicorp/packer | builder/azure/common/devicelogin.go | tokenFromDeviceFlow | func tokenFromDeviceFlow(say func(string), oauthCfg adal.OAuthConfig, clientID, resource string) (*adal.ServicePrincipalToken, error) {
cl := autorest.NewClientWithUserAgent(useragent.String())
deviceCode, err := adal.InitiateDeviceAuth(&cl, oauthCfg, clientID, resource)
if err != nil {
return nil, fmt.Errorf("Failed to start device auth: %v", err)
}
// Example message: “To sign in, open https://aka.ms/devicelogin and enter
// the code 0000000 to authenticate.”
say(fmt.Sprintf("Microsoft Azure: %s", to.String(deviceCode.Message)))
token, err := adal.WaitForUserCompletion(&cl, deviceCode)
if err != nil {
return nil, fmt.Errorf("Failed to complete device auth: %v", err)
}
spt, err := adal.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token: %v", err)
}
return spt, nil
} | go | func tokenFromDeviceFlow(say func(string), oauthCfg adal.OAuthConfig, clientID, resource string) (*adal.ServicePrincipalToken, error) {
cl := autorest.NewClientWithUserAgent(useragent.String())
deviceCode, err := adal.InitiateDeviceAuth(&cl, oauthCfg, clientID, resource)
if err != nil {
return nil, fmt.Errorf("Failed to start device auth: %v", err)
}
// Example message: “To sign in, open https://aka.ms/devicelogin and enter
// the code 0000000 to authenticate.”
say(fmt.Sprintf("Microsoft Azure: %s", to.String(deviceCode.Message)))
token, err := adal.WaitForUserCompletion(&cl, deviceCode)
if err != nil {
return nil, fmt.Errorf("Failed to complete device auth: %v", err)
}
spt, err := adal.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token: %v", err)
}
return spt, nil
} | [
"func",
"tokenFromDeviceFlow",
"(",
"say",
"func",
"(",
"string",
")",
",",
"oauthCfg",
"adal",
".",
"OAuthConfig",
",",
"clientID",
",",
"resource",
"string",
")",
"(",
"*",
"adal",
".",
"ServicePrincipalToken",
",",
"error",
")",
"{",
"cl",
":=",
"autore... | // tokenFromDeviceFlow prints a message to the screen for user to take action to
// consent application on a browser and in the meanwhile the authentication
// endpoint is polled until user gives consent, denies or the flow times out.
// Returned token must be saved. | [
"tokenFromDeviceFlow",
"prints",
"a",
"message",
"to",
"the",
"screen",
"for",
"user",
"to",
"take",
"action",
"to",
"consent",
"application",
"on",
"a",
"browser",
"and",
"in",
"the",
"meanwhile",
"the",
"authentication",
"endpoint",
"is",
"polled",
"until",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/devicelogin.go#L125-L146 |
165,125 | hashicorp/packer | builder/azure/common/devicelogin.go | tokenCachePath | func tokenCachePath(tenantID string) string {
var dir string
u, err := user.Current()
if err != nil || u.HomeDir == "" {
dir, _ = filepath.Abs(os.Args[0])
} else {
dir = u.HomeDir
}
return filepath.Join(dir, ".azure", "packer", fmt.Sprintf("oauth-%s.json", tenantID))
} | go | func tokenCachePath(tenantID string) string {
var dir string
u, err := user.Current()
if err != nil || u.HomeDir == "" {
dir, _ = filepath.Abs(os.Args[0])
} else {
dir = u.HomeDir
}
return filepath.Join(dir, ".azure", "packer", fmt.Sprintf("oauth-%s.json", tenantID))
} | [
"func",
"tokenCachePath",
"(",
"tenantID",
"string",
")",
"string",
"{",
"var",
"dir",
"string",
"\n\n",
"u",
",",
"err",
":=",
"user",
".",
"Current",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"u",
".",
"HomeDir",
"==",
"\"",
"\"",
"{",
"dir... | // tokenCachePath returns the full path the OAuth 2.0 token should be saved at
// for given tenant ID. | [
"tokenCachePath",
"returns",
"the",
"full",
"path",
"the",
"OAuth",
"2",
".",
"0",
"token",
"should",
"be",
"saved",
"at",
"for",
"given",
"tenant",
"ID",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/devicelogin.go#L150-L161 |
165,126 | hashicorp/packer | builder/azure/common/devicelogin.go | mkTokenCallback | func mkTokenCallback(path string) adal.TokenRefreshCallback {
return func(t adal.Token) error {
if err := adal.SaveToken(path, 0600, t); err != nil {
return err
}
return nil
}
} | go | func mkTokenCallback(path string) adal.TokenRefreshCallback {
return func(t adal.Token) error {
if err := adal.SaveToken(path, 0600, t); err != nil {
return err
}
return nil
}
} | [
"func",
"mkTokenCallback",
"(",
"path",
"string",
")",
"adal",
".",
"TokenRefreshCallback",
"{",
"return",
"func",
"(",
"t",
"adal",
".",
"Token",
")",
"error",
"{",
"if",
"err",
":=",
"adal",
".",
"SaveToken",
"(",
"path",
",",
"0600",
",",
"t",
")",
... | // mkTokenCallback returns a callback function that can be used to save the
// token initially or register to the Azure SDK to be called when the token is
// refreshed. | [
"mkTokenCallback",
"returns",
"a",
"callback",
"function",
"that",
"can",
"be",
"used",
"to",
"save",
"the",
"token",
"initially",
"or",
"register",
"to",
"the",
"Azure",
"SDK",
"to",
"be",
"called",
"when",
"the",
"token",
"is",
"refreshed",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/devicelogin.go#L166-L173 |
165,127 | hashicorp/packer | builder/azure/common/devicelogin.go | FindTenantID | func FindTenantID(env azure.Environment, subscriptionID string) (string, error) {
const hdrKey = "WWW-Authenticate"
c := subscriptions.NewClientWithBaseURI(env.ResourceManagerEndpoint)
// we expect this request to fail (err != nil), but we are only interested
// in headers, so surface the error if the Response is not present (i.e.
// network error etc)
subs, err := c.Get(context.TODO(), subscriptionID)
if subs.Response.Response == nil {
return "", fmt.Errorf("Request failed: %v", err)
}
// Expecting 401 StatusUnauthorized here, just read the header
if subs.StatusCode != http.StatusUnauthorized {
return "", fmt.Errorf("Unexpected response from Get Subscription: %v", err)
}
hdr := subs.Header.Get(hdrKey)
if hdr == "" {
return "", fmt.Errorf("Header %v not found in Get Subscription response", hdrKey)
}
// Example value for hdr:
// Bearer authorization_uri="https://login.windows.net/996fe9d1-6171-40aa-945b-4c64b63bf655", error="invalid_token", error_description="The authentication failed because of missing 'Authorization' header."
r := regexp.MustCompile(`authorization_uri=".*/([0-9a-f\-]+)"`)
m := r.FindStringSubmatch(hdr)
if m == nil {
return "", fmt.Errorf("Could not find the tenant ID in header: %s %q", hdrKey, hdr)
}
return m[1], nil
} | go | func FindTenantID(env azure.Environment, subscriptionID string) (string, error) {
const hdrKey = "WWW-Authenticate"
c := subscriptions.NewClientWithBaseURI(env.ResourceManagerEndpoint)
// we expect this request to fail (err != nil), but we are only interested
// in headers, so surface the error if the Response is not present (i.e.
// network error etc)
subs, err := c.Get(context.TODO(), subscriptionID)
if subs.Response.Response == nil {
return "", fmt.Errorf("Request failed: %v", err)
}
// Expecting 401 StatusUnauthorized here, just read the header
if subs.StatusCode != http.StatusUnauthorized {
return "", fmt.Errorf("Unexpected response from Get Subscription: %v", err)
}
hdr := subs.Header.Get(hdrKey)
if hdr == "" {
return "", fmt.Errorf("Header %v not found in Get Subscription response", hdrKey)
}
// Example value for hdr:
// Bearer authorization_uri="https://login.windows.net/996fe9d1-6171-40aa-945b-4c64b63bf655", error="invalid_token", error_description="The authentication failed because of missing 'Authorization' header."
r := regexp.MustCompile(`authorization_uri=".*/([0-9a-f\-]+)"`)
m := r.FindStringSubmatch(hdr)
if m == nil {
return "", fmt.Errorf("Could not find the tenant ID in header: %s %q", hdrKey, hdr)
}
return m[1], nil
} | [
"func",
"FindTenantID",
"(",
"env",
"azure",
".",
"Environment",
",",
"subscriptionID",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"const",
"hdrKey",
"=",
"\"",
"\"",
"\n",
"c",
":=",
"subscriptions",
".",
"NewClientWithBaseURI",
"(",
"env",
"."... | // FindTenantID figures out the AAD tenant ID of the subscription by making an
// unauthenticated request to the Get Subscription Details endpoint and parses
// the value from WWW-Authenticate header. | [
"FindTenantID",
"figures",
"out",
"the",
"AAD",
"tenant",
"ID",
"of",
"the",
"subscription",
"by",
"making",
"an",
"unauthenticated",
"request",
"to",
"the",
"Get",
"Subscription",
"Details",
"endpoint",
"and",
"parses",
"the",
"value",
"from",
"WWW",
"-",
"Au... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/devicelogin.go#L178-L207 |
165,128 | hashicorp/packer | builder/azure/pkcs12/bmp-string.go | bmpString | func bmpString(s string) ([]byte, error) {
// References:
// https://tools.ietf.org/html/rfc7292#appendix-B.1
// http://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane
// - non-BMP characters are encoded in UTF 16 by using a surrogate pair of 16-bit codes
// EncodeRune returns 0xfffd if the rune does not need special encoding
// - the above RFC provides the info that BMPStrings are NULL terminated.
ret := make([]byte, 0, 2*len(s)+2)
for _, r := range s {
if t, _ := utf16.EncodeRune(r); t != 0xfffd {
return nil, errors.New("pkcs12: string contains characters that cannot be encoded in UCS-2")
}
ret = append(ret, byte(r/256), byte(r%256))
}
return append(ret, 0, 0), nil
} | go | func bmpString(s string) ([]byte, error) {
// References:
// https://tools.ietf.org/html/rfc7292#appendix-B.1
// http://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane
// - non-BMP characters are encoded in UTF 16 by using a surrogate pair of 16-bit codes
// EncodeRune returns 0xfffd if the rune does not need special encoding
// - the above RFC provides the info that BMPStrings are NULL terminated.
ret := make([]byte, 0, 2*len(s)+2)
for _, r := range s {
if t, _ := utf16.EncodeRune(r); t != 0xfffd {
return nil, errors.New("pkcs12: string contains characters that cannot be encoded in UCS-2")
}
ret = append(ret, byte(r/256), byte(r%256))
}
return append(ret, 0, 0), nil
} | [
"func",
"bmpString",
"(",
"s",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// References:",
"// https://tools.ietf.org/html/rfc7292#appendix-B.1",
"// http://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane",
"// - non-BMP characters are encoded in... | // bmpString returns s encoded in UCS-2 with a zero terminator. | [
"bmpString",
"returns",
"s",
"encoded",
"in",
"UCS",
"-",
"2",
"with",
"a",
"zero",
"terminator",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/pkcs12/bmp-string.go#L13-L31 |
165,129 | hashicorp/packer | builder/azure/arm/template_funcs.go | templateCleanImageName | func templateCleanImageName(s string) string {
if ok, _ := assertManagedImageName(s, ""); ok {
return s
}
b := []byte(s)
newb := make([]byte, len(b))
for i := range newb {
if isValidByteValue(b[i]) {
newb[i] = b[i]
} else {
newb[i] = '-'
}
}
newb = bytes.TrimRight(newb, "-_.")
return string(newb)
} | go | func templateCleanImageName(s string) string {
if ok, _ := assertManagedImageName(s, ""); ok {
return s
}
b := []byte(s)
newb := make([]byte, len(b))
for i := range newb {
if isValidByteValue(b[i]) {
newb[i] = b[i]
} else {
newb[i] = '-'
}
}
newb = bytes.TrimRight(newb, "-_.")
return string(newb)
} | [
"func",
"templateCleanImageName",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"ok",
",",
"_",
":=",
"assertManagedImageName",
"(",
"s",
",",
"\"",
"\"",
")",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"b",
":=",
"[",
"]",
"byte",
"(",
"s",
... | // Clean up image name by replacing invalid characters with "-"
// Names are not allowed to end in '.', '-', or '_' and are trimmed. | [
"Clean",
"up",
"image",
"name",
"by",
"replacing",
"invalid",
"characters",
"with",
"-",
"Names",
"are",
"not",
"allowed",
"to",
"end",
"in",
".",
"-",
"or",
"_",
"and",
"are",
"trimmed",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/arm/template_funcs.go#L25-L41 |
165,130 | hashicorp/packer | communicator/winrm/time.go | formatDuration | func formatDuration(duration time.Duration) string {
// We're not supporting negative durations
if duration.Seconds() <= 0 {
return "PT0S"
}
h := int(duration.Hours())
m := int(duration.Minutes()) - (h * 60)
s := int(duration.Seconds()) - (h*3600 + m*60)
res := "PT"
if h > 0 {
res = fmt.Sprintf("%s%dH", res, h)
}
if m > 0 {
res = fmt.Sprintf("%s%dM", res, m)
}
if s > 0 {
res = fmt.Sprintf("%s%dS", res, s)
}
return res
} | go | func formatDuration(duration time.Duration) string {
// We're not supporting negative durations
if duration.Seconds() <= 0 {
return "PT0S"
}
h := int(duration.Hours())
m := int(duration.Minutes()) - (h * 60)
s := int(duration.Seconds()) - (h*3600 + m*60)
res := "PT"
if h > 0 {
res = fmt.Sprintf("%s%dH", res, h)
}
if m > 0 {
res = fmt.Sprintf("%s%dM", res, m)
}
if s > 0 {
res = fmt.Sprintf("%s%dS", res, s)
}
return res
} | [
"func",
"formatDuration",
"(",
"duration",
"time",
".",
"Duration",
")",
"string",
"{",
"// We're not supporting negative durations",
"if",
"duration",
".",
"Seconds",
"(",
")",
"<=",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"h",
":=",
"int",
"(",
... | // formatDuration formats the given time.Duration into an ISO8601
// duration string. | [
"formatDuration",
"formats",
"the",
"given",
"time",
".",
"Duration",
"into",
"an",
"ISO8601",
"duration",
"string",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/communicator/winrm/time.go#L10-L32 |
165,131 | hashicorp/packer | builder/file/builder.go | Run | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
artifact := new(FileArtifact)
if b.config.Source != "" {
source, err := os.Open(b.config.Source)
defer source.Close()
if err != nil {
return nil, err
}
// Create will truncate an existing file
target, err := os.Create(b.config.Target)
defer target.Close()
if err != nil {
return nil, err
}
ui.Say(fmt.Sprintf("Copying %s to %s", source.Name(), target.Name()))
bytes, err := io.Copy(target, source)
if err != nil {
return nil, err
}
ui.Say(fmt.Sprintf("Copied %d bytes", bytes))
artifact.filename = target.Name()
} else {
// We're going to write Contents; if it's empty we'll just create an
// empty file.
err := ioutil.WriteFile(b.config.Target, []byte(b.config.Content), 0600)
if err != nil {
return nil, err
}
artifact.filename = b.config.Target
}
if hook != nil {
if err := hook.Run(ctx, packer.HookProvision, ui, new(packer.MockCommunicator), nil); err != nil {
return nil, err
}
}
return artifact, nil
} | go | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
artifact := new(FileArtifact)
if b.config.Source != "" {
source, err := os.Open(b.config.Source)
defer source.Close()
if err != nil {
return nil, err
}
// Create will truncate an existing file
target, err := os.Create(b.config.Target)
defer target.Close()
if err != nil {
return nil, err
}
ui.Say(fmt.Sprintf("Copying %s to %s", source.Name(), target.Name()))
bytes, err := io.Copy(target, source)
if err != nil {
return nil, err
}
ui.Say(fmt.Sprintf("Copied %d bytes", bytes))
artifact.filename = target.Name()
} else {
// We're going to write Contents; if it's empty we'll just create an
// empty file.
err := ioutil.WriteFile(b.config.Target, []byte(b.config.Content), 0600)
if err != nil {
return nil, err
}
artifact.filename = b.config.Target
}
if hook != nil {
if err := hook.Run(ctx, packer.HookProvision, ui, new(packer.MockCommunicator), nil); err != nil {
return nil, err
}
}
return artifact, nil
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"ui",
"packer",
".",
"Ui",
",",
"hook",
"packer",
".",
"Hook",
")",
"(",
"packer",
".",
"Artifact",
",",
"error",
")",
"{",
"artifact",
":=",
"new",
"(",
"F... | // Run is where the actual build should take place. It takes a Build and a Ui. | [
"Run",
"is",
"where",
"the",
"actual",
"build",
"should",
"take",
"place",
".",
"It",
"takes",
"a",
"Build",
"and",
"a",
"Ui",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/file/builder.go#L37-L78 |
165,132 | hashicorp/packer | builder/googlecompute/step_teardown_instance.go | Run | func (s *StepTeardownInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
name := config.InstanceName
if name == "" {
return multistep.ActionHalt
}
ui.Say("Deleting instance...")
instanceLog, _ := driver.GetSerialPortOutput(config.Zone, name)
state.Put("instance_log", instanceLog)
errCh, err := driver.DeleteInstance(config.Zone, name)
if err == nil {
select {
case err = <-errCh:
case <-time.After(config.stateTimeout):
err = errors.New("time out while waiting for instance to delete")
}
}
if err != nil {
ui.Error(fmt.Sprintf(
"Error deleting instance. Please delete it manually.\n\n"+
"Name: %s\n"+
"Error: %s", name, err))
return multistep.ActionHalt
}
ui.Message("Instance has been deleted!")
state.Put("instance_name", "")
return multistep.ActionContinue
} | go | func (s *StepTeardownInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
name := config.InstanceName
if name == "" {
return multistep.ActionHalt
}
ui.Say("Deleting instance...")
instanceLog, _ := driver.GetSerialPortOutput(config.Zone, name)
state.Put("instance_log", instanceLog)
errCh, err := driver.DeleteInstance(config.Zone, name)
if err == nil {
select {
case err = <-errCh:
case <-time.After(config.stateTimeout):
err = errors.New("time out while waiting for instance to delete")
}
}
if err != nil {
ui.Error(fmt.Sprintf(
"Error deleting instance. Please delete it manually.\n\n"+
"Name: %s\n"+
"Error: %s", name, err))
return multistep.ActionHalt
}
ui.Message("Instance has been deleted!")
state.Put("instance_name", "")
return multistep.ActionContinue
} | [
"func",
"(",
"s",
"*",
"StepTeardownInstance",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"state",
"multistep",
".",
"StateBag",
")",
"multistep",
".",
"StepAction",
"{",
"config",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",... | // Run executes the Packer build step that tears down a GCE instance. | [
"Run",
"executes",
"the",
"Packer",
"build",
"step",
"that",
"tears",
"down",
"a",
"GCE",
"instance",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/step_teardown_instance.go#L20-L53 |
165,133 | hashicorp/packer | builder/googlecompute/step_teardown_instance.go | Cleanup | func (s *StepTeardownInstance) Cleanup(state multistep.StateBag) {
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
ui.Say("Deleting disk...")
errCh, err := driver.DeleteDisk(config.Zone, config.DiskName)
if err == nil {
select {
case err = <-errCh:
case <-time.After(config.stateTimeout):
err = errors.New("time out while waiting for disk to delete")
}
}
if err != nil {
ui.Error(fmt.Sprintf(
"Error deleting disk. Please delete it manually.\n\n"+
"DiskName: %s\n"+
"Zone: %s\n"+
"Error: %s", config.DiskName, config.Zone, err))
}
ui.Message("Disk has been deleted!")
return
} | go | func (s *StepTeardownInstance) Cleanup(state multistep.StateBag) {
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
ui.Say("Deleting disk...")
errCh, err := driver.DeleteDisk(config.Zone, config.DiskName)
if err == nil {
select {
case err = <-errCh:
case <-time.After(config.stateTimeout):
err = errors.New("time out while waiting for disk to delete")
}
}
if err != nil {
ui.Error(fmt.Sprintf(
"Error deleting disk. Please delete it manually.\n\n"+
"DiskName: %s\n"+
"Zone: %s\n"+
"Error: %s", config.DiskName, config.Zone, err))
}
ui.Message("Disk has been deleted!")
return
} | [
"func",
"(",
"s",
"*",
"StepTeardownInstance",
")",
"Cleanup",
"(",
"state",
"multistep",
".",
"StateBag",
")",
"{",
"config",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"*",
"Config",
")",
"\n",
"driver",
":=",
"state",
".",
"Get",
... | // Deleting the instance does not remove the boot disk. This cleanup removes
// the disk. | [
"Deleting",
"the",
"instance",
"does",
"not",
"remove",
"the",
"boot",
"disk",
".",
"This",
"cleanup",
"removes",
"the",
"disk",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/step_teardown_instance.go#L57-L83 |
165,134 | hashicorp/packer | communicator/ssh/communicator.go | New | func New(address string, config *Config) (result *comm, err error) {
// Establish an initial connection and connect
result = &comm{
config: config,
address: address,
}
if err = result.reconnect(); err != nil {
result = nil
return
}
return
} | go | func New(address string, config *Config) (result *comm, err error) {
// Establish an initial connection and connect
result = &comm{
config: config,
address: address,
}
if err = result.reconnect(); err != nil {
result = nil
return
}
return
} | [
"func",
"New",
"(",
"address",
"string",
",",
"config",
"*",
"Config",
")",
"(",
"result",
"*",
"comm",
",",
"err",
"error",
")",
"{",
"// Establish an initial connection and connect",
"result",
"=",
"&",
"comm",
"{",
"config",
":",
"config",
",",
"address",... | // Creates a new packer.Communicator implementation over SSH. This takes
// an already existing TCP connection and SSH configuration. | [
"Creates",
"a",
"new",
"packer",
".",
"Communicator",
"implementation",
"over",
"SSH",
".",
"This",
"takes",
"an",
"already",
"existing",
"TCP",
"connection",
"and",
"SSH",
"configuration",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/communicator/ssh/communicator.go#L71-L84 |
165,135 | hashicorp/packer | builder/parallels/common/prlctl_post_config.go | Prepare | func (c *PrlctlPostConfig) Prepare(ctx *interpolate.Context) []error {
if c.PrlctlPost == nil {
c.PrlctlPost = make([][]string, 0)
}
return nil
} | go | func (c *PrlctlPostConfig) Prepare(ctx *interpolate.Context) []error {
if c.PrlctlPost == nil {
c.PrlctlPost = make([][]string, 0)
}
return nil
} | [
"func",
"(",
"c",
"*",
"PrlctlPostConfig",
")",
"Prepare",
"(",
"ctx",
"*",
"interpolate",
".",
"Context",
")",
"[",
"]",
"error",
"{",
"if",
"c",
".",
"PrlctlPost",
"==",
"nil",
"{",
"c",
".",
"PrlctlPost",
"=",
"make",
"(",
"[",
"]",
"[",
"]",
... | // Prepare sets the default value of "PrlctlPost" property. | [
"Prepare",
"sets",
"the",
"default",
"value",
"of",
"PrlctlPost",
"property",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/prlctl_post_config.go#L14-L20 |
165,136 | hashicorp/packer | builder/oracle/oci/driver_mock.go | DeleteImage | func (d *driverMock) DeleteImage(ctx context.Context, id string) error {
if d.DeleteImageErr != nil {
return d.DeleteImageErr
}
d.DeleteImageID = id
return nil
} | go | func (d *driverMock) DeleteImage(ctx context.Context, id string) error {
if d.DeleteImageErr != nil {
return d.DeleteImageErr
}
d.DeleteImageID = id
return nil
} | [
"func",
"(",
"d",
"*",
"driverMock",
")",
"DeleteImage",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"string",
")",
"error",
"{",
"if",
"d",
".",
"DeleteImageErr",
"!=",
"nil",
"{",
"return",
"d",
".",
"DeleteImageErr",
"\n",
"}",
"\n\n",
"d",
... | // DeleteImage mocks deleting a custom image. | [
"DeleteImage",
"mocks",
"deleting",
"a",
"custom",
"image",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/oracle/oci/driver_mock.go#L54-L62 |
165,137 | hashicorp/packer | builder/cloudstack/builder.go | Run | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
b.ui = ui
// Create a CloudStack API client.
client := cloudstack.NewAsyncClient(
b.config.APIURL,
b.config.APIKey,
b.config.SecretKey,
!b.config.SSLNoVerify,
)
// Set the time to wait before timing out
client.AsyncTimeout(int64(b.config.AsyncTimeout.Seconds()))
// Some CloudStack service providers only allow HTTP GET calls.
client.HTTPGETOnly = b.config.HTTPGetOnly
// Set up the state.
state := new(multistep.BasicStateBag)
state.Put("client", client)
state.Put("config", b.config)
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps.
steps := []multistep.Step{
&stepPrepareConfig{},
&common.StepHTTPServer{
HTTPDir: b.config.HTTPDir,
HTTPPortMin: b.config.HTTPPortMin,
HTTPPortMax: b.config.HTTPPortMax,
},
&stepKeypair{
Debug: b.config.PackerDebug,
Comm: &b.config.Comm,
DebugKeyPath: fmt.Sprintf("cs_%s.pem", b.config.PackerBuildName),
},
&stepCreateSecurityGroup{},
&stepCreateInstance{
Ctx: b.config.ctx,
Debug: b.config.PackerDebug,
},
&stepSetupNetworking{},
&communicator.StepConnect{
Config: &b.config.Comm,
Host: commHost,
SSHConfig: b.config.Comm.SSHConfigFunc(),
SSHPort: commPort,
WinRMPort: commPort,
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
&stepShutdownInstance{},
&stepCreateTemplate{},
}
// Configure the runner and run the steps.
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// If there was an error, return that
if rawErr, ok := state.GetOk("error"); ok {
ui.Error(rawErr.(error).Error())
return nil, rawErr.(error)
}
// If there was no template created, just return
if _, ok := state.GetOk("template"); !ok {
return nil, nil
}
// Build the artifact and return it
artifact := &Artifact{
client: client,
config: b.config,
template: state.Get("template").(*cloudstack.CreateTemplateResponse),
}
return artifact, nil
} | go | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
b.ui = ui
// Create a CloudStack API client.
client := cloudstack.NewAsyncClient(
b.config.APIURL,
b.config.APIKey,
b.config.SecretKey,
!b.config.SSLNoVerify,
)
// Set the time to wait before timing out
client.AsyncTimeout(int64(b.config.AsyncTimeout.Seconds()))
// Some CloudStack service providers only allow HTTP GET calls.
client.HTTPGETOnly = b.config.HTTPGetOnly
// Set up the state.
state := new(multistep.BasicStateBag)
state.Put("client", client)
state.Put("config", b.config)
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps.
steps := []multistep.Step{
&stepPrepareConfig{},
&common.StepHTTPServer{
HTTPDir: b.config.HTTPDir,
HTTPPortMin: b.config.HTTPPortMin,
HTTPPortMax: b.config.HTTPPortMax,
},
&stepKeypair{
Debug: b.config.PackerDebug,
Comm: &b.config.Comm,
DebugKeyPath: fmt.Sprintf("cs_%s.pem", b.config.PackerBuildName),
},
&stepCreateSecurityGroup{},
&stepCreateInstance{
Ctx: b.config.ctx,
Debug: b.config.PackerDebug,
},
&stepSetupNetworking{},
&communicator.StepConnect{
Config: &b.config.Comm,
Host: commHost,
SSHConfig: b.config.Comm.SSHConfigFunc(),
SSHPort: commPort,
WinRMPort: commPort,
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
&stepShutdownInstance{},
&stepCreateTemplate{},
}
// Configure the runner and run the steps.
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// If there was an error, return that
if rawErr, ok := state.GetOk("error"); ok {
ui.Error(rawErr.(error).Error())
return nil, rawErr.(error)
}
// If there was no template created, just return
if _, ok := state.GetOk("template"); !ok {
return nil, nil
}
// Build the artifact and return it
artifact := &Artifact{
client: client,
config: b.config,
template: state.Get("template").(*cloudstack.CreateTemplateResponse),
}
return artifact, nil
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"ui",
"packer",
".",
"Ui",
",",
"hook",
"packer",
".",
"Hook",
")",
"(",
"packer",
".",
"Artifact",
",",
"error",
")",
"{",
"b",
".",
"ui",
"=",
"ui",
"\n... | // Run implements the packer.Builder interface. | [
"Run",
"implements",
"the",
"packer",
".",
"Builder",
"interface",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/cloudstack/builder.go#L35-L116 |
165,138 | hashicorp/packer | builder/vagrant/artifact.go | NewArtifact | func NewArtifact(provider, dir string) packer.Artifact {
return &artifact{
OutputDir: dir,
BoxName: "package.box",
Provider: provider,
}
} | go | func NewArtifact(provider, dir string) packer.Artifact {
return &artifact{
OutputDir: dir,
BoxName: "package.box",
Provider: provider,
}
} | [
"func",
"NewArtifact",
"(",
"provider",
",",
"dir",
"string",
")",
"packer",
".",
"Artifact",
"{",
"return",
"&",
"artifact",
"{",
"OutputDir",
":",
"dir",
",",
"BoxName",
":",
"\"",
"\"",
",",
"Provider",
":",
"provider",
",",
"}",
"\n",
"}"
] | // NewArtifact returns a vagrant artifact containing the .box file | [
"NewArtifact",
"returns",
"a",
"vagrant",
"artifact",
"containing",
"the",
".",
"box",
"file"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vagrant/artifact.go#L22-L28 |
165,139 | hashicorp/packer | builder/parallels/common/step_compact_disk.go | Run | func (s *StepCompactDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
driver := state.Get("driver").(Driver)
vmName := state.Get("vmName").(string)
ui := state.Get("ui").(packer.Ui)
if s.Skip {
ui.Say("Skipping disk compaction step...")
return multistep.ActionContinue
}
ui.Say("Compacting the disk image")
diskPath, err := driver.DiskPath(vmName)
if err != nil {
err = fmt.Errorf("Error detecting virtual disk path: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if err := driver.CompactDisk(diskPath); err != nil {
state.Put("error", fmt.Errorf("Error compacting disk: %s", err))
ui.Error(err.Error())
return multistep.ActionHalt
}
return multistep.ActionContinue
} | go | func (s *StepCompactDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
driver := state.Get("driver").(Driver)
vmName := state.Get("vmName").(string)
ui := state.Get("ui").(packer.Ui)
if s.Skip {
ui.Say("Skipping disk compaction step...")
return multistep.ActionContinue
}
ui.Say("Compacting the disk image")
diskPath, err := driver.DiskPath(vmName)
if err != nil {
err = fmt.Errorf("Error detecting virtual disk path: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
if err := driver.CompactDisk(diskPath); err != nil {
state.Put("error", fmt.Errorf("Error compacting disk: %s", err))
ui.Error(err.Error())
return multistep.ActionHalt
}
return multistep.ActionContinue
} | [
"func",
"(",
"s",
"*",
"StepCompactDisk",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"state",
"multistep",
".",
"StateBag",
")",
"multistep",
".",
"StepAction",
"{",
"driver",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"D... | // Run runs the compaction of the virtual disk attached to the VM. | [
"Run",
"runs",
"the",
"compaction",
"of",
"the",
"virtual",
"disk",
"attached",
"to",
"the",
"VM",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/step_compact_disk.go#L26-L52 |
165,140 | hashicorp/packer | builder/googlecompute/winrm.go | winrmConfig | func winrmConfig(state multistep.StateBag) (*communicator.WinRMConfig, error) {
config := state.Get("config").(*Config)
password := state.Get("winrm_password").(string)
return &communicator.WinRMConfig{
Username: config.Comm.WinRMUser,
Password: password,
}, nil
} | go | func winrmConfig(state multistep.StateBag) (*communicator.WinRMConfig, error) {
config := state.Get("config").(*Config)
password := state.Get("winrm_password").(string)
return &communicator.WinRMConfig{
Username: config.Comm.WinRMUser,
Password: password,
}, nil
} | [
"func",
"winrmConfig",
"(",
"state",
"multistep",
".",
"StateBag",
")",
"(",
"*",
"communicator",
".",
"WinRMConfig",
",",
"error",
")",
"{",
"config",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"*",
"Config",
")",
"\n",
"password",
"... | // winrmConfig returns the WinRM configuration. | [
"winrmConfig",
"returns",
"the",
"WinRM",
"configuration",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/winrm.go#L9-L17 |
165,141 | hashicorp/packer | builder/parallels/common/driver_9.go | Import | func (d *Parallels9Driver) Import(name, srcPath, dstDir string, reassignMAC bool) error {
err := d.Prlctl("register", srcPath, "--preserve-uuid")
if err != nil {
return err
}
srcID, err := getVMID(srcPath)
if err != nil {
return err
}
srcMAC := "auto"
if !reassignMAC {
srcMAC, err = getFirstMACAddress(srcPath)
if err != nil {
return err
}
}
err = d.Prlctl("clone", srcID, "--name", name, "--dst", dstDir)
if err != nil {
return err
}
err = d.Prlctl("unregister", srcID)
if err != nil {
return err
}
err = d.Prlctl("set", name, "--device-set", "net0", "--mac", srcMAC)
if err != nil {
return err
}
return nil
} | go | func (d *Parallels9Driver) Import(name, srcPath, dstDir string, reassignMAC bool) error {
err := d.Prlctl("register", srcPath, "--preserve-uuid")
if err != nil {
return err
}
srcID, err := getVMID(srcPath)
if err != nil {
return err
}
srcMAC := "auto"
if !reassignMAC {
srcMAC, err = getFirstMACAddress(srcPath)
if err != nil {
return err
}
}
err = d.Prlctl("clone", srcID, "--name", name, "--dst", dstDir)
if err != nil {
return err
}
err = d.Prlctl("unregister", srcID)
if err != nil {
return err
}
err = d.Prlctl("set", name, "--device-set", "net0", "--mac", srcMAC)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"Import",
"(",
"name",
",",
"srcPath",
",",
"dstDir",
"string",
",",
"reassignMAC",
"bool",
")",
"error",
"{",
"err",
":=",
"d",
".",
"Prlctl",
"(",
"\"",
"\"",
",",
"srcPath",
",",
"\"",
"\"",
")",
"... | // Import creates a clone of the source VM and reassigns the MAC address if needed. | [
"Import",
"creates",
"a",
"clone",
"of",
"the",
"source",
"VM",
"and",
"reassigns",
"the",
"MAC",
"address",
"if",
"needed",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L34-L68 |
165,142 | hashicorp/packer | builder/parallels/common/driver_9.go | CompactDisk | func (d *Parallels9Driver) CompactDisk(diskPath string) error {
prlDiskToolPath, err := exec.LookPath("prl_disk_tool")
if err != nil {
return err
}
// Analyze the disk content and remove unused blocks
command := []string{
"compact",
"--hdd", diskPath,
}
if err := exec.Command(prlDiskToolPath, command...).Run(); err != nil {
return err
}
// Remove null blocks
command = []string{
"compact", "--buildmap",
"--hdd", diskPath,
}
if err := exec.Command(prlDiskToolPath, command...).Run(); err != nil {
return err
}
return nil
} | go | func (d *Parallels9Driver) CompactDisk(diskPath string) error {
prlDiskToolPath, err := exec.LookPath("prl_disk_tool")
if err != nil {
return err
}
// Analyze the disk content and remove unused blocks
command := []string{
"compact",
"--hdd", diskPath,
}
if err := exec.Command(prlDiskToolPath, command...).Run(); err != nil {
return err
}
// Remove null blocks
command = []string{
"compact", "--buildmap",
"--hdd", diskPath,
}
if err := exec.Command(prlDiskToolPath, command...).Run(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"CompactDisk",
"(",
"diskPath",
"string",
")",
"error",
"{",
"prlDiskToolPath",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",... | // CompactDisk performs the compaction of the specified virtual disk image. | [
"CompactDisk",
"performs",
"the",
"compaction",
"of",
"the",
"specified",
"virtual",
"disk",
"image",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L124-L149 |
165,143 | hashicorp/packer | builder/parallels/common/driver_9.go | DeviceAddCDROM | func (d *Parallels9Driver) DeviceAddCDROM(name string, image string) (string, error) {
command := []string{
"set", name,
"--device-add", "cdrom",
"--image", image,
"--enable", "--connect",
}
out, err := exec.Command(d.PrlctlPath, command...).Output()
if err != nil {
return "", err
}
deviceRe := regexp.MustCompile(`\s+(cdrom\d+)\s+`)
matches := deviceRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not determine cdrom device name in the output:\n%s", string(out))
}
deviceName := matches[1]
return deviceName, nil
} | go | func (d *Parallels9Driver) DeviceAddCDROM(name string, image string) (string, error) {
command := []string{
"set", name,
"--device-add", "cdrom",
"--image", image,
"--enable", "--connect",
}
out, err := exec.Command(d.PrlctlPath, command...).Output()
if err != nil {
return "", err
}
deviceRe := regexp.MustCompile(`\s+(cdrom\d+)\s+`)
matches := deviceRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not determine cdrom device name in the output:\n%s", string(out))
}
deviceName := matches[1]
return deviceName, nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"DeviceAddCDROM",
"(",
"name",
"string",
",",
"image",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"command",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"name",
",",
"\"",
"\"",
",",
"\... | // DeviceAddCDROM adds a virtual CDROM device and attaches the specified image. | [
"DeviceAddCDROM",
"adds",
"a",
"virtual",
"CDROM",
"device",
"and",
"attaches",
"the",
"specified",
"image",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L152-L174 |
165,144 | hashicorp/packer | builder/parallels/common/driver_9.go | DiskPath | func (d *Parallels9Driver) DiskPath(name string) (string, error) {
out, err := exec.Command(d.PrlctlPath, "list", "-i", name).Output()
if err != nil {
return "", err
}
HDDRe := regexp.MustCompile("hdd0.* image='(.*)' type=*")
matches := HDDRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not determine hdd image path in the output:\n%s", string(out))
}
HDDPath := matches[1]
return HDDPath, nil
} | go | func (d *Parallels9Driver) DiskPath(name string) (string, error) {
out, err := exec.Command(d.PrlctlPath, "list", "-i", name).Output()
if err != nil {
return "", err
}
HDDRe := regexp.MustCompile("hdd0.* image='(.*)' type=*")
matches := HDDRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not determine hdd image path in the output:\n%s", string(out))
}
HDDPath := matches[1]
return HDDPath, nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"DiskPath",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"d",
".",
"PrlctlPath",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"n... | // DiskPath returns a full path to the first virtual disk drive. | [
"DiskPath",
"returns",
"a",
"full",
"path",
"to",
"the",
"first",
"virtual",
"disk",
"drive",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L177-L192 |
165,145 | hashicorp/packer | builder/parallels/common/driver_9.go | IsRunning | func (d *Parallels9Driver) IsRunning(name string) (bool, error) {
var stdout bytes.Buffer
cmd := exec.Command(d.PrlctlPath, "list", name, "--no-header", "--output", "status")
cmd.Stdout = &stdout
if err := cmd.Run(); err != nil {
return false, err
}
log.Printf("Checking VM state: %s\n", strings.TrimSpace(stdout.String()))
for _, line := range strings.Split(stdout.String(), "\n") {
if line == "running" {
return true, nil
}
if line == "suspended" {
return true, nil
}
if line == "paused" {
return true, nil
}
if line == "stopping" {
return true, nil
}
}
return false, nil
} | go | func (d *Parallels9Driver) IsRunning(name string) (bool, error) {
var stdout bytes.Buffer
cmd := exec.Command(d.PrlctlPath, "list", name, "--no-header", "--output", "status")
cmd.Stdout = &stdout
if err := cmd.Run(); err != nil {
return false, err
}
log.Printf("Checking VM state: %s\n", strings.TrimSpace(stdout.String()))
for _, line := range strings.Split(stdout.String(), "\n") {
if line == "running" {
return true, nil
}
if line == "suspended" {
return true, nil
}
if line == "paused" {
return true, nil
}
if line == "stopping" {
return true, nil
}
}
return false, nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"IsRunning",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"var",
"stdout",
"bytes",
".",
"Buffer",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"d",
".",
"PrlctlPath",
",",
"\""... | // IsRunning determines whether the VM is running or not. | [
"IsRunning",
"determines",
"whether",
"the",
"VM",
"is",
"running",
"or",
"not",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L195-L223 |
165,146 | hashicorp/packer | builder/parallels/common/driver_9.go | Stop | func (d *Parallels9Driver) Stop(name string) error {
if err := d.Prlctl("stop", name, "--kill"); err != nil {
return err
}
// We sleep here for a little bit to let the session "unlock"
time.Sleep(2 * time.Second)
return nil
} | go | func (d *Parallels9Driver) Stop(name string) error {
if err := d.Prlctl("stop", name, "--kill"); err != nil {
return err
}
// We sleep here for a little bit to let the session "unlock"
time.Sleep(2 * time.Second)
return nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"Stop",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"d",
".",
"Prlctl",
"(",
"\"",
"\"",
",",
"name",
",",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}... | // Stop forcibly stops the VM. | [
"Stop",
"forcibly",
"stops",
"the",
"VM",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L226-L235 |
165,147 | hashicorp/packer | builder/parallels/common/driver_9.go | Version | func (d *Parallels9Driver) Version() (string, error) {
out, err := exec.Command(d.PrlctlPath, "--version").Output()
if err != nil {
return "", err
}
versionRe := regexp.MustCompile(`prlctl version (\d+\.\d+.\d+)`)
matches := versionRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not find Parallels Desktop version in output:\n%s", string(out))
}
version := matches[1]
return version, nil
} | go | func (d *Parallels9Driver) Version() (string, error) {
out, err := exec.Command(d.PrlctlPath, "--version").Output()
if err != nil {
return "", err
}
versionRe := regexp.MustCompile(`prlctl version (\d+\.\d+.\d+)`)
matches := versionRe.FindStringSubmatch(string(out))
if matches == nil {
return "", fmt.Errorf(
"Could not find Parallels Desktop version in output:\n%s", string(out))
}
version := matches[1]
return version, nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"Version",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"d",
".",
"PrlctlPath",
",",
"\"",
"\"",
")",
".",
"Output",
"(",
")",
"\n",
"if",
... | // Version returns the version of Parallels Desktop installed on that host. | [
"Version",
"returns",
"the",
"version",
"of",
"Parallels",
"Desktop",
"installed",
"on",
"that",
"host",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L266-L281 |
165,148 | hashicorp/packer | builder/parallels/common/driver_9.go | MAC | func (d *Parallels9Driver) MAC(vmName string) (string, error) {
var stdout bytes.Buffer
cmd := exec.Command(d.PrlctlPath, "list", "-i", vmName)
cmd.Stdout = &stdout
if err := cmd.Run(); err != nil {
log.Printf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
return "", err
}
stdoutString := strings.TrimSpace(stdout.String())
re := regexp.MustCompile("net0.* mac=([0-9A-F]{12}) card=.*")
macMatch := re.FindAllStringSubmatch(stdoutString, 1)
if len(macMatch) != 1 {
return "", fmt.Errorf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
}
mac := macMatch[0][1]
log.Printf("Found MAC address for NIC: net0 - %s\n", mac)
return mac, nil
} | go | func (d *Parallels9Driver) MAC(vmName string) (string, error) {
var stdout bytes.Buffer
cmd := exec.Command(d.PrlctlPath, "list", "-i", vmName)
cmd.Stdout = &stdout
if err := cmd.Run(); err != nil {
log.Printf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
return "", err
}
stdoutString := strings.TrimSpace(stdout.String())
re := regexp.MustCompile("net0.* mac=([0-9A-F]{12}) card=.*")
macMatch := re.FindAllStringSubmatch(stdoutString, 1)
if len(macMatch) != 1 {
return "", fmt.Errorf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
}
mac := macMatch[0][1]
log.Printf("Found MAC address for NIC: net0 - %s\n", mac)
return mac, nil
} | [
"func",
"(",
"d",
"*",
"Parallels9Driver",
")",
"MAC",
"(",
"vmName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"stdout",
"bytes",
".",
"Buffer",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"d",
".",
"PrlctlPath",
",",
"\"",
... | // MAC returns the MAC address of the VM's first network interface. | [
"MAC",
"returns",
"the",
"MAC",
"address",
"of",
"the",
"VM",
"s",
"first",
"network",
"interface",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_9.go#L353-L374 |
165,149 | hashicorp/packer | builder/azure/common/gluestrings.go | GlueStrings | func GlueStrings(a, b string) string {
shift := 0
for shift < len(a) {
i := 0
for (i+shift < len(a)) && (i < len(b)) && (a[i+shift] == b[i]) {
i++
}
if i+shift == len(a) {
break
}
shift++
}
return a[:shift] + b
} | go | func GlueStrings(a, b string) string {
shift := 0
for shift < len(a) {
i := 0
for (i+shift < len(a)) && (i < len(b)) && (a[i+shift] == b[i]) {
i++
}
if i+shift == len(a) {
break
}
shift++
}
return a[:shift] + b
} | [
"func",
"GlueStrings",
"(",
"a",
",",
"b",
"string",
")",
"string",
"{",
"shift",
":=",
"0",
"\n",
"for",
"shift",
"<",
"len",
"(",
"a",
")",
"{",
"i",
":=",
"0",
"\n",
"for",
"(",
"i",
"+",
"shift",
"<",
"len",
"(",
"a",
")",
")",
"&&",
"(... | // removes overlap between the end of a and the start of b and
// glues them together | [
"removes",
"overlap",
"between",
"the",
"end",
"of",
"a",
"and",
"the",
"start",
"of",
"b",
"and",
"glues",
"them",
"together"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/common/gluestrings.go#L5-L19 |
165,150 | hashicorp/packer | main.go | realMain | func realMain() int {
var wrapConfig panicwrap.WrapConfig
// When following env variable is set, packer
// wont panic wrap itself as it's already wrapped.
// i.e.: when terraform runs it.
wrapConfig.CookieKey = "PACKER_WRAP_COOKIE"
wrapConfig.CookieValue = "49C22B1A-3A93-4C98-97FA-E07D18C787B5"
if !panicwrap.Wrapped(&wrapConfig) {
// Generate a UUID for this packer run and pass it to the environment.
// GenerateUUID always returns a nil error (based on rand.Read) so we'll
// just ignore it.
UUID, _ := uuid.GenerateUUID()
os.Setenv("PACKER_RUN_UUID", UUID)
// Determine where logs should go in general (requested by the user)
logWriter, err := logOutput()
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't setup log output: %s", err)
return 1
}
if logWriter == nil {
logWriter = ioutil.Discard
}
packer.LogSecretFilter.SetOutput(logWriter)
//packer.LogSecrets.
// Disable logging here
log.SetOutput(ioutil.Discard)
// We always send logs to a temporary file that we use in case
// there is a panic. Otherwise, we delete it.
logTempFile, err := tmp.File("packer-log")
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't setup logging tempfile: %s", err)
return 1
}
defer os.Remove(logTempFile.Name())
defer logTempFile.Close()
// Tell the logger to log to this file
os.Setenv(EnvLog, "")
os.Setenv(EnvLogFile, "")
// Setup the prefixed readers that send data properly to
// stdout/stderr.
doneCh := make(chan struct{})
outR, outW := io.Pipe()
go copyOutput(outR, doneCh)
// Enable checkpoint for panic reporting
if config, _ := loadConfig(); config != nil && !config.DisableCheckpoint {
packer.CheckpointReporter = packer.NewCheckpointReporter(
config.DisableCheckpointSignature,
)
}
// Create the configuration for panicwrap and wrap our executable
wrapConfig.Handler = panicHandler(logTempFile)
wrapConfig.Writer = io.MultiWriter(logTempFile, &packer.LogSecretFilter)
wrapConfig.Stdout = outW
wrapConfig.DetectDuration = 500 * time.Millisecond
wrapConfig.ForwardSignals = []os.Signal{syscall.SIGTERM}
exitStatus, err := panicwrap.Wrap(&wrapConfig)
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't start Packer: %s", err)
return 1
}
// If >= 0, we're the parent, so just exit
if exitStatus >= 0 {
// Close the stdout writer so that our copy process can finish
outW.Close()
// Wait for the output copying to finish
<-doneCh
return exitStatus
}
// We're the child, so just close the tempfile we made in order to
// save file handles since the tempfile is only used by the parent.
logTempFile.Close()
}
// Call the real main
return wrappedMain()
} | go | func realMain() int {
var wrapConfig panicwrap.WrapConfig
// When following env variable is set, packer
// wont panic wrap itself as it's already wrapped.
// i.e.: when terraform runs it.
wrapConfig.CookieKey = "PACKER_WRAP_COOKIE"
wrapConfig.CookieValue = "49C22B1A-3A93-4C98-97FA-E07D18C787B5"
if !panicwrap.Wrapped(&wrapConfig) {
// Generate a UUID for this packer run and pass it to the environment.
// GenerateUUID always returns a nil error (based on rand.Read) so we'll
// just ignore it.
UUID, _ := uuid.GenerateUUID()
os.Setenv("PACKER_RUN_UUID", UUID)
// Determine where logs should go in general (requested by the user)
logWriter, err := logOutput()
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't setup log output: %s", err)
return 1
}
if logWriter == nil {
logWriter = ioutil.Discard
}
packer.LogSecretFilter.SetOutput(logWriter)
//packer.LogSecrets.
// Disable logging here
log.SetOutput(ioutil.Discard)
// We always send logs to a temporary file that we use in case
// there is a panic. Otherwise, we delete it.
logTempFile, err := tmp.File("packer-log")
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't setup logging tempfile: %s", err)
return 1
}
defer os.Remove(logTempFile.Name())
defer logTempFile.Close()
// Tell the logger to log to this file
os.Setenv(EnvLog, "")
os.Setenv(EnvLogFile, "")
// Setup the prefixed readers that send data properly to
// stdout/stderr.
doneCh := make(chan struct{})
outR, outW := io.Pipe()
go copyOutput(outR, doneCh)
// Enable checkpoint for panic reporting
if config, _ := loadConfig(); config != nil && !config.DisableCheckpoint {
packer.CheckpointReporter = packer.NewCheckpointReporter(
config.DisableCheckpointSignature,
)
}
// Create the configuration for panicwrap and wrap our executable
wrapConfig.Handler = panicHandler(logTempFile)
wrapConfig.Writer = io.MultiWriter(logTempFile, &packer.LogSecretFilter)
wrapConfig.Stdout = outW
wrapConfig.DetectDuration = 500 * time.Millisecond
wrapConfig.ForwardSignals = []os.Signal{syscall.SIGTERM}
exitStatus, err := panicwrap.Wrap(&wrapConfig)
if err != nil {
fmt.Fprintf(os.Stderr, "Couldn't start Packer: %s", err)
return 1
}
// If >= 0, we're the parent, so just exit
if exitStatus >= 0 {
// Close the stdout writer so that our copy process can finish
outW.Close()
// Wait for the output copying to finish
<-doneCh
return exitStatus
}
// We're the child, so just close the tempfile we made in order to
// save file handles since the tempfile is only used by the parent.
logTempFile.Close()
}
// Call the real main
return wrappedMain()
} | [
"func",
"realMain",
"(",
")",
"int",
"{",
"var",
"wrapConfig",
"panicwrap",
".",
"WrapConfig",
"\n",
"// When following env variable is set, packer",
"// wont panic wrap itself as it's already wrapped.",
"// i.e.: when terraform runs it.",
"wrapConfig",
".",
"CookieKey",
"=",
"... | // realMain is executed from main and returns the exit status to exit with. | [
"realMain",
"is",
"executed",
"from",
"main",
"and",
"returns",
"the",
"exit",
"status",
"to",
"exit",
"with",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/main.go#L39-L128 |
165,151 | hashicorp/packer | main.go | wrappedMain | func wrappedMain() int {
// If there is no explicit number of Go threads to use, then set it
if os.Getenv("GOMAXPROCS") == "" {
runtime.GOMAXPROCS(runtime.NumCPU())
}
packer.LogSecretFilter.SetOutput(os.Stderr)
log.SetOutput(&packer.LogSecretFilter)
log.Printf("[INFO] Packer version: %s", version.FormattedVersion())
log.Printf("Packer Target OS/Arch: %s %s", runtime.GOOS, runtime.GOARCH)
log.Printf("Built with Go Version: %s", runtime.Version())
inPlugin := os.Getenv(plugin.MagicCookieKey) == plugin.MagicCookieValue
config, err := loadConfig()
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading configuration: \n\n%s\n", err)
return 1
}
log.Printf("Packer config: %+v", config)
// Fire off the checkpoint.
go runCheckpoint(config)
if !config.DisableCheckpoint {
packer.CheckpointReporter = packer.NewCheckpointReporter(
config.DisableCheckpointSignature,
)
}
cacheDir, err := packer.CachePath()
if err != nil {
fmt.Fprintf(os.Stderr, "Error preparing cache directory: \n\n%s\n", err)
return 1
}
log.Printf("Setting cache directory: %s", cacheDir)
// Determine if we're in machine-readable mode by mucking around with
// the arguments...
args, machineReadable := extractMachineReadable(os.Args[1:])
defer plugin.CleanupClients()
var ui packer.Ui
if machineReadable {
// Setup the UI as we're being machine-readable
ui = &packer.MachineReadableUi{
Writer: os.Stdout,
}
// Set this so that we don't get colored output in our machine-
// readable UI.
if err := os.Setenv("PACKER_NO_COLOR", "1"); err != nil {
fmt.Fprintf(os.Stderr, "Packer failed to initialize UI: %s\n", err)
return 1
}
} else {
basicUi := &packer.BasicUi{
Reader: os.Stdin,
Writer: os.Stdout,
ErrorWriter: os.Stdout,
}
ui = basicUi
if !inPlugin {
if TTY, err := tty.Open(); err != nil {
fmt.Fprintf(os.Stderr, "No tty available: %s\n", err)
} else {
basicUi.TTY = TTY
defer TTY.Close()
}
}
}
// Create the CLI meta
CommandMeta = &command.Meta{
CoreConfig: &packer.CoreConfig{
Components: packer.ComponentFinder{
Builder: config.LoadBuilder,
Hook: config.LoadHook,
PostProcessor: config.LoadPostProcessor,
Provisioner: config.LoadProvisioner,
},
Version: version.Version,
},
Ui: ui,
}
cli := &cli.CLI{
Args: args,
Autocomplete: true,
Commands: Commands,
HelpFunc: excludeHelpFunc(Commands, []string{"plugin"}),
HelpWriter: os.Stdout,
Name: "packer",
Version: version.Version,
}
exitCode, err := cli.Run()
if !inPlugin {
if err := packer.CheckpointReporter.Finalize(cli.Subcommand(), exitCode, err); err != nil {
log.Printf("[WARN] (telemetry) Error finalizing report. This is safe to ignore. %s", err.Error())
}
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
return 1
}
return exitCode
} | go | func wrappedMain() int {
// If there is no explicit number of Go threads to use, then set it
if os.Getenv("GOMAXPROCS") == "" {
runtime.GOMAXPROCS(runtime.NumCPU())
}
packer.LogSecretFilter.SetOutput(os.Stderr)
log.SetOutput(&packer.LogSecretFilter)
log.Printf("[INFO] Packer version: %s", version.FormattedVersion())
log.Printf("Packer Target OS/Arch: %s %s", runtime.GOOS, runtime.GOARCH)
log.Printf("Built with Go Version: %s", runtime.Version())
inPlugin := os.Getenv(plugin.MagicCookieKey) == plugin.MagicCookieValue
config, err := loadConfig()
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading configuration: \n\n%s\n", err)
return 1
}
log.Printf("Packer config: %+v", config)
// Fire off the checkpoint.
go runCheckpoint(config)
if !config.DisableCheckpoint {
packer.CheckpointReporter = packer.NewCheckpointReporter(
config.DisableCheckpointSignature,
)
}
cacheDir, err := packer.CachePath()
if err != nil {
fmt.Fprintf(os.Stderr, "Error preparing cache directory: \n\n%s\n", err)
return 1
}
log.Printf("Setting cache directory: %s", cacheDir)
// Determine if we're in machine-readable mode by mucking around with
// the arguments...
args, machineReadable := extractMachineReadable(os.Args[1:])
defer plugin.CleanupClients()
var ui packer.Ui
if machineReadable {
// Setup the UI as we're being machine-readable
ui = &packer.MachineReadableUi{
Writer: os.Stdout,
}
// Set this so that we don't get colored output in our machine-
// readable UI.
if err := os.Setenv("PACKER_NO_COLOR", "1"); err != nil {
fmt.Fprintf(os.Stderr, "Packer failed to initialize UI: %s\n", err)
return 1
}
} else {
basicUi := &packer.BasicUi{
Reader: os.Stdin,
Writer: os.Stdout,
ErrorWriter: os.Stdout,
}
ui = basicUi
if !inPlugin {
if TTY, err := tty.Open(); err != nil {
fmt.Fprintf(os.Stderr, "No tty available: %s\n", err)
} else {
basicUi.TTY = TTY
defer TTY.Close()
}
}
}
// Create the CLI meta
CommandMeta = &command.Meta{
CoreConfig: &packer.CoreConfig{
Components: packer.ComponentFinder{
Builder: config.LoadBuilder,
Hook: config.LoadHook,
PostProcessor: config.LoadPostProcessor,
Provisioner: config.LoadProvisioner,
},
Version: version.Version,
},
Ui: ui,
}
cli := &cli.CLI{
Args: args,
Autocomplete: true,
Commands: Commands,
HelpFunc: excludeHelpFunc(Commands, []string{"plugin"}),
HelpWriter: os.Stdout,
Name: "packer",
Version: version.Version,
}
exitCode, err := cli.Run()
if !inPlugin {
if err := packer.CheckpointReporter.Finalize(cli.Subcommand(), exitCode, err); err != nil {
log.Printf("[WARN] (telemetry) Error finalizing report. This is safe to ignore. %s", err.Error())
}
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
return 1
}
return exitCode
} | [
"func",
"wrappedMain",
"(",
")",
"int",
"{",
"// If there is no explicit number of Go threads to use, then set it",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"==",
"\"",
"\"",
"{",
"runtime",
".",
"GOMAXPROCS",
"(",
"runtime",
".",
"NumCPU",
"(",
")",
"... | // wrappedMain is called only when we're wrapped by panicwrap and
// returns the exit status to exit with. | [
"wrappedMain",
"is",
"called",
"only",
"when",
"we",
"re",
"wrapped",
"by",
"panicwrap",
"and",
"returns",
"the",
"exit",
"status",
"to",
"exit",
"with",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/main.go#L132-L241 |
165,152 | hashicorp/packer | main.go | excludeHelpFunc | func excludeHelpFunc(commands map[string]cli.CommandFactory, exclude []string) cli.HelpFunc {
// Make search slice into a map so we can use use the `if found` idiom
// instead of a nested loop.
var excludes = make(map[string]interface{}, len(exclude))
for _, item := range exclude {
excludes[item] = nil
}
// Create filtered list of commands
helpCommands := []string{}
for command := range commands {
if _, found := excludes[command]; !found {
helpCommands = append(helpCommands, command)
}
}
return cli.FilteredHelpFunc(helpCommands, cli.BasicHelpFunc("packer"))
} | go | func excludeHelpFunc(commands map[string]cli.CommandFactory, exclude []string) cli.HelpFunc {
// Make search slice into a map so we can use use the `if found` idiom
// instead of a nested loop.
var excludes = make(map[string]interface{}, len(exclude))
for _, item := range exclude {
excludes[item] = nil
}
// Create filtered list of commands
helpCommands := []string{}
for command := range commands {
if _, found := excludes[command]; !found {
helpCommands = append(helpCommands, command)
}
}
return cli.FilteredHelpFunc(helpCommands, cli.BasicHelpFunc("packer"))
} | [
"func",
"excludeHelpFunc",
"(",
"commands",
"map",
"[",
"string",
"]",
"cli",
".",
"CommandFactory",
",",
"exclude",
"[",
"]",
"string",
")",
"cli",
".",
"HelpFunc",
"{",
"// Make search slice into a map so we can use use the `if found` idiom",
"// instead of a nested loo... | // excludeHelpFunc filters commands we don't want to show from the list of
// commands displayed in packer's help text. | [
"excludeHelpFunc",
"filters",
"commands",
"we",
"don",
"t",
"want",
"to",
"show",
"from",
"the",
"list",
"of",
"commands",
"displayed",
"in",
"packer",
"s",
"help",
"text",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/main.go#L245-L262 |
165,153 | hashicorp/packer | main.go | extractMachineReadable | func extractMachineReadable(args []string) ([]string, bool) {
for i, arg := range args {
if arg == "-machine-readable" {
// We found it. Slice it out.
result := make([]string, len(args)-1)
copy(result, args[:i])
copy(result[i:], args[i+1:])
return result, true
}
}
return args, false
} | go | func extractMachineReadable(args []string) ([]string, bool) {
for i, arg := range args {
if arg == "-machine-readable" {
// We found it. Slice it out.
result := make([]string, len(args)-1)
copy(result, args[:i])
copy(result[i:], args[i+1:])
return result, true
}
}
return args, false
} | [
"func",
"extractMachineReadable",
"(",
"args",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"bool",
")",
"{",
"for",
"i",
",",
"arg",
":=",
"range",
"args",
"{",
"if",
"arg",
"==",
"\"",
"\"",
"{",
"// We found it. Slice it out.",
"result",
"... | // extractMachineReadable checks the args for the machine readable
// flag and returns whether or not it is on. It modifies the args
// to remove this flag. | [
"extractMachineReadable",
"checks",
"the",
"args",
"for",
"the",
"machine",
"readable",
"flag",
"and",
"returns",
"whether",
"or",
"not",
"it",
"is",
"on",
".",
"It",
"modifies",
"the",
"args",
"to",
"remove",
"this",
"flag",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/main.go#L267-L279 |
165,154 | hashicorp/packer | builder/amazon/common/regions.go | ValidateRegion | func (c *AccessConfig) ValidateRegion(regions ...string) error {
ec2conn, err := c.NewEC2Connection()
if err != nil {
return err
}
validRegions, err := listEC2Regions(ec2conn)
if err != nil {
return err
}
var invalidRegions []string
for _, region := range regions {
if region == "" {
continue
}
found := false
for _, validRegion := range validRegions {
if region == validRegion {
found = true
break
}
}
if !found {
invalidRegions = append(invalidRegions, region)
}
}
if len(invalidRegions) > 0 {
return fmt.Errorf("Invalid region(s): %v, available regions: %v", invalidRegions, validRegions)
}
return nil
} | go | func (c *AccessConfig) ValidateRegion(regions ...string) error {
ec2conn, err := c.NewEC2Connection()
if err != nil {
return err
}
validRegions, err := listEC2Regions(ec2conn)
if err != nil {
return err
}
var invalidRegions []string
for _, region := range regions {
if region == "" {
continue
}
found := false
for _, validRegion := range validRegions {
if region == validRegion {
found = true
break
}
}
if !found {
invalidRegions = append(invalidRegions, region)
}
}
if len(invalidRegions) > 0 {
return fmt.Errorf("Invalid region(s): %v, available regions: %v", invalidRegions, validRegions)
}
return nil
} | [
"func",
"(",
"c",
"*",
"AccessConfig",
")",
"ValidateRegion",
"(",
"regions",
"...",
"string",
")",
"error",
"{",
"ec2conn",
",",
"err",
":=",
"c",
".",
"NewEC2Connection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\... | // ValidateRegion returns an nil if the regions are valid
// and exists; otherwise an error.
// ValidateRegion calls ec2conn.DescribeRegions to get the list of
// regions available to this account. | [
"ValidateRegion",
"returns",
"an",
"nil",
"if",
"the",
"regions",
"are",
"valid",
"and",
"exists",
";",
"otherwise",
"an",
"error",
".",
"ValidateRegion",
"calls",
"ec2conn",
".",
"DescribeRegions",
"to",
"get",
"the",
"list",
"of",
"regions",
"available",
"to... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/amazon/common/regions.go#L26-L58 |
165,155 | hashicorp/packer | builder/parallels/common/driver_11.go | Verify | func (d *Parallels11Driver) Verify() error {
stdout, err := exec.Command(d.PrlsrvctlPath, "info", "--license").Output()
if err != nil {
return err
}
editionRe := regexp.MustCompile(`edition="(\w+)"`)
matches := editionRe.FindStringSubmatch(string(stdout))
if matches == nil {
return fmt.Errorf(
"Could not determine your Parallels Desktop edition using: %s info --license", d.PrlsrvctlPath)
}
switch matches[1] {
case "pro", "business":
break
default:
return fmt.Errorf("Packer can be used only with Parallels Desktop 11 Pro or Business edition. You use: %s edition", matches[1])
}
return nil
} | go | func (d *Parallels11Driver) Verify() error {
stdout, err := exec.Command(d.PrlsrvctlPath, "info", "--license").Output()
if err != nil {
return err
}
editionRe := regexp.MustCompile(`edition="(\w+)"`)
matches := editionRe.FindStringSubmatch(string(stdout))
if matches == nil {
return fmt.Errorf(
"Could not determine your Parallels Desktop edition using: %s info --license", d.PrlsrvctlPath)
}
switch matches[1] {
case "pro", "business":
break
default:
return fmt.Errorf("Packer can be used only with Parallels Desktop 11 Pro or Business edition. You use: %s edition", matches[1])
}
return nil
} | [
"func",
"(",
"d",
"*",
"Parallels11Driver",
")",
"Verify",
"(",
")",
"error",
"{",
"stdout",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"d",
".",
"PrlsrvctlPath",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Output",
"(",
")",
"\n",
"if",
"er... | // Verify raises an error if the builder could not be used on that host machine. | [
"Verify",
"raises",
"an",
"error",
"if",
"the",
"builder",
"could",
"not",
"be",
"used",
"on",
"that",
"host",
"machine",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/driver_11.go#L16-L37 |
165,156 | hashicorp/packer | builder/vmware/common/driver_workstation9_windows.go | workstationProgramFilePaths | func workstationProgramFilePaths() []string {
path, err := workstationVMwareRoot()
if err != nil {
log.Printf("Error finding VMware root: %s", err)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_HOME") != "" {
paths = append(paths, os.Getenv("VMWARE_HOME"))
}
if path != "" {
paths = append(paths, path)
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Workstation"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Workstation"))
}
return paths
} | go | func workstationProgramFilePaths() []string {
path, err := workstationVMwareRoot()
if err != nil {
log.Printf("Error finding VMware root: %s", err)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_HOME") != "" {
paths = append(paths, os.Getenv("VMWARE_HOME"))
}
if path != "" {
paths = append(paths, path)
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Workstation"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Workstation"))
}
return paths
} | [
"func",
"workstationProgramFilePaths",
"(",
")",
"[",
"]",
"string",
"{",
"path",
",",
"err",
":=",
"workstationVMwareRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"pa... | // workstationProgramFilesPaths returns a list of paths that are eligible
// to contain program files we may want just as vmware.exe. | [
"workstationProgramFilesPaths",
"returns",
"a",
"list",
"of",
"paths",
"that",
"are",
"eligible",
"to",
"contain",
"program",
"files",
"we",
"may",
"want",
"just",
"as",
"vmware",
".",
"exe",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_workstation9_windows.go#L166-L192 |
165,157 | hashicorp/packer | builder/vmware/common/driver_workstation9_windows.go | workstationDataFilePaths | func workstationDataFilePaths() []string {
leasesPath, err := workstationDhcpLeasesPathRegistry()
if err != nil {
log.Printf("Error getting DHCP leases path: %s", err)
}
if leasesPath != "" {
leasesPath = filepath.Dir(leasesPath)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_DATA") != "" {
paths = append(paths, os.Getenv("VMWARE_DATA"))
}
if leasesPath != "" {
paths = append(paths, leasesPath)
}
if os.Getenv("ProgramData") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramData"), "/VMware"))
}
if os.Getenv("ALLUSERSPROFILE") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware"))
}
return paths
} | go | func workstationDataFilePaths() []string {
leasesPath, err := workstationDhcpLeasesPathRegistry()
if err != nil {
log.Printf("Error getting DHCP leases path: %s", err)
}
if leasesPath != "" {
leasesPath = filepath.Dir(leasesPath)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_DATA") != "" {
paths = append(paths, os.Getenv("VMWARE_DATA"))
}
if leasesPath != "" {
paths = append(paths, leasesPath)
}
if os.Getenv("ProgramData") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramData"), "/VMware"))
}
if os.Getenv("ALLUSERSPROFILE") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware"))
}
return paths
} | [
"func",
"workstationDataFilePaths",
"(",
")",
"[",
"]",
"string",
"{",
"leasesPath",
",",
"err",
":=",
"workstationDhcpLeasesPathRegistry",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
... | // workstationDataFilePaths returns a list of paths that are eligible
// to contain data files we may want such as vmnet NAT configuration files. | [
"workstationDataFilePaths",
"returns",
"a",
"list",
"of",
"paths",
"that",
"are",
"eligible",
"to",
"contain",
"data",
"files",
"we",
"may",
"want",
"such",
"as",
"vmnet",
"NAT",
"configuration",
"files",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_workstation9_windows.go#L196-L226 |
165,158 | hashicorp/packer | builder/docker/ecr_login.go | EcrGetLogin | func (c *AwsAccessConfig) EcrGetLogin(ecrUrl string) (string, string, error) {
exp := regexp.MustCompile(`(?:http://|https://|)([0-9]*)\.dkr\.ecr\.(.*)\.amazonaws\.com.*`)
splitUrl := exp.FindStringSubmatch(ecrUrl)
if len(splitUrl) != 3 {
return "", "", fmt.Errorf("Failed to parse the ECR URL: %s it should be on the form <account number>.dkr.ecr.<region>.amazonaws.com", ecrUrl)
}
accountId := splitUrl[1]
region := splitUrl[2]
log.Println(fmt.Sprintf("Getting ECR token for account: %s in %s..", accountId, region))
c.cfg = &common.AccessConfig{
AccessKey: c.AccessKey,
ProfileName: c.Profile,
RawRegion: region,
SecretKey: c.SecretKey,
Token: c.Token,
}
session, err := c.cfg.Session()
if err != nil {
return "", "", fmt.Errorf("failed to create session: %s", err)
}
service := ecr.New(session)
params := &ecr.GetAuthorizationTokenInput{
RegistryIds: []*string{
aws.String(accountId),
},
}
resp, err := service.GetAuthorizationToken(params)
if err != nil {
return "", "", fmt.Errorf(err.Error())
}
auth, err := base64.StdEncoding.DecodeString(*resp.AuthorizationData[0].AuthorizationToken)
if err != nil {
return "", "", fmt.Errorf("Error decoding ECR AuthorizationToken: %s", err)
}
authParts := strings.SplitN(string(auth), ":", 2)
log.Printf("Successfully got login for ECR: %s", ecrUrl)
return authParts[0], authParts[1], nil
} | go | func (c *AwsAccessConfig) EcrGetLogin(ecrUrl string) (string, string, error) {
exp := regexp.MustCompile(`(?:http://|https://|)([0-9]*)\.dkr\.ecr\.(.*)\.amazonaws\.com.*`)
splitUrl := exp.FindStringSubmatch(ecrUrl)
if len(splitUrl) != 3 {
return "", "", fmt.Errorf("Failed to parse the ECR URL: %s it should be on the form <account number>.dkr.ecr.<region>.amazonaws.com", ecrUrl)
}
accountId := splitUrl[1]
region := splitUrl[2]
log.Println(fmt.Sprintf("Getting ECR token for account: %s in %s..", accountId, region))
c.cfg = &common.AccessConfig{
AccessKey: c.AccessKey,
ProfileName: c.Profile,
RawRegion: region,
SecretKey: c.SecretKey,
Token: c.Token,
}
session, err := c.cfg.Session()
if err != nil {
return "", "", fmt.Errorf("failed to create session: %s", err)
}
service := ecr.New(session)
params := &ecr.GetAuthorizationTokenInput{
RegistryIds: []*string{
aws.String(accountId),
},
}
resp, err := service.GetAuthorizationToken(params)
if err != nil {
return "", "", fmt.Errorf(err.Error())
}
auth, err := base64.StdEncoding.DecodeString(*resp.AuthorizationData[0].AuthorizationToken)
if err != nil {
return "", "", fmt.Errorf("Error decoding ECR AuthorizationToken: %s", err)
}
authParts := strings.SplitN(string(auth), ":", 2)
log.Printf("Successfully got login for ECR: %s", ecrUrl)
return authParts[0], authParts[1], nil
} | [
"func",
"(",
"c",
"*",
"AwsAccessConfig",
")",
"EcrGetLogin",
"(",
"ecrUrl",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"exp",
":=",
"regexp",
".",
"MustCompile",
"(",
"`(?:http://|https://|)([0-9]*)\\.dkr\\.ecr\\.(.*)\\.amazonaws\\.com.*`"... | // Get a login token for Amazon AWS ECR. Returns username and password
// or an error. | [
"Get",
"a",
"login",
"token",
"for",
"Amazon",
"AWS",
"ECR",
".",
"Returns",
"username",
"and",
"password",
"or",
"an",
"error",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/docker/ecr_login.go#L25-L71 |
165,159 | hashicorp/packer | builder/oracle/oci/config_provider.go | NewRawConfigurationProvider | func NewRawConfigurationProvider(tenancy, user, region, fingerprint, privateKey string, privateKeyPassphrase *string) common.ConfigurationProvider {
return rawConfigurationProvider{tenancy, user, region, fingerprint, privateKey, privateKeyPassphrase}
} | go | func NewRawConfigurationProvider(tenancy, user, region, fingerprint, privateKey string, privateKeyPassphrase *string) common.ConfigurationProvider {
return rawConfigurationProvider{tenancy, user, region, fingerprint, privateKey, privateKeyPassphrase}
} | [
"func",
"NewRawConfigurationProvider",
"(",
"tenancy",
",",
"user",
",",
"region",
",",
"fingerprint",
",",
"privateKey",
"string",
",",
"privateKeyPassphrase",
"*",
"string",
")",
"common",
".",
"ConfigurationProvider",
"{",
"return",
"rawConfigurationProvider",
"{",... | // NewRawConfigurationProvider will create a rawConfigurationProvider. | [
"NewRawConfigurationProvider",
"will",
"create",
"a",
"rawConfigurationProvider",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/oracle/oci/config_provider.go#L23-L25 |
165,160 | hashicorp/packer | builder/alicloud/ecs/access_config.go | Client | func (c *AlicloudAccessConfig) Client() (*ClientWrapper, error) {
if c.client != nil {
return c.client, nil
}
if c.SecurityToken == "" {
c.SecurityToken = os.Getenv("SECURITY_TOKEN")
}
client, err := ecs.NewClientWithStsToken(c.AlicloudRegion, c.AlicloudAccessKey,
c.AlicloudSecretKey, c.SecurityToken)
if err != nil {
return nil, err
}
client.AppendUserAgent(Packer, version.FormattedVersion())
client.SetReadTimeout(DefaultRequestReadTimeout)
c.client = &ClientWrapper{client}
return c.client, nil
} | go | func (c *AlicloudAccessConfig) Client() (*ClientWrapper, error) {
if c.client != nil {
return c.client, nil
}
if c.SecurityToken == "" {
c.SecurityToken = os.Getenv("SECURITY_TOKEN")
}
client, err := ecs.NewClientWithStsToken(c.AlicloudRegion, c.AlicloudAccessKey,
c.AlicloudSecretKey, c.SecurityToken)
if err != nil {
return nil, err
}
client.AppendUserAgent(Packer, version.FormattedVersion())
client.SetReadTimeout(DefaultRequestReadTimeout)
c.client = &ClientWrapper{client}
return c.client, nil
} | [
"func",
"(",
"c",
"*",
"AlicloudAccessConfig",
")",
"Client",
"(",
")",
"(",
"*",
"ClientWrapper",
",",
"error",
")",
"{",
"if",
"c",
".",
"client",
"!=",
"nil",
"{",
"return",
"c",
".",
"client",
",",
"nil",
"\n",
"}",
"\n",
"if",
"c",
".",
"Sec... | // Client for AlicloudClient | [
"Client",
"for",
"AlicloudClient"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/alicloud/ecs/access_config.go#L28-L47 |
165,161 | hashicorp/packer | communicator/ssh/connect.go | ProxyConnectFunc | func ProxyConnectFunc(socksProxy string, socksAuth *proxy.Auth, network, addr string) func() (net.Conn, error) {
return func() (net.Conn, error) {
// create a socks5 dialer
dialer, err := proxy.SOCKS5("tcp", socksProxy, socksAuth, proxy.Direct)
if err != nil {
return nil, fmt.Errorf("Can't connect to the proxy: %s", err)
}
c, err := dialer.Dial(network, addr)
if err != nil {
return nil, err
}
return c, nil
}
} | go | func ProxyConnectFunc(socksProxy string, socksAuth *proxy.Auth, network, addr string) func() (net.Conn, error) {
return func() (net.Conn, error) {
// create a socks5 dialer
dialer, err := proxy.SOCKS5("tcp", socksProxy, socksAuth, proxy.Direct)
if err != nil {
return nil, fmt.Errorf("Can't connect to the proxy: %s", err)
}
c, err := dialer.Dial(network, addr)
if err != nil {
return nil, err
}
return c, nil
}
} | [
"func",
"ProxyConnectFunc",
"(",
"socksProxy",
"string",
",",
"socksAuth",
"*",
"proxy",
".",
"Auth",
",",
"network",
",",
"addr",
"string",
")",
"func",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"func",
"(",
")",
"(",
"net... | // ProxyConnectFunc is a convenience method for returning a function
// that connects to a host using SOCKS5 proxy | [
"ProxyConnectFunc",
"is",
"a",
"convenience",
"method",
"for",
"returning",
"a",
"function",
"that",
"connects",
"to",
"a",
"host",
"using",
"SOCKS5",
"proxy"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/communicator/ssh/connect.go#L33-L48 |
165,162 | hashicorp/packer | common/net/configure_port.go | Listen | func (lc ListenRangeConfig) Listen(ctx context.Context) (*Listener, error) {
if lc.Network == "" {
lc.Network = "tcp"
}
portRange := lc.Max - lc.Min
var listener *Listener
err := retry.Config{
RetryDelay: func() time.Duration { return 1 * time.Millisecond },
}.Run(ctx, func(context.Context) error {
port := lc.Min
if portRange > 0 {
port += rand.Intn(portRange)
}
lockFilePath, err := packer.CachePath("port", strconv.Itoa(port))
if err != nil {
return err
}
lock := filelock.New(lockFilePath)
locked, err := lock.TryLock()
if err != nil {
return err
}
if !locked {
return ErrPortFileLocked(port)
}
l, err := lc.ListenConfig.Listen(ctx, lc.Network, fmt.Sprintf("%s:%d", lc.Addr, port))
if err != nil {
if err := lock.Unlock(); err != nil {
log.Fatalf("Could not unlock file lock for port %d: %v", port, err)
}
return &ErrPortBusy{
Port: port,
Err: err,
}
}
log.Printf("Found available port: %d on IP: %s", port, lc.Addr)
listener = &Listener{
Address: lc.Addr,
Port: port,
Listener: l,
lock: lock,
}
return nil
})
return listener, err
} | go | func (lc ListenRangeConfig) Listen(ctx context.Context) (*Listener, error) {
if lc.Network == "" {
lc.Network = "tcp"
}
portRange := lc.Max - lc.Min
var listener *Listener
err := retry.Config{
RetryDelay: func() time.Duration { return 1 * time.Millisecond },
}.Run(ctx, func(context.Context) error {
port := lc.Min
if portRange > 0 {
port += rand.Intn(portRange)
}
lockFilePath, err := packer.CachePath("port", strconv.Itoa(port))
if err != nil {
return err
}
lock := filelock.New(lockFilePath)
locked, err := lock.TryLock()
if err != nil {
return err
}
if !locked {
return ErrPortFileLocked(port)
}
l, err := lc.ListenConfig.Listen(ctx, lc.Network, fmt.Sprintf("%s:%d", lc.Addr, port))
if err != nil {
if err := lock.Unlock(); err != nil {
log.Fatalf("Could not unlock file lock for port %d: %v", port, err)
}
return &ErrPortBusy{
Port: port,
Err: err,
}
}
log.Printf("Found available port: %d on IP: %s", port, lc.Addr)
listener = &Listener{
Address: lc.Addr,
Port: port,
Listener: l,
lock: lock,
}
return nil
})
return listener, err
} | [
"func",
"(",
"lc",
"ListenRangeConfig",
")",
"Listen",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"Listener",
",",
"error",
")",
"{",
"if",
"lc",
".",
"Network",
"==",
"\"",
"\"",
"{",
"lc",
".",
"Network",
"=",
"\"",
"\"",
"\n",
"}",
... | // Listen tries to Listen to a random open TCP port in the [min, max) range
// until ctx is cancelled.
// Listen uses net.ListenConfig.Listen internally. | [
"Listen",
"tries",
"to",
"Listen",
"to",
"a",
"random",
"open",
"TCP",
"port",
"in",
"the",
"[",
"min",
"max",
")",
"range",
"until",
"ctx",
"is",
"cancelled",
".",
"Listen",
"uses",
"net",
".",
"ListenConfig",
".",
"Listen",
"internally",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/common/net/configure_port.go#L54-L105 |
165,163 | hashicorp/packer | communicator/none/communicator.go | New | func New(config string) (result *comm, err error) {
// Establish an initial connection and connect
result = &comm{
config: config,
}
return
} | go | func New(config string) (result *comm, err error) {
// Establish an initial connection and connect
result = &comm{
config: config,
}
return
} | [
"func",
"New",
"(",
"config",
"string",
")",
"(",
"result",
"*",
"comm",
",",
"err",
"error",
")",
"{",
"// Establish an initial connection and connect",
"result",
"=",
"&",
"comm",
"{",
"config",
":",
"config",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] | // Creates a null packer.Communicator implementation. This takes
// an already existing configuration. | [
"Creates",
"a",
"null",
"packer",
".",
"Communicator",
"implementation",
".",
"This",
"takes",
"an",
"already",
"existing",
"configuration",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/communicator/none/communicator.go#L18-L25 |
165,164 | hashicorp/packer | builder/azure/pkcs12/pkcs12.go | unmarshal | func unmarshal(in []byte, out interface{}) error {
trailing, err := asn1.Unmarshal(in, out)
if err != nil {
return err
}
if len(trailing) != 0 {
return errors.New("pkcs12: trailing data found")
}
return nil
} | go | func unmarshal(in []byte, out interface{}) error {
trailing, err := asn1.Unmarshal(in, out)
if err != nil {
return err
}
if len(trailing) != 0 {
return errors.New("pkcs12: trailing data found")
}
return nil
} | [
"func",
"unmarshal",
"(",
"in",
"[",
"]",
"byte",
",",
"out",
"interface",
"{",
"}",
")",
"error",
"{",
"trailing",
",",
"err",
":=",
"asn1",
".",
"Unmarshal",
"(",
"in",
",",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n"... | // unmarshal calls asn1.Unmarshal, but also returns an error if there is any
// trailing data after unmarshalling. | [
"unmarshal",
"calls",
"asn1",
".",
"Unmarshal",
"but",
"also",
"returns",
"an",
"error",
"if",
"there",
"is",
"any",
"trailing",
"data",
"after",
"unmarshalling",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/pkcs12/pkcs12.go#L96-L105 |
165,165 | hashicorp/packer | builder/azure/pkcs12/pkcs12.go | Decode | func Decode(pfxData []byte, password string) (privateKey interface{}, certificate *x509.Certificate, err error) {
encodedPassword, err := bmpString(password)
if err != nil {
return nil, nil, err
}
bags, encodedPassword, err := getSafeContents(pfxData, encodedPassword)
if err != nil {
return nil, nil, err
}
if len(bags) != 2 {
err = errors.New("pkcs12: expected exactly two safe bags in the PFX PDU")
return
}
for _, bag := range bags {
switch {
case bag.Id.Equal(oidCertBag):
if certificate != nil {
err = errors.New("pkcs12: expected exactly one certificate bag")
}
certsData, err := decodeCertBag(bag.Value.Bytes)
if err != nil {
return nil, nil, err
}
certs, err := x509.ParseCertificates(certsData)
if err != nil {
return nil, nil, err
}
if len(certs) != 1 {
err = errors.New("pkcs12: expected exactly one certificate in the certBag")
return nil, nil, err
}
certificate = certs[0]
case bag.Id.Equal(oidPKCS8ShroudedKeyBag):
if privateKey != nil {
err = errors.New("pkcs12: expected exactly one key bag")
}
if privateKey, err = decodePkcs8ShroudedKeyBag(bag.Value.Bytes, encodedPassword); err != nil {
return nil, nil, err
}
}
}
if certificate == nil {
return nil, nil, errors.New("pkcs12: certificate missing")
}
if privateKey == nil {
return nil, nil, errors.New("pkcs12: private key missing")
}
return
} | go | func Decode(pfxData []byte, password string) (privateKey interface{}, certificate *x509.Certificate, err error) {
encodedPassword, err := bmpString(password)
if err != nil {
return nil, nil, err
}
bags, encodedPassword, err := getSafeContents(pfxData, encodedPassword)
if err != nil {
return nil, nil, err
}
if len(bags) != 2 {
err = errors.New("pkcs12: expected exactly two safe bags in the PFX PDU")
return
}
for _, bag := range bags {
switch {
case bag.Id.Equal(oidCertBag):
if certificate != nil {
err = errors.New("pkcs12: expected exactly one certificate bag")
}
certsData, err := decodeCertBag(bag.Value.Bytes)
if err != nil {
return nil, nil, err
}
certs, err := x509.ParseCertificates(certsData)
if err != nil {
return nil, nil, err
}
if len(certs) != 1 {
err = errors.New("pkcs12: expected exactly one certificate in the certBag")
return nil, nil, err
}
certificate = certs[0]
case bag.Id.Equal(oidPKCS8ShroudedKeyBag):
if privateKey != nil {
err = errors.New("pkcs12: expected exactly one key bag")
}
if privateKey, err = decodePkcs8ShroudedKeyBag(bag.Value.Bytes, encodedPassword); err != nil {
return nil, nil, err
}
}
}
if certificate == nil {
return nil, nil, errors.New("pkcs12: certificate missing")
}
if privateKey == nil {
return nil, nil, errors.New("pkcs12: private key missing")
}
return
} | [
"func",
"Decode",
"(",
"pfxData",
"[",
"]",
"byte",
",",
"password",
"string",
")",
"(",
"privateKey",
"interface",
"{",
"}",
",",
"certificate",
"*",
"x509",
".",
"Certificate",
",",
"err",
"error",
")",
"{",
"encodedPassword",
",",
"err",
":=",
"bmpStr... | // Decode extracts a certificate and private key from pfxData. This function
// assumes that there is only one certificate and only one private key in the
// pfxData. | [
"Decode",
"extracts",
"a",
"certificate",
"and",
"private",
"key",
"from",
"pfxData",
".",
"This",
"function",
"assumes",
"that",
"there",
"is",
"only",
"one",
"certificate",
"and",
"only",
"one",
"private",
"key",
"in",
"the",
"pfxData",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/pkcs12/pkcs12.go#L212-L267 |
165,166 | hashicorp/packer | config.go | decodeConfig | func decodeConfig(r io.Reader, c *config) error {
decoder := json.NewDecoder(r)
return decoder.Decode(c)
} | go | func decodeConfig(r io.Reader, c *config) error {
decoder := json.NewDecoder(r)
return decoder.Decode(c)
} | [
"func",
"decodeConfig",
"(",
"r",
"io",
".",
"Reader",
",",
"c",
"*",
"config",
")",
"error",
"{",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
")",
"\n",
"return",
"decoder",
".",
"Decode",
"(",
"c",
")",
"\n",
"}"
] | // Decodes configuration in JSON format from the given io.Reader into
// the config object pointed to. | [
"Decodes",
"configuration",
"in",
"JSON",
"format",
"from",
"the",
"given",
"io",
".",
"Reader",
"into",
"the",
"config",
"object",
"pointed",
"to",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L37-L40 |
165,167 | hashicorp/packer | config.go | Discover | func (c *config) Discover() error {
// If we are already inside a plugin process we should not need to
// discover anything.
if os.Getenv(plugin.MagicCookieKey) == plugin.MagicCookieValue {
return nil
}
// First, look in the same directory as the executable.
exePath, err := osext.Executable()
if err != nil {
log.Printf("[ERR] Error loading exe directory: %s", err)
} else {
if err := c.discover(filepath.Dir(exePath)); err != nil {
return err
}
}
// Next, look in the plugins directory.
dir, err := packer.ConfigDir()
if err != nil {
log.Printf("[ERR] Error loading config directory: %s", err)
} else {
if err := c.discover(filepath.Join(dir, "plugins")); err != nil {
return err
}
}
// Next, look in the CWD.
if err := c.discover("."); err != nil {
return err
}
// Finally, try to use an internal plugin. Note that this will not override
// any previously-loaded plugins.
if err := c.discoverInternal(); err != nil {
return err
}
return nil
} | go | func (c *config) Discover() error {
// If we are already inside a plugin process we should not need to
// discover anything.
if os.Getenv(plugin.MagicCookieKey) == plugin.MagicCookieValue {
return nil
}
// First, look in the same directory as the executable.
exePath, err := osext.Executable()
if err != nil {
log.Printf("[ERR] Error loading exe directory: %s", err)
} else {
if err := c.discover(filepath.Dir(exePath)); err != nil {
return err
}
}
// Next, look in the plugins directory.
dir, err := packer.ConfigDir()
if err != nil {
log.Printf("[ERR] Error loading config directory: %s", err)
} else {
if err := c.discover(filepath.Join(dir, "plugins")); err != nil {
return err
}
}
// Next, look in the CWD.
if err := c.discover("."); err != nil {
return err
}
// Finally, try to use an internal plugin. Note that this will not override
// any previously-loaded plugins.
if err := c.discoverInternal(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"config",
")",
"Discover",
"(",
")",
"error",
"{",
"// If we are already inside a plugin process we should not need to",
"// discover anything.",
"if",
"os",
".",
"Getenv",
"(",
"plugin",
".",
"MagicCookieKey",
")",
"==",
"plugin",
".",
"Magic... | // Discover discovers plugins.
//
// Search the directory of the executable, then the plugins directory, and
// finally the CWD, in that order. Any conflicts will overwrite previously
// found plugins, in that order.
// Hence, the priority order is the reverse of the search order - i.e., the
// CWD has the highest priority. | [
"Discover",
"discovers",
"plugins",
".",
"Search",
"the",
"directory",
"of",
"the",
"executable",
"then",
"the",
"plugins",
"directory",
"and",
"finally",
"the",
"CWD",
"in",
"that",
"order",
".",
"Any",
"conflicts",
"will",
"overwrite",
"previously",
"found",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L49-L88 |
165,168 | hashicorp/packer | config.go | LoadBuilder | func (c *config) LoadBuilder(name string) (packer.Builder, error) {
log.Printf("Loading builder: %s\n", name)
bin, ok := c.Builders[name]
if !ok {
log.Printf("Builder not found: %s\n", name)
return nil, nil
}
return c.pluginClient(bin).Builder()
} | go | func (c *config) LoadBuilder(name string) (packer.Builder, error) {
log.Printf("Loading builder: %s\n", name)
bin, ok := c.Builders[name]
if !ok {
log.Printf("Builder not found: %s\n", name)
return nil, nil
}
return c.pluginClient(bin).Builder()
} | [
"func",
"(",
"c",
"*",
"config",
")",
"LoadBuilder",
"(",
"name",
"string",
")",
"(",
"packer",
".",
"Builder",
",",
"error",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
")",
"\n",
"bin",
",",
"ok",
":=",
"c",
".",
"Bui... | // This is a proper packer.BuilderFunc that can be used to load packer.Builder
// implementations from the defined plugins. | [
"This",
"is",
"a",
"proper",
"packer",
".",
"BuilderFunc",
"that",
"can",
"be",
"used",
"to",
"load",
"packer",
".",
"Builder",
"implementations",
"from",
"the",
"defined",
"plugins",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L92-L101 |
165,169 | hashicorp/packer | config.go | LoadHook | func (c *config) LoadHook(name string) (packer.Hook, error) {
log.Printf("Loading hook: %s\n", name)
return c.pluginClient(name).Hook()
} | go | func (c *config) LoadHook(name string) (packer.Hook, error) {
log.Printf("Loading hook: %s\n", name)
return c.pluginClient(name).Hook()
} | [
"func",
"(",
"c",
"*",
"config",
")",
"LoadHook",
"(",
"name",
"string",
")",
"(",
"packer",
".",
"Hook",
",",
"error",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
")",
"\n",
"return",
"c",
".",
"pluginClient",
"(",
"name... | // This is a proper implementation of packer.HookFunc that can be used
// to load packer.Hook implementations from the defined plugins. | [
"This",
"is",
"a",
"proper",
"implementation",
"of",
"packer",
".",
"HookFunc",
"that",
"can",
"be",
"used",
"to",
"load",
"packer",
".",
"Hook",
"implementations",
"from",
"the",
"defined",
"plugins",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L105-L108 |
165,170 | hashicorp/packer | config.go | LoadPostProcessor | func (c *config) LoadPostProcessor(name string) (packer.PostProcessor, error) {
log.Printf("Loading post-processor: %s", name)
bin, ok := c.PostProcessors[name]
if !ok {
log.Printf("Post-processor not found: %s", name)
return nil, nil
}
return c.pluginClient(bin).PostProcessor()
} | go | func (c *config) LoadPostProcessor(name string) (packer.PostProcessor, error) {
log.Printf("Loading post-processor: %s", name)
bin, ok := c.PostProcessors[name]
if !ok {
log.Printf("Post-processor not found: %s", name)
return nil, nil
}
return c.pluginClient(bin).PostProcessor()
} | [
"func",
"(",
"c",
"*",
"config",
")",
"LoadPostProcessor",
"(",
"name",
"string",
")",
"(",
"packer",
".",
"PostProcessor",
",",
"error",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"bin",
",",
"ok",
":=",
"c",
".",
"... | // This is a proper packer.PostProcessorFunc that can be used to load
// packer.PostProcessor implementations from defined plugins. | [
"This",
"is",
"a",
"proper",
"packer",
".",
"PostProcessorFunc",
"that",
"can",
"be",
"used",
"to",
"load",
"packer",
".",
"PostProcessor",
"implementations",
"from",
"defined",
"plugins",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L112-L121 |
165,171 | hashicorp/packer | config.go | LoadProvisioner | func (c *config) LoadProvisioner(name string) (packer.Provisioner, error) {
log.Printf("Loading provisioner: %s\n", name)
bin, ok := c.Provisioners[name]
if !ok {
log.Printf("Provisioner not found: %s\n", name)
return nil, nil
}
return c.pluginClient(bin).Provisioner()
} | go | func (c *config) LoadProvisioner(name string) (packer.Provisioner, error) {
log.Printf("Loading provisioner: %s\n", name)
bin, ok := c.Provisioners[name]
if !ok {
log.Printf("Provisioner not found: %s\n", name)
return nil, nil
}
return c.pluginClient(bin).Provisioner()
} | [
"func",
"(",
"c",
"*",
"config",
")",
"LoadProvisioner",
"(",
"name",
"string",
")",
"(",
"packer",
".",
"Provisioner",
",",
"error",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"name",
")",
"\n",
"bin",
",",
"ok",
":=",
"c",
"."... | // This is a proper packer.ProvisionerFunc that can be used to load
// packer.Provisioner implementations from defined plugins. | [
"This",
"is",
"a",
"proper",
"packer",
".",
"ProvisionerFunc",
"that",
"can",
"be",
"used",
"to",
"load",
"packer",
".",
"Provisioner",
"implementations",
"from",
"defined",
"plugins",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/config.go#L125-L134 |
165,172 | hashicorp/packer | builder/googlecompute/builder.go | Run | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
driver, err := NewDriverGCE(
ui, b.config.ProjectId, &b.config.Account)
if err != nil {
return nil, err
}
// Set up the state.
state := new(multistep.BasicStateBag)
state.Put("config", b.config)
state.Put("driver", driver)
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps.
steps := []multistep.Step{
new(StepCheckExistingImage),
&StepCreateSSHKey{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("gce_%s.pem", b.config.PackerBuildName),
},
&StepCreateInstance{
Debug: b.config.PackerDebug,
},
&StepCreateWindowsPassword{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("gce_windows_%s.pem", b.config.PackerBuildName),
},
&StepInstanceInfo{
Debug: b.config.PackerDebug,
},
&communicator.StepConnect{
Config: &b.config.Comm,
Host: commHost,
SSHConfig: b.config.Comm.SSHConfigFunc(),
WinRMConfig: winrmConfig,
},
new(common.StepProvision),
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
}
if _, exists := b.config.Metadata[StartupScriptKey]; exists || b.config.StartupScriptFile != "" {
steps = append(steps, new(StepWaitStartupScript))
}
steps = append(steps, new(StepTeardownInstance), new(StepCreateImage))
// Run the steps.
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// Report any errors.
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
if _, ok := state.GetOk("image"); !ok {
log.Println("Failed to find image in state. Bug?")
return nil, nil
}
artifact := &Artifact{
image: state.Get("image").(*Image),
driver: driver,
config: b.config,
}
return artifact, nil
} | go | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
driver, err := NewDriverGCE(
ui, b.config.ProjectId, &b.config.Account)
if err != nil {
return nil, err
}
// Set up the state.
state := new(multistep.BasicStateBag)
state.Put("config", b.config)
state.Put("driver", driver)
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps.
steps := []multistep.Step{
new(StepCheckExistingImage),
&StepCreateSSHKey{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("gce_%s.pem", b.config.PackerBuildName),
},
&StepCreateInstance{
Debug: b.config.PackerDebug,
},
&StepCreateWindowsPassword{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("gce_windows_%s.pem", b.config.PackerBuildName),
},
&StepInstanceInfo{
Debug: b.config.PackerDebug,
},
&communicator.StepConnect{
Config: &b.config.Comm,
Host: commHost,
SSHConfig: b.config.Comm.SSHConfigFunc(),
WinRMConfig: winrmConfig,
},
new(common.StepProvision),
&common.StepCleanupTempKeys{
Comm: &b.config.Comm,
},
}
if _, exists := b.config.Metadata[StartupScriptKey]; exists || b.config.StartupScriptFile != "" {
steps = append(steps, new(StepWaitStartupScript))
}
steps = append(steps, new(StepTeardownInstance), new(StepCreateImage))
// Run the steps.
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// Report any errors.
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
if _, ok := state.GetOk("image"); !ok {
log.Println("Failed to find image in state. Bug?")
return nil, nil
}
artifact := &Artifact{
image: state.Get("image").(*Image),
driver: driver,
config: b.config,
}
return artifact, nil
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"ui",
"packer",
".",
"Ui",
",",
"hook",
"packer",
".",
"Hook",
")",
"(",
"packer",
".",
"Artifact",
",",
"error",
")",
"{",
"driver",
",",
"err",
":=",
"New... | // Run executes a googlecompute Packer build and returns a packer.Artifact
// representing a GCE machine image. | [
"Run",
"executes",
"a",
"googlecompute",
"Packer",
"build",
"and",
"returns",
"a",
"packer",
".",
"Artifact",
"representing",
"a",
"GCE",
"machine",
"image",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/builder.go#L37-L103 |
165,173 | hashicorp/packer | builder/googlecompute/artifact.go | Destroy | func (a *Artifact) Destroy() error {
log.Printf("Destroying image: %s", a.image.Name)
errCh := a.driver.DeleteImage(a.image.Name)
return <-errCh
} | go | func (a *Artifact) Destroy() error {
log.Printf("Destroying image: %s", a.image.Name)
errCh := a.driver.DeleteImage(a.image.Name)
return <-errCh
} | [
"func",
"(",
"a",
"*",
"Artifact",
")",
"Destroy",
"(",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"a",
".",
"image",
".",
"Name",
")",
"\n",
"errCh",
":=",
"a",
".",
"driver",
".",
"DeleteImage",
"(",
"a",
".",
"image",
"."... | // Destroy destroys the GCE image represented by the artifact. | [
"Destroy",
"destroys",
"the",
"GCE",
"image",
"represented",
"by",
"the",
"artifact",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/artifact.go#L21-L25 |
165,174 | hashicorp/packer | builder/amazon/chroot/device.go | AvailableDevice | func AvailableDevice() (string, error) {
prefix, err := devicePrefix()
if err != nil {
return "", err
}
letters := "fghijklmnop"
for _, letter := range letters {
device := fmt.Sprintf("/dev/%s%c", prefix, letter)
// If the block device itself, i.e. /dev/sf, exists, then we
// can't use any of the numbers either.
if _, err := os.Stat(device); err == nil {
continue
}
// To be able to build both Paravirtual and HVM images, the unnumbered
// device and the first numbered one must be available.
// E.g. /dev/xvdf and /dev/xvdf1
numbered_device := fmt.Sprintf("%s%d", device, 1)
if _, err := os.Stat(numbered_device); err != nil {
return device, nil
}
}
return "", errors.New("available device could not be found")
} | go | func AvailableDevice() (string, error) {
prefix, err := devicePrefix()
if err != nil {
return "", err
}
letters := "fghijklmnop"
for _, letter := range letters {
device := fmt.Sprintf("/dev/%s%c", prefix, letter)
// If the block device itself, i.e. /dev/sf, exists, then we
// can't use any of the numbers either.
if _, err := os.Stat(device); err == nil {
continue
}
// To be able to build both Paravirtual and HVM images, the unnumbered
// device and the first numbered one must be available.
// E.g. /dev/xvdf and /dev/xvdf1
numbered_device := fmt.Sprintf("%s%d", device, 1)
if _, err := os.Stat(numbered_device); err != nil {
return device, nil
}
}
return "", errors.New("available device could not be found")
} | [
"func",
"AvailableDevice",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"prefix",
",",
"err",
":=",
"devicePrefix",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"letters",
":=",
"\"",
"\"",... | // AvailableDevice finds an available device and returns it. Note that
// you should externally hold a flock or something in order to guarantee
// that this device is available across processes. | [
"AvailableDevice",
"finds",
"an",
"available",
"device",
"and",
"returns",
"it",
".",
"Note",
"that",
"you",
"should",
"externally",
"hold",
"a",
"flock",
"or",
"something",
"in",
"order",
"to",
"guarantee",
"that",
"this",
"device",
"is",
"available",
"across... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/amazon/chroot/device.go#L14-L40 |
165,175 | hashicorp/packer | post-processor/vagrant/virtualbox.go | DecompressOva | func DecompressOva(dir, src string) error {
log.Printf("Turning ova to dir: %s => %s", src, dir)
srcF, err := os.Open(src)
if err != nil {
return err
}
defer srcF.Close()
tarReader := tar.NewReader(srcF)
for {
hdr, err := tarReader.Next()
if hdr == nil || err == io.EOF {
break
}
if err != nil {
return err
}
// We use the fileinfo to get the file name because we are not
// expecting path information as from the tar header. It's important
// that we not use the path name from the tar header without checking
// for the presence of `..`. If we accidentally allow for that, we can
// open ourselves up to a path traversal vulnerability.
info := hdr.FileInfo()
// Shouldn't be any directories, skip them
if info.IsDir() {
continue
}
// We wrap this in an anonymous function so that the defers
// inside are handled more quickly so we can give up file handles.
err = func() error {
path := filepath.Join(dir, info.Name())
output, err := os.Create(path)
if err != nil {
return err
}
defer output.Close()
os.Chmod(path, info.Mode())
os.Chtimes(path, hdr.AccessTime, hdr.ModTime)
_, err = io.Copy(output, tarReader)
return err
}()
if err != nil {
return err
}
}
return nil
} | go | func DecompressOva(dir, src string) error {
log.Printf("Turning ova to dir: %s => %s", src, dir)
srcF, err := os.Open(src)
if err != nil {
return err
}
defer srcF.Close()
tarReader := tar.NewReader(srcF)
for {
hdr, err := tarReader.Next()
if hdr == nil || err == io.EOF {
break
}
if err != nil {
return err
}
// We use the fileinfo to get the file name because we are not
// expecting path information as from the tar header. It's important
// that we not use the path name from the tar header without checking
// for the presence of `..`. If we accidentally allow for that, we can
// open ourselves up to a path traversal vulnerability.
info := hdr.FileInfo()
// Shouldn't be any directories, skip them
if info.IsDir() {
continue
}
// We wrap this in an anonymous function so that the defers
// inside are handled more quickly so we can give up file handles.
err = func() error {
path := filepath.Join(dir, info.Name())
output, err := os.Create(path)
if err != nil {
return err
}
defer output.Close()
os.Chmod(path, info.Mode())
os.Chtimes(path, hdr.AccessTime, hdr.ModTime)
_, err = io.Copy(output, tarReader)
return err
}()
if err != nil {
return err
}
}
return nil
} | [
"func",
"DecompressOva",
"(",
"dir",
",",
"src",
"string",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"src",
",",
"dir",
")",
"\n",
"srcF",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil"... | // DecompressOva takes an ova file and decompresses it into the target
// directory. | [
"DecompressOva",
"takes",
"an",
"ova",
"file",
"and",
"decompresses",
"it",
"into",
"the",
"target",
"directory",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/post-processor/vagrant/virtualbox.go#L122-L173 |
165,176 | hashicorp/packer | helper/common/shared_state.go | sharedStateFilename | func sharedStateFilename(suffix string, buildName string) string {
uuid := os.Getenv("PACKER_RUN_UUID")
return filepath.Join(os.TempDir(), fmt.Sprintf("packer-%s-%s-%s", uuid, suffix, buildName))
} | go | func sharedStateFilename(suffix string, buildName string) string {
uuid := os.Getenv("PACKER_RUN_UUID")
return filepath.Join(os.TempDir(), fmt.Sprintf("packer-%s-%s-%s", uuid, suffix, buildName))
} | [
"func",
"sharedStateFilename",
"(",
"suffix",
"string",
",",
"buildName",
"string",
")",
"string",
"{",
"uuid",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"os",
".",
"TempDir",
"(",
")",
",",
"fmt",
... | // Used to set variables which we need to access later in the build, where
// state bag and config information won't work | [
"Used",
"to",
"set",
"variables",
"which",
"we",
"need",
"to",
"access",
"later",
"in",
"the",
"build",
"where",
"state",
"bag",
"and",
"config",
"information",
"won",
"t",
"work"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/helper/common/shared_state.go#L12-L15 |
165,177 | hashicorp/packer | builder/parallels/common/ssh_config.go | Prepare | func (c *SSHConfig) Prepare(ctx *interpolate.Context) []error {
// TODO: backwards compatibility, write fixer instead
if c.SSHWaitTimeout != 0 {
c.Comm.SSHTimeout = c.SSHWaitTimeout
}
return c.Comm.Prepare(ctx)
} | go | func (c *SSHConfig) Prepare(ctx *interpolate.Context) []error {
// TODO: backwards compatibility, write fixer instead
if c.SSHWaitTimeout != 0 {
c.Comm.SSHTimeout = c.SSHWaitTimeout
}
return c.Comm.Prepare(ctx)
} | [
"func",
"(",
"c",
"*",
"SSHConfig",
")",
"Prepare",
"(",
"ctx",
"*",
"interpolate",
".",
"Context",
")",
"[",
"]",
"error",
"{",
"// TODO: backwards compatibility, write fixer instead",
"if",
"c",
".",
"SSHWaitTimeout",
"!=",
"0",
"{",
"c",
".",
"Comm",
".",... | // Prepare sets the default values for SSH communicator properties. | [
"Prepare",
"sets",
"the",
"default",
"values",
"for",
"SSH",
"communicator",
"properties",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/parallels/common/ssh_config.go#L20-L27 |
165,178 | hashicorp/packer | builder/azure/arm/azure_error_response.go | formatAzureErrorResponse | func formatAzureErrorResponse(error azureErrorDetails, buf *bytes.Buffer, indent string) {
if error.isEmpty() {
return
}
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s : %s\n", indent, error.Code, error.Message))
for _, x := range error.Details {
newIndent := fmt.Sprintf("%s ", indent)
var aer azureErrorResponse
err := json.Unmarshal([]byte(x.Message), &aer)
if err == nil {
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s\n", newIndent, x.Code))
formatAzureErrorResponse(aer.ErrorDetails, buf, newIndent)
} else {
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s : %s\n", newIndent, x.Code, x.Message))
}
}
} | go | func formatAzureErrorResponse(error azureErrorDetails, buf *bytes.Buffer, indent string) {
if error.isEmpty() {
return
}
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s : %s\n", indent, error.Code, error.Message))
for _, x := range error.Details {
newIndent := fmt.Sprintf("%s ", indent)
var aer azureErrorResponse
err := json.Unmarshal([]byte(x.Message), &aer)
if err == nil {
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s\n", newIndent, x.Code))
formatAzureErrorResponse(aer.ErrorDetails, buf, newIndent)
} else {
buf.WriteString(fmt.Sprintf("ERROR: %s-> %s : %s\n", newIndent, x.Code, x.Message))
}
}
} | [
"func",
"formatAzureErrorResponse",
"(",
"error",
"azureErrorDetails",
",",
"buf",
"*",
"bytes",
".",
"Buffer",
",",
"indent",
"string",
")",
"{",
"if",
"error",
".",
"isEmpty",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteString",
"(",
... | // format a Azure Error Response by recursing through the JSON structure.
//
// Errors may contain nested errors, which are JSON documents that have been
// serialized and escaped. Keep following this nesting all the way down... | [
"format",
"a",
"Azure",
"Error",
"Response",
"by",
"recursing",
"through",
"the",
"JSON",
"structure",
".",
"Errors",
"may",
"contain",
"nested",
"errors",
"which",
"are",
"JSON",
"documents",
"that",
"have",
"been",
"serialized",
"and",
"escaped",
".",
"Keep"... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/arm/azure_error_response.go#L49-L67 |
165,179 | hashicorp/packer | builder/azure/arm/builder.go | setRuntimeParameters | func (b *Builder) setRuntimeParameters(stateBag multistep.StateBag) {
stateBag.Put(constants.ArmLocation, b.config.Location)
stateBag.Put(constants.ArmManagedImageLocation, b.config.manageImageLocation)
} | go | func (b *Builder) setRuntimeParameters(stateBag multistep.StateBag) {
stateBag.Put(constants.ArmLocation, b.config.Location)
stateBag.Put(constants.ArmManagedImageLocation, b.config.manageImageLocation)
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"setRuntimeParameters",
"(",
"stateBag",
"multistep",
".",
"StateBag",
")",
"{",
"stateBag",
".",
"Put",
"(",
"constants",
".",
"ArmLocation",
",",
"b",
".",
"config",
".",
"Location",
")",
"\n",
"stateBag",
".",
"P... | // Parameters that are only known at runtime after querying Azure. | [
"Parameters",
"that",
"are",
"only",
"known",
"at",
"runtime",
"after",
"querying",
"Azure",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/azure/arm/builder.go#L375-L378 |
165,180 | hashicorp/packer | builder/amazon/common/access_config.go | Session | func (c *AccessConfig) Session() (*session.Session, error) {
if c.session != nil {
return c.session, nil
}
config := aws.NewConfig().WithCredentialsChainVerboseErrors(true)
staticCreds := credentials.NewStaticCredentials(c.AccessKey, c.SecretKey, c.Token)
if _, err := staticCreds.Get(); err != credentials.ErrStaticCredentialsEmpty {
config.WithCredentials(staticCreds)
}
if c.RawRegion != "" {
config = config.WithRegion(c.RawRegion)
}
if c.CustomEndpointEc2 != "" {
config = config.WithEndpoint(c.CustomEndpointEc2)
}
config = config.WithHTTPClient(cleanhttp.DefaultClient())
transport := config.HTTPClient.Transport.(*http.Transport)
if c.InsecureSkipTLSVerify {
transport.TLSClientConfig = &tls.Config{
InsecureSkipVerify: true,
}
}
transport.Proxy = http.ProxyFromEnvironment
opts := session.Options{
SharedConfigState: session.SharedConfigEnable,
Config: *config,
}
if c.ProfileName != "" {
opts.Profile = c.ProfileName
}
if c.MFACode != "" {
opts.AssumeRoleTokenProvider = func() (string, error) {
return c.MFACode, nil
}
}
sess, err := session.NewSessionWithOptions(opts)
if err != nil {
return nil, err
}
log.Printf("Found region %s", *sess.Config.Region)
c.session = sess
cp, err := c.session.Config.Credentials.Get()
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NoCredentialProviders" {
return nil, fmt.Errorf("No valid credential sources found for AWS Builder. " +
"Please see https://www.packer.io/docs/builders/amazon.html#specifying-amazon-credentials " +
"for more information on providing credentials for the AWS Builder.")
} else {
return nil, fmt.Errorf("Error loading credentials for AWS Provider: %s", err)
}
}
log.Printf("[INFO] AWS Auth provider used: %q", cp.ProviderName)
if c.DecodeAuthZMessages {
DecodeAuthZMessages(c.session)
}
LogEnvOverrideWarnings()
return c.session, nil
} | go | func (c *AccessConfig) Session() (*session.Session, error) {
if c.session != nil {
return c.session, nil
}
config := aws.NewConfig().WithCredentialsChainVerboseErrors(true)
staticCreds := credentials.NewStaticCredentials(c.AccessKey, c.SecretKey, c.Token)
if _, err := staticCreds.Get(); err != credentials.ErrStaticCredentialsEmpty {
config.WithCredentials(staticCreds)
}
if c.RawRegion != "" {
config = config.WithRegion(c.RawRegion)
}
if c.CustomEndpointEc2 != "" {
config = config.WithEndpoint(c.CustomEndpointEc2)
}
config = config.WithHTTPClient(cleanhttp.DefaultClient())
transport := config.HTTPClient.Transport.(*http.Transport)
if c.InsecureSkipTLSVerify {
transport.TLSClientConfig = &tls.Config{
InsecureSkipVerify: true,
}
}
transport.Proxy = http.ProxyFromEnvironment
opts := session.Options{
SharedConfigState: session.SharedConfigEnable,
Config: *config,
}
if c.ProfileName != "" {
opts.Profile = c.ProfileName
}
if c.MFACode != "" {
opts.AssumeRoleTokenProvider = func() (string, error) {
return c.MFACode, nil
}
}
sess, err := session.NewSessionWithOptions(opts)
if err != nil {
return nil, err
}
log.Printf("Found region %s", *sess.Config.Region)
c.session = sess
cp, err := c.session.Config.Credentials.Get()
if err != nil {
if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NoCredentialProviders" {
return nil, fmt.Errorf("No valid credential sources found for AWS Builder. " +
"Please see https://www.packer.io/docs/builders/amazon.html#specifying-amazon-credentials " +
"for more information on providing credentials for the AWS Builder.")
} else {
return nil, fmt.Errorf("Error loading credentials for AWS Provider: %s", err)
}
}
log.Printf("[INFO] AWS Auth provider used: %q", cp.ProviderName)
if c.DecodeAuthZMessages {
DecodeAuthZMessages(c.session)
}
LogEnvOverrideWarnings()
return c.session, nil
} | [
"func",
"(",
"c",
"*",
"AccessConfig",
")",
"Session",
"(",
")",
"(",
"*",
"session",
".",
"Session",
",",
"error",
")",
"{",
"if",
"c",
".",
"session",
"!=",
"nil",
"{",
"return",
"c",
".",
"session",
",",
"nil",
"\n",
"}",
"\n\n",
"config",
":=... | // Config returns a valid aws.Config object for access to AWS services, or
// an error if the authentication and region couldn't be resolved | [
"Config",
"returns",
"a",
"valid",
"aws",
".",
"Config",
"object",
"for",
"access",
"to",
"AWS",
"services",
"or",
"an",
"error",
"if",
"the",
"authentication",
"and",
"region",
"couldn",
"t",
"be",
"resolved"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/amazon/common/access_config.go#L54-L123 |
165,181 | hashicorp/packer | builder/googlecompute/networking.go | getNetworking | func getNetworking(c *InstanceConfig) (string, string, error) {
networkId := c.Network
subnetworkId := c.Subnetwork
// Apply network naming requirements per
// https://cloud.google.com/compute/docs/reference/latest/instances#resource
switch c.Network {
// It is possible to omit the network property as long as a subnet is
// specified. That will be validated later.
case "":
break
// This special short name should be expanded.
case "default":
networkId = "global/networks/default"
// A value other than "default" was provided for the network name.
default:
// If the value doesn't contain a slash, we assume it's not a full or
// partial URL. We will expand it into a partial URL here and avoid
// making an API call to discover the network as it's common for the
// caller to not have permission against network discovery APIs.
if !strings.Contains(c.Network, "/") {
networkId = "projects/" + c.NetworkProjectId + "/global/networks/" + c.Network
}
}
// Apply subnetwork naming requirements per
// https://cloud.google.com/compute/docs/reference/latest/instances#resource
switch c.Subnetwork {
case "":
// You can't omit both subnetwork and network
if networkId == "" {
return networkId, subnetworkId, fmt.Errorf("both network and subnetwork were empty.")
}
// An empty subnetwork is only valid for networks in legacy mode or
// auto-subnet mode. We could make an API call to get that information
// about the network, but it's common for the caller to not have
// permission to that API. We'll proceed assuming they're correct in
// omitting the subnetwork and let the compute.insert API surface an
// error about an invalid network configuration if it exists.
break
default:
// If the value doesn't contain a slash, we assume it's not a full or
// partial URL. We will expand it into a partial URL here and avoid
// making a call to discover the subnetwork.
if !strings.Contains(c.Subnetwork, "/") {
subnetworkId = "projects/" + c.NetworkProjectId + "/regions/" + c.Region + "/subnetworks/" + c.Subnetwork
}
}
return networkId, subnetworkId, nil
} | go | func getNetworking(c *InstanceConfig) (string, string, error) {
networkId := c.Network
subnetworkId := c.Subnetwork
// Apply network naming requirements per
// https://cloud.google.com/compute/docs/reference/latest/instances#resource
switch c.Network {
// It is possible to omit the network property as long as a subnet is
// specified. That will be validated later.
case "":
break
// This special short name should be expanded.
case "default":
networkId = "global/networks/default"
// A value other than "default" was provided for the network name.
default:
// If the value doesn't contain a slash, we assume it's not a full or
// partial URL. We will expand it into a partial URL here and avoid
// making an API call to discover the network as it's common for the
// caller to not have permission against network discovery APIs.
if !strings.Contains(c.Network, "/") {
networkId = "projects/" + c.NetworkProjectId + "/global/networks/" + c.Network
}
}
// Apply subnetwork naming requirements per
// https://cloud.google.com/compute/docs/reference/latest/instances#resource
switch c.Subnetwork {
case "":
// You can't omit both subnetwork and network
if networkId == "" {
return networkId, subnetworkId, fmt.Errorf("both network and subnetwork were empty.")
}
// An empty subnetwork is only valid for networks in legacy mode or
// auto-subnet mode. We could make an API call to get that information
// about the network, but it's common for the caller to not have
// permission to that API. We'll proceed assuming they're correct in
// omitting the subnetwork and let the compute.insert API surface an
// error about an invalid network configuration if it exists.
break
default:
// If the value doesn't contain a slash, we assume it's not a full or
// partial URL. We will expand it into a partial URL here and avoid
// making a call to discover the subnetwork.
if !strings.Contains(c.Subnetwork, "/") {
subnetworkId = "projects/" + c.NetworkProjectId + "/regions/" + c.Region + "/subnetworks/" + c.Subnetwork
}
}
return networkId, subnetworkId, nil
} | [
"func",
"getNetworking",
"(",
"c",
"*",
"InstanceConfig",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"networkId",
":=",
"c",
".",
"Network",
"\n",
"subnetworkId",
":=",
"c",
".",
"Subnetwork",
"\n\n",
"// Apply network naming requirements per",
... | // This method will build a network and subnetwork ID from the provided
// instance config, and return them in that order. | [
"This",
"method",
"will",
"build",
"a",
"network",
"and",
"subnetwork",
"ID",
"from",
"the",
"provided",
"instance",
"config",
"and",
"return",
"them",
"in",
"that",
"order",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/networking.go#L10-L59 |
165,182 | hashicorp/packer | builder/oracle/oci/artifact.go | Destroy | func (a *Artifact) Destroy() error {
return a.driver.DeleteImage(context.TODO(), *a.Image.Id)
} | go | func (a *Artifact) Destroy() error {
return a.driver.DeleteImage(context.TODO(), *a.Image.Id)
} | [
"func",
"(",
"a",
"*",
"Artifact",
")",
"Destroy",
"(",
")",
"error",
"{",
"return",
"a",
".",
"driver",
".",
"DeleteImage",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"*",
"a",
".",
"Image",
".",
"Id",
")",
"\n",
"}"
] | // Destroy deletes the custom image associated with the artifact. | [
"Destroy",
"deletes",
"the",
"custom",
"image",
"associated",
"with",
"the",
"artifact",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/oracle/oci/artifact.go#L51-L53 |
165,183 | hashicorp/packer | builder/vmware/common/driver_player5_windows.go | playerVMwareRoot | func playerVMwareRoot() (s string, err error) {
key := `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\vmplayer.exe`
subkey := "Path"
s, err = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
if err != nil {
log.Printf(`Unable to read registry key %s\%s`, key, subkey)
return
}
return normalizePath(s), nil
} | go | func playerVMwareRoot() (s string, err error) {
key := `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\vmplayer.exe`
subkey := "Path"
s, err = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
if err != nil {
log.Printf(`Unable to read registry key %s\%s`, key, subkey)
return
}
return normalizePath(s), nil
} | [
"func",
"playerVMwareRoot",
"(",
")",
"(",
"s",
"string",
",",
"err",
"error",
")",
"{",
"key",
":=",
"`SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\vmplayer.exe`",
"\n",
"subkey",
":=",
"\"",
"\"",
"\n",
"s",
",",
"err",
"=",
"readRegString",
"(",
"... | // This reads the VMware installation path from the Windows registry. | [
"This",
"reads",
"the",
"VMware",
"installation",
"path",
"from",
"the",
"Windows",
"registry",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_player5_windows.go#L84-L94 |
165,184 | hashicorp/packer | builder/vmware/common/driver_player5_windows.go | playerProgramFilePaths | func playerProgramFilePaths() []string {
path, err := playerVMwareRoot()
if err != nil {
log.Printf("Error finding VMware root: %s", err)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_HOME") != "" {
paths = append(paths, os.Getenv("VMWARE_HOME"))
}
if path != "" {
paths = append(paths, path)
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Player"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Player"))
}
if os.Getenv("QEMU_HOME") != "" {
paths = append(paths, os.Getenv("QEMU_HOME"))
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/QEMU"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/QEMU"))
}
if os.Getenv("SystemDrive") != "" {
paths = append(paths,
filepath.Join(os.Getenv("SystemDrive"), "/QEMU"))
}
return paths
} | go | func playerProgramFilePaths() []string {
path, err := playerVMwareRoot()
if err != nil {
log.Printf("Error finding VMware root: %s", err)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_HOME") != "" {
paths = append(paths, os.Getenv("VMWARE_HOME"))
}
if path != "" {
paths = append(paths, path)
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Player"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Player"))
}
if os.Getenv("QEMU_HOME") != "" {
paths = append(paths, os.Getenv("QEMU_HOME"))
}
if os.Getenv("ProgramFiles(x86)") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles(x86)"), "/QEMU"))
}
if os.Getenv("ProgramFiles") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramFiles"), "/QEMU"))
}
if os.Getenv("SystemDrive") != "" {
paths = append(paths,
filepath.Join(os.Getenv("SystemDrive"), "/QEMU"))
}
return paths
} | [
"func",
"playerProgramFilePaths",
"(",
")",
"[",
"]",
"string",
"{",
"path",
",",
"err",
":=",
"playerVMwareRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"paths",
":... | // playerProgramFilesPaths returns a list of paths that are eligible
// to contain program files we may want just as vmware.exe. | [
"playerProgramFilesPaths",
"returns",
"a",
"list",
"of",
"paths",
"that",
"are",
"eligible",
"to",
"contain",
"program",
"files",
"we",
"may",
"want",
"just",
"as",
"vmware",
".",
"exe",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_player5_windows.go#L122-L167 |
165,185 | hashicorp/packer | builder/vmware/common/driver_player5_windows.go | playerDataFilePaths | func playerDataFilePaths() []string {
leasesPath, err := playerDhcpLeasesPathRegistry()
if err != nil {
log.Printf("Error getting DHCP leases path: %s", err)
}
if leasesPath != "" {
leasesPath = filepath.Dir(leasesPath)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_DATA") != "" {
paths = append(paths, os.Getenv("VMWARE_DATA"))
}
if leasesPath != "" {
paths = append(paths, leasesPath)
}
if os.Getenv("ProgramData") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramData"), "/VMware"))
}
if os.Getenv("ALLUSERSPROFILE") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware"))
}
return paths
} | go | func playerDataFilePaths() []string {
leasesPath, err := playerDhcpLeasesPathRegistry()
if err != nil {
log.Printf("Error getting DHCP leases path: %s", err)
}
if leasesPath != "" {
leasesPath = filepath.Dir(leasesPath)
}
paths := make([]string, 0, 5)
if os.Getenv("VMWARE_DATA") != "" {
paths = append(paths, os.Getenv("VMWARE_DATA"))
}
if leasesPath != "" {
paths = append(paths, leasesPath)
}
if os.Getenv("ProgramData") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ProgramData"), "/VMware"))
}
if os.Getenv("ALLUSERSPROFILE") != "" {
paths = append(paths,
filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware"))
}
return paths
} | [
"func",
"playerDataFilePaths",
"(",
")",
"[",
"]",
"string",
"{",
"leasesPath",
",",
"err",
":=",
"playerDhcpLeasesPathRegistry",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
... | // playerDataFilePaths returns a list of paths that are eligible
// to contain data files we may want such as vmnet NAT configuration files. | [
"playerDataFilePaths",
"returns",
"a",
"list",
"of",
"paths",
"that",
"are",
"eligible",
"to",
"contain",
"data",
"files",
"we",
"may",
"want",
"such",
"as",
"vmnet",
"NAT",
"configuration",
"files",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_player5_windows.go#L171-L201 |
165,186 | hashicorp/packer | builder/yandex/template_func.go | templateCleanImageName | func templateCleanImageName(s string) string {
if reImageFamily.MatchString(s) {
return s
}
b := []byte(strings.ToLower(s))
newb := make([]byte, len(b))
for i := range newb {
if isalphanumeric(b[i]) {
newb[i] = b[i]
} else {
newb[i] = '-'
}
}
return string(newb)
} | go | func templateCleanImageName(s string) string {
if reImageFamily.MatchString(s) {
return s
}
b := []byte(strings.ToLower(s))
newb := make([]byte, len(b))
for i := range newb {
if isalphanumeric(b[i]) {
newb[i] = b[i]
} else {
newb[i] = '-'
}
}
return string(newb)
} | [
"func",
"templateCleanImageName",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"reImageFamily",
".",
"MatchString",
"(",
"s",
")",
"{",
"return",
"s",
"\n",
"}",
"\n",
"b",
":=",
"[",
"]",
"byte",
"(",
"strings",
".",
"ToLower",
"(",
"s",
")",
")",
... | // Clean up image name by replacing invalid characters with "-"
// and converting upper cases to lower cases | [
"Clean",
"up",
"image",
"name",
"by",
"replacing",
"invalid",
"characters",
"with",
"-",
"and",
"converting",
"upper",
"cases",
"to",
"lower",
"cases"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/yandex/template_func.go#L18-L32 |
165,187 | hashicorp/packer | provisioner/shell/unix_reader.go | scanUnixLine | func scanUnixLine(data []byte, atEOF bool) (advance int, token []byte, err error) {
advance, token, err = bufio.ScanLines(data, atEOF)
if advance == 0 {
// If we reached the end of a line without a newline, then
// just return as it is. Otherwise the Scanner will keep trying
// to scan, blocking forever.
return
}
return advance, append(token, '\n'), err
} | go | func scanUnixLine(data []byte, atEOF bool) (advance int, token []byte, err error) {
advance, token, err = bufio.ScanLines(data, atEOF)
if advance == 0 {
// If we reached the end of a line without a newline, then
// just return as it is. Otherwise the Scanner will keep trying
// to scan, blocking forever.
return
}
return advance, append(token, '\n'), err
} | [
"func",
"scanUnixLine",
"(",
"data",
"[",
"]",
"byte",
",",
"atEOF",
"bool",
")",
"(",
"advance",
"int",
",",
"token",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"advance",
",",
"token",
",",
"err",
"=",
"bufio",
".",
"ScanLines",
"(",
"data"... | // scanUnixLine is a bufio.Scanner SplitFunc. It tokenizes on lines, but
// only returns unix-style lines. So even if the line is "one\r\n", the
// token returned will be "one\n". | [
"scanUnixLine",
"is",
"a",
"bufio",
".",
"Scanner",
"SplitFunc",
".",
"It",
"tokenizes",
"on",
"lines",
"but",
"only",
"returns",
"unix",
"-",
"style",
"lines",
".",
"So",
"even",
"if",
"the",
"line",
"is",
"one",
"\\",
"r",
"\\",
"n",
"the",
"token",
... | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/provisioner/shell/unix_reader.go#L55-L65 |
165,188 | hashicorp/packer | builder/yandex/builder.go | Run | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
driver, err := NewDriverYC(ui, b.config)
if err != nil {
return nil, err
}
// Set up the state
state := &multistep.BasicStateBag{}
state.Put("config", b.config)
state.Put("driver", driver)
state.Put("sdk", driver.SDK())
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps
steps := []multistep.Step{
&stepCreateSSHKey{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("yc_%s.pem", b.config.PackerBuildName),
},
&stepCreateInstance{
Debug: b.config.PackerDebug,
SerialLogFile: b.config.SerialLogFile,
},
&stepInstanceInfo{},
&communicator.StepConnect{
Config: &b.config.Communicator,
Host: commHost,
SSHConfig: b.config.Communicator.SSHConfigFunc(),
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Communicator,
},
&stepTeardownInstance{},
&stepCreateImage{},
}
// Run the steps
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// Report any errors
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
image, ok := state.GetOk("image")
if !ok {
return nil, fmt.Errorf("Failed to find 'image' in state. Bug?")
}
artifact := &Artifact{
image: image.(*compute.Image),
config: b.config,
}
return artifact, nil
} | go | func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
driver, err := NewDriverYC(ui, b.config)
if err != nil {
return nil, err
}
// Set up the state
state := &multistep.BasicStateBag{}
state.Put("config", b.config)
state.Put("driver", driver)
state.Put("sdk", driver.SDK())
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps
steps := []multistep.Step{
&stepCreateSSHKey{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("yc_%s.pem", b.config.PackerBuildName),
},
&stepCreateInstance{
Debug: b.config.PackerDebug,
SerialLogFile: b.config.SerialLogFile,
},
&stepInstanceInfo{},
&communicator.StepConnect{
Config: &b.config.Communicator,
Host: commHost,
SSHConfig: b.config.Communicator.SSHConfigFunc(),
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Communicator,
},
&stepTeardownInstance{},
&stepCreateImage{},
}
// Run the steps
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// Report any errors
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
image, ok := state.GetOk("image")
if !ok {
return nil, fmt.Errorf("Failed to find 'image' in state. Bug?")
}
artifact := &Artifact{
image: image.(*compute.Image),
config: b.config,
}
return artifact, nil
} | [
"func",
"(",
"b",
"*",
"Builder",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"ui",
"packer",
".",
"Ui",
",",
"hook",
"packer",
".",
"Hook",
")",
"(",
"packer",
".",
"Artifact",
",",
"error",
")",
"{",
"driver",
",",
"err",
":=",
"New... | // Run executes a yandex Packer build and returns a packer.Artifact
// representing a Yandex.Cloud compute image. | [
"Run",
"executes",
"a",
"yandex",
"Packer",
"build",
"and",
"returns",
"a",
"packer",
".",
"Artifact",
"representing",
"a",
"Yandex",
".",
"Cloud",
"compute",
"image",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/yandex/builder.go#L36-L94 |
165,189 | hashicorp/packer | builder/vmware/common/driver_esx5.go | UpdateVMX | func (ESX5Driver) UpdateVMX(_, password string, port int, data map[string]string) {
// Do not set remotedisplay.vnc.ip - this breaks ESXi.
data["remotedisplay.vnc.enabled"] = "TRUE"
data["remotedisplay.vnc.port"] = fmt.Sprintf("%d", port)
if len(password) > 0 {
data["remotedisplay.vnc.password"] = password
}
} | go | func (ESX5Driver) UpdateVMX(_, password string, port int, data map[string]string) {
// Do not set remotedisplay.vnc.ip - this breaks ESXi.
data["remotedisplay.vnc.enabled"] = "TRUE"
data["remotedisplay.vnc.port"] = fmt.Sprintf("%d", port)
if len(password) > 0 {
data["remotedisplay.vnc.password"] = password
}
} | [
"func",
"(",
"ESX5Driver",
")",
"UpdateVMX",
"(",
"_",
",",
"password",
"string",
",",
"port",
"int",
",",
"data",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"// Do not set remotedisplay.vnc.ip - this breaks ESXi.",
"data",
"[",
"\"",
"\"",
"]",
"=",
"\"... | // UpdateVMX, adds the VNC port to the VMX data. | [
"UpdateVMX",
"adds",
"the",
"VNC",
"port",
"to",
"the",
"VMX",
"data",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/driver_esx5.go#L430-L437 |
165,190 | hashicorp/packer | builder/vmware/common/vmx.go | ParseVMX | func ParseVMX(contents string) map[string]string {
results := make(map[string]string)
lineRe := regexp.MustCompile(`^(.+?)\s*=\s*"?(.*?)"?\s*$`)
for _, line := range strings.Split(contents, "\n") {
matches := lineRe.FindStringSubmatch(line)
if matches == nil {
continue
}
key := strings.ToLower(matches[1])
results[key] = matches[2]
}
return results
} | go | func ParseVMX(contents string) map[string]string {
results := make(map[string]string)
lineRe := regexp.MustCompile(`^(.+?)\s*=\s*"?(.*?)"?\s*$`)
for _, line := range strings.Split(contents, "\n") {
matches := lineRe.FindStringSubmatch(line)
if matches == nil {
continue
}
key := strings.ToLower(matches[1])
results[key] = matches[2]
}
return results
} | [
"func",
"ParseVMX",
"(",
"contents",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"results",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"lineRe",
":=",
"regexp",
".",
"MustCompile",
"(",
"`^(.+?)\\s*=\\s*\"?(.*?)\"?\\s*$... | // ParseVMX parses the keys and values from a VMX file and returns
// them as a Go map. | [
"ParseVMX",
"parses",
"the",
"keys",
"and",
"values",
"from",
"a",
"VMX",
"file",
"and",
"returns",
"them",
"as",
"a",
"Go",
"map",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/vmx.go#L17-L33 |
165,191 | hashicorp/packer | builder/vmware/common/vmx.go | EncodeVMX | func EncodeVMX(contents map[string]string) string {
var buf bytes.Buffer
i := 0
keys := make([]string, len(contents))
for k := range contents {
keys[i] = k
i++
}
// a list of VMX key fragments that the value must not be quoted
// fragments are used to cover multiples (i.e. multiple disks)
// keys are still lowercase at this point, use lower fragments
noQuotes := []string{
".virtualssd",
}
// a list of VMX key fragments that are case sensitive
// fragments are used to cover multiples (i.e. multiple disks)
caseSensitive := []string{
".virtualSSD",
}
sort.Strings(keys)
for _, k := range keys {
pat := "%s = \"%s\"\n"
// items with no quotes
for _, q := range noQuotes {
if strings.Contains(k, q) {
pat = "%s = %s\n"
break
}
}
key := k
// case sensitive key fragments
for _, c := range caseSensitive {
key = strings.Replace(key, strings.ToLower(c), c, 1)
}
buf.WriteString(fmt.Sprintf(pat, key, contents[k]))
}
return buf.String()
} | go | func EncodeVMX(contents map[string]string) string {
var buf bytes.Buffer
i := 0
keys := make([]string, len(contents))
for k := range contents {
keys[i] = k
i++
}
// a list of VMX key fragments that the value must not be quoted
// fragments are used to cover multiples (i.e. multiple disks)
// keys are still lowercase at this point, use lower fragments
noQuotes := []string{
".virtualssd",
}
// a list of VMX key fragments that are case sensitive
// fragments are used to cover multiples (i.e. multiple disks)
caseSensitive := []string{
".virtualSSD",
}
sort.Strings(keys)
for _, k := range keys {
pat := "%s = \"%s\"\n"
// items with no quotes
for _, q := range noQuotes {
if strings.Contains(k, q) {
pat = "%s = %s\n"
break
}
}
key := k
// case sensitive key fragments
for _, c := range caseSensitive {
key = strings.Replace(key, strings.ToLower(c), c, 1)
}
buf.WriteString(fmt.Sprintf(pat, key, contents[k]))
}
return buf.String()
} | [
"func",
"EncodeVMX",
"(",
"contents",
"map",
"[",
"string",
"]",
"string",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n\n",
"i",
":=",
"0",
"\n",
"keys",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"contents",
")",
")",... | // EncodeVMX takes a map and turns it into valid VMX contents. | [
"EncodeVMX",
"takes",
"a",
"map",
"and",
"turns",
"it",
"into",
"valid",
"VMX",
"contents",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/vmx.go#L36-L78 |
165,192 | hashicorp/packer | builder/vmware/common/vmx.go | WriteVMX | func WriteVMX(path string, data map[string]string) (err error) {
log.Printf("Writing VMX to: %s", path)
f, err := os.Create(path)
if err != nil {
return
}
defer f.Close()
var buf bytes.Buffer
buf.WriteString(EncodeVMX(data))
if _, err = io.Copy(f, &buf); err != nil {
return
}
return
} | go | func WriteVMX(path string, data map[string]string) (err error) {
log.Printf("Writing VMX to: %s", path)
f, err := os.Create(path)
if err != nil {
return
}
defer f.Close()
var buf bytes.Buffer
buf.WriteString(EncodeVMX(data))
if _, err = io.Copy(f, &buf); err != nil {
return
}
return
} | [
"func",
"WriteVMX",
"(",
"path",
"string",
",",
"data",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"err",
"error",
")",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"pa... | // WriteVMX takes a path to a VMX file and contents in the form of a
// map and writes it out. | [
"WriteVMX",
"takes",
"a",
"path",
"to",
"a",
"VMX",
"file",
"and",
"contents",
"in",
"the",
"form",
"of",
"a",
"map",
"and",
"writes",
"it",
"out",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/vmware/common/vmx.go#L82-L97 |
165,193 | hashicorp/packer | template/interpolate/i.go | Render | func Render(v string, ctx *Context) (string, error) {
return (&I{Value: v}).Render(ctx)
} | go | func Render(v string, ctx *Context) (string, error) {
return (&I{Value: v}).Render(ctx)
} | [
"func",
"Render",
"(",
"v",
"string",
",",
"ctx",
"*",
"Context",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"(",
"&",
"I",
"{",
"Value",
":",
"v",
"}",
")",
".",
"Render",
"(",
"ctx",
")",
"\n",
"}"
] | // Render is shorthand for constructing an I and calling Render. | [
"Render",
"is",
"shorthand",
"for",
"constructing",
"an",
"I",
"and",
"calling",
"Render",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/interpolate/i.go#L40-L42 |
165,194 | hashicorp/packer | template/interpolate/i.go | Validate | func Validate(v string, ctx *Context) error {
return (&I{Value: v}).Validate(ctx)
} | go | func Validate(v string, ctx *Context) error {
return (&I{Value: v}).Validate(ctx)
} | [
"func",
"Validate",
"(",
"v",
"string",
",",
"ctx",
"*",
"Context",
")",
"error",
"{",
"return",
"(",
"&",
"I",
"{",
"Value",
":",
"v",
"}",
")",
".",
"Validate",
"(",
"ctx",
")",
"\n",
"}"
] | // Validate is shorthand for constructing an I and calling Validate. | [
"Validate",
"is",
"shorthand",
"for",
"constructing",
"an",
"I",
"and",
"calling",
"Validate",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/interpolate/i.go#L45-L47 |
165,195 | hashicorp/packer | template/interpolate/i.go | Render | func (i *I) Render(ictx *Context) (string, error) {
tpl, err := i.template(ictx)
if err != nil {
return "", err
}
var result bytes.Buffer
var data interface{}
if ictx != nil {
data = ictx.Data
}
if err := tpl.Execute(&result, data); err != nil {
return "", err
}
return result.String(), nil
} | go | func (i *I) Render(ictx *Context) (string, error) {
tpl, err := i.template(ictx)
if err != nil {
return "", err
}
var result bytes.Buffer
var data interface{}
if ictx != nil {
data = ictx.Data
}
if err := tpl.Execute(&result, data); err != nil {
return "", err
}
return result.String(), nil
} | [
"func",
"(",
"i",
"*",
"I",
")",
"Render",
"(",
"ictx",
"*",
"Context",
")",
"(",
"string",
",",
"error",
")",
"{",
"tpl",
",",
"err",
":=",
"i",
".",
"template",
"(",
"ictx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",... | // Render renders the interpolation with the given context. | [
"Render",
"renders",
"the",
"interpolation",
"with",
"the",
"given",
"context",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/interpolate/i.go#L56-L72 |
165,196 | hashicorp/packer | template/interpolate/i.go | Validate | func (i *I) Validate(ctx *Context) error {
_, err := i.template(ctx)
return err
} | go | func (i *I) Validate(ctx *Context) error {
_, err := i.template(ctx)
return err
} | [
"func",
"(",
"i",
"*",
"I",
")",
"Validate",
"(",
"ctx",
"*",
"Context",
")",
"error",
"{",
"_",
",",
"err",
":=",
"i",
".",
"template",
"(",
"ctx",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Validate validates that the template is syntactically valid. | [
"Validate",
"validates",
"that",
"the",
"template",
"is",
"syntactically",
"valid",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/template/interpolate/i.go#L75-L78 |
165,197 | hashicorp/packer | builder/amazon/chroot/step_register_ami.go | buildBaseRegisterOpts | func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSize int64, snapshotID string) *ec2.RegisterImageInput {
var (
mappings []*ec2.BlockDeviceMapping
rootDeviceName string
)
generatingNewBlockDeviceMappings := config.FromScratch || len(config.AMIMappings) > 0
if generatingNewBlockDeviceMappings {
mappings = config.AMIBlockDevices.BuildAMIDevices()
rootDeviceName = config.RootDeviceName
} else {
// If config.FromScratch is false, source image must be set
mappings = sourceImage.BlockDeviceMappings
rootDeviceName = *sourceImage.RootDeviceName
}
newMappings := make([]*ec2.BlockDeviceMapping, len(mappings))
for i, device := range mappings {
newDevice := device
if *newDevice.DeviceName == rootDeviceName {
if newDevice.Ebs != nil {
newDevice.Ebs.SnapshotId = aws.String(snapshotID)
} else {
newDevice.Ebs = &ec2.EbsBlockDevice{SnapshotId: aws.String(snapshotID)}
}
if generatingNewBlockDeviceMappings || rootVolumeSize > *newDevice.Ebs.VolumeSize {
newDevice.Ebs.VolumeSize = aws.Int64(rootVolumeSize)
}
}
// assume working from a snapshot, so we unset the Encrypted field if set,
// otherwise AWS API will return InvalidParameter
if newDevice.Ebs != nil && newDevice.Ebs.Encrypted != nil {
newDevice.Ebs.Encrypted = nil
}
newMappings[i] = newDevice
}
if config.FromScratch {
return &ec2.RegisterImageInput{
Name: &config.AMIName,
Architecture: aws.String(ec2.ArchitectureValuesX8664),
RootDeviceName: aws.String(rootDeviceName),
VirtualizationType: aws.String(config.AMIVirtType),
BlockDeviceMappings: newMappings,
}
}
return buildRegisterOptsFromExistingImage(config, sourceImage, newMappings, rootDeviceName)
} | go | func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSize int64, snapshotID string) *ec2.RegisterImageInput {
var (
mappings []*ec2.BlockDeviceMapping
rootDeviceName string
)
generatingNewBlockDeviceMappings := config.FromScratch || len(config.AMIMappings) > 0
if generatingNewBlockDeviceMappings {
mappings = config.AMIBlockDevices.BuildAMIDevices()
rootDeviceName = config.RootDeviceName
} else {
// If config.FromScratch is false, source image must be set
mappings = sourceImage.BlockDeviceMappings
rootDeviceName = *sourceImage.RootDeviceName
}
newMappings := make([]*ec2.BlockDeviceMapping, len(mappings))
for i, device := range mappings {
newDevice := device
if *newDevice.DeviceName == rootDeviceName {
if newDevice.Ebs != nil {
newDevice.Ebs.SnapshotId = aws.String(snapshotID)
} else {
newDevice.Ebs = &ec2.EbsBlockDevice{SnapshotId: aws.String(snapshotID)}
}
if generatingNewBlockDeviceMappings || rootVolumeSize > *newDevice.Ebs.VolumeSize {
newDevice.Ebs.VolumeSize = aws.Int64(rootVolumeSize)
}
}
// assume working from a snapshot, so we unset the Encrypted field if set,
// otherwise AWS API will return InvalidParameter
if newDevice.Ebs != nil && newDevice.Ebs.Encrypted != nil {
newDevice.Ebs.Encrypted = nil
}
newMappings[i] = newDevice
}
if config.FromScratch {
return &ec2.RegisterImageInput{
Name: &config.AMIName,
Architecture: aws.String(ec2.ArchitectureValuesX8664),
RootDeviceName: aws.String(rootDeviceName),
VirtualizationType: aws.String(config.AMIVirtType),
BlockDeviceMappings: newMappings,
}
}
return buildRegisterOptsFromExistingImage(config, sourceImage, newMappings, rootDeviceName)
} | [
"func",
"buildBaseRegisterOpts",
"(",
"config",
"*",
"Config",
",",
"sourceImage",
"*",
"ec2",
".",
"Image",
",",
"rootVolumeSize",
"int64",
",",
"snapshotID",
"string",
")",
"*",
"ec2",
".",
"RegisterImageInput",
"{",
"var",
"(",
"mappings",
"[",
"]",
"*",
... | // Builds the base register opts with architecture, name, root block device, mappings, virtualizationtype | [
"Builds",
"the",
"base",
"register",
"opts",
"with",
"architecture",
"name",
"root",
"block",
"device",
"mappings",
"virtualizationtype"
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/amazon/chroot/step_register_ami.go#L77-L128 |
165,198 | hashicorp/packer | helper/ssh/ssh.go | FileSigner | func FileSigner(path string) (ssh.Signer, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
keyBytes, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
// We parse the private key on our own first so that we can
// show a nicer error if the private key has a password.
block, _ := pem.Decode(keyBytes)
if block == nil {
return nil, fmt.Errorf(
"Failed to read key '%s': no key found", path)
}
if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
return nil, fmt.Errorf(
"Failed to read key '%s': password protected keys are\n"+
"not supported. Please decrypt the key prior to use.", path)
}
signer, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, fmt.Errorf("Error setting up SSH config: %s", err)
}
return signer, nil
} | go | func FileSigner(path string) (ssh.Signer, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
keyBytes, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
// We parse the private key on our own first so that we can
// show a nicer error if the private key has a password.
block, _ := pem.Decode(keyBytes)
if block == nil {
return nil, fmt.Errorf(
"Failed to read key '%s': no key found", path)
}
if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
return nil, fmt.Errorf(
"Failed to read key '%s': password protected keys are\n"+
"not supported. Please decrypt the key prior to use.", path)
}
signer, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, fmt.Errorf("Error setting up SSH config: %s", err)
}
return signer, nil
} | [
"func",
"FileSigner",
"(",
"path",
"string",
")",
"(",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
... | // FileSigner returns an ssh.Signer for a key file. | [
"FileSigner",
"returns",
"an",
"ssh",
".",
"Signer",
"for",
"a",
"key",
"file",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/helper/ssh/ssh.go#L13-L44 |
165,199 | hashicorp/packer | builder/googlecompute/step_create_instance.go | Run | func (s *StepCreateInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
c := state.Get("config").(*Config)
d := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
sourceImage, err := getImage(c, d)
if err != nil {
err := fmt.Errorf("Error getting source image for instance creation: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say(fmt.Sprintf("Using image: %s", sourceImage.Name))
if sourceImage.IsWindows() && c.Comm.Type == "winrm" && c.Comm.WinRMPassword == "" {
state.Put("create_windows_password", true)
}
ui.Say("Creating instance...")
name := c.InstanceName
var errCh <-chan error
var metadata map[string]string
metadata, err = c.createInstanceMetadata(sourceImage, string(c.Comm.SSHPublicKey))
errCh, err = d.RunInstance(&InstanceConfig{
AcceleratorType: c.AcceleratorType,
AcceleratorCount: c.AcceleratorCount,
Address: c.Address,
Description: "New instance created by Packer",
DisableDefaultServiceAccount: c.DisableDefaultServiceAccount,
DiskSizeGb: c.DiskSizeGb,
DiskType: c.DiskType,
Image: sourceImage,
Labels: c.Labels,
MachineType: c.MachineType,
Metadata: metadata,
MinCpuPlatform: c.MinCpuPlatform,
Name: name,
Network: c.Network,
NetworkProjectId: c.NetworkProjectId,
OmitExternalIP: c.OmitExternalIP,
OnHostMaintenance: c.OnHostMaintenance,
Preemptible: c.Preemptible,
Region: c.Region,
ServiceAccountEmail: c.ServiceAccountEmail,
Scopes: c.Scopes,
Subnetwork: c.Subnetwork,
Tags: c.Tags,
Zone: c.Zone,
})
if err == nil {
ui.Message("Waiting for creation operation to complete...")
select {
case err = <-errCh:
case <-time.After(c.stateTimeout):
err = errors.New("time out while waiting for instance to create")
}
}
if err != nil {
err := fmt.Errorf("Error creating instance: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Message("Instance has been created!")
if s.Debug {
if name != "" {
ui.Message(fmt.Sprintf("Instance: %s started in %s", name, c.Zone))
}
}
// Things succeeded, store the name so we can remove it later
state.Put("instance_name", name)
return multistep.ActionContinue
} | go | func (s *StepCreateInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
c := state.Get("config").(*Config)
d := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
sourceImage, err := getImage(c, d)
if err != nil {
err := fmt.Errorf("Error getting source image for instance creation: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Say(fmt.Sprintf("Using image: %s", sourceImage.Name))
if sourceImage.IsWindows() && c.Comm.Type == "winrm" && c.Comm.WinRMPassword == "" {
state.Put("create_windows_password", true)
}
ui.Say("Creating instance...")
name := c.InstanceName
var errCh <-chan error
var metadata map[string]string
metadata, err = c.createInstanceMetadata(sourceImage, string(c.Comm.SSHPublicKey))
errCh, err = d.RunInstance(&InstanceConfig{
AcceleratorType: c.AcceleratorType,
AcceleratorCount: c.AcceleratorCount,
Address: c.Address,
Description: "New instance created by Packer",
DisableDefaultServiceAccount: c.DisableDefaultServiceAccount,
DiskSizeGb: c.DiskSizeGb,
DiskType: c.DiskType,
Image: sourceImage,
Labels: c.Labels,
MachineType: c.MachineType,
Metadata: metadata,
MinCpuPlatform: c.MinCpuPlatform,
Name: name,
Network: c.Network,
NetworkProjectId: c.NetworkProjectId,
OmitExternalIP: c.OmitExternalIP,
OnHostMaintenance: c.OnHostMaintenance,
Preemptible: c.Preemptible,
Region: c.Region,
ServiceAccountEmail: c.ServiceAccountEmail,
Scopes: c.Scopes,
Subnetwork: c.Subnetwork,
Tags: c.Tags,
Zone: c.Zone,
})
if err == nil {
ui.Message("Waiting for creation operation to complete...")
select {
case err = <-errCh:
case <-time.After(c.stateTimeout):
err = errors.New("time out while waiting for instance to create")
}
}
if err != nil {
err := fmt.Errorf("Error creating instance: %s", err)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
ui.Message("Instance has been created!")
if s.Debug {
if name != "" {
ui.Message(fmt.Sprintf("Instance: %s started in %s", name, c.Zone))
}
}
// Things succeeded, store the name so we can remove it later
state.Put("instance_name", name)
return multistep.ActionContinue
} | [
"func",
"(",
"s",
"*",
"StepCreateInstance",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"state",
"multistep",
".",
"StateBag",
")",
"multistep",
".",
"StepAction",
"{",
"c",
":=",
"state",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"(",
"*",... | // Run executes the Packer build step that creates a GCE instance. | [
"Run",
"executes",
"the",
"Packer",
"build",
"step",
"that",
"creates",
"a",
"GCE",
"instance",
"."
] | d343852c15da050ee3ad039cc4cadfbf7f9b1759 | https://github.com/hashicorp/packer/blob/d343852c15da050ee3ad039cc4cadfbf7f9b1759/builder/googlecompute/step_create_instance.go#L76-L157 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.