Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.3k

[ "func", "(", "d", "*", "HypervPS4Driver", ")", "GetVirtualMachineNetworkAdapterAddress", "(", "vmName", "string", ")", "(", "string", ",", "error", ")", "{", "return", "hyperv", ".", "GetVirtualMachineNetworkAdapterAddress", "(", "vmName", ")", "\n", "}" ]

[ "Get", "network", "adapter", "address" ]

[ "func", "(", "d", "*", "HypervPS4Driver", ")", "SetNetworkAdapterVlanId", "(", "switchName", "string", ",", "vlanId", "string", ")", "error", "{", "return", "hyperv", ".", "SetNetworkAdapterVlanId", "(", "switchName", ",", "vlanId", ")", "\n", "}" ]

[ "Set", "the", "vlan", "to", "use", "for", "switch" ]

[ "func", "(", "d", "*", "HypervPS4Driver", ")", "SetVirtualMachineVlanId", "(", "vmName", "string", ",", "vlanId", "string", ")", "error", "{", "return", "hyperv", ".", "SetVirtualMachineVlanId", "(", "vmName", ",", "vlanId", ")", "\n", "}" ]

[ "Set", "the", "vlan", "to", "use", "for", "machine" ]

[ "func", "(", "d", "*", "HypervPS4Driver", ")", "Connect", "(", "vmName", "string", ")", "(", "context", ".", "CancelFunc", ",", "error", ")", "{", "return", "hyperv", ".", "ConnectVirtualMachine", "(", "vmName", ")", "\n", "}" ]

[ "Connect", "connects", "to", "a", "VM", "specified", "by", "the", "name", "given", "." ]

[ "func", "NewRunner", "(", "steps", "[", "]", "multistep", ".", "Step", ",", "config", "PackerConfig", ",", "ui", "packer", ".", "Ui", ")", "multistep", ".", "Runner", "{", "runner", ",", "_", ":=", "newRunner", "(", "steps", ",", "config", ",", "ui", ")", "\n", "return", "runner", "\n", "}" ]

[ "NewRunner", "returns", "a", "multistep", ".", "Runner", "that", "runs", "steps", "augmented", "with", "support", "for", "-", "debug", "and", "-", "on", "-", "error", "command", "line", "arguments", "." ]

[ "func", "NewRunnerWithPauseFn", "(", "steps", "[", "]", "multistep", ".", "Step", ",", "config", "PackerConfig", ",", "ui", "packer", ".", "Ui", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "Runner", "{", "runner", ",", "pauseFn", ":=", "newRunner", "(", "steps", ",", "config", ",", "ui", ")", "\n", "if", "pauseFn", "!=", "nil", "{", "state", ".", "Put", "(", "\"", "\"", ",", "pauseFn", ")", "\n", "}", "\n", "return", "runner", "\n", "}" ]

[ "NewRunnerWithPauseFn", "returns", "a", "multistep", ".", "Runner", "that", "runs", "steps", "augmented", "with", "support", "for", "-", "debug", "and", "-", "on", "-", "error", "command", "line", "arguments", ".", "With", "-", "debug", "it", "puts", "the", "multistep", ".", "DebugPauseFn", "that", "will", "pause", "execution", "between", "steps", "into", "the", "state", "under", "the", "key", "pauseFn", "." ]

[ "func", "decodeAWSError", "(", "decoder", "stsDecoder", ",", "err", "error", ")", "error", "{", "groups", ":=", "encodedFailureMessagePattern", ".", "FindStringSubmatch", "(", "err", ".", "Error", "(", ")", ")", "\n", "if", "groups", "!=", "nil", "&&", "len", "(", "groups", ")", ">", "1", "{", "result", ",", "decodeErr", ":=", "decoder", ".", "DecodeAuthorizationMessage", "(", "&", "sts", ".", "DecodeAuthorizationMessageInput", "{", "EncodedMessage", ":", "aws", ".", "String", "(", "groups", "[", "2", "]", ")", ",", "}", ")", "\n", "if", "decodeErr", "==", "nil", "{", "msg", ":=", "aws", ".", "StringValue", "(", "result", ".", "DecodedMessage", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "groups", "[", "1", "]", ",", "msg", ",", "groups", "[", "3", "]", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "decodeErr", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "decodeError", "replaces", "encoded", "authorization", "messages", "with", "the", "decoded", "results" ]

[ "func", "DecodeAuthZMessages", "(", "sess", "*", "session", ".", "Session", ")", "{", "azd", ":=", "&", "authZMessageDecoder", "{", "Decoder", ":", "sts", ".", "New", "(", "sess", ")", ",", "}", "\n", "sess", ".", "Handlers", ".", "UnmarshalError", ".", "AfterEachFn", "=", "azd", ".", "afterEachFn", "\n", "}" ]

[ "DecodeAuthZMessages", "enables", "automatic", "decoding", "of", "any", "encoded", "authorization", "messages" ]

[ "func", "(", "c", "*", "AccessConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ")", "[", "]", "error", "{", "var", "errs", "[", "]", "error", "\n\n", "if", "c", ".", "Endpoint", "==", "\"", "\"", "{", "// Use Joyent public cloud as the default endpoint if none is specified", "c", ".", "Endpoint", "=", "\"", "\"", "\n", "}", "\n\n", "if", "c", ".", "Account", "==", "\"", "\"", "{", "errs", "=", "append", "(", "errs", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "KeyID", "==", "\"", "\"", "{", "errs", "=", "append", "(", "errs", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "KeyMaterial", "==", "\"", "\"", "{", "signer", ",", "err", ":=", "c", ".", "createSSHAgentSigner", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "c", ".", "signer", "=", "signer", "\n", "}", "else", "{", "signer", ",", "err", ":=", "c", ".", "createPrivateKeySigner", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "c", ".", "signer", "=", "signer", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errs", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Prepare", "performs", "basic", "validation", "on", "the", "AccessConfig", "and", "ensures", "we", "can", "sign", "a", "request", "." ]

[ "func", "(", "a", "*", "Artifact", ")", "Destroy", "(", ")", "error", "{", "// Create a new parameter struct.", "p", ":=", "a", ".", "client", ".", "Template", ".", "NewDeleteTemplateParams", "(", "a", ".", "template", ".", "Id", ")", "\n\n", "// Destroy the template.", "log", ".", "Printf", "(", "\"", "\"", ",", "a", ".", "template", ".", "Name", ")", "\n", "_", ",", "err", ":=", "a", ".", "client", ".", "Template", ".", "DeleteTemplate", "(", "p", ")", "\n", "if", "err", "!=", "nil", "{", "// This is a very poor way to be told the ID does no longer exist :(", "if", "strings", ".", "Contains", "(", "err", ".", "Error", "(", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "a", ".", "template", ".", "Id", ")", ")", "{", "return", "nil", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "a", ".", "template", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Destroy", "the", "CloudStack", "template", "represented", "by", "the", "artifact", "." ]

[ "func", "(", "s", "*", "StepInstanceInfo", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "config", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "Config", ")", "\n", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n\n", "instanceName", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "errCh", ":=", "driver", ".", "WaitForInstance", "(", "\"", "\"", ",", "config", ".", "Zone", ",", "instanceName", ")", "\n", "var", "err", "error", "\n", "select", "{", "case", "err", "=", "<-", "errCh", ":", "case", "<-", "time", ".", "After", "(", "config", ".", "stateTimeout", ")", ":", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "if", "config", ".", "UseInternalIP", "{", "ip", ",", "err", ":=", "driver", ".", "GetInternalIP", "(", "config", ".", "Zone", ",", "instanceName", ")", "\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "if", "s", ".", "Debug", "{", "if", "ip", "!=", "\"", "\"", "{", "ui", ".", "Message", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ip", ")", ")", "\n", "}", "\n", "}", "\n", "ui", ".", "Message", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ip", ")", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "ip", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}", "else", "{", "ip", ",", "err", ":=", "driver", ".", "GetNatIP", "(", "config", ".", "Zone", ",", "instanceName", ")", "\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "if", "s", ".", "Debug", "{", "if", "ip", "!=", "\"", "\"", "{", "ui", ".", "Message", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ip", ")", ")", "\n", "}", "\n", "}", "\n", "ui", ".", "Message", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ip", ")", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "ip", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}", "\n", "}" ]

[ "Run", "executes", "the", "Packer", "build", "step", "that", "gathers", "GCE", "instance", "info", ".", "This", "adds", "instance_ip", "to", "the", "multistep", "state", "." ]

[ "func", "(", "s", "*", "StepWaitStartupScript", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "config", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "Config", ")", "\n", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n", "instanceName", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n\n", "// Keep checking the serial port output to see if the startup script is done.", "err", ":=", "retry", ".", "Config", "{", "ShouldRetry", ":", "func", "(", "error", ")", "bool", "{", "return", "true", "\n", "}", ",", "RetryDelay", ":", "(", "&", "retry", ".", "Backoff", "{", "InitialBackoff", ":", "10", "*", "time", ".", "Second", ",", "MaxBackoff", ":", "60", "*", "time", ".", "Second", ",", "Multiplier", ":", "2", "}", ")", ".", "Linear", ",", "}", ".", "Run", "(", "ctx", ",", "func", "(", "ctx", "context", ".", "Context", ")", "error", "{", "status", ",", "err", ":=", "driver", ".", "GetInstanceMetadata", "(", "config", ".", "Zone", ",", "instanceName", ",", "StartupScriptStatusKey", ")", "\n\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "status", "==", "StartupScriptStatusError", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "done", ":=", "status", "==", "StartupScriptStatusDone", "\n", "if", "!", "done", "{", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Run", "reads", "the", "instance", "metadata", "and", "looks", "for", "the", "log", "entry", "indicating", "the", "startup", "script", "finished", "." ]

[ "func", "createInterpolatedCommands", "(", "config", "*", "Config", ",", "script", "string", ",", "flattenedEnvVars", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "config", ".", "Ctx", ".", "Data", "=", "&", "ExecuteCommandTemplate", "{", "Vars", ":", "flattenedEnvVars", ",", "Script", ":", "script", ",", "Command", ":", "script", ",", "WinRMPassword", ":", "getWinRMPassword", "(", "config", ".", "PackerBuildName", ")", ",", "}", "\n\n", "interpolatedCmds", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "config", ".", "ExecuteCommand", ")", ")", "\n", "for", "i", ",", "cmd", ":=", "range", "config", ".", "ExecuteCommand", "{", "interpolatedCmd", ",", "err", ":=", "interpolate", ".", "Render", "(", "cmd", ",", "&", "config", ".", "Ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "interpolatedCmds", "[", "i", "]", "=", "interpolatedCmd", "\n", "}", "\n", "return", "interpolatedCmds", ",", "nil", "\n", "}" ]

[ "Generates", "the", "final", "command", "to", "send", "to", "the", "communicator", "using", "either", "the", "user", "-", "provided", "ExecuteCommand", "or", "defaulting", "to", "something", "that", "makes", "sense", "for", "the", "host", "OS" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Init", "(", "args", "[", "]", "string", ")", "error", "{", "_", ",", "_", ",", "err", ":=", "d", ".", "vagrantCmd", "(", "append", "(", "[", "]", "string", "{", "\"", "\"", "}", ",", "args", "...", ")", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Calls", "vagrant", "init" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Up", "(", "args", "[", "]", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "stdout", ",", "stderr", ",", "err", ":=", "d", ".", "vagrantCmd", "(", "append", "(", "[", "]", "string", "{", "\"", "\"", "}", ",", "args", "...", ")", "...", ")", "\n", "return", "stdout", ",", "stderr", ",", "err", "\n", "}" ]

[ "Calls", "vagrant", "up" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Halt", "(", "id", "string", ")", "error", "{", "args", ":=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "if", "id", "!=", "\"", "\"", "{", "args", "=", "append", "(", "args", ",", "id", ")", "\n", "}", "\n", "_", ",", "_", ",", "err", ":=", "d", ".", "vagrantCmd", "(", "args", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Calls", "vagrant", "halt" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Package", "(", "args", "[", "]", "string", ")", "error", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "d", ".", "VagrantCWD", ",", "\"", "\"", ")", ")", "\n", "_", ",", "_", ",", "err", ":=", "d", ".", "vagrantCmd", "(", "append", "(", "[", "]", "string", "{", "\"", "\"", "}", ",", "args", "...", ")", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Calls", "vagrant", "package" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Verify", "(", ")", "error", "{", "vagrantPath", ",", "err", ":=", "exec", ".", "LookPath", "(", "d", ".", "vagrantBinary", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "_", ",", "err", "=", "os", ".", "Stat", "(", "vagrantPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "constraints", ",", "err", ":=", "version", ".", "NewConstraint", "(", "VAGRANT_MIN_VERSION", ")", "\n", "vers", ",", "err", ":=", "d", ".", "Version", "(", ")", "\n", "v", ",", "err", ":=", "version", ".", "NewVersion", "(", "vers", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "constraints", ".", "Check", "(", "v", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Verify", "makes", "sure", "that", "Vagrant", "exists", "at", "the", "given", "path" ]

[ "func", "(", "d", "*", "Vagrant_2_2_Driver", ")", "Version", "(", ")", "(", "string", ",", "error", ")", "{", "stdoutString", ",", "_", ",", "err", ":=", "d", ".", "vagrantCmd", "(", "[", "]", "string", "{", "\"", "\"", "}", "...", ")", "\n", "// Example stdout:", "// \tInstalled Version: 2.2.3", "//", "// Vagrant was unable to check for the latest version of Vagrant.", "// Please check manually at https://www.vagrantup.com", "// Use regex to find version", "reg", ":=", "regexp", ".", "MustCompile", "(", "`(\\d+\\.)?(\\d+\\.)?(\\*|\\d+)`", ")", "\n", "version", ":=", "reg", ".", "FindString", "(", "stdoutString", ")", "\n", "if", "version", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "version", ",", "nil", "\n", "}" ]

[ "Version", "reads", "the", "version", "of", "VirtualBox", "that", "is", "installed", "." ]

[ "func", "waitForDropletUnlocked", "(", "client", "*", "godo", ".", "Client", ",", "dropletId", "int", ",", "timeout", "time", ".", "Duration", ")", "error", "{", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "defer", "close", "(", "done", ")", "\n\n", "result", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "attempts", ":=", "0", "\n", "for", "{", "attempts", "+=", "1", "\n\n", "log", ".", "Printf", "(", "\"", "\"", ",", "attempts", ")", "\n", "droplet", ",", "_", ",", "err", ":=", "client", ".", "Droplets", ".", "Get", "(", "context", ".", "TODO", "(", ")", ",", "dropletId", ")", "\n", "if", "err", "!=", "nil", "{", "result", "<-", "err", "\n", "return", "\n", "}", "\n\n", "if", "!", "droplet", ".", "Locked", "{", "result", "<-", "nil", "\n", "return", "\n", "}", "\n\n", "// Wait 3 seconds in between", "time", ".", "Sleep", "(", "3", "*", "time", ".", "Second", ")", "\n\n", "// Verify we shouldn't exit", "select", "{", "case", "<-", "done", ":", "// We finished, so just exit the goroutine", "return", "\n", "default", ":", "// Keep going", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "log", ".", "Printf", "(", "\"", "\"", ",", "timeout", "/", "time", ".", "Second", ")", "\n", "select", "{", "case", "err", ":=", "<-", "result", ":", "return", "err", "\n", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "waitForDropletUnlocked", "waits", "for", "the", "Droplet", "to", "be", "unlocked", "to", "avoid", "pending", "errors", "when", "making", "state", "changes", "." ]

[ "func", "escapeWithSpaces", "(", "stringToEscape", "string", ")", "string", "{", "escapedString", ":=", "url", ".", "QueryEscape", "(", "stringToEscape", ")", "\n", "escapedString", "=", "strings", ".", "Replace", "(", "escapedString", ",", "\"", "\"", ",", "`%20`", ",", "-", "1", ")", "\n", "return", "escapedString", "\n", "}" ]

[ "Encode", "everything", "except", "for", "+", "signs" ]

[ "func", "WaitUntilAMIAvailable", "(", "ctx", "aws", ".", "Context", ",", "conn", "*", "ec2", ".", "EC2", ",", "imageId", "string", ")", "error", "{", "imageInput", ":=", "ec2", ".", "DescribeImagesInput", "{", "ImageIds", ":", "[", "]", "*", "string", "{", "&", "imageId", "}", ",", "}", "\n\n", "waitOpts", ":=", "getWaiterOptions", "(", ")", "\n", "if", "len", "(", "waitOpts", ")", "==", "0", "{", "// Bump this default to 30 minutes because the aws default", "// of ten minutes doesn't work for some of our long-running copies.", "waitOpts", "=", "append", "(", "waitOpts", ",", "request", ".", "WithWaiterMaxAttempts", "(", "120", ")", ")", "\n", "}", "\n", "err", ":=", "conn", ".", "WaitUntilImageAvailableWithContext", "(", "ctx", ",", "&", "imageInput", ",", "waitOpts", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Following", "are", "wrapper", "functions", "that", "use", "Packer", "s", "environment", "-", "variables", "to", "determing", "retry", "logic", "then", "call", "the", "AWS", "SDK", "s", "built", "-", "in", "waiters", "." ]

[ "func", "WaitUntilSpotRequestFulfilled", "(", "ctx", "aws", ".", "Context", ",", "conn", "*", "ec2", ".", "EC2", ",", "spotRequestId", "string", ")", "error", "{", "spotRequestInput", ":=", "ec2", ".", "DescribeSpotInstanceRequestsInput", "{", "SpotInstanceRequestIds", ":", "[", "]", "*", "string", "{", "&", "spotRequestId", "}", ",", "}", "\n\n", "err", ":=", "conn", ".", "WaitUntilSpotInstanceRequestFulfilledWithContext", "(", "ctx", ",", "&", "spotRequestInput", ",", "getWaiterOptions", "(", ")", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "This", "function", "works", "for", "both", "requesting", "and", "cancelling", "spot", "instances", "." ]

[ "func", "WaitUntilVolumeAttached", "(", "ctx", "aws", ".", "Context", ",", "conn", "*", "ec2", ".", "EC2", ",", "volumeId", "string", ")", "error", "{", "volumeInput", ":=", "ec2", ".", "DescribeVolumesInput", "{", "VolumeIds", ":", "[", "]", "*", "string", "{", "&", "volumeId", "}", ",", "}", "\n\n", "err", ":=", "WaitForVolumeToBeAttached", "(", "conn", ",", "ctx", ",", "&", "volumeInput", ",", "getWaiterOptions", "(", ")", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Wrappers", "for", "our", "custom", "AWS", "waiters" ]

[ "func", "(", "s", "*", "StepShutdown", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "comm", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Communicator", ")", "\n", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n", "vmName", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "if", "s", ".", "Command", "!=", "\"", "\"", "{", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "s", ".", "Command", ")", "\n\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "cmd", ":=", "&", "packer", ".", "RemoteCmd", "{", "Command", ":", "s", ".", "Command", ",", "Stdout", ":", "&", "stdout", ",", "Stderr", ":", "&", "stderr", ",", "}", "\n", "if", "err", ":=", "comm", ".", "Start", "(", "ctx", ",", "cmd", ")", ";", "err", "!=", "nil", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "// Wait for the machine to actually shut down", "log", ".", "Printf", "(", "\"", "\"", ",", "s", ".", "Timeout", ")", "\n", "shutdownTimer", ":=", "time", ".", "After", "(", "s", ".", "Timeout", ")", "\n", "for", "{", "running", ",", "_", ":=", "driver", ".", "IsRunning", "(", "vmName", ")", "\n", "if", "!", "running", "{", "break", "\n", "}", "\n\n", "select", "{", "case", "<-", "shutdownTimer", ":", "log", ".", "Printf", "(", "\"", "\"", ",", "stdout", ".", "String", "(", ")", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "stderr", ".", "String", "(", ")", ")", "\n", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "default", ":", "time", ".", "Sleep", "(", "500", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "driver", ".", "Stop", "(", "vmName", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n", "}", "\n\n", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Run", "shuts", "down", "the", "VM", "." ]

[ "func", "(", "*", "NoopProgressTracker", ")", "TrackProgress", "(", "_", "string", ",", "_", ",", "_", "int64", ",", "stream", "io", ".", "ReadCloser", ")", "io", ".", "ReadCloser", "{", "return", "stream", "\n", "}" ]

[ "TrackProgress", "returns", "stream" ]

[ "func", "(", "c", "*", "PrlctlConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ")", "[", "]", "error", "{", "if", "c", ".", "Prlctl", "==", "nil", "{", "c", ".", "Prlctl", "=", "make", "(", "[", "]", "[", "]", "string", ",", "0", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Prepare", "sets", "the", "default", "value", "of", "Prlctl", "property", "." ]

[ "func", "(", "ps", "*", "PowerShellCmd", ")", "Output", "(", "fileContents", "string", ",", "params", "...", "string", ")", "(", "string", ",", "error", ")", "{", "path", ",", "err", ":=", "ps", ".", "getPowerShellPath", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "filename", ",", "err", ":=", "saveScript", "(", "fileContents", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "debug", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "!=", "\"", "\"", "\n", "verbose", ":=", "debug", "||", "os", ".", "Getenv", "(", "\"", "\"", ")", "!=", "\"", "\"", "\n\n", "if", "!", "debug", "{", "defer", "os", ".", "Remove", "(", "filename", ")", "\n", "}", "\n\n", "args", ":=", "createArgs", "(", "filename", ",", "params", "...", ")", "\n\n", "if", "verbose", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "path", ",", "args", ")", "\n", "}", "\n\n", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "command", ":=", "exec", ".", "Command", "(", "path", ",", "args", "...", ")", "\n", "command", ".", "Stdout", "=", "&", "stdout", "\n", "command", ".", "Stderr", "=", "&", "stderr", "\n\n", "err", "=", "command", ".", "Run", "(", ")", "\n\n", "if", "ps", ".", "Stdout", "!=", "nil", "{", "stdout", ".", "WriteTo", "(", "ps", ".", "Stdout", ")", "\n", "}", "\n\n", "if", "ps", ".", "Stderr", "!=", "nil", "{", "stderr", ".", "WriteTo", "(", "ps", ".", "Stderr", ")", "\n", "}", "\n\n", "stderrString", ":=", "strings", ".", "TrimSpace", "(", "stderr", ".", "String", "(", ")", ")", "\n\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "exec", ".", "ExitError", ")", ";", "ok", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "stderrString", ")", "\n", "}", "\n\n", "if", "len", "(", "stderrString", ")", ">", "0", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "stderrString", ")", "\n", "}", "\n\n", "stdoutString", ":=", "strings", ".", "TrimSpace", "(", "stdout", ".", "String", "(", ")", ")", "\n\n", "if", "verbose", "&&", "stdoutString", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "stdoutString", ")", "\n", "}", "\n\n", "// only write the stderr string if verbose because", "// the error string will already be in the err return value.", "if", "verbose", "&&", "stderrString", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "stderrString", ")", "\n", "}", "\n\n", "return", "stdoutString", ",", "err", "\n", "}" ]

[ "Output", "runs", "the", "PowerShell", "command", "and", "returns", "its", "standard", "output", "." ]

[ "func", "(", "c", "*", "WindowsContainerCommunicator", ")", "Upload", "(", "dst", "string", ",", "src", "io", ".", "Reader", ",", "fi", "*", "os", ".", "FileInfo", ")", "error", "{", "// Create a temporary file to store the upload", "tempfile", ",", "err", ":=", "ioutil", ".", "TempFile", "(", "c", ".", "HostDir", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "os", ".", "Remove", "(", "tempfile", ".", "Name", "(", ")", ")", "\n\n", "// Copy the contents to the temporary file", "_", ",", "err", "=", "io", ".", "Copy", "(", "tempfile", ",", "src", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "fi", "!=", "nil", "{", "tempfile", ".", "Chmod", "(", "(", "*", "fi", ")", ".", "Mode", "(", ")", ")", "\n", "}", "\n", "tempfile", ".", "Close", "(", ")", "\n\n", "// Copy the file into place by copying the temporary file we put", "// into the shared folder into the proper location in the container", "cmd", ":=", "&", "packer", ".", "RemoteCmd", "{", "Command", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ContainerDir", ",", "filepath", ".", "Base", "(", "tempfile", ".", "Name", "(", ")", ")", ",", "dst", ")", ",", "}", "\n", "ctx", ":=", "context", ".", "TODO", "(", ")", "\n", "if", "err", ":=", "c", ".", "Start", "(", "ctx", ",", "cmd", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Wait for the copy to complete", "cmd", ".", "Wait", "(", ")", "\n", "if", "cmd", ".", "ExitStatus", "(", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cmd", ".", "ExitStatus", "(", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Upload", "uses", "docker", "exec", "to", "copy", "the", "file", "from", "the", "host", "to", "the", "container" ]

[ "func", "(", "c", "*", "WindowsContainerCommunicator", ")", "Download", "(", "src", "string", ",", "dst", "io", ".", "Writer", ")", "error", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "c", ".", "ContainerID", ",", "src", ")", "\n", "// Copy file onto temp file on mounted volume inside container", "var", "stdout", ",", "stderr", "bytes", ".", "Buffer", "\n", "cmd", ":=", "&", "packer", ".", "RemoteCmd", "{", "Command", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "src", ",", "c", ".", "ContainerDir", ",", "filepath", ".", "Base", "(", "src", ")", ")", ",", "Stdout", ":", "&", "stdout", ",", "Stderr", ":", "&", "stderr", ",", "}", "\n", "ctx", ":=", "context", ".", "TODO", "(", ")", "\n", "if", "err", ":=", "c", ".", "Start", "(", "ctx", ",", "cmd", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Wait for the copy to complete", "cmd", ".", "Wait", "(", ")", "\n\n", "if", "cmd", ".", "ExitStatus", "(", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "stderr", ".", "String", "(", ")", ",", "stdout", ".", "String", "(", ")", ",", "cmd", ".", "ExitStatus", "(", ")", ")", "\n", "}", "\n\n", "// Read that copied file into a new file opened on host machine", "fsrc", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "c", ".", "HostDir", ",", "filepath", ".", "Base", "(", "src", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "fsrc", ".", "Close", "(", ")", "\n", "defer", "os", ".", "Remove", "(", "fsrc", ".", "Name", "(", ")", ")", "\n\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "dst", ",", "fsrc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Download", "pulls", "a", "file", "out", "of", "a", "container", "using", "docker", "cp", ".", "We", "have", "a", "source", "path", "and", "want", "to", "write", "to", "an", "io", ".", "Writer" ]

[ "func", "DeprecatedTemplateFunc", "(", "funcName", ",", "useInstead", "string", ",", "deprecated", "func", "(", "string", ")", "string", ")", "func", "(", "string", ")", "string", "{", "once", ":=", "sync", ".", "Once", "{", "}", "\n", "return", "func", "(", "in", "string", ")", "string", "{", "once", ".", "Do", "(", "func", "(", ")", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "funcName", ",", "useInstead", ")", "\n", "}", ")", "\n", "return", "deprecated", "(", "in", ")", "\n", "}", "\n", "}" ]

[ "DeprecatedTemplateFunc", "wraps", "a", "template", "func", "to", "warn", "users", "that", "it", "s", "deprecated", ".", "The", "deprecation", "warning", "is", "called", "only", "once", "." ]

[ "func", "NewDriverOCI", "(", "cfg", "*", "Config", ")", "(", "Driver", ",", "error", ")", "{", "coreClient", ",", "err", ":=", "core", ".", "NewComputeClientWithConfigurationProvider", "(", "cfg", ".", "ConfigProvider", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "vcnClient", ",", "err", ":=", "core", ".", "NewVirtualNetworkClientWithConfigurationProvider", "(", "cfg", ".", "ConfigProvider", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "driverOCI", "{", "computeClient", ":", "coreClient", ",", "vcnClient", ":", "vcnClient", ",", "cfg", ":", "cfg", ",", "}", ",", "nil", "\n", "}" ]

[ "NewDriverOCI", "Creates", "a", "new", "driverOCI", "with", "a", "connected", "compute", "client", "and", "a", "connected", "vcn", "client", "." ]

[ "func", "(", "d", "*", "driverOCI", ")", "DeleteImage", "(", "ctx", "context", ".", "Context", ",", "id", "string", ")", "error", "{", "_", ",", "err", ":=", "d", ".", "computeClient", ".", "DeleteImage", "(", "ctx", ",", "core", ".", "DeleteImageRequest", "{", "ImageId", ":", "&", "id", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "DeleteImage", "deletes", "a", "custom", "image", "." ]

[ "func", "waitForResourceToReachState", "(", "getResourceState", "func", "(", "string", ")", "(", "string", ",", "error", ")", ",", "id", "string", ",", "waitStates", "[", "]", "string", ",", "terminalState", "string", ",", "maxRetries", "int", ",", "waitDuration", "time", ".", "Duration", ")", "error", "{", "for", "i", ":=", "0", ";", "maxRetries", "==", "0", "||", "i", "<", "maxRetries", ";", "i", "++", "{", "state", ",", "err", ":=", "getResourceState", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "stringSliceContains", "(", "waitStates", ",", "state", ")", "{", "time", ".", "Sleep", "(", "waitDuration", ")", "\n", "continue", "\n", "}", "else", "if", "state", "==", "terminalState", "{", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "state", ",", "waitStates", ",", "terminalState", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "maxRetries", ",", "terminalState", ")", "\n", "}" ]

[ "WaitForResourceToReachState", "checks", "the", "response", "of", "a", "request", "through", "a", "polled", "get", "and", "waits", "until", "the", "desired", "state", "or", "until", "the", "max", "retried", "has", "been", "reached", "." ]

[ "func", "stringSliceContains", "(", "slice", "[", "]", "string", ",", "value", "string", ")", "bool", "{", "for", "_", ",", "elem", ":=", "range", "slice", "{", "if", "elem", "==", "value", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "stringSliceContains", "loops", "through", "a", "slice", "of", "strings", "returning", "a", "boolean", "based", "on", "whether", "a", "given", "value", "is", "contained", "in", "the", "slice", "." ]

[ "func", "Server", "(", ")", "(", "*", "packrpc", ".", "Server", ",", "error", ")", "{", "if", "os", ".", "Getenv", "(", "MagicCookieKey", ")", "!=", "MagicCookieValue", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// If there is no explicit number of Go threads to use, then set it", "if", "os", ".", "Getenv", "(", "\"", "\"", ")", "==", "\"", "\"", "{", "runtime", ".", "GOMAXPROCS", "(", "runtime", ".", "NumCPU", "(", ")", ")", "\n", "}", "\n\n", "minPort", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "10", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "maxPort", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "10", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "minPort", ")", "\n", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "maxPort", ")", "\n\n", "listener", ",", "err", ":=", "serverListener", "(", "minPort", ",", "maxPort", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "listener", ".", "Close", "(", ")", "\n\n", "// Output the address to stdout", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "listener", ".", "Addr", "(", ")", ".", "Network", "(", ")", ",", "listener", ".", "Addr", "(", ")", ".", "String", "(", ")", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "APIVersion", ",", "listener", ".", "Addr", "(", ")", ".", "Network", "(", ")", ",", "listener", ".", "Addr", "(", ")", ".", "String", "(", ")", ")", "\n", "os", ".", "Stdout", ".", "Sync", "(", ")", "\n\n", "// Accept a connection", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "conn", ",", "err", ":=", "listener", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Eat the interrupts", "ch", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "ch", ",", "os", ".", "Interrupt", ",", "syscall", ".", "SIGTERM", ")", "\n", "go", "func", "(", ")", "{", "var", "count", "int32", "=", "0", "\n", "for", "{", "<-", "ch", "\n", "newCount", ":=", "atomic", ".", "AddInt32", "(", "&", "count", ",", "1", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "newCount", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Serve a single connection", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "packrpc", ".", "NewServer", "(", "conn", ")", "\n", "}" ]

[ "Server", "waits", "for", "a", "connection", "to", "this", "plugin", "and", "returns", "a", "Packer", "RPC", "server", "that", "you", "can", "use", "to", "register", "components", "and", "serve", "them", "." ]

[ "func", "(", "d", "*", "driverTriton", ")", "WaitForMachineState", "(", "machineId", "string", ",", "state", "string", ",", "timeout", "time", ".", "Duration", ")", "error", "{", "return", "waitFor", "(", "func", "(", ")", "(", "bool", ",", "error", ")", "{", "computeClient", ",", "_", ":=", "d", ".", "client", ".", "Compute", "(", ")", "\n", "machine", ",", "err", ":=", "computeClient", ".", "Instances", "(", ")", ".", "Get", "(", "context", ".", "Background", "(", ")", ",", "&", "compute", ".", "GetInstanceInput", "{", "ID", ":", "machineId", ",", "}", ")", "\n", "if", "machine", "==", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "machine", ".", "State", "==", "state", ",", "err", "\n", "}", ",", "3", "*", "time", ".", "Second", ",", "timeout", ",", ")", "\n", "}" ]

[ "waitForMachineState", "uses", "the", "supplied", "client", "to", "wait", "for", "the", "state", "of", "the", "machine", "with", "the", "given", "ID", "to", "reach", "the", "state", "described", "in", "state", ".", "If", "timeout", "is", "reached", "before", "the", "machine", "reaches", "the", "required", "state", "an", "error", "is", "returned", ".", "If", "the", "machine", "reaches", "the", "target", "state", "within", "the", "timeout", "nil", "is", "returned", "." ]

[ "func", "(", "d", "*", "driverTriton", ")", "WaitForMachineDeletion", "(", "machineId", "string", ",", "timeout", "time", ".", "Duration", ")", "error", "{", "return", "waitFor", "(", "func", "(", ")", "(", "bool", ",", "error", ")", "{", "computeClient", ",", "_", ":=", "d", ".", "client", ".", "Compute", "(", ")", "\n", "_", ",", "err", ":=", "computeClient", ".", "Instances", "(", ")", ".", "Get", "(", "context", ".", "Background", "(", ")", ",", "&", "compute", ".", "GetInstanceInput", "{", "ID", ":", "machineId", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "// Return true only when we receive a 410 (Gone) response. A 404", "// indicates that the machine is being deleted whereas a 410 indicates", "// that this process has completed.", "if", "terrors", ".", "IsSpecificStatusCode", "(", "err", ",", "http", ".", "StatusGone", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "err", "\n", "}", ",", "3", "*", "time", ".", "Second", ",", "timeout", ",", ")", "\n", "}" ]

[ "waitForMachineDeletion", "uses", "the", "supplied", "client", "to", "wait", "for", "the", "machine", "with", "the", "given", "ID", "to", "be", "deleted", ".", "It", "is", "expected", "that", "the", "API", "call", "to", "delete", "the", "machine", "has", "already", "been", "issued", "at", "this", "point", "." ]

[ "func", "uncomment", "(", "eof", "sentinelSignaller", ",", "in", "<-", "chan", "byte", ")", "(", "chan", "byte", ",", "sentinelSignaller", ")", "{", "out", ":=", "make", "(", "chan", "byte", ")", "\n", "eoc", ":=", "make", "(", "sentinelSignaller", ")", "\n\n", "go", "func", "(", "in", "<-", "chan", "byte", ",", "out", "chan", "byte", ")", "{", "var", "endofline", "bool", "\n", "for", "stillReading", ":=", "true", ";", "stillReading", ";", "{", "select", "{", "case", "<-", "eof", ":", "stillReading", "=", "false", "\n", "case", "ch", ":=", "<-", "in", ":", "switch", "ch", "{", "case", "'#'", ":", "endofline", "=", "true", "\n", "case", "'\\n'", ":", "if", "endofline", "{", "endofline", "=", "false", "\n", "}", "\n", "}", "\n", "if", "!", "endofline", "{", "out", "<-", "ch", "\n", "}", "\n", "}", "\n", "}", "\n", "close", "(", "eoc", ")", "\n", "}", "(", "in", ",", "out", ")", "\n", "return", "out", ",", "eoc", "\n", "}" ]

[ "low", "-", "level", "parsing", "strip", "the", "comments", "and", "extraneous", "newlines", "from", "a", "byte", "channel" ]

[ "func", "parseTokenParameter", "(", "in", "chan", "string", ")", "tkParameter", "{", "var", "result", "tkParameter", "\n", "for", "{", "token", ":=", "<-", "in", "\n", "if", "result", ".", "name", "==", "\"", "\"", "{", "result", ".", "name", "=", "token", "\n", "continue", "\n", "}", "\n", "switch", "token", "{", "case", "\"", "\"", ":", "fallthrough", "\n", "case", "\"", "\"", ":", "fallthrough", "\n", "case", "\"", "\"", ":", "goto", "leave", "\n", "default", ":", "result", ".", "operand", "=", "append", "(", "result", ".", "operand", ",", "token", ")", "\n", "}", "\n", "}", "\n", "leave", ":", "return", "result", "\n", "}" ]

[ "convert", "a", "channel", "of", "pseudo", "-", "tokens", "into", "an", "tkParameter", "struct" ]

[ "func", "parseDhcpConfig", "(", "eof", "sentinelSignaller", ",", "in", "chan", "string", ")", "(", "tkGroup", ",", "error", ")", "{", "var", "tokens", "[", "]", "string", "\n", "var", "result", "tkGroup", "\n\n", "toParameter", ":=", "func", "(", "tokens", "[", "]", "string", ")", "tkParameter", "{", "out", ":=", "make", "(", "chan", "string", ")", "\n", "go", "func", "(", "out", "chan", "string", ")", "{", "for", "_", ",", "v", ":=", "range", "tokens", "{", "out", "<-", "v", "\n", "}", "\n", "out", "<-", "\"", "\"", "\n", "}", "(", "out", ")", "\n", "return", "parseTokenParameter", "(", "out", ")", "\n", "}", "\n\n", "for", "stillReading", ",", "currentgroup", ":=", "true", ",", "&", "result", ";", "stillReading", ";", "{", "select", "{", "case", "<-", "eof", ":", "stillReading", "=", "false", "\n\n", "case", "tk", ":=", "<-", "in", ":", "switch", "tk", "{", "case", "\"", "\"", ":", "grp", ":=", "&", "tkGroup", "{", "parent", ":", "currentgroup", "}", "\n", "grp", ".", "id", "=", "toParameter", "(", "tokens", ")", "\n", "currentgroup", ".", "groups", "=", "append", "(", "currentgroup", ".", "groups", ",", "grp", ")", "\n", "currentgroup", "=", "grp", "\n", "case", "\"", "\"", ":", "if", "currentgroup", ".", "parent", "==", "nil", "{", "return", "tkGroup", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "tokens", ")", ">", "0", "{", "return", "tkGroup", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tokens", ")", "\n", "}", "\n", "currentgroup", "=", "currentgroup", ".", "parent", "\n", "case", "\"", "\"", ":", "arg", ":=", "toParameter", "(", "tokens", ")", "\n", "currentgroup", ".", "params", "=", "append", "(", "currentgroup", ".", "params", ",", "arg", ")", "\n", "default", ":", "tokens", "=", "append", "(", "tokens", ",", "tk", ")", "\n", "continue", "\n", "}", "\n", "tokens", "=", "[", "]", "string", "{", "}", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "convert", "a", "channel", "of", "pseudo", "-", "tokens", "into", "an", "tkGroup", "tree" ]

[ "func", "parseNetworkingCommand_answer", "(", "row", "[", "]", "string", ")", "(", "*", "networkingCommandEntry", ",", "error", ")", "{", "if", "len", "(", "row", ")", "!=", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "2", ",", "len", "(", "row", ")", ")", "\n", "}", "\n", "vnet", ":=", "networkingVNET", "{", "value", ":", "row", "[", "0", "]", "}", "\n", "if", "!", "vnet", ".", "Valid", "(", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "value", ":=", "row", "[", "1", "]", "\n\n", "result", ":=", "networkingCommandEntry_answer", "{", "vnet", ":", "vnet", ",", "value", ":", "value", "}", "\n", "return", "&", "networkingCommandEntry", "{", "entry", ":", "result", ",", "answer", ":", "&", "result", "}", ",", "nil", "\n", "}" ]

[ "networking", "command", "entry", "parsers" ]

[ "func", "ReadNetworkingConfig", "(", "fd", "*", "os", ".", "File", ")", "(", "NetworkingConfig", ",", "error", ")", "{", "// start piecing together different parts of the file", "fromfile", ",", "eof", ":=", "consumeFile", "(", "fd", ")", "\n", "tokenized", ",", "eot", ":=", "tokenizeNetworkingConfig", "(", "eof", ",", "fromfile", ")", "\n", "rows", ",", "eos", ":=", "splitNetworkingConfig", "(", "eot", ",", "tokenized", ")", "\n", "entries", ",", "eop", ":=", "parseNetworkingConfig", "(", "eos", ",", "rows", ")", "\n\n", "// parse the version", "parsed_version", ",", "err", ":=", "networkingReadVersion", "(", "<-", "rows", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NetworkingConfig", "{", "}", ",", "err", "\n", "}", "\n\n", "// verify that it's 1.0 since that's all we support.", "version", ":=", "parsed_version", ".", "Number", "(", ")", "\n", "if", "version", "!=", "1.0", "{", "return", "NetworkingConfig", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "1.0", ",", "version", ")", "\n", "}", "\n\n", "// convert to a configuration", "result", ":=", "flattenNetworkingConfig", "(", "eop", ",", "entries", ")", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Constructor", "for", "networking", "file" ]

[ "func", "consumeFile", "(", "fd", "*", "os", ".", "File", ")", "(", "chan", "byte", ",", "sentinelSignaller", ")", "{", "fromfile", ":=", "make", "(", "chan", "byte", ")", "\n", "eof", ":=", "make", "(", "sentinelSignaller", ")", "\n", "go", "func", "(", ")", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "for", "{", "_", ",", "err", ":=", "fd", ".", "Read", "(", "b", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "fromfile", "<-", "b", "[", "0", "]", "\n", "}", "\n", "close", "(", "eof", ")", "\n", "}", "(", ")", "\n", "return", "fromfile", ",", "eof", "\n", "}" ]

[ "generic", "async", "file", "reader" ]

[ "func", "(", "s", "*", "StepCheckExistingImage", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "c", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "Config", ")", "\n", "d", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "c", ".", "imageAlreadyExists", "=", "d", ".", "ImageExists", "(", "c", ".", "ImageName", ")", "\n", "if", "!", "c", ".", "PackerForce", "&&", "c", ".", "imageAlreadyExists", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", "+", "\"", "\"", ",", "c", ".", "ImageName", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Run", "executes", "the", "Packer", "build", "step", "that", "checks", "if", "the", "image", "already", "exists", "." ]

[ "func", "getImageVisibility", "(", "visibility", "string", ")", "(", "*", "images", ".", "ImageVisibility", ",", "error", ")", "{", "visibilities", ":=", "[", "...", "]", "images", ".", "ImageVisibility", "{", "images", ".", "ImageVisibilityPublic", ",", "images", ".", "ImageVisibilityPrivate", ",", "images", ".", "ImageVisibilityCommunity", ",", "images", ".", "ImageVisibilityShared", ",", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "visibilities", "{", "if", "string", "(", "v", ")", "==", "visibility", "{", "return", "&", "v", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "visibility", ")", "\n", "}" ]

[ "Retrieve", "the", "specific", "ImageVisibility", "using", "the", "exported", "const", "from", "images" ]

[ "func", "(", "c", "*", "SourceMachineConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ")", "[", "]", "error", "{", "var", "errs", "[", "]", "error", "\n\n", "if", "c", ".", "MachinePackage", "==", "\"", "\"", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "MachineImage", "!=", "\"", "\"", "&&", "c", ".", "MachineImageFilters", ".", "Name", "!=", "\"", "\"", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "MachineNetworks", "==", "nil", "{", "c", ".", "MachineNetworks", "=", "[", "]", "string", "{", "}", "\n", "}", "\n\n", "if", "c", ".", "MachineMetadata", "==", "nil", "{", "c", ".", "MachineMetadata", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n\n", "if", "c", ".", "MachineTags", "==", "nil", "{", "c", ".", "MachineTags", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "errs", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Prepare", "performs", "basic", "validation", "on", "a", "SourceMachineConfig", "struct", "." ]

[ "func", "(", "h", "*", "DispatchHook", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "ui", "Ui", ",", "comm", "Communicator", ",", "data", "interface", "{", "}", ")", "error", "{", "hooks", ",", "ok", ":=", "h", ".", "Mapping", "[", "name", "]", "\n", "if", "!", "ok", "{", "// No hooks for that name. No problem.", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "hook", ":=", "range", "hooks", "{", "if", "err", ":=", "ctx", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "hook", ".", "Run", "(", "ctx", ",", "name", ",", "ui", ",", "comm", ",", "data", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Runs", "the", "hook", "with", "the", "given", "name", "by", "dispatching", "it", "to", "the", "proper", "hooks", "if", "a", "mapping", "exists", ".", "If", "a", "mapping", "doesn", "t", "exist", "then", "nothing", "happens", "." ]

[ "func", "getVMIP", "(", "state", "multistep", ".", "StateBag", ")", "(", "string", ",", "error", ")", "{", "c", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "proxmox", ".", "Client", ")", "\n", "vmRef", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "proxmox", ".", "VmRef", ")", "\n\n", "ifs", ",", "err", ":=", "c", ".", "GetVmAgentNetworkInterfaces", "(", "vmRef", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// TODO: Do something smarter here? Allow specifying interface? Or address family?", "// For now, just go for first non-loopback", "for", "_", ",", "iface", ":=", "range", "ifs", "{", "for", "_", ",", "addr", ":=", "range", "iface", ".", "IPAddresses", "{", "if", "addr", ".", "IsLoopback", "(", ")", "{", "continue", "\n", "}", "\n", "return", "addr", ".", "String", "(", ")", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "Reads", "the", "first", "non", "-", "loopback", "interface", "s", "IP", "address", "from", "the", "VM", ".", "qemu", "-", "guest", "-", "agent", "package", "must", "be", "installed", "on", "the", "VM" ]

[ "func", "ConfigTmpDir", "(", ")", "(", "string", ",", "error", ")", "{", "if", "tmpdir", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", ";", "tmpdir", "!=", "\"", "\"", "{", "return", "filepath", ".", "Abs", "(", "tmpdir", ")", "\n", "}", "\n", "configdir", ",", "err", ":=", "packer", ".", "ConfigDir", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "td", ":=", "filepath", ".", "Join", "(", "configdir", ",", "\"", "\"", ")", "\n", "_", ",", "err", "=", "os", ".", "Stat", "(", "td", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "err", "=", "os", ".", "MkdirAll", "(", "td", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "td", ",", "nil", "\n", "}" ]

[ "ConfigTmpDir", "returns", "the", "configuration", "tmp", "directory", "for", "Docker" ]

[ "func", "(", "c", "*", "ToolsConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ")", "[", "]", "error", "{", "if", "c", ".", "ParallelsToolsMode", "==", "\"", "\"", "{", "c", ".", "ParallelsToolsMode", "=", "ParallelsToolsModeUpload", "\n", "}", "\n\n", "if", "c", ".", "ParallelsToolsGuestPath", "==", "\"", "\"", "{", "c", ".", "ParallelsToolsGuestPath", "=", "\"", "\"", "\n", "}", "\n\n", "validMode", ":=", "false", "\n", "validModes", ":=", "[", "]", "string", "{", "ParallelsToolsModeDisable", ",", "ParallelsToolsModeAttach", ",", "ParallelsToolsModeUpload", ",", "}", "\n\n", "for", "_", ",", "mode", ":=", "range", "validModes", "{", "if", "c", ".", "ParallelsToolsMode", "==", "mode", "{", "validMode", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "var", "errs", "[", "]", "error", "\n", "if", "!", "validMode", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "validModes", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "ParallelsToolsFlavor", "==", "\"", "\"", "{", "if", "c", ".", "ParallelsToolsMode", "!=", "ParallelsToolsModeDisable", "{", "errs", "=", "append", "(", "errs", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "errs", "\n", "}" ]

[ "Prepare", "validates", "&", "sets", "up", "configuration", "options", "related", "to", "Parallels", "Tools", "." ]

[ "func", "NewArtifact", "(", "dir", "string", ")", "(", "packer", ".", "Artifact", ",", "error", ")", "{", "files", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "5", ")", "\n", "visit", ":=", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "info", ".", "IsDir", "(", ")", "{", "files", "=", "append", "(", "files", ",", "path", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "filepath", ".", "Walk", "(", "dir", ",", "visit", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "artifact", "{", "dir", ":", "dir", ",", "f", ":", "files", ",", "}", ",", "nil", "\n", "}" ]

[ "NewArtifact", "returns", "a", "hyperv", "artifact", "containing", "the", "files", "in", "the", "given", "directory", "." ]

[ "func", "(", "c", "*", "Communicator", ")", "Upload", "(", "dst", "string", ",", "src", "io", ".", "Reader", ",", "fi", "*", "os", ".", "FileInfo", ")", "error", "{", "if", "fi", "==", "nil", "{", "return", "c", ".", "uploadReader", "(", "dst", ",", "src", ")", "\n", "}", "\n", "return", "c", ".", "uploadFile", "(", "dst", ",", "src", ",", "fi", ")", "\n", "}" ]

[ "Upload", "uploads", "a", "file", "to", "the", "docker", "container" ]

[ "func", "(", "c", "*", "Communicator", ")", "uploadReader", "(", "dst", "string", ",", "src", "io", ".", "Reader", ")", "error", "{", "// Create a temporary file to store the upload", "tempfile", ",", "err", ":=", "ioutil", ".", "TempFile", "(", "c", ".", "HostDir", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "os", ".", "Remove", "(", "tempfile", ".", "Name", "(", ")", ")", "\n", "defer", "tempfile", ".", "Close", "(", ")", "\n\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "tempfile", ",", "src", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "tempfile", ".", "Seek", "(", "0", ",", "0", ")", "\n", "fi", ",", "err", ":=", "tempfile", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "c", ".", "uploadFile", "(", "dst", ",", "tempfile", ",", "&", "fi", ")", "\n", "}" ]

[ "uploadReader", "writes", "an", "io", ".", "Reader", "to", "a", "temporary", "file", "before", "uploading" ]

[ "func", "(", "c", "*", "Communicator", ")", "uploadFile", "(", "dst", "string", ",", "src", "io", ".", "Reader", ",", "fi", "*", "os", ".", "FileInfo", ")", "error", "{", "// command format: docker cp /path/to/infile containerid:/path/to/outfile", "log", ".", "Printf", "(", "\"", "\"", ",", "dst", ",", "c", ".", "ContainerID", ")", "\n\n", "localCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ContainerID", ",", "filepath", ".", "Dir", "(", "dst", ")", ")", ")", "\n\n", "stderrP", ",", "err", ":=", "localCmd", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "stdin", ",", "err", ":=", "localCmd", ".", "StdinPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "localCmd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "archive", ":=", "tar", ".", "NewWriter", "(", "stdin", ")", "\n", "header", ",", "err", ":=", "tar", ".", "FileInfoHeader", "(", "*", "fi", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "header", ".", "Name", "=", "filepath", ".", "Base", "(", "dst", ")", "\n", "archive", ".", "WriteHeader", "(", "header", ")", "\n", "numBytes", ",", "err", ":=", "io", ".", "Copy", "(", "archive", ",", "src", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "numBytes", ",", "dst", ")", "\n\n", "if", "err", ":=", "archive", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "stdin", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "stderrOut", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "stderrP", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "localCmd", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dst", ",", "stderrOut", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "fixDestinationOwner", "(", "dst", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "uploadFile", "uses", "docker", "cp", "to", "copy", "the", "file", "from", "the", "host", "to", "the", "container" ]

[ "func", "(", "c", "*", "Communicator", ")", "Download", "(", "src", "string", ",", "dst", "io", ".", "Writer", ")", "error", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "c", ".", "ContainerID", ",", "src", ")", "\n", "localCmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "ContainerID", ",", "src", ")", ",", "\"", "\"", ")", "\n\n", "pipe", ",", "err", ":=", "localCmd", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "stderrP", ",", "err", ":=", "localCmd", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "localCmd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// When you use - to send docker cp to stdout it is streamed as a tar; this", "// enables it to work with directories. We don't actually support", "// directories in Download() but we still need to handle the tar format.", "stderrOut", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "stderrP", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "string", "(", "stderrOut", ")", "!=", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "stderrOut", ")", ")", "\n", "}", "\n\n", "archive", ":=", "tar", ".", "NewReader", "(", "pipe", ")", "\n", "_", ",", "err", "=", "archive", ".", "Next", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "numBytes", ",", "err", ":=", "io", ".", "Copy", "(", "dst", ",", "archive", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "numBytes", ",", "src", ")", "\n\n", "if", "err", "=", "localCmd", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "src", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Download", "pulls", "a", "file", "out", "of", "a", "container", "using", "docker", "cp", ".", "We", "have", "a", "source", "path", "and", "want", "to", "write", "to", "an", "io", ".", "Writer", "not", "a", "file", ".", "We", "use", "-", "to", "make", "docker", "cp", "to", "write", "to", "stdout", "and", "then", "copy", "the", "stream", "to", "our", "destination", "io", ".", "Writer", "." ]

[ "func", "(", "c", "*", "Communicator", ")", "run", "(", "cmd", "*", "exec", ".", "Cmd", ",", "remote", "*", "packer", ".", "RemoteCmd", ",", "stdin", "io", ".", "WriteCloser", ",", "stdout", ",", "stderr", "io", ".", "ReadCloser", ")", "{", "// For Docker, remote communication must be serialized since it", "// only supports single execution.", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "repeat", ":=", "func", "(", "w", "io", ".", "Writer", ",", "r", "io", ".", "ReadCloser", ")", "{", "io", ".", "Copy", "(", "w", ",", "r", ")", "\n", "r", ".", "Close", "(", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "\n\n", "if", "remote", ".", "Stdout", "!=", "nil", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "repeat", "(", "remote", ".", "Stdout", ",", "stdout", ")", "\n", "}", "\n\n", "if", "remote", ".", "Stderr", "!=", "nil", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "repeat", "(", "remote", ".", "Stderr", ",", "stderr", ")", "\n", "}", "\n\n", "// Start the command", "log", ".", "Printf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "cmd", ".", "Args", ",", "\"", "\"", ")", ")", "\n", "if", "err", ":=", "cmd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "remote", ".", "SetExited", "(", "254", ")", "\n", "return", "\n", "}", "\n\n", "var", "exitStatus", "int", "\n\n", "if", "remote", ".", "Stdin", "!=", "nil", "{", "go", "func", "(", ")", "{", "io", ".", "Copy", "(", "stdin", ",", "remote", ".", "Stdin", ")", "\n", "// close stdin to support commands that wait for stdin to be closed before exiting.", "stdin", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "}", "\n\n", "wg", ".", "Wait", "(", ")", "\n", "err", ":=", "cmd", ".", "Wait", "(", ")", "\n\n", "if", "exitErr", ",", "ok", ":=", "err", ".", "(", "*", "exec", ".", "ExitError", ")", ";", "ok", "{", "exitStatus", "=", "1", "\n\n", "// There is no process-independent way to get the REAL", "// exit status so we just try to go deeper.", "if", "status", ",", "ok", ":=", "exitErr", ".", "Sys", "(", ")", ".", "(", "syscall", ".", "WaitStatus", ")", ";", "ok", "{", "exitStatus", "=", "status", ".", "ExitStatus", "(", ")", "\n", "}", "\n", "}", "\n\n", "// Set the exit status which triggers waiters", "remote", ".", "SetExited", "(", "exitStatus", ")", "\n", "}" ]

[ "Runs", "the", "given", "command", "and", "blocks", "until", "completion" ]

[ "func", "amiRegionCopy", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ",", "config", "*", "AccessConfig", ",", "name", ",", "imageId", ",", "target", ",", "source", ",", "keyId", "string", ",", "encrypt", "*", "bool", ")", "(", "string", ",", "[", "]", "string", ",", "error", ")", "{", "snapshotIds", ":=", "[", "]", "string", "{", "}", "\n\n", "// Connect to the region where the AMI will be copied to", "session", ",", "err", ":=", "config", ".", "Session", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "snapshotIds", ",", "err", "\n", "}", "\n\n", "regionconn", ":=", "ec2", ".", "New", "(", "session", ".", "Copy", "(", "&", "aws", ".", "Config", "{", "Region", ":", "aws", ".", "String", "(", "target", ")", ",", "}", ")", ")", "\n\n", "resp", ",", "err", ":=", "regionconn", ".", "CopyImage", "(", "&", "ec2", ".", "CopyImageInput", "{", "SourceRegion", ":", "&", "source", ",", "SourceImageId", ":", "&", "imageId", ",", "Name", ":", "&", "name", ",", "Encrypted", ":", "encrypt", ",", "KmsKeyId", ":", "aws", ".", "String", "(", "keyId", ")", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "snapshotIds", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "imageId", ",", "target", ",", "err", ")", "\n", "}", "\n\n", "// Wait for the image to become ready", "if", "err", ":=", "WaitUntilAMIAvailable", "(", "ctx", ",", "regionconn", ",", "*", "resp", ".", "ImageId", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "snapshotIds", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "*", "resp", ".", "ImageId", ",", "target", ",", "err", ")", "\n", "}", "\n\n", "// Getting snapshot IDs out of the copied AMI", "describeImageResp", ",", "err", ":=", "regionconn", ".", "DescribeImages", "(", "&", "ec2", ".", "DescribeImagesInput", "{", "ImageIds", ":", "[", "]", "*", "string", "{", "resp", ".", "ImageId", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "snapshotIds", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "imageId", ",", "target", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "blockDeviceMapping", ":=", "range", "describeImageResp", ".", "Images", "[", "0", "]", ".", "BlockDeviceMappings", "{", "if", "blockDeviceMapping", ".", "Ebs", "!=", "nil", "&&", "blockDeviceMapping", ".", "Ebs", ".", "SnapshotId", "!=", "nil", "{", "snapshotIds", "=", "append", "(", "snapshotIds", ",", "*", "blockDeviceMapping", ".", "Ebs", ".", "SnapshotId", ")", "\n", "}", "\n", "}", "\n\n", "return", "*", "resp", ".", "ImageId", ",", "snapshotIds", ",", "nil", "\n", "}" ]

[ "amiRegionCopy", "does", "a", "copy", "for", "the", "given", "AMI", "to", "the", "target", "region", "and", "returns", "the", "resulting", "ID", "and", "snapshot", "IDs", "or", "error", "." ]

[ "func", "extractScript", "(", "p", "*", "Provisioner", ")", "(", "string", ",", "error", ")", "{", "temp", ",", "err", ":=", "tmp", ".", "File", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "temp", ".", "Close", "(", ")", "\n", "writer", ":=", "bufio", ".", "NewWriter", "(", "temp", ")", "\n", "for", "_", ",", "command", ":=", "range", "p", ".", "config", ".", "Inline", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "command", ")", "\n", "if", "_", ",", "err", ":=", "writer", ".", "WriteString", "(", "command", "+", "\"", "\\n", "\"", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "writer", ".", "Flush", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "temp", ".", "Name", "(", ")", ",", "nil", "\n", "}" ]

[ "Takes", "the", "inline", "scripts", "concatenates", "them", "into", "a", "temporary", "file", "and", "returns", "a", "string", "containing", "the", "location", "of", "said", "file", "." ]

[ "func", "(", "p", "*", "Provisioner", ")", "prepareEnvVars", "(", "elevated", "bool", ")", "(", "err", "error", ")", "{", "// Collate all required env vars into a plain string with required", "// formatting applied", "flattenedEnvVars", ":=", "p", ".", "createFlattenedEnvVars", "(", "elevated", ")", "\n", "// Create a powershell script on the target build fs containing the", "// flattened env vars", "err", "=", "p", ".", "uploadEnvVars", "(", "flattenedEnvVars", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "\n", "}" ]

[ "Environment", "variables", "required", "within", "the", "remote", "environment", "are", "uploaded", "within", "a", "PS", "script", "and", "then", "enabled", "by", "dot", "sourcing", "the", "script", "immediately", "prior", "to", "execution", "of", "the", "main", "command" ]

[ "func", "NewCore", "(", "c", "*", "CoreConfig", ")", "(", "*", "Core", ",", "error", ")", "{", "result", ":=", "&", "Core", "{", "Template", ":", "c", ".", "Template", ",", "components", ":", "c", ".", "Components", ",", "variables", ":", "c", ".", "Variables", ",", "version", ":", "c", ".", "Version", ",", "only", ":", "c", ".", "Only", ",", "except", ":", "c", ".", "Except", ",", "}", "\n\n", "if", "err", ":=", "result", ".", "validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "result", ".", "init", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "secret", ":=", "range", "result", ".", "secrets", "{", "LogSecretFilter", ".", "Set", "(", "secret", ")", "\n", "}", "\n\n", "// Go through and interpolate all the build names. We should be able", "// to do this at this point with the variables.", "result", ".", "builds", "=", "make", "(", "map", "[", "string", "]", "*", "template", ".", "Builder", ")", "\n", "for", "_", ",", "b", ":=", "range", "c", ".", "Template", ".", "Builders", "{", "v", ",", "err", ":=", "interpolate", ".", "Render", "(", "b", ".", "Name", ",", "result", ".", "Context", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "b", ".", "Name", ",", "err", ")", "\n", "}", "\n\n", "result", ".", "builds", "[", "v", "]", "=", "b", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "NewCore", "creates", "a", "new", "Core", "." ]

[ "func", "(", "c", "*", "Core", ")", "BuildNames", "(", ")", "[", "]", "string", "{", "r", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "c", ".", "builds", ")", ")", "\n", "for", "n", ":=", "range", "c", ".", "builds", "{", "r", "=", "append", "(", "r", ",", "n", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "r", ")", "\n\n", "return", "r", "\n", "}" ]

[ "BuildNames", "returns", "the", "builds", "that", "are", "available", "in", "this", "configured", "core", "." ]

[ "func", "(", "c", "*", "Core", ")", "Context", "(", ")", "*", "interpolate", ".", "Context", "{", "return", "&", "interpolate", ".", "Context", "{", "TemplatePath", ":", "c", ".", "Template", ".", "Path", ",", "UserVariables", ":", "c", ".", "variables", ",", "}", "\n", "}" ]

[ "Context", "returns", "an", "interpolation", "context", "." ]

[ "func", "WaitForImage", "(", "ctx", "context", ".", "Context", ",", "client", "*", "gophercloud", ".", "ServiceClient", ",", "imageId", "string", ")", "error", "{", "maxNumErrors", ":=", "10", "\n", "numErrors", ":=", "0", "\n\n", "for", "{", "if", "err", ":=", "ctx", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "image", ",", "err", ":=", "images", ".", "Get", "(", "client", ",", "imageId", ")", ".", "Extract", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errCode", ",", "ok", ":=", "err", ".", "(", "*", "gophercloud", ".", "ErrUnexpectedResponseCode", ")", "\n", "if", "ok", "&&", "(", "errCode", ".", "Actual", "==", "500", "||", "errCode", ".", "Actual", "==", "404", ")", "{", "numErrors", "++", "\n", "if", "numErrors", ">=", "maxNumErrors", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "numErrors", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "errCode", ".", "Actual", ",", "err", ")", "\n", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Second", ")", "\n", "continue", "\n", "}", "\n\n", "return", "err", "\n", "}", "\n\n", "if", "image", ".", "Status", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "log", ".", "Printf", "(", "\"", "\"", ",", "image", ".", "Status", ")", "\n", "time", ".", "Sleep", "(", "2", "*", "time", ".", "Second", ")", "\n", "}", "\n", "}" ]

[ "WaitForImage", "waits", "for", "the", "given", "Image", "ID", "to", "become", "ready", "." ]

[ "func", "NewDriver", "(", "dconfig", "*", "DriverConfig", ",", "config", "*", "SSHConfig", ",", "vmName", "string", ")", "(", "Driver", ",", "error", ")", "{", "drivers", ":=", "[", "]", "Driver", "{", "}", "\n\n", "if", "dconfig", ".", "RemoteType", "!=", "\"", "\"", "{", "drivers", "=", "[", "]", "Driver", "{", "&", "ESX5Driver", "{", "Host", ":", "dconfig", ".", "RemoteHost", ",", "Port", ":", "dconfig", ".", "RemotePort", ",", "Username", ":", "dconfig", ".", "RemoteUser", ",", "Password", ":", "dconfig", ".", "RemotePassword", ",", "PrivateKeyFile", ":", "dconfig", ".", "RemotePrivateKey", ",", "Datastore", ":", "dconfig", ".", "RemoteDatastore", ",", "CacheDatastore", ":", "dconfig", ".", "RemoteCacheDatastore", ",", "CacheDirectory", ":", "dconfig", ".", "RemoteCacheDirectory", ",", "VMName", ":", "vmName", ",", "CommConfig", ":", "config", ".", "Comm", ",", "}", ",", "}", "\n\n", "}", "else", "{", "switch", "runtime", ".", "GOOS", "{", "case", "\"", "\"", ":", "drivers", "=", "[", "]", "Driver", "{", "&", "Fusion6Driver", "{", "Fusion5Driver", ":", "Fusion5Driver", "{", "AppPath", ":", "dconfig", ".", "FusionAppPath", ",", "SSHConfig", ":", "config", ",", "}", ",", "}", ",", "&", "Fusion5Driver", "{", "AppPath", ":", "dconfig", ".", "FusionAppPath", ",", "SSHConfig", ":", "config", ",", "}", ",", "}", "\n", "case", "\"", "\"", ":", "fallthrough", "\n", "case", "\"", "\"", ":", "drivers", "=", "[", "]", "Driver", "{", "&", "Workstation10Driver", "{", "Workstation9Driver", ":", "Workstation9Driver", "{", "SSHConfig", ":", "config", ",", "}", ",", "}", ",", "&", "Workstation9Driver", "{", "SSHConfig", ":", "config", ",", "}", ",", "&", "Player6Driver", "{", "Player5Driver", ":", "Player5Driver", "{", "SSHConfig", ":", "config", ",", "}", ",", "}", ",", "&", "Player5Driver", "{", "SSHConfig", ":", "config", ",", "}", ",", "}", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "runtime", ".", "GOOS", ")", "\n", "}", "\n", "}", "\n\n", "errs", ":=", "\"", "\"", "\n", "for", "_", ",", "driver", ":=", "range", "drivers", "{", "err", ":=", "driver", ".", "Verify", "(", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "driver", ",", "err", "==", "nil", ")", "\n\n", "if", "err", "==", "nil", "{", "return", "driver", ",", "nil", "\n", "}", "\n", "errs", "+=", "\"", "\"", "+", "err", ".", "Error", "(", ")", "+", "\"", "\\n", "\"", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", ",", "errs", ")", "\n", "}" ]

[ "NewDriver", "returns", "a", "new", "driver", "implementation", "for", "this", "operating", "system", "or", "an", "error", "if", "the", "driver", "couldn", "t", "be", "initialized", "." ]

[ "func", "ReadDhcpConfig", "(", "path", "string", ")", "(", "DhcpConfiguration", ",", "error", ")", "{", "fd", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "fd", ".", "Close", "(", ")", "\n", "return", "ReadDhcpConfiguration", "(", "fd", ")", "\n", "}" ]

[ "read", "the", "dhcp", "configuration", "out", "of", "the", "specified", "path" ]

[ "func", "readVMXConfig", "(", "path", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "map", "[", "string", "]", "string", "{", "}", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "vmxBytes", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "map", "[", "string", "]", "string", "{", "}", ",", "err", "\n", "}", "\n", "return", "ParseVMX", "(", "string", "(", "vmxBytes", ")", ")", ",", "nil", "\n", "}" ]

[ "read", "the", "VMX", "configuration", "from", "the", "specified", "path" ]

[ "func", "readCustomDeviceName", "(", "vmxData", "map", "[", "string", "]", "string", ")", "(", "string", ",", "error", ")", "{", "connectionType", ",", "ok", ":=", "vmxData", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "||", "connectionType", "!=", "\"", "\"", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "connectionType", ")", "\n", "}", "\n\n", "device", ",", "ok", ":=", "vmxData", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "||", "device", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "connectionType", ",", "device", ")", "\n", "}", "\n", "return", "device", ",", "nil", "\n", "}" ]

[ "read", "the", "connection", "type", "out", "of", "a", "vmx", "configuration" ]

[ "func", "(", "c", "*", "OutputConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ",", "pc", "*", "common", ".", "PackerConfig", ")", "[", "]", "error", "{", "if", "c", ".", "OutputDir", "==", "\"", "\"", "{", "c", ".", "OutputDir", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pc", ".", "PackerBuildName", ")", "\n", "}", "\n\n", "var", "errs", "[", "]", "error", "\n\n", "if", "path", ".", "IsAbs", "(", "c", ".", "OutputDir", ")", "{", "c", ".", "OutputDir", "=", "path", ".", "Clean", "(", "c", ".", "OutputDir", ")", "\n", "}", "else", "{", "wd", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "c", ".", "OutputDir", "=", "path", ".", "Clean", "(", "path", ".", "Join", "(", "wd", ",", "c", ".", "OutputDir", ")", ")", "\n", "}", "\n\n", "if", "!", "pc", ".", "PackerForce", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "c", ".", "OutputDir", ")", ";", "err", "==", "nil", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "OutputDir", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "errs", "\n", "}" ]

[ "Prepare", "configures", "the", "output", "directory", "or", "returns", "an", "error", "if", "it", "already", "exists", "." ]

[ "func", "(", "s", "*", "StepUploadParallelsTools", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "comm", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Communicator", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n\n", "// If we're attaching then don't do this, since we attached.", "if", "s", ".", "ParallelsToolsMode", "!=", "ParallelsToolsModeUpload", "{", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}", "\n\n", "// Get the Parallels Tools path on the host machine", "parallelsToolsPath", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "parallelsToolsPath", ")", "\n", "if", "err", "!=", "nil", "{", "state", ".", "Put", "(", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "s", ".", "Ctx", ".", "Data", "=", "&", "toolsPathTemplate", "{", "Flavor", ":", "s", ".", "ParallelsToolsFlavor", ",", "}", "\n\n", "s", ".", "ParallelsToolsGuestPath", ",", "err", "=", "interpolate", ".", "Render", "(", "s", ".", "ParallelsToolsGuestPath", ",", "&", "s", ".", "Ctx", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "ui", ".", "Say", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "ParallelsToolsFlavor", ",", "s", ".", "ParallelsToolsGuestPath", ")", ")", "\n", "if", "err", ":=", "comm", ".", "Upload", "(", "s", ".", "ParallelsToolsGuestPath", ",", "f", ",", "nil", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Run", "uploads", "the", "Parallels", "Tools", "ISO", "to", "the", "VM", "." ]

[ "func", "NewStepCreateBlockStorageInstance", "(", "conn", "*", "ncloud", ".", "Conn", ",", "ui", "packer", ".", "Ui", ",", "config", "*", "Config", ")", "*", "StepCreateBlockStorageInstance", "{", "var", "step", "=", "&", "StepCreateBlockStorageInstance", "{", "Conn", ":", "conn", ",", "Say", ":", "func", "(", "message", "string", ")", "{", "ui", ".", "Say", "(", "message", ")", "}", ",", "Error", ":", "func", "(", "e", "error", ")", "{", "ui", ".", "Error", "(", "e", ".", "Error", "(", ")", ")", "}", ",", "Config", ":", "config", ",", "}", "\n\n", "step", ".", "CreateBlockStorageInstance", "=", "step", ".", "createBlockStorageInstance", "\n\n", "return", "step", "\n", "}" ]

[ "NewStepCreateBlockStorageInstance", "make", "StepCreateBlockStorage", "struct", "to", "make", "extra", "block", "storage" ]

[ "func", "CommHost", "(", "client", "*", "gophercloud", ".", "ServiceClient", ",", "sshinterface", "string", ",", "sshipversion", "string", ")", "func", "(", "multistep", ".", "StateBag", ")", "(", "string", ",", "error", ")", "{", "return", "func", "(", "state", "multistep", ".", "StateBag", ")", "(", "string", ",", "error", ")", "{", "s", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "servers", ".", "Server", ")", "\n\n", "// If we have a specific interface, try that", "if", "sshinterface", "!=", "\"", "\"", "{", "if", "addr", ":=", "sshAddrFromPool", "(", "s", ",", "sshinterface", ",", "sshipversion", ")", ";", "addr", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "addr", ",", "sshinterface", ")", "\n", "return", "addr", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// If we have a floating IP, use that", "ip", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "floatingips", ".", "FloatingIP", ")", "\n", "if", "ip", "!=", "nil", "&&", "ip", ".", "FloatingIP", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "ip", ".", "FloatingIP", ")", "\n", "return", "ip", ".", "FloatingIP", ",", "nil", "\n", "}", "\n\n", "if", "s", ".", "AccessIPv4", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "s", ".", "AccessIPv4", ")", "\n", "return", "s", ".", "AccessIPv4", ",", "nil", "\n", "}", "\n\n", "// Try to get it from the requested interface", "if", "addr", ":=", "sshAddrFromPool", "(", "s", ",", "sshinterface", ",", "sshipversion", ")", ";", "addr", "!=", "\"", "\"", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "addr", ")", "\n", "return", "addr", ",", "nil", "\n", "}", "\n\n", "s", ",", "err", ":=", "servers", ".", "Get", "(", "client", ",", "s", ".", "ID", ")", ".", "Extract", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "state", ".", "Put", "(", "\"", "\"", ",", "s", ")", "\n", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Second", ")", "\n\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "CommHost", "looks", "up", "the", "host", "for", "the", "communicator", "." ]

[ "func", "listDirectories", "(", "path", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "names", ":=", "[", "]", "string", "{", "}", "\n", "items", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "item", ":=", "range", "items", "{", "// We only want directories", "if", "item", ".", "IsDir", "(", ")", "{", "currentDir", ":=", "filepath", ".", "Join", "(", "path", ",", "item", ".", "Name", "(", ")", ")", "\n", "names", "=", "append", "(", "names", ",", "currentDir", ")", "\n\n", "// Do some recursion", "subNames", ",", "err", ":=", "listDirectories", "(", "currentDir", ")", "\n", "if", "err", "==", "nil", "{", "names", "=", "append", "(", "names", ",", "subNames", "...", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "names", ",", "nil", "\n", "}" ]

[ "listDirectories", "recursively", "lists", "directories", "under", "the", "specified", "path" ]

[ "func", "discoverTypesInPath", "(", "path", ",", "typeID", "string", ")", "(", "[", "]", "plugin", ",", "error", ")", "{", "postProcessors", ":=", "[", "]", "plugin", "{", "}", "\n\n", "dirs", ",", "err", ":=", "listDirectories", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "postProcessors", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "dir", ":=", "range", "dirs", "{", "fset", ":=", "token", ".", "NewFileSet", "(", ")", "\n", "goPackages", ",", "err", ":=", "parser", ".", "ParseDir", "(", "fset", ",", "dir", ",", "nil", ",", "parser", ".", "AllErrors", ")", "\n", "if", "err", "!=", "nil", "{", "return", "postProcessors", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "goPackage", ":=", "range", "goPackages", "{", "ast", ".", "PackageExports", "(", "goPackage", ")", "\n", "ast", ".", "Inspect", "(", "goPackage", ",", "func", "(", "n", "ast", ".", "Node", ")", "bool", "{", "switch", "x", ":=", "n", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "TypeSpec", ":", "if", "x", ".", "Name", ".", "Name", "==", "typeID", "{", "derivedName", ":=", "deriveName", "(", "path", ",", "dir", ")", "\n", "postProcessors", "=", "append", "(", "postProcessors", ",", "plugin", "{", "Package", ":", "goPackage", ".", "Name", ",", "PluginName", ":", "derivedName", ",", "ImportName", ":", "deriveImport", "(", "x", ".", "Name", ".", "Name", ",", "derivedName", ")", ",", "TypeName", ":", "x", ".", "Name", ".", "Name", ",", "Path", ":", "dir", ",", "}", ")", "\n", "// The AST stops parsing when we return false. Once we", "// find the symbol we want we can stop parsing.", "// DEBUG:", "// fmt.Printf(\"package %#v\\n\", goPackage)", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "postProcessors", ",", "nil", "\n", "}" ]

[ "discoverTypesInPath", "searches", "for", "types", "of", "typeID", "in", "path", "and", "returns", "a", "list", "of", "plugins", "it", "finds", "." ]

[ "func", "(", "c", "*", "Config", ")", "ReadSSHPrivateKeyFile", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "privateKey", "[", "]", "byte", "\n\n", "if", "c", ".", "SSHPrivateKeyFile", "!=", "\"", "\"", "{", "keyPath", ",", "err", ":=", "packer", ".", "ExpandUser", "(", "c", ".", "SSHPrivateKeyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "privateKey", ",", "err", "=", "ioutil", ".", "ReadFile", "(", "keyPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "privateKey", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "privateKey", ",", "nil", "\n", "}" ]

[ "ReadSSHPrivateKeyFile", "returns", "the", "SSH", "private", "key", "bytes" ]

[ "func", "(", "c", "*", "Config", ")", "SSHConfigFunc", "(", ")", "func", "(", "multistep", ".", "StateBag", ")", "(", "*", "ssh", ".", "ClientConfig", ",", "error", ")", "{", "return", "func", "(", "state", "multistep", ".", "StateBag", ")", "(", "*", "ssh", ".", "ClientConfig", ",", "error", ")", "{", "sshConfig", ":=", "&", "ssh", ".", "ClientConfig", "{", "User", ":", "c", ".", "SSHUsername", ",", "HostKeyCallback", ":", "ssh", ".", "InsecureIgnoreHostKey", "(", ")", ",", "}", "\n\n", "if", "c", ".", "SSHAgentAuth", "{", "authSock", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "authSock", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sshAgent", ",", "err", ":=", "net", ".", "Dial", "(", "\"", "\"", ",", "authSock", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "authSock", ",", "err", ")", "\n", "}", "\n\n", "sshConfig", ".", "Auth", "=", "append", "(", "sshConfig", ".", "Auth", ",", "ssh", ".", "PublicKeysCallback", "(", "agent", ".", "NewClient", "(", "sshAgent", ")", ".", "Signers", ")", ")", "\n", "}", "\n\n", "var", "privateKeys", "[", "]", "[", "]", "byte", "\n", "if", "c", ".", "SSHPrivateKeyFile", "!=", "\"", "\"", "{", "privateKey", ",", "err", ":=", "c", ".", "ReadSSHPrivateKeyFile", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "privateKeys", "=", "append", "(", "privateKeys", ",", "privateKey", ")", "\n", "}", "\n\n", "// aws,alicloud,cloudstack,digitalOcean,oneAndOne,openstack,oracle & profitbricks key", "if", "iKey", ",", "hasKey", ":=", "state", ".", "GetOk", "(", "\"", "\"", ")", ";", "hasKey", "{", "privateKeys", "=", "append", "(", "privateKeys", ",", "[", "]", "byte", "(", "iKey", ".", "(", "string", ")", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "SSHPrivateKey", ")", "!=", "0", "{", "privateKeys", "=", "append", "(", "privateKeys", ",", "c", ".", "SSHPrivateKey", ")", "\n", "}", "\n\n", "for", "_", ",", "key", ":=", "range", "privateKeys", "{", "signer", ",", "err", ":=", "ssh", ".", "ParsePrivateKey", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "sshConfig", ".", "Auth", "=", "append", "(", "sshConfig", ".", "Auth", ",", "ssh", ".", "PublicKeys", "(", "signer", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "SSHPassword", "!=", "\"", "\"", "{", "sshConfig", ".", "Auth", "=", "append", "(", "sshConfig", ".", "Auth", ",", "ssh", ".", "Password", "(", "c", ".", "SSHPassword", ")", ",", "ssh", ".", "KeyboardInteractive", "(", "packerssh", ".", "PasswordKeyboardInteractive", "(", "c", ".", "SSHPassword", ")", ")", ",", ")", "\n", "}", "\n", "return", "sshConfig", ",", "nil", "\n", "}", "\n", "}" ]

[ "SSHConfigFunc", "returns", "a", "function", "that", "can", "be", "used", "for", "the", "SSH", "communicator", "config", "for", "connecting", "to", "the", "instance", "created", "over", "SSH", "using", "the", "private", "key", "or", "password", "." ]

[ "func", "(", "c", "*", "Config", ")", "Port", "(", ")", "int", "{", "switch", "c", ".", "Type", "{", "case", "\"", "\"", ":", "return", "c", ".", "SSHPort", "\n", "case", "\"", "\"", ":", "return", "c", ".", "WinRMPort", "\n", "default", ":", "return", "0", "\n", "}", "\n", "}" ]

[ "Port", "returns", "the", "port", "that", "will", "be", "used", "for", "access", "based", "on", "config", "." ]

[ "func", "(", "c", "*", "Config", ")", "Host", "(", ")", "string", "{", "switch", "c", ".", "Type", "{", "case", "\"", "\"", ":", "return", "c", ".", "SSHHost", "\n", "case", "\"", "\"", ":", "return", "c", ".", "WinRMHost", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "Host", "returns", "the", "port", "that", "will", "be", "used", "for", "access", "based", "on", "config", "." ]

[ "func", "(", "c", "*", "Config", ")", "User", "(", ")", "string", "{", "switch", "c", ".", "Type", "{", "case", "\"", "\"", ":", "return", "c", ".", "SSHUsername", "\n", "case", "\"", "\"", ":", "return", "c", ".", "WinRMUser", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "User", "returns", "the", "port", "that", "will", "be", "used", "for", "access", "based", "on", "config", "." ]

[ "func", "(", "c", "*", "Config", ")", "Password", "(", ")", "string", "{", "switch", "c", ".", "Type", "{", "case", "\"", "\"", ":", "return", "c", ".", "SSHPassword", "\n", "case", "\"", "\"", ":", "return", "c", ".", "WinRMPassword", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "Password", "returns", "the", "port", "that", "will", "be", "used", "for", "access", "based", "on", "config", "." ]

[ "func", "(", "s", "expressionSequence", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "b", "BCDriver", ")", "error", "{", "// validate should never fail here, since it should be called before", "// expressionSequence.Do. Only reason we don't panic is so we can clean up.", "if", "errs", ":=", "s", ".", "Validate", "(", ")", ";", "errs", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "exp", ":=", "range", "s", "{", "if", "err", ":=", "ctx", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "exp", ".", "Do", "(", "ctx", ",", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "b", ".", "Flush", "(", ")", "\n", "}" ]

[ "Do", "executes", "every", "expression", "in", "the", "sequence", "and", "then", "flushes", "remaining", "scancodes", "." ]

[ "func", "(", "s", "expressionSequence", ")", "Validate", "(", ")", "(", "errs", "[", "]", "error", ")", "{", "for", "_", ",", "exp", ":=", "range", "s", "{", "if", "err", ":=", "exp", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Validate", "tells", "us", "if", "every", "expression", "in", "the", "sequence", "is", "valid", "." ]

[ "func", "GenerateExpressionSequence", "(", "command", "string", ")", "(", "expressionSequence", ",", "error", ")", "{", "seq", ":=", "expressionSequence", "{", "}", "\n", "if", "command", "==", "\"", "\"", "{", "return", "seq", ",", "nil", "\n", "}", "\n", "got", ",", "err", ":=", "ParseReader", "(", "\"", "\"", ",", "strings", ".", "NewReader", "(", "command", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "exp", ":=", "range", "got", ".", "(", "[", "]", "interface", "{", "}", ")", "{", "seq", "=", "append", "(", "seq", ",", "exp", ".", "(", "expression", ")", ")", "\n", "}", "\n", "return", "seq", ",", "nil", "\n", "}" ]

[ "GenerateExpressionSequence", "generates", "a", "sequence", "of", "expressions", "from", "the", "given", "command", ".", "This", "is", "the", "primary", "entry", "point", "to", "the", "boot", "command", "parser", "." ]

[ "func", "(", "w", "*", "waitExpression", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "driver", "BCDriver", ")", "error", "{", "driver", ".", "Flush", "(", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "w", ".", "d", ")", "\n", "select", "{", "case", "<-", "time", ".", "After", "(", "w", ".", "d", ")", ":", "return", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "Do", "waits", "the", "amount", "of", "time", "described", "by", "the", "expression", ".", "It", "is", "cancellable", "through", "the", "context", "." ]

[ "func", "(", "w", "*", "waitExpression", ")", "Validate", "(", ")", "error", "{", "if", "w", ".", "d", "<=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "w", ".", "d", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "returns", "an", "error", "if", "the", "time", "is", "<", "=", "0" ]

[ "func", "(", "s", "*", "specialExpression", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "driver", "BCDriver", ")", "error", "{", "return", "driver", ".", "SendSpecial", "(", "s", ".", "s", ",", "s", ".", "action", ")", "\n", "}" ]

[ "Do", "sends", "the", "special", "command", "to", "the", "driver", "along", "with", "the", "key", "action", "." ]

[ "func", "(", "l", "*", "literal", ")", "Do", "(", "ctx", "context", ".", "Context", ",", "driver", "BCDriver", ")", "error", "{", "return", "driver", ".", "SendKey", "(", "l", ".", "s", ",", "l", ".", "action", ")", "\n", "}" ]

[ "Do", "sends", "the", "key", "to", "the", "driver", "along", "with", "the", "key", "action", "." ]

[ "func", "(", "c", "*", "ShutdownConfig", ")", "Prepare", "(", "ctx", "*", "interpolate", ".", "Context", ")", "[", "]", "error", "{", "if", "c", ".", "RawShutdownTimeout", "==", "\"", "\"", "{", "c", ".", "RawShutdownTimeout", "=", "\"", "\"", "\n", "}", "\n\n", "var", "errs", "[", "]", "error", "\n", "var", "err", "error", "\n", "c", ".", "ShutdownTimeout", ",", "err", "=", "time", ".", "ParseDuration", "(", "c", ".", "RawShutdownTimeout", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "errs", "\n", "}" ]

[ "Prepare", "sets", "default", "values", "to", "the", "VM", "shutdown", "configuration", "." ]

[ "func", "(", "s", "*", "StepCollateArtifacts", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n\n", "if", "s", ".", "SkipExport", "{", "// Get the path to the main build directory from the statebag", "var", "buildDir", "string", "\n", "if", "v", ",", "ok", ":=", "state", ".", "GetOk", "(", "\"", "\"", ")", ";", "ok", "{", "buildDir", "=", "v", ".", "(", "string", ")", "\n", "}", "\n", "// If the user has chosen to skip a full export of the VM the only", "// artifacts that they are interested in will be the VHDs. The", "// called function searches for all disks under the given source", "// directory and moves them to a 'Virtual Hard Disks' folder under", "// the destination directory", "err", ":=", "driver", ".", "MoveCreatedVHDsToOutputDir", "(", "buildDir", ",", "s", ".", "OutputDir", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "state", ".", "Put", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n", "}", "else", "{", "// Get the full path to the export directory from the statebag", "var", "exportPath", "string", "\n", "if", "v", ",", "ok", ":=", "state", ".", "GetOk", "(", "\"", "\"", ")", ";", "ok", "{", "exportPath", "=", "v", ".", "(", "string", ")", "\n", "}", "\n", "// The export process exports the VM into a folder named 'vm name'", "// under the output directory. However, to maintain backwards", "// compatibility, we now need to shuffle around the exported folders", "// so the 'Snapshots', 'Virtual Hard Disks' and 'Virtual Machines'", "// directories appear *directly* under <output directory>.", "// The empty '<output directory>/<vm name>' directory is removed", "// when complete.", "// The 'Snapshots' folder will not be moved into the output", "// directory if it is empty.", "err", ":=", "driver", ".", "PreserveLegacyExportBehaviour", "(", "exportPath", ",", "s", ".", "OutputDir", ")", "\n", "if", "err", "!=", "nil", "{", "// No need to halt here; Just warn the user instead", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "ui", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Runs", "the", "step", "required", "to", "collate", "all", "build", "artifacts", "under", "the", "specified", "output", "directory" ]

[ "func", "NewServer", "(", "conn", "io", ".", "ReadWriteCloser", ")", "(", "*", "Server", ",", "error", ")", "{", "mux", ",", "err", ":=", "newMuxBrokerServer", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "result", ":=", "newServerWithMux", "(", "mux", ",", "0", ")", "\n", "result", ".", "closeMux", "=", "true", "\n", "go", "mux", ".", "Run", "(", ")", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "NewServer", "returns", "a", "new", "Packer", "RPC", "server", "." ]

[ "func", "(", "s", "*", "Server", ")", "Serve", "(", ")", "{", "// Accept a connection on stream ID 0, which is always used for", "// normal client to server connections.", "stream", ",", "err", ":=", "s", ".", "mux", ".", "Accept", "(", "s", ".", "streamId", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "defer", "stream", ".", "Close", "(", ")", "\n\n", "h", ":=", "&", "codec", ".", "MsgpackHandle", "{", "RawToString", ":", "true", ",", "WriteExt", ":", "true", ",", "}", "\n", "rpcCodec", ":=", "codec", ".", "GoRpc", ".", "ServerCodec", "(", "stream", ",", "h", ")", "\n", "s", ".", "server", ".", "ServeCodec", "(", "rpcCodec", ")", "\n", "}" ]

[ "ServeConn", "serves", "a", "single", "connection", "over", "the", "RPC", "server", ".", "It", "is", "up", "to", "the", "caller", "to", "obtain", "a", "proper", "io", ".", "ReadWriteCloser", "." ]

[ "func", "(", "pp", "*", "PP", ")", "ppList", "(", ")", "[", "]", "map", "[", "string", "]", "interface", "{", "}", "{", "pps", ":=", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "0", ",", "len", "(", "pp", ".", "PostProcessors", ")", ")", "\n", "for", "_", ",", "rawPP", ":=", "range", "pp", ".", "PostProcessors", "{", "switch", "pp", ":=", "rawPP", ".", "(", "type", ")", "{", "case", "string", ":", "case", "map", "[", "string", "]", "interface", "{", "}", ":", "pps", "=", "append", "(", "pps", ",", "pp", ")", "\n", "case", "[", "]", "interface", "{", "}", ":", "for", "_", ",", "innerRawPP", ":=", "range", "pp", "{", "if", "innerPP", ",", "ok", ":=", "innerRawPP", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "pps", "=", "append", "(", "pps", ",", "innerPP", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "pps", "\n", "}" ]

[ "postProcessors", "converts", "the", "variable", "structure", "of", "the", "template", "to", "a", "list" ]

[ "func", "(", "s", "*", "StepAttachFloppy", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "state", "multistep", ".", "StateBag", ")", "multistep", ".", "StepAction", "{", "// Determine if we even have a floppy disk to attach", "var", "floppyPath", "string", "\n", "if", "floppyPathRaw", ",", "ok", ":=", "state", ".", "GetOk", "(", "\"", "\"", ")", ";", "ok", "{", "floppyPath", "=", "floppyPathRaw", ".", "(", "string", ")", "\n", "}", "else", "{", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "multistep", ".", "ActionContinue", "\n", "}", "\n\n", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "ui", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "packer", ".", "Ui", ")", "\n", "vmName", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "// Delete the floppy disk controller", "delCommand", ":=", "[", "]", "string", "{", "\"", "\"", ",", "vmName", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "// This will almost certainly fail with 'The fdd0 device does not exist.'", "driver", ".", "Prlctl", "(", "delCommand", "...", ")", "\n\n", "ui", ".", "Say", "(", "\"", "\"", ")", "\n", "// Attaching the floppy disk", "addCommand", ":=", "[", "]", "string", "{", "\"", "\"", ",", "vmName", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "floppyPath", ",", "\"", "\"", ",", "}", "\n", "if", "err", ":=", "driver", ".", "Prlctl", "(", "addCommand", "...", ")", ";", "err", "!=", "nil", "{", "state", ".", "Put", "(", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "return", "multistep", ".", "ActionHalt", "\n", "}", "\n\n", "// Track the path so that we can unregister it from Parallels later", "s", ".", "floppyPath", "=", "floppyPath", "\n\n", "return", "multistep", ".", "ActionContinue", "\n", "}" ]

[ "Run", "adds", "a", "virtual", "FDD", "device", "to", "the", "VM", "and", "attaches", "the", "image", ".", "If", "the", "image", "is", "not", "specified", "then", "this", "step", "will", "be", "skipped", "." ]

[ "func", "(", "s", "*", "StepAttachFloppy", ")", "Cleanup", "(", "state", "multistep", ".", "StateBag", ")", "{", "driver", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "Driver", ")", "\n", "vmName", ":=", "state", ".", "Get", "(", "\"", "\"", ")", ".", "(", "string", ")", "\n\n", "if", "s", ".", "floppyPath", "==", "\"", "\"", "{", "return", "\n", "}", "\n\n", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "command", ":=", "[", "]", "string", "{", "\"", "\"", ",", "vmName", ",", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "driver", ".", "Prlctl", "(", "command", "...", ")", "\n", "}" ]

[ "Cleanup", "removes", "the", "virtual", "FDD", "device", "attached", "to", "the", "VM", "." ]

[ "func", "(", "d", "*", "pcXTDriver", ")", "Flush", "(", ")", "error", "{", "defer", "func", "(", ")", "{", "d", ".", "buffer", "=", "nil", "\n", "}", "(", ")", "\n", "sc", ",", "err", ":=", "chunkScanCodes", "(", "d", ".", "buffer", ",", "d", ".", "scancodeChunkSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "b", ":=", "range", "sc", "{", "if", "err", ":=", "d", ".", "sendImpl", "(", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "time", ".", "Sleep", "(", "d", ".", "interval", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Flush", "send", "all", "scanecodes", "." ]

[ "func", "(", "d", "*", "pcXTDriver", ")", "send", "(", "codes", "[", "]", "string", ")", "{", "d", ".", "buffer", "=", "append", "(", "d", ".", "buffer", ",", "codes", ")", "\n", "}" ]

[ "send", "stores", "the", "codes", "in", "an", "internal", "buffer", ".", "Use", "Flush", "to", "send", "them", "." ]

[ "func", "NewKeyPair", "(", "config", "CreateKeyPairConfig", ")", "(", "KeyPair", ",", "error", ")", "{", "if", "config", ".", "Type", "==", "Default", "{", "config", ".", "Type", "=", "Ecdsa", "\n", "}", "\n\n", "switch", "config", ".", "Type", "{", "case", "Ecdsa", ":", "return", "newEcdsaKeyPair", "(", "config", ")", "\n", "case", "Rsa", ":", "return", "newRsaKeyPair", "(", "config", ")", "\n", "}", "\n\n", "return", "KeyPair", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "Type", ".", "String", "(", ")", ")", "\n", "}" ]

[ "NewKeyPair", "generates", "a", "new", "SSH", "key", "pair", "using", "the", "specified", "CreateKeyPairConfig", "." ]

[ "func", "newEcdsaKeyPair", "(", "config", "CreateKeyPairConfig", ")", "(", "KeyPair", ",", "error", ")", "{", "var", "curve", "elliptic", ".", "Curve", "\n\n", "switch", "config", ".", "Bits", "{", "case", "0", ":", "config", ".", "Bits", "=", "521", "\n", "fallthrough", "\n", "case", "521", ":", "curve", "=", "elliptic", ".", "P521", "(", ")", "\n", "case", "384", ":", "curve", "=", "elliptic", ".", "P384", "(", ")", "\n", "case", "256", ":", "curve", "=", "elliptic", ".", "P256", "(", ")", "\n", "case", "224", ":", "// Not supported by \"golang.org/x/crypto/ssh\".", "return", "KeyPair", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "Bits", ")", "\n", "default", ":", "return", "KeyPair", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "Bits", ")", "\n", "}", "\n\n", "privateKey", ",", "err", ":=", "ecdsa", ".", "GenerateKey", "(", "curve", ",", "rand", ".", "Reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "sshPublicKey", ",", "err", ":=", "gossh", ".", "NewPublicKey", "(", "&", "privateKey", ".", "PublicKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "privateRaw", ",", "err", ":=", "x509", ".", "MarshalECPrivateKey", "(", "privateKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "privatePem", ",", "err", ":=", "rawPemBlock", "(", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Headers", ":", "nil", ",", "Bytes", ":", "privateRaw", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "KeyPair", "{", "PrivateKeyPemBlock", ":", "privatePem", ",", "PublicKeyAuthorizedKeysLine", ":", "authorizedKeysLine", "(", "sshPublicKey", ",", "config", ".", "Comment", ")", ",", "Comment", ":", "config", ".", "Comment", ",", "}", ",", "nil", "\n", "}" ]

[ "newEcdsaKeyPair", "returns", "a", "new", "ECDSA", "SSH", "key", "pair", "." ]

[ "func", "newRsaKeyPair", "(", "config", "CreateKeyPairConfig", ")", "(", "KeyPair", ",", "error", ")", "{", "if", "config", ".", "Bits", "==", "0", "{", "config", ".", "Bits", "=", "defaultRsaBits", "\n", "}", "\n\n", "privateKey", ",", "err", ":=", "rsa", ".", "GenerateKey", "(", "rand", ".", "Reader", ",", "config", ".", "Bits", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "sshPublicKey", ",", "err", ":=", "gossh", ".", "NewPublicKey", "(", "&", "privateKey", ".", "PublicKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "privatePemBlock", ",", "err", ":=", "rawPemBlock", "(", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Headers", ":", "nil", ",", "Bytes", ":", "x509", ".", "MarshalPKCS1PrivateKey", "(", "privateKey", ")", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "KeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "KeyPair", "{", "PrivateKeyPemBlock", ":", "privatePemBlock", ",", "PublicKeyAuthorizedKeysLine", ":", "authorizedKeysLine", "(", "sshPublicKey", ",", "config", ".", "Comment", ")", ",", "Comment", ":", "config", ".", "Comment", ",", "}", ",", "nil", "\n", "}" ]

[ "newRsaKeyPair", "returns", "a", "new", "RSA", "SSH", "key", "pair", "." ]

[ "func", "rawPemBlock", "(", "block", "*", "pem", ".", "Block", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "buffer", ":=", "bytes", ".", "NewBuffer", "(", "nil", ")", "\n\n", "err", ":=", "pem", ".", "Encode", "(", "buffer", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "buffer", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "rawPemBlock", "encodes", "a", "pem", ".", "Block", "to", "a", "slice", "of", "bytes", "." ]