repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
apcera/libretto | virtualmachine/azure/arm/util.go | deletePublicIP | func (vm *VM) deletePublicIP(authorizer autorest.Authorizer) error {
// Delete the Public IP of this VM
publicIPAddressesClient := network.NewPublicIPAddressesClient(vm.Creds.SubscriptionID)
publicIPAddressesClient.Authorizer = authorizer
_, errc := publicIPAddressesClient.Delete(vm.ResourceGroup, vm.PublicIP, nil)
return <-errc
} | go | func (vm *VM) deletePublicIP(authorizer autorest.Authorizer) error {
// Delete the Public IP of this VM
publicIPAddressesClient := network.NewPublicIPAddressesClient(vm.Creds.SubscriptionID)
publicIPAddressesClient.Authorizer = authorizer
_, errc := publicIPAddressesClient.Delete(vm.ResourceGroup, vm.PublicIP, nil)
return <-errc
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"deletePublicIP",
"(",
"authorizer",
"autorest",
".",
"Authorizer",
")",
"error",
"{",
"// Delete the Public IP of this VM",
"publicIPAddressesClient",
":=",
"network",
".",
"NewPublicIPAddressesClient",
"(",
"vm",
".",
"Creds",
".",
"SubscriptionID",
")",
"\n",
"publicIPAddressesClient",
".",
"Authorizer",
"=",
"authorizer",
"\n\n",
"_",
",",
"errc",
":=",
"publicIPAddressesClient",
".",
"Delete",
"(",
"vm",
".",
"ResourceGroup",
",",
"vm",
".",
"PublicIP",
",",
"nil",
")",
"\n",
"return",
"<-",
"errc",
"\n",
"}"
] | // deletePublicIP deletes the reserved Public IP of the given VM from the VM's resource group, returns an error
// if the operation does not succeed. | [
"deletePublicIP",
"deletes",
"the",
"reserved",
"Public",
"IP",
"of",
"the",
"given",
"VM",
"from",
"the",
"VM",
"s",
"resource",
"group",
"returns",
"an",
"error",
"if",
"the",
"operation",
"does",
"not",
"succeed",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/arm/util.go#L286-L293 | train |
apcera/libretto | virtualmachine/azure/arm/util.go | deleteDeployment | func (vm *VM) deleteDeployment(authorizer autorest.Authorizer) error {
// Get the deployments client
deploymentsClient := resources.NewDeploymentsClient(vm.Creds.SubscriptionID)
deploymentsClient.Authorizer = authorizer
// Delete the deployment
_, errc := deploymentsClient.Delete(vm.ResourceGroup, vm.DeploymentName, nil)
return <-errc
} | go | func (vm *VM) deleteDeployment(authorizer autorest.Authorizer) error {
// Get the deployments client
deploymentsClient := resources.NewDeploymentsClient(vm.Creds.SubscriptionID)
deploymentsClient.Authorizer = authorizer
// Delete the deployment
_, errc := deploymentsClient.Delete(vm.ResourceGroup, vm.DeploymentName, nil)
return <-errc
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"deleteDeployment",
"(",
"authorizer",
"autorest",
".",
"Authorizer",
")",
"error",
"{",
"// Get the deployments client",
"deploymentsClient",
":=",
"resources",
".",
"NewDeploymentsClient",
"(",
"vm",
".",
"Creds",
".",
"SubscriptionID",
")",
"\n",
"deploymentsClient",
".",
"Authorizer",
"=",
"authorizer",
"\n\n",
"// Delete the deployment",
"_",
",",
"errc",
":=",
"deploymentsClient",
".",
"Delete",
"(",
"vm",
".",
"ResourceGroup",
",",
"vm",
".",
"DeploymentName",
",",
"nil",
")",
"\n",
"return",
"<-",
"errc",
"\n",
"}"
] | // deleteDeployment deletes the deployed azure arm template for this vm. | [
"deleteDeployment",
"deletes",
"the",
"deployed",
"azure",
"arm",
"template",
"for",
"this",
"vm",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/arm/util.go#L296-L304 | train |
apcera/libretto | virtualmachine/virtualbox/vm.go | GetIPs | func (vm *VM) GetIPs() ([]net.IP, error) {
vm.waitUntilReady()
return vm.ips, nil
} | go | func (vm *VM) GetIPs() ([]net.IP, error) {
vm.waitUntilReady()
return vm.ips, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetIPs",
"(",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"vm",
".",
"waitUntilReady",
"(",
")",
"\n\n",
"return",
"vm",
".",
"ips",
",",
"nil",
"\n",
"}"
] | // GetIPs returns a list of ip addresses associated with the vm through VBox Guest Additions. | [
"GetIPs",
"returns",
"a",
"list",
"of",
"ip",
"addresses",
"associated",
"with",
"the",
"vm",
"through",
"VBox",
"Guest",
"Additions",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/vm.go#L168-L172 | train |
apcera/libretto | virtualmachine/virtualbox/vm.go | GetState | func (vm *VM) GetState() (string, error) {
stdout, err := runner.RunCombinedError("showvminfo", vm.Name)
if err != nil {
return "", lvm.WrapErrors(lvm.ErrVMInfoFailed, err)
}
for _, line := range strings.Split(stdout, "\n") {
// See if this is a NIC
if match := stateRegexp.FindStringSubmatch(line); match != nil {
if match := runningRegexp.FindStringSubmatch(line); match != nil {
return lvm.VMRunning, nil
}
return lvm.VMHalted, nil
}
}
return lvm.VMUnknown, lvm.ErrVMStateFailed
} | go | func (vm *VM) GetState() (string, error) {
stdout, err := runner.RunCombinedError("showvminfo", vm.Name)
if err != nil {
return "", lvm.WrapErrors(lvm.ErrVMInfoFailed, err)
}
for _, line := range strings.Split(stdout, "\n") {
// See if this is a NIC
if match := stateRegexp.FindStringSubmatch(line); match != nil {
if match := runningRegexp.FindStringSubmatch(line); match != nil {
return lvm.VMRunning, nil
}
return lvm.VMHalted, nil
}
}
return lvm.VMUnknown, lvm.ErrVMStateFailed
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetState",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"stdout",
",",
"err",
":=",
"runner",
".",
"RunCombinedError",
"(",
"\"",
"\"",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"lvm",
".",
"WrapErrors",
"(",
"lvm",
".",
"ErrVMInfoFailed",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"stdout",
",",
"\"",
"\\n",
"\"",
")",
"{",
"// See if this is a NIC",
"if",
"match",
":=",
"stateRegexp",
".",
"FindStringSubmatch",
"(",
"line",
")",
";",
"match",
"!=",
"nil",
"{",
"if",
"match",
":=",
"runningRegexp",
".",
"FindStringSubmatch",
"(",
"line",
")",
";",
"match",
"!=",
"nil",
"{",
"return",
"lvm",
".",
"VMRunning",
",",
"nil",
"\n",
"}",
"\n",
"return",
"lvm",
".",
"VMHalted",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"lvm",
".",
"VMUnknown",
",",
"lvm",
".",
"ErrVMStateFailed",
"\n",
"}"
] | // GetState gets the power state of the VM being serviced by this driver. | [
"GetState",
"gets",
"the",
"power",
"state",
"of",
"the",
"VM",
"being",
"serviced",
"by",
"this",
"driver",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/vm.go#L175-L190 | train |
apcera/libretto | virtualmachine/virtualbox/vm.go | GetInterfaces | func (vm *VM) GetInterfaces() ([]NIC, error) {
nics := []NIC{}
stdout, err := runner.RunCombinedError("showvminfo", vm.Name)
if err != nil {
return nil, err
}
for _, line := range strings.Split(stdout, "\n") {
// See if this is a NIC
if match := nicRegexp.FindStringSubmatch(line); match != nil {
var nic NIC
// Get the nic index and the backing
// substr is the nic index with a trailing `:`
substr := strings.Split(match[0], " ")[1]
//Remove the trailing `:` and convert to an integer
idx, err := strconv.Atoi(strings.TrimSuffix(substr, ":"))
if err != nil {
return nil, err
}
nic.Idx = idx
if match := backingRegexp.FindStringSubmatch(line); match != nil {
nic.Backing = Nat
} else if match := disabledRegexp.FindStringSubmatch(line); match != nil {
nic.Backing = Disabled
} else {
nic.Backing = Unsupported
}
nics = append(nics, nic)
}
}
return nics, nil
} | go | func (vm *VM) GetInterfaces() ([]NIC, error) {
nics := []NIC{}
stdout, err := runner.RunCombinedError("showvminfo", vm.Name)
if err != nil {
return nil, err
}
for _, line := range strings.Split(stdout, "\n") {
// See if this is a NIC
if match := nicRegexp.FindStringSubmatch(line); match != nil {
var nic NIC
// Get the nic index and the backing
// substr is the nic index with a trailing `:`
substr := strings.Split(match[0], " ")[1]
//Remove the trailing `:` and convert to an integer
idx, err := strconv.Atoi(strings.TrimSuffix(substr, ":"))
if err != nil {
return nil, err
}
nic.Idx = idx
if match := backingRegexp.FindStringSubmatch(line); match != nil {
nic.Backing = Nat
} else if match := disabledRegexp.FindStringSubmatch(line); match != nil {
nic.Backing = Disabled
} else {
nic.Backing = Unsupported
}
nics = append(nics, nic)
}
}
return nics, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetInterfaces",
"(",
")",
"(",
"[",
"]",
"NIC",
",",
"error",
")",
"{",
"nics",
":=",
"[",
"]",
"NIC",
"{",
"}",
"\n",
"stdout",
",",
"err",
":=",
"runner",
".",
"RunCombinedError",
"(",
"\"",
"\"",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"stdout",
",",
"\"",
"\\n",
"\"",
")",
"{",
"// See if this is a NIC",
"if",
"match",
":=",
"nicRegexp",
".",
"FindStringSubmatch",
"(",
"line",
")",
";",
"match",
"!=",
"nil",
"{",
"var",
"nic",
"NIC",
"\n",
"// Get the nic index and the backing",
"// substr is the nic index with a trailing `:`",
"substr",
":=",
"strings",
".",
"Split",
"(",
"match",
"[",
"0",
"]",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
"\n",
"//Remove the trailing `:` and convert to an integer",
"idx",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"strings",
".",
"TrimSuffix",
"(",
"substr",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"nic",
".",
"Idx",
"=",
"idx",
"\n",
"if",
"match",
":=",
"backingRegexp",
".",
"FindStringSubmatch",
"(",
"line",
")",
";",
"match",
"!=",
"nil",
"{",
"nic",
".",
"Backing",
"=",
"Nat",
"\n",
"}",
"else",
"if",
"match",
":=",
"disabledRegexp",
".",
"FindStringSubmatch",
"(",
"line",
")",
";",
"match",
"!=",
"nil",
"{",
"nic",
".",
"Backing",
"=",
"Disabled",
"\n",
"}",
"else",
"{",
"nic",
".",
"Backing",
"=",
"Unsupported",
"\n",
"}",
"\n",
"nics",
"=",
"append",
"(",
"nics",
",",
"nic",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nics",
",",
"nil",
"\n",
"}"
] | // GetInterfaces gets all the network cards attached to this VM | [
"GetInterfaces",
"gets",
"all",
"the",
"network",
"cards",
"attached",
"to",
"this",
"VM"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/vm.go#L193-L224 | train |
apcera/libretto | virtualmachine/virtualbox/vm.go | Provision | func (vm *VM) Provision() error {
var name string
if vm.Name == "" {
name = fmt.Sprintf("vm-%s", uuid.Variant4())
vm.Name = name
}
src := vm.Src
if src == "" {
return lvm.ErrSourceNotSpecified
}
ovaPath, err := filepath.Abs(src)
if err != nil {
return err
}
vm.Src = ovaPath
// See comment on mutex definition for details.
createMutex.Lock()
_, err = runner.RunCombinedError("import", vm.Src, "--vsys", "0", "--vmname", vm.Name)
createMutex.Unlock()
if err != nil {
return err
}
err = vm.configure()
if err != nil {
return err
}
return vm.waitUntilReady()
} | go | func (vm *VM) Provision() error {
var name string
if vm.Name == "" {
name = fmt.Sprintf("vm-%s", uuid.Variant4())
vm.Name = name
}
src := vm.Src
if src == "" {
return lvm.ErrSourceNotSpecified
}
ovaPath, err := filepath.Abs(src)
if err != nil {
return err
}
vm.Src = ovaPath
// See comment on mutex definition for details.
createMutex.Lock()
_, err = runner.RunCombinedError("import", vm.Src, "--vsys", "0", "--vmname", vm.Name)
createMutex.Unlock()
if err != nil {
return err
}
err = vm.configure()
if err != nil {
return err
}
return vm.waitUntilReady()
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Provision",
"(",
")",
"error",
"{",
"var",
"name",
"string",
"\n",
"if",
"vm",
".",
"Name",
"==",
"\"",
"\"",
"{",
"name",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"uuid",
".",
"Variant4",
"(",
")",
")",
"\n",
"vm",
".",
"Name",
"=",
"name",
"\n",
"}",
"\n\n",
"src",
":=",
"vm",
".",
"Src",
"\n",
"if",
"src",
"==",
"\"",
"\"",
"{",
"return",
"lvm",
".",
"ErrSourceNotSpecified",
"\n",
"}",
"\n",
"ovaPath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"src",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vm",
".",
"Src",
"=",
"ovaPath",
"\n\n",
"// See comment on mutex definition for details.",
"createMutex",
".",
"Lock",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"runner",
".",
"RunCombinedError",
"(",
"\"",
"\"",
",",
"vm",
".",
"Src",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"vm",
".",
"Name",
")",
"\n",
"createMutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"vm",
".",
"configure",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"vm",
".",
"waitUntilReady",
"(",
")",
"\n",
"}"
] | // Provision imports the VM and waits until it is booted up. | [
"Provision",
"imports",
"the",
"VM",
"and",
"waits",
"until",
"it",
"is",
"booted",
"up",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/vm.go#L227-L258 | train |
apcera/libretto | virtualmachine/virtualbox/vm.go | Run | func (f vboxRunner) Run(args ...string) (string, string, error) {
var vboxManagePath string
// If vBoxManage is not found in the system path, fall back to the
// hard coded path.
if path, err := exec.LookPath("VBoxManage"); err == nil {
vboxManagePath = path
} else {
vboxManagePath = VBOXMANAGE
}
cmd := exec.Command(vboxManagePath, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
var stdout bytes.Buffer
var stderr bytes.Buffer
cmd.Stdout, cmd.Stderr = &stdout, &stderr
err := cmd.Run()
return stdout.String(), stderr.String(), err
} | go | func (f vboxRunner) Run(args ...string) (string, string, error) {
var vboxManagePath string
// If vBoxManage is not found in the system path, fall back to the
// hard coded path.
if path, err := exec.LookPath("VBoxManage"); err == nil {
vboxManagePath = path
} else {
vboxManagePath = VBOXMANAGE
}
cmd := exec.Command(vboxManagePath, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
var stdout bytes.Buffer
var stderr bytes.Buffer
cmd.Stdout, cmd.Stderr = &stdout, &stderr
err := cmd.Run()
return stdout.String(), stderr.String(), err
} | [
"func",
"(",
"f",
"vboxRunner",
")",
"Run",
"(",
"args",
"...",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"var",
"vboxManagePath",
"string",
"\n",
"// If vBoxManage is not found in the system path, fall back to the",
"// hard coded path.",
"if",
"path",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
";",
"err",
"==",
"nil",
"{",
"vboxManagePath",
"=",
"path",
"\n",
"}",
"else",
"{",
"vboxManagePath",
"=",
"VBOXMANAGE",
"\n",
"}",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"vboxManagePath",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n\n",
"var",
"stdout",
"bytes",
".",
"Buffer",
"\n",
"var",
"stderr",
"bytes",
".",
"Buffer",
"\n",
"cmd",
".",
"Stdout",
",",
"cmd",
".",
"Stderr",
"=",
"&",
"stdout",
",",
"&",
"stderr",
"\n",
"err",
":=",
"cmd",
".",
"Run",
"(",
")",
"\n",
"return",
"stdout",
".",
"String",
"(",
")",
",",
"stderr",
".",
"String",
"(",
")",
",",
"err",
"\n",
"}"
] | // Run runs a VBoxManage command. | [
"Run",
"runs",
"a",
"VBoxManage",
"command",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/vm.go#L261-L279 | train |
apcera/libretto | virtualmachine/digitalocean/vm.go | Provision | func (vm *VM) Provision() error {
b, err := json.Marshal(vm.Config)
if err != nil {
return err
}
client := &http.Client{}
req, err := BuildRequest(vm.APIToken, "POST", apiBaseURL+apiDropletURL, bytes.NewReader(b))
if err != nil {
return err
}
rsp, err := client.Do(req)
if err != nil {
return err
}
defer rsp.Body.Close()
b, err = ioutil.ReadAll(rsp.Body)
if err != nil {
return err
}
if rsp.Status[0] != StatusOk {
return fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
// Fill out vm.Droplet with data on new droplet
r := &DropletResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return err
}
vm.Droplet = r.Droplet
return nil
} | go | func (vm *VM) Provision() error {
b, err := json.Marshal(vm.Config)
if err != nil {
return err
}
client := &http.Client{}
req, err := BuildRequest(vm.APIToken, "POST", apiBaseURL+apiDropletURL, bytes.NewReader(b))
if err != nil {
return err
}
rsp, err := client.Do(req)
if err != nil {
return err
}
defer rsp.Body.Close()
b, err = ioutil.ReadAll(rsp.Body)
if err != nil {
return err
}
if rsp.Status[0] != StatusOk {
return fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
// Fill out vm.Droplet with data on new droplet
r := &DropletResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return err
}
vm.Droplet = r.Droplet
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Provision",
"(",
")",
"error",
"{",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"vm",
".",
"Config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"client",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n",
"req",
",",
"err",
":=",
"BuildRequest",
"(",
"vm",
".",
"APIToken",
",",
"\"",
"\"",
",",
"apiBaseURL",
"+",
"apiDropletURL",
",",
"bytes",
".",
"NewReader",
"(",
"b",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"rsp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"rsp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"b",
",",
"err",
"=",
"ioutil",
".",
"ReadAll",
"(",
"rsp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"rsp",
".",
"Status",
"[",
"0",
"]",
"!=",
"StatusOk",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rsp",
".",
"Status",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n\n",
"// Fill out vm.Droplet with data on new droplet",
"r",
":=",
"&",
"DropletResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vm",
".",
"Droplet",
"=",
"r",
".",
"Droplet",
"\n",
"return",
"nil",
"\n",
"}"
] | // Provision creates a new VM | [
"Provision",
"creates",
"a",
"new",
"VM"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/vm.go#L165-L197 | train |
apcera/libretto | virtualmachine/digitalocean/vm.go | GetIPs | func (vm *VM) GetIPs() ([]net.IP, error) {
var ips []net.IP
if err := vm.Update(); err != nil {
return nil, err
}
for _, ip := range vm.Droplet.Networks.V4 {
ips = append(ips, net.ParseIP(ip.IPAddress))
}
for _, ip := range vm.Droplet.Networks.V6 {
ips = append(ips, net.ParseIP(ip.IPAddress))
}
return ips, nil
} | go | func (vm *VM) GetIPs() ([]net.IP, error) {
var ips []net.IP
if err := vm.Update(); err != nil {
return nil, err
}
for _, ip := range vm.Droplet.Networks.V4 {
ips = append(ips, net.ParseIP(ip.IPAddress))
}
for _, ip := range vm.Droplet.Networks.V6 {
ips = append(ips, net.ParseIP(ip.IPAddress))
}
return ips, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetIPs",
"(",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"var",
"ips",
"[",
"]",
"net",
".",
"IP",
"\n",
"if",
"err",
":=",
"vm",
".",
"Update",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"vm",
".",
"Droplet",
".",
"Networks",
".",
"V4",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"net",
".",
"ParseIP",
"(",
"ip",
".",
"IPAddress",
")",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"vm",
".",
"Droplet",
".",
"Networks",
".",
"V6",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"net",
".",
"ParseIP",
"(",
"ip",
".",
"IPAddress",
")",
")",
"\n",
"}",
"\n",
"return",
"ips",
",",
"nil",
"\n",
"}"
] | // GetIPs returns a list of ip addresses associated with the VM | [
"GetIPs",
"returns",
"a",
"list",
"of",
"ip",
"addresses",
"associated",
"with",
"the",
"VM"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/vm.go#L200-L212 | train |
apcera/libretto | virtualmachine/digitalocean/vm.go | GetState | func (vm *VM) GetState() (string, error) {
id := fmt.Sprintf("%v", vm.Droplet.ID)
if id == "" {
return "", ErrNoInstanceID
}
client := &http.Client{}
req, err := BuildRequest(vm.APIToken, "GET", apiBaseURL+apiDropletURL+"/"+id, nil)
if err != nil {
return "", err
}
rsp, err := client.Do(req)
if err != nil {
return "", err
}
defer rsp.Body.Close()
b, err := ioutil.ReadAll(rsp.Body)
if err != nil {
return "", err
}
if rsp.StatusCode == StatusNotFound {
return "not_found", nil
}
if rsp.Status[0] != StatusOk {
return "", fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
// Fill out vm.Droplet with data on droplet
r := &DropletResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return "", err
}
vm.Droplet = r.Droplet
return vm.Droplet.Status, nil
} | go | func (vm *VM) GetState() (string, error) {
id := fmt.Sprintf("%v", vm.Droplet.ID)
if id == "" {
return "", ErrNoInstanceID
}
client := &http.Client{}
req, err := BuildRequest(vm.APIToken, "GET", apiBaseURL+apiDropletURL+"/"+id, nil)
if err != nil {
return "", err
}
rsp, err := client.Do(req)
if err != nil {
return "", err
}
defer rsp.Body.Close()
b, err := ioutil.ReadAll(rsp.Body)
if err != nil {
return "", err
}
if rsp.StatusCode == StatusNotFound {
return "not_found", nil
}
if rsp.Status[0] != StatusOk {
return "", fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
// Fill out vm.Droplet with data on droplet
r := &DropletResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return "", err
}
vm.Droplet = r.Droplet
return vm.Droplet.Status, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetState",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"id",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"vm",
".",
"Droplet",
".",
"ID",
")",
"\n",
"if",
"id",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"client",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n",
"req",
",",
"err",
":=",
"BuildRequest",
"(",
"vm",
".",
"APIToken",
",",
"\"",
"\"",
",",
"apiBaseURL",
"+",
"apiDropletURL",
"+",
"\"",
"\"",
"+",
"id",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"rsp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"rsp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"rsp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"rsp",
".",
"StatusCode",
"==",
"StatusNotFound",
"{",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n",
"if",
"rsp",
".",
"Status",
"[",
"0",
"]",
"!=",
"StatusOk",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rsp",
".",
"Status",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n\n",
"// Fill out vm.Droplet with data on droplet",
"r",
":=",
"&",
"DropletResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"vm",
".",
"Droplet",
"=",
"r",
".",
"Droplet",
"\n",
"return",
"vm",
".",
"Droplet",
".",
"Status",
",",
"nil",
"\n",
"}"
] | // GetState gets the running state of the VM through the DigitalOcean API
// Returns droplet state if available and 'not_found' if ID could not be located. | [
"GetState",
"gets",
"the",
"running",
"state",
"of",
"the",
"VM",
"through",
"the",
"DigitalOcean",
"API",
"Returns",
"droplet",
"state",
"if",
"available",
"and",
"not_found",
"if",
"ID",
"could",
"not",
"be",
"located",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/vm.go#L255-L290 | train |
apcera/libretto | virtualmachine/openstack/util.go | findImageAPIVersion | func findImageAPIVersion(tokenID string, imageEndpoint string) (int, error) {
// Try to fetch image API version from the imageEndpoint
if strings.HasSuffix(imageEndpoint, "/v1/") {
return 1, nil
}
if strings.HasSuffix(imageEndpoint, "/v2/") {
return 2, nil
}
// Try to fetch version number using the endpoint
versionReq, err := http.NewRequest("GET", imageEndpoint, nil)
if err != nil {
return 0, fmt.Errorf("unable to get image API version")
}
versionReq.Header.Add("X-Auth-Token", tokenID)
versionClient := &http.Client{}
// Send the request to upload the image
resp, err := versionClient.Do(versionReq)
if err != nil {
return 0, fmt.Errorf("failed to send a image API version request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
bodyStr := string(body)
if resp.StatusCode != http.StatusMultipleChoices {
return 0, fmt.Errorf("image API version request returned bad response, %s", bodyStr)
}
// Prefer V2 over V1
if match, _ := regexp.MatchString(".*\"id\": \"v2\\.[0-2]+.*\"", bodyStr); match {
return 2, nil
}
if match, _ := regexp.MatchString(".*\"id\": \"v1\\.[0-1]+.*\"", bodyStr); match {
return 1, nil
}
return 0, fmt.Errorf("image API version is not supported")
} | go | func findImageAPIVersion(tokenID string, imageEndpoint string) (int, error) {
// Try to fetch image API version from the imageEndpoint
if strings.HasSuffix(imageEndpoint, "/v1/") {
return 1, nil
}
if strings.HasSuffix(imageEndpoint, "/v2/") {
return 2, nil
}
// Try to fetch version number using the endpoint
versionReq, err := http.NewRequest("GET", imageEndpoint, nil)
if err != nil {
return 0, fmt.Errorf("unable to get image API version")
}
versionReq.Header.Add("X-Auth-Token", tokenID)
versionClient := &http.Client{}
// Send the request to upload the image
resp, err := versionClient.Do(versionReq)
if err != nil {
return 0, fmt.Errorf("failed to send a image API version request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
bodyStr := string(body)
if resp.StatusCode != http.StatusMultipleChoices {
return 0, fmt.Errorf("image API version request returned bad response, %s", bodyStr)
}
// Prefer V2 over V1
if match, _ := regexp.MatchString(".*\"id\": \"v2\\.[0-2]+.*\"", bodyStr); match {
return 2, nil
}
if match, _ := regexp.MatchString(".*\"id\": \"v1\\.[0-1]+.*\"", bodyStr); match {
return 1, nil
}
return 0, fmt.Errorf("image API version is not supported")
} | [
"func",
"findImageAPIVersion",
"(",
"tokenID",
"string",
",",
"imageEndpoint",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"// Try to fetch image API version from the imageEndpoint",
"if",
"strings",
".",
"HasSuffix",
"(",
"imageEndpoint",
",",
"\"",
"\"",
")",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"imageEndpoint",
",",
"\"",
"\"",
")",
"{",
"return",
"2",
",",
"nil",
"\n",
"}",
"\n\n",
"// Try to fetch version number using the endpoint",
"versionReq",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"imageEndpoint",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"versionReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"tokenID",
")",
"\n",
"versionClient",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n\n",
"// Send the request to upload the image",
"resp",
",",
"err",
":=",
"versionClient",
".",
"Do",
"(",
"versionReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyStr",
":=",
"string",
"(",
"body",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusMultipleChoices",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"bodyStr",
")",
"\n",
"}",
"\n\n",
"// Prefer V2 over V1",
"if",
"match",
",",
"_",
":=",
"regexp",
".",
"MatchString",
"(",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\\",
"\\\"",
"\"",
",",
"bodyStr",
")",
";",
"match",
"{",
"return",
"2",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"match",
",",
"_",
":=",
"regexp",
".",
"MatchString",
"(",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\\",
"\\\"",
"\"",
",",
"bodyStr",
")",
";",
"match",
"{",
"return",
"1",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // findImageAPIVersion finds the Image API version number. It first checks whether the given
// imageEndpoint has version info. If it is not, then a Get request is sent to imageEndpoint to
// fetch supported APIs. If any V2 api is supported then it returns 2, else If any V1 api is
// supported then it returns 1. Otherwise, it returns an error. | [
"findImageAPIVersion",
"finds",
"the",
"Image",
"API",
"version",
"number",
".",
"It",
"first",
"checks",
"whether",
"the",
"given",
"imageEndpoint",
"has",
"version",
"info",
".",
"If",
"it",
"is",
"not",
"then",
"a",
"Get",
"request",
"is",
"sent",
"to",
"imageEndpoint",
"to",
"fetch",
"supported",
"APIs",
".",
"If",
"any",
"V2",
"api",
"is",
"supported",
"then",
"it",
"returns",
"2",
"else",
"If",
"any",
"V1",
"api",
"is",
"supported",
"then",
"it",
"returns",
"1",
".",
"Otherwise",
"it",
"returns",
"an",
"error",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L117-L157 | train |
apcera/libretto | virtualmachine/openstack/util.go | reserveImage | func reserveImage(tokenID string, imageEndpoint string, imageMetadata ImageMetadata, imageApiVersion int) (string, error) {
// Form the URI to create the image
imagesURI := ""
if imageVersionEncoded(imageEndpoint) {
imagesURI = fmt.Sprintf("%simages", imageEndpoint)
} else {
imagesURI = fmt.Sprintf("%sv%d/images", imageEndpoint, imageApiVersion)
}
// Prepare the request to create the image
var createReq *http.Request
var err error
if imageApiVersion == 1 {
createReq, err = http.NewRequest("POST", imagesURI, nil)
} else {
imageStr, imgErr := json.Marshal(imageMetadata)
if imgErr != nil {
return "", imgErr
}
createReq, err = http.NewRequest("POST", imagesURI, bytes.NewBuffer(imageStr))
}
if err != nil {
return "", err
}
createReq.Header.Add("X-Auth-Token", tokenID)
if imageApiVersion == 1 {
createReq.Header.Add("Content-Type", "application/octet-stream")
createReq.Header.Add("X-Image-Meta-Name", imageMetadata.Name)
createReq.Header.Add("X-Image-Meta-container_format", imageMetadata.ContainerFormat)
createReq.Header.Add("X-Image-Meta-disk_format", imageMetadata.DiskFormat)
createReq.Header.Add("X-Image-Meta-min_disk", strconv.Itoa(imageMetadata.MinDisk))
createReq.Header.Add("X-Image-Meta-min_ram", strconv.Itoa(imageMetadata.MinRAM))
} else {
createReq.Header.Add("Content-Type", "application/json")
}
// Send the request to create the image
httpClient := &http.Client{}
resp, err := httpClient.Do(createReq)
if err != nil {
return "", fmt.Errorf("failed to send a image reserve request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
if resp.StatusCode != 201 {
return "", fmt.Errorf("reserve image request returned bad response, %s", string(body))
}
// Parse the result to see if image is created
var dat map[string]interface{}
if err := json.Unmarshal(body, &dat); err != nil {
return "", err
}
if imageApiVersion == 1 {
dat = dat["image"].(map[string]interface{})
}
if dat["status"] != imageQueued {
return "", fmt.Errorf("image has never been created")
}
// Retrieve the image ID from http response block
idFromResponse := dat["id"]
switch idFromResponse.(type) {
case string:
return idFromResponse.(string), nil
default:
return "", fmt.Errorf("unable to parse the upload image response")
}
} | go | func reserveImage(tokenID string, imageEndpoint string, imageMetadata ImageMetadata, imageApiVersion int) (string, error) {
// Form the URI to create the image
imagesURI := ""
if imageVersionEncoded(imageEndpoint) {
imagesURI = fmt.Sprintf("%simages", imageEndpoint)
} else {
imagesURI = fmt.Sprintf("%sv%d/images", imageEndpoint, imageApiVersion)
}
// Prepare the request to create the image
var createReq *http.Request
var err error
if imageApiVersion == 1 {
createReq, err = http.NewRequest("POST", imagesURI, nil)
} else {
imageStr, imgErr := json.Marshal(imageMetadata)
if imgErr != nil {
return "", imgErr
}
createReq, err = http.NewRequest("POST", imagesURI, bytes.NewBuffer(imageStr))
}
if err != nil {
return "", err
}
createReq.Header.Add("X-Auth-Token", tokenID)
if imageApiVersion == 1 {
createReq.Header.Add("Content-Type", "application/octet-stream")
createReq.Header.Add("X-Image-Meta-Name", imageMetadata.Name)
createReq.Header.Add("X-Image-Meta-container_format", imageMetadata.ContainerFormat)
createReq.Header.Add("X-Image-Meta-disk_format", imageMetadata.DiskFormat)
createReq.Header.Add("X-Image-Meta-min_disk", strconv.Itoa(imageMetadata.MinDisk))
createReq.Header.Add("X-Image-Meta-min_ram", strconv.Itoa(imageMetadata.MinRAM))
} else {
createReq.Header.Add("Content-Type", "application/json")
}
// Send the request to create the image
httpClient := &http.Client{}
resp, err := httpClient.Do(createReq)
if err != nil {
return "", fmt.Errorf("failed to send a image reserve request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
if resp.StatusCode != 201 {
return "", fmt.Errorf("reserve image request returned bad response, %s", string(body))
}
// Parse the result to see if image is created
var dat map[string]interface{}
if err := json.Unmarshal(body, &dat); err != nil {
return "", err
}
if imageApiVersion == 1 {
dat = dat["image"].(map[string]interface{})
}
if dat["status"] != imageQueued {
return "", fmt.Errorf("image has never been created")
}
// Retrieve the image ID from http response block
idFromResponse := dat["id"]
switch idFromResponse.(type) {
case string:
return idFromResponse.(string), nil
default:
return "", fmt.Errorf("unable to parse the upload image response")
}
} | [
"func",
"reserveImage",
"(",
"tokenID",
"string",
",",
"imageEndpoint",
"string",
",",
"imageMetadata",
"ImageMetadata",
",",
"imageApiVersion",
"int",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Form the URI to create the image",
"imagesURI",
":=",
"\"",
"\"",
"\n",
"if",
"imageVersionEncoded",
"(",
"imageEndpoint",
")",
"{",
"imagesURI",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"imageEndpoint",
")",
"\n",
"}",
"else",
"{",
"imagesURI",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"imageEndpoint",
",",
"imageApiVersion",
")",
"\n",
"}",
"\n\n",
"// Prepare the request to create the image",
"var",
"createReq",
"*",
"http",
".",
"Request",
"\n",
"var",
"err",
"error",
"\n",
"if",
"imageApiVersion",
"==",
"1",
"{",
"createReq",
",",
"err",
"=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"imagesURI",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"imageStr",
",",
"imgErr",
":=",
"json",
".",
"Marshal",
"(",
"imageMetadata",
")",
"\n",
"if",
"imgErr",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"imgErr",
"\n",
"}",
"\n\n",
"createReq",
",",
"err",
"=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"imagesURI",
",",
"bytes",
".",
"NewBuffer",
"(",
"imageStr",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"tokenID",
")",
"\n",
"if",
"imageApiVersion",
"==",
"1",
"{",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"imageMetadata",
".",
"Name",
")",
"\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"imageMetadata",
".",
"ContainerFormat",
")",
"\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"imageMetadata",
".",
"DiskFormat",
")",
"\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"imageMetadata",
".",
"MinDisk",
")",
")",
"\n",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"imageMetadata",
".",
"MinRAM",
")",
")",
"\n",
"}",
"else",
"{",
"createReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Send the request to create the image",
"httpClient",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n",
"resp",
",",
"err",
":=",
"httpClient",
".",
"Do",
"(",
"createReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"201",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"body",
")",
")",
"\n",
"}",
"\n\n",
"// Parse the result to see if image is created",
"var",
"dat",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"dat",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"imageApiVersion",
"==",
"1",
"{",
"dat",
"=",
"dat",
"[",
"\"",
"\"",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"dat",
"[",
"\"",
"\"",
"]",
"!=",
"imageQueued",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Retrieve the image ID from http response block",
"idFromResponse",
":=",
"dat",
"[",
"\"",
"\"",
"]",
"\n",
"switch",
"idFromResponse",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"return",
"idFromResponse",
".",
"(",
"string",
")",
",",
"nil",
"\n",
"default",
":",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // Reserves an Image ID at the specified image endpoint using the information in given imageMetadata
// Returns the reserved Image ID if reservation is successful, otherwise returns an error.
// Requires client's token to reserve the image. | [
"Reserves",
"an",
"Image",
"ID",
"at",
"the",
"specified",
"image",
"endpoint",
"using",
"the",
"information",
"in",
"given",
"imageMetadata",
"Returns",
"the",
"reserved",
"Image",
"ID",
"if",
"reservation",
"is",
"successful",
"otherwise",
"returns",
"an",
"error",
".",
"Requires",
"client",
"s",
"token",
"to",
"reserve",
"the",
"image",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L169-L241 | train |
apcera/libretto | virtualmachine/openstack/util.go | uploadImage | func uploadImage(tokenID string, imageEndpoint string, imageID string, imagePath string, imageApiVersion int) error {
// Read the image file
file, err := os.Open(imagePath)
if err != nil {
return fmt.Errorf("unable to open image file")
}
defer file.Close()
stat, err := file.Stat()
if err != nil {
return fmt.Errorf("unable to get the stats of the image file: %s", err)
}
imageFileSize := stat.Size()
// Prepare the request to upload the image file
imageLocation := ""
if imageVersionEncoded(imageEndpoint) {
imageLocation = fmt.Sprintf("%simages/%s", imageEndpoint, imageID)
} else {
imageLocation = fmt.Sprintf("%sv%d/images/%s", imageEndpoint, imageApiVersion, imageID)
}
if imageApiVersion == 2 {
imageLocation += "/file"
}
uploadReq, err := http.NewRequest("PUT", imageLocation, file)
if err != nil {
return fmt.Errorf("unable to upload image to the openstack")
}
uploadReq.Header.Add("Content-Type", "application/octet-stream")
uploadReq.Header.Add("X-Auth-Token", tokenID)
uploadReq.Header.Add("Content-Length", fmt.Sprintf("%d", imageFileSize))
uploadClient := &http.Client{}
// Send the request to upload the image
resp, err := uploadClient.Do(uploadReq)
if err != nil {
return fmt.Errorf("failed to send a upload image request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
if (imageApiVersion == 1 && resp.StatusCode != http.StatusOK) ||
(imageApiVersion == 2 && resp.StatusCode != http.StatusNoContent) {
return fmt.Errorf("upload image request returned bad response, %s", string(body))
}
return nil
} | go | func uploadImage(tokenID string, imageEndpoint string, imageID string, imagePath string, imageApiVersion int) error {
// Read the image file
file, err := os.Open(imagePath)
if err != nil {
return fmt.Errorf("unable to open image file")
}
defer file.Close()
stat, err := file.Stat()
if err != nil {
return fmt.Errorf("unable to get the stats of the image file: %s", err)
}
imageFileSize := stat.Size()
// Prepare the request to upload the image file
imageLocation := ""
if imageVersionEncoded(imageEndpoint) {
imageLocation = fmt.Sprintf("%simages/%s", imageEndpoint, imageID)
} else {
imageLocation = fmt.Sprintf("%sv%d/images/%s", imageEndpoint, imageApiVersion, imageID)
}
if imageApiVersion == 2 {
imageLocation += "/file"
}
uploadReq, err := http.NewRequest("PUT", imageLocation, file)
if err != nil {
return fmt.Errorf("unable to upload image to the openstack")
}
uploadReq.Header.Add("Content-Type", "application/octet-stream")
uploadReq.Header.Add("X-Auth-Token", tokenID)
uploadReq.Header.Add("Content-Length", fmt.Sprintf("%d", imageFileSize))
uploadClient := &http.Client{}
// Send the request to upload the image
resp, err := uploadClient.Do(uploadReq)
if err != nil {
return fmt.Errorf("failed to send a upload image request")
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
if (imageApiVersion == 1 && resp.StatusCode != http.StatusOK) ||
(imageApiVersion == 2 && resp.StatusCode != http.StatusNoContent) {
return fmt.Errorf("upload image request returned bad response, %s", string(body))
}
return nil
} | [
"func",
"uploadImage",
"(",
"tokenID",
"string",
",",
"imageEndpoint",
"string",
",",
"imageID",
"string",
",",
"imagePath",
"string",
",",
"imageApiVersion",
"int",
")",
"error",
"{",
"// Read the image file",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"imagePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n\n",
"stat",
",",
"err",
":=",
"file",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"imageFileSize",
":=",
"stat",
".",
"Size",
"(",
")",
"\n\n",
"// Prepare the request to upload the image file",
"imageLocation",
":=",
"\"",
"\"",
"\n",
"if",
"imageVersionEncoded",
"(",
"imageEndpoint",
")",
"{",
"imageLocation",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"imageEndpoint",
",",
"imageID",
")",
"\n",
"}",
"else",
"{",
"imageLocation",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"imageEndpoint",
",",
"imageApiVersion",
",",
"imageID",
")",
"\n",
"}",
"\n",
"if",
"imageApiVersion",
"==",
"2",
"{",
"imageLocation",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"uploadReq",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"imageLocation",
",",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"uploadReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"uploadReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"tokenID",
")",
"\n",
"uploadReq",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"imageFileSize",
")",
")",
"\n\n",
"uploadClient",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n\n",
"// Send the request to upload the image",
"resp",
",",
"err",
":=",
"uploadClient",
".",
"Do",
"(",
"uploadReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"(",
"imageApiVersion",
"==",
"1",
"&&",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
")",
"||",
"(",
"imageApiVersion",
"==",
"2",
"&&",
"resp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusNoContent",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"body",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Uploads the image to an reserved image location at the imageEndpoint using the reserved image ID and imageMetadata.
// Returns nil error if the upload is successful, otherwise returns an error.
// Requires client's token to upload the image. | [
"Uploads",
"the",
"image",
"to",
"an",
"reserved",
"image",
"location",
"at",
"the",
"imageEndpoint",
"using",
"the",
"reserved",
"image",
"ID",
"and",
"imageMetadata",
".",
"Returns",
"nil",
"error",
"if",
"the",
"upload",
"is",
"successful",
"otherwise",
"returns",
"an",
"error",
".",
"Requires",
"client",
"s",
"token",
"to",
"upload",
"the",
"image",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L246-L296 | train |
apcera/libretto | virtualmachine/openstack/util.go | createImage | func createImage(vm *VM) (string, error) {
// Get the openstack provider
provider, err := getProviderClient(vm)
if err != nil {
return "", ErrAuthenticatingClient
}
endpointOpts := gophercloud.EndpointOpts{
Region: vm.Region,
}
// Find the Image Endpoint to upload the image
imageEndpoint, err := findImageEndpoint(provider, endpointOpts)
if err != nil {
return "", err
}
// Find the Image API version number
version, err := findImageAPIVersion(provider.TokenID, imageEndpoint)
if err != nil {
return "", err
}
// Reserve an ImageID at imageEndpoint using the given image metadata
imageID, err := reserveImage(provider.TokenID, imageEndpoint, vm.ImageMetadata, version)
if err != nil {
return "", err
}
// Upload the image to the imageEndpoint with reserved ImageID using the given image path
err = uploadImage(provider.TokenID, imageEndpoint, imageID, vm.ImagePath, version)
if err != nil {
return "", err
}
return imageID, nil
} | go | func createImage(vm *VM) (string, error) {
// Get the openstack provider
provider, err := getProviderClient(vm)
if err != nil {
return "", ErrAuthenticatingClient
}
endpointOpts := gophercloud.EndpointOpts{
Region: vm.Region,
}
// Find the Image Endpoint to upload the image
imageEndpoint, err := findImageEndpoint(provider, endpointOpts)
if err != nil {
return "", err
}
// Find the Image API version number
version, err := findImageAPIVersion(provider.TokenID, imageEndpoint)
if err != nil {
return "", err
}
// Reserve an ImageID at imageEndpoint using the given image metadata
imageID, err := reserveImage(provider.TokenID, imageEndpoint, vm.ImageMetadata, version)
if err != nil {
return "", err
}
// Upload the image to the imageEndpoint with reserved ImageID using the given image path
err = uploadImage(provider.TokenID, imageEndpoint, imageID, vm.ImagePath, version)
if err != nil {
return "", err
}
return imageID, nil
} | [
"func",
"createImage",
"(",
"vm",
"*",
"VM",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Get the openstack provider",
"provider",
",",
"err",
":=",
"getProviderClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"ErrAuthenticatingClient",
"\n",
"}",
"\n\n",
"endpointOpts",
":=",
"gophercloud",
".",
"EndpointOpts",
"{",
"Region",
":",
"vm",
".",
"Region",
",",
"}",
"\n",
"// Find the Image Endpoint to upload the image",
"imageEndpoint",
",",
"err",
":=",
"findImageEndpoint",
"(",
"provider",
",",
"endpointOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Find the Image API version number",
"version",
",",
"err",
":=",
"findImageAPIVersion",
"(",
"provider",
".",
"TokenID",
",",
"imageEndpoint",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Reserve an ImageID at imageEndpoint using the given image metadata",
"imageID",
",",
"err",
":=",
"reserveImage",
"(",
"provider",
".",
"TokenID",
",",
"imageEndpoint",
",",
"vm",
".",
"ImageMetadata",
",",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Upload the image to the imageEndpoint with reserved ImageID using the given image path",
"err",
"=",
"uploadImage",
"(",
"provider",
".",
"TokenID",
",",
"imageEndpoint",
",",
"imageID",
",",
"vm",
".",
"ImagePath",
",",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"imageID",
",",
"nil",
"\n",
"}"
] | // Creates an Image based on the given FilePath and returns the UUID of the image | [
"Creates",
"an",
"Image",
"based",
"on",
"the",
"given",
"FilePath",
"and",
"returns",
"the",
"UUID",
"of",
"the",
"image"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L299-L334 | train |
apcera/libretto | virtualmachine/openstack/util.go | getServer | func getServer(vm *VM) (*servers.Server, error) {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return nil, ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return nil, err
}
status, err := servers.Get(client, vm.InstanceID).Extract()
if status != nil && err != nil {
return nil, fmt.Errorf("failed to retrieve the server for VM")
}
return status, nil
} | go | func getServer(vm *VM) (*servers.Server, error) {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return nil, ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return nil, err
}
status, err := servers.Get(client, vm.InstanceID).Extract()
if status != nil && err != nil {
return nil, fmt.Errorf("failed to retrieve the server for VM")
}
return status, nil
} | [
"func",
"getServer",
"(",
"vm",
"*",
"VM",
")",
"(",
"*",
"servers",
".",
"Server",
",",
"error",
")",
"{",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"nil",
",",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"client",
",",
"err",
":=",
"getComputeClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"status",
",",
"err",
":=",
"servers",
".",
"Get",
"(",
"client",
",",
"vm",
".",
"InstanceID",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"status",
"!=",
"nil",
"&&",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"status",
",",
"nil",
"\n",
"}"
] | // getServer returns the Openstack server object for the VM. An error is returned
// if the instance ID is missing, if there was a problem querying Openstack, or if
// there is no instances with the given VM ID. | [
"getServer",
"returns",
"the",
"Openstack",
"server",
"object",
"for",
"the",
"VM",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"instance",
"ID",
"is",
"missing",
"if",
"there",
"was",
"a",
"problem",
"querying",
"Openstack",
"or",
"if",
"there",
"is",
"no",
"instances",
"with",
"the",
"given",
"VM",
"ID",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L339-L356 | train |
apcera/libretto | virtualmachine/openstack/util.go | findImageEndpoint | func findImageEndpoint(client *gophercloud.ProviderClient, eo gophercloud.EndpointOpts) (string, error) {
eo.ApplyDefaults("image")
url, err := client.EndpointLocator(eo)
if err != nil {
return "", fmt.Errorf("error on locating image endpoint")
}
return url, nil
} | go | func findImageEndpoint(client *gophercloud.ProviderClient, eo gophercloud.EndpointOpts) (string, error) {
eo.ApplyDefaults("image")
url, err := client.EndpointLocator(eo)
if err != nil {
return "", fmt.Errorf("error on locating image endpoint")
}
return url, nil
} | [
"func",
"findImageEndpoint",
"(",
"client",
"*",
"gophercloud",
".",
"ProviderClient",
",",
"eo",
"gophercloud",
".",
"EndpointOpts",
")",
"(",
"string",
",",
"error",
")",
"{",
"eo",
".",
"ApplyDefaults",
"(",
"\"",
"\"",
")",
"\n",
"url",
",",
"err",
":=",
"client",
".",
"EndpointLocator",
"(",
"eo",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"url",
",",
"nil",
"\n",
"}"
] | // Finds the image endpoint in the given openstack Region. Region is passed within gophercloud.EndpointOpts | [
"Finds",
"the",
"image",
"endpoint",
"in",
"the",
"given",
"openstack",
"Region",
".",
"Region",
"is",
"passed",
"within",
"gophercloud",
".",
"EndpointOpts"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L359-L366 | train |
apcera/libretto | virtualmachine/openstack/util.go | waitUntil | func waitUntil(vm *VM, state string) error {
var curState string
var err error
for i := 0; i < ActionTimeout; i++ {
curState, err = vm.GetState()
if err != nil {
return err
}
if curState == state {
break
}
if curState == lvm.VMError {
return fmt.Errorf("failed to bring the VM to state: %s", state)
}
time.Sleep(1 * time.Second)
}
if curState != state {
return ErrActionTimeout
}
return nil
} | go | func waitUntil(vm *VM, state string) error {
var curState string
var err error
for i := 0; i < ActionTimeout; i++ {
curState, err = vm.GetState()
if err != nil {
return err
}
if curState == state {
break
}
if curState == lvm.VMError {
return fmt.Errorf("failed to bring the VM to state: %s", state)
}
time.Sleep(1 * time.Second)
}
if curState != state {
return ErrActionTimeout
}
return nil
} | [
"func",
"waitUntil",
"(",
"vm",
"*",
"VM",
",",
"state",
"string",
")",
"error",
"{",
"var",
"curState",
"string",
"\n",
"var",
"err",
"error",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"ActionTimeout",
";",
"i",
"++",
"{",
"curState",
",",
"err",
"=",
"vm",
".",
"GetState",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"curState",
"==",
"state",
"{",
"break",
"\n",
"}",
"\n\n",
"if",
"curState",
"==",
"lvm",
".",
"VMError",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"state",
")",
"\n",
"}",
"\n\n",
"time",
".",
"Sleep",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"if",
"curState",
"!=",
"state",
"{",
"return",
"ErrActionTimeout",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Waits until the given VM becomes in requested state in given ActionTimeout seconds | [
"Waits",
"until",
"the",
"given",
"VM",
"becomes",
"in",
"requested",
"state",
"in",
"given",
"ActionTimeout",
"seconds"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L369-L392 | train |
apcera/libretto | virtualmachine/openstack/util.go | waitUntilSSHReady | func waitUntilSSHReady(vm *VM) error {
client, err := vm.GetSSH(ssh.Options{})
if err != nil {
return err
}
return client.WaitForSSH(SSHTimeout)
} | go | func waitUntilSSHReady(vm *VM) error {
client, err := vm.GetSSH(ssh.Options{})
if err != nil {
return err
}
return client.WaitForSSH(SSHTimeout)
} | [
"func",
"waitUntilSSHReady",
"(",
"vm",
"*",
"VM",
")",
"error",
"{",
"client",
",",
"err",
":=",
"vm",
".",
"GetSSH",
"(",
"ssh",
".",
"Options",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"client",
".",
"WaitForSSH",
"(",
"SSHTimeout",
")",
"\n",
"}"
] | // Waits until the given VM becomes ready. Basically, waits until vm can be sshed. | [
"Waits",
"until",
"the",
"given",
"VM",
"becomes",
"ready",
".",
"Basically",
"waits",
"until",
"vm",
"can",
"be",
"sshed",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L395-L401 | train |
apcera/libretto | virtualmachine/openstack/util.go | createAndAttachVolume | func createAndAttachVolume(vm *VM) error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
cClient, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
bsClient, err := getBlockStorageClient(vm)
if err != nil {
return err
}
// Creates a new Volume for this VM
volume := vm.Volume
vOpts := volumes.CreateOpts{Size: volume.Size, Name: volume.Name, VolumeType: volume.Type}
vol, err := volumes.Create(bsClient, vOpts).Extract()
if err != nil {
return fmt.Errorf("failed to create a new volume for the VM: %s", err)
}
// Cleanup the volume if something goes wrong
var cleanup = func(err error) error {
if errDeleteVolume := volumes.Delete(bsClient, vol.ID).ExtractErr(); errDeleteVolume != nil {
return fmt.Errorf("%s %s", err, errDeleteVolume)
}
return err
}
// Wait until Volume becomes available
err = waitUntilVolume(bsClient, vol.ID, volumeStateAvailable)
if err != nil {
return cleanup(fmt.Errorf("failed to create a new volume for the VM: %s", err))
}
// Attach the new volume to this VM
vaOpts := volumeattach.CreateOpts{Device: volume.Device, VolumeID: vol.ID}
va, err := volumeattach.Create(cClient, vm.InstanceID, vaOpts).Extract()
if err != nil {
return cleanup(fmt.Errorf("failed to attach the volume to the VM: %s", err))
}
// Wait until Volume is attached to the VM
err = waitUntilVolume(bsClient, vol.ID, volumeStateInUse)
if err != nil {
errVaDelete := volumeattach.Delete(cClient, vm.InstanceID, vol.ID).ExtractErr()
err = fmt.Errorf("%s %s", err, errVaDelete)
return cleanup(fmt.Errorf("failed to attach the volume to the VM: %s", err))
}
vm.Volume.ID = vol.ID
vm.Volume.Device = va.Device
return nil
} | go | func createAndAttachVolume(vm *VM) error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
cClient, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
bsClient, err := getBlockStorageClient(vm)
if err != nil {
return err
}
// Creates a new Volume for this VM
volume := vm.Volume
vOpts := volumes.CreateOpts{Size: volume.Size, Name: volume.Name, VolumeType: volume.Type}
vol, err := volumes.Create(bsClient, vOpts).Extract()
if err != nil {
return fmt.Errorf("failed to create a new volume for the VM: %s", err)
}
// Cleanup the volume if something goes wrong
var cleanup = func(err error) error {
if errDeleteVolume := volumes.Delete(bsClient, vol.ID).ExtractErr(); errDeleteVolume != nil {
return fmt.Errorf("%s %s", err, errDeleteVolume)
}
return err
}
// Wait until Volume becomes available
err = waitUntilVolume(bsClient, vol.ID, volumeStateAvailable)
if err != nil {
return cleanup(fmt.Errorf("failed to create a new volume for the VM: %s", err))
}
// Attach the new volume to this VM
vaOpts := volumeattach.CreateOpts{Device: volume.Device, VolumeID: vol.ID}
va, err := volumeattach.Create(cClient, vm.InstanceID, vaOpts).Extract()
if err != nil {
return cleanup(fmt.Errorf("failed to attach the volume to the VM: %s", err))
}
// Wait until Volume is attached to the VM
err = waitUntilVolume(bsClient, vol.ID, volumeStateInUse)
if err != nil {
errVaDelete := volumeattach.Delete(cClient, vm.InstanceID, vol.ID).ExtractErr()
err = fmt.Errorf("%s %s", err, errVaDelete)
return cleanup(fmt.Errorf("failed to attach the volume to the VM: %s", err))
}
vm.Volume.ID = vol.ID
vm.Volume.Device = va.Device
return nil
} | [
"func",
"createAndAttachVolume",
"(",
"vm",
"*",
"VM",
")",
"error",
"{",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"cClient",
",",
"err",
":=",
"getComputeClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"bsClient",
",",
"err",
":=",
"getBlockStorageClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Creates a new Volume for this VM",
"volume",
":=",
"vm",
".",
"Volume",
"\n",
"vOpts",
":=",
"volumes",
".",
"CreateOpts",
"{",
"Size",
":",
"volume",
".",
"Size",
",",
"Name",
":",
"volume",
".",
"Name",
",",
"VolumeType",
":",
"volume",
".",
"Type",
"}",
"\n",
"vol",
",",
"err",
":=",
"volumes",
".",
"Create",
"(",
"bsClient",
",",
"vOpts",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Cleanup the volume if something goes wrong",
"var",
"cleanup",
"=",
"func",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"errDeleteVolume",
":=",
"volumes",
".",
"Delete",
"(",
"bsClient",
",",
"vol",
".",
"ID",
")",
".",
"ExtractErr",
"(",
")",
";",
"errDeleteVolume",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"errDeleteVolume",
")",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Wait until Volume becomes available",
"err",
"=",
"waitUntilVolume",
"(",
"bsClient",
",",
"vol",
".",
"ID",
",",
"volumeStateAvailable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"cleanup",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// Attach the new volume to this VM",
"vaOpts",
":=",
"volumeattach",
".",
"CreateOpts",
"{",
"Device",
":",
"volume",
".",
"Device",
",",
"VolumeID",
":",
"vol",
".",
"ID",
"}",
"\n",
"va",
",",
"err",
":=",
"volumeattach",
".",
"Create",
"(",
"cClient",
",",
"vm",
".",
"InstanceID",
",",
"vaOpts",
")",
".",
"Extract",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"cleanup",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// Wait until Volume is attached to the VM",
"err",
"=",
"waitUntilVolume",
"(",
"bsClient",
",",
"vol",
".",
"ID",
",",
"volumeStateInUse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errVaDelete",
":=",
"volumeattach",
".",
"Delete",
"(",
"cClient",
",",
"vm",
".",
"InstanceID",
",",
"vol",
".",
"ID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"errVaDelete",
")",
"\n",
"return",
"cleanup",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n\n",
"vm",
".",
"Volume",
".",
"ID",
"=",
"vol",
".",
"ID",
"\n",
"vm",
".",
"Volume",
".",
"Device",
"=",
"va",
".",
"Device",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // createAndAttachVolume creates a new volume with the given volume specs and then attaches this volume to the given VM. | [
"createAndAttachVolume",
"creates",
"a",
"new",
"volume",
"with",
"the",
"given",
"volume",
"specs",
"and",
"then",
"attaches",
"this",
"volume",
"to",
"the",
"given",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L404-L462 | train |
apcera/libretto | virtualmachine/openstack/util.go | deattachAndDeleteVolume | func deattachAndDeleteVolume(vm *VM) error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
cClient, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
bsClient, err := getBlockStorageClient(vm)
if err != nil {
return err
}
// Deattach the volume from the VM
err = volumeattach.Delete(cClient, vm.InstanceID, vm.Volume.ID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to deattach volume from the VM: %s", err)
}
// Wait until Volume is de-attached from the VM
err = waitUntilVolume(bsClient, vm.Volume.ID, volumeStateAvailable)
if err != nil {
return fmt.Errorf("failed to deattach volume from the VM: %s", err)
}
// Delete the volume
err = volumes.Delete(bsClient, vm.Volume.ID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to delete volume: %s", err)
}
// Wait until Volume is deleted
err = waitUntilVolume(bsClient, vm.Volume.ID, volumeStateDeleted)
if err != nil {
return fmt.Errorf("failed to delete volume: %s", err)
}
return nil
} | go | func deattachAndDeleteVolume(vm *VM) error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
cClient, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
bsClient, err := getBlockStorageClient(vm)
if err != nil {
return err
}
// Deattach the volume from the VM
err = volumeattach.Delete(cClient, vm.InstanceID, vm.Volume.ID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to deattach volume from the VM: %s", err)
}
// Wait until Volume is de-attached from the VM
err = waitUntilVolume(bsClient, vm.Volume.ID, volumeStateAvailable)
if err != nil {
return fmt.Errorf("failed to deattach volume from the VM: %s", err)
}
// Delete the volume
err = volumes.Delete(bsClient, vm.Volume.ID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to delete volume: %s", err)
}
// Wait until Volume is deleted
err = waitUntilVolume(bsClient, vm.Volume.ID, volumeStateDeleted)
if err != nil {
return fmt.Errorf("failed to delete volume: %s", err)
}
return nil
} | [
"func",
"deattachAndDeleteVolume",
"(",
"vm",
"*",
"VM",
")",
"error",
"{",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"cClient",
",",
"err",
":=",
"getComputeClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"bsClient",
",",
"err",
":=",
"getBlockStorageClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Deattach the volume from the VM",
"err",
"=",
"volumeattach",
".",
"Delete",
"(",
"cClient",
",",
"vm",
".",
"InstanceID",
",",
"vm",
".",
"Volume",
".",
"ID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Wait until Volume is de-attached from the VM",
"err",
"=",
"waitUntilVolume",
"(",
"bsClient",
",",
"vm",
".",
"Volume",
".",
"ID",
",",
"volumeStateAvailable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Delete the volume",
"err",
"=",
"volumes",
".",
"Delete",
"(",
"bsClient",
",",
"vm",
".",
"Volume",
".",
"ID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Wait until Volume is deleted",
"err",
"=",
"waitUntilVolume",
"(",
"bsClient",
",",
"vm",
".",
"Volume",
".",
"ID",
",",
"volumeStateDeleted",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // deattachAndDeleteVolume deattaches the volume from the given VM and then completely deletes the volume. | [
"deattachAndDeleteVolume",
"deattaches",
"the",
"volume",
"from",
"the",
"given",
"VM",
"and",
"then",
"completely",
"deletes",
"the",
"volume",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L465-L506 | train |
apcera/libretto | virtualmachine/openstack/util.go | deleteVM | func deleteVM(client *gophercloud.ServiceClient, vmID string) error {
err := servers.Delete(client, vmID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to destroy vm %s: %s", vmID, err)
}
return nil
} | go | func deleteVM(client *gophercloud.ServiceClient, vmID string) error {
err := servers.Delete(client, vmID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to destroy vm %s: %s", vmID, err)
}
return nil
} | [
"func",
"deleteVM",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"vmID",
"string",
")",
"error",
"{",
"err",
":=",
"servers",
".",
"Delete",
"(",
"client",
",",
"vmID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vmID",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // deleteVM deletes the instance. | [
"deleteVM",
"deletes",
"the",
"instance",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L509-L515 | train |
apcera/libretto | virtualmachine/openstack/util.go | findImageIDByName | func findImageIDByName(client *gophercloud.ServiceClient, imageName string) (string, error) {
if imageName == "" {
return "", fmt.Errorf("empty image name")
}
// We have the option of filtering the image list. If we want the full
// collection, leave it as an empty struct
opts := images.ListOpts{Name: imageName}
// Retrieve image list
page, err := images.ListDetail(client, opts).AllPages()
if err != nil {
return "", fmt.Errorf("error on retrieving image pages: %s", err)
}
imageList, err := images.ExtractImages(page)
if err != nil {
return "", fmt.Errorf("error on extracting image list: %s", err)
}
if len(imageList) == 0 {
return "", nil
}
if len(imageList) > 1 {
return "", fmt.Errorf("there exists more than one image with the same name")
}
return imageList[0].ID, err
} | go | func findImageIDByName(client *gophercloud.ServiceClient, imageName string) (string, error) {
if imageName == "" {
return "", fmt.Errorf("empty image name")
}
// We have the option of filtering the image list. If we want the full
// collection, leave it as an empty struct
opts := images.ListOpts{Name: imageName}
// Retrieve image list
page, err := images.ListDetail(client, opts).AllPages()
if err != nil {
return "", fmt.Errorf("error on retrieving image pages: %s", err)
}
imageList, err := images.ExtractImages(page)
if err != nil {
return "", fmt.Errorf("error on extracting image list: %s", err)
}
if len(imageList) == 0 {
return "", nil
}
if len(imageList) > 1 {
return "", fmt.Errorf("there exists more than one image with the same name")
}
return imageList[0].ID, err
} | [
"func",
"findImageIDByName",
"(",
"client",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"imageName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"imageName",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We have the option of filtering the image list. If we want the full",
"// collection, leave it as an empty struct",
"opts",
":=",
"images",
".",
"ListOpts",
"{",
"Name",
":",
"imageName",
"}",
"\n\n",
"// Retrieve image list",
"page",
",",
"err",
":=",
"images",
".",
"ListDetail",
"(",
"client",
",",
"opts",
")",
".",
"AllPages",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"imageList",
",",
"err",
":=",
"images",
".",
"ExtractImages",
"(",
"page",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"imageList",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"imageList",
")",
">",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"imageList",
"[",
"0",
"]",
".",
"ID",
",",
"err",
"\n",
"}"
] | // findImageIDByName finds the ImageID for the given imageName, returns an error if there is
// no image or more than one image with the given Image Name. | [
"findImageIDByName",
"finds",
"the",
"ImageID",
"for",
"the",
"given",
"imageName",
"returns",
"an",
"error",
"if",
"there",
"is",
"no",
"image",
"or",
"more",
"than",
"one",
"image",
"with",
"the",
"given",
"Image",
"Name",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L519-L548 | train |
apcera/libretto | virtualmachine/openstack/util.go | waitUntilVolume | func waitUntilVolume(blockStorateClient *gophercloud.ServiceClient, volumeID string, state string) error {
for i := 0; i < VolumeActionTimeout; i++ {
vol, err := volumes.Get(blockStorateClient, volumeID).Extract()
switch {
case vol == nil && state == "nil":
return nil
case vol == nil || err != nil:
return fmt.Errorf("failed on getting volume Status: %s", err)
case vol.Status == state:
return nil
case vol.Status == lvm.VMError || vol.Status == volumeStateErrorDeleting:
return fmt.Errorf("failed to bring the volume to state %s, ended up at state %s", state, vol.Status)
}
time.Sleep(1 * time.Second)
}
return ErrActionTimeout
} | go | func waitUntilVolume(blockStorateClient *gophercloud.ServiceClient, volumeID string, state string) error {
for i := 0; i < VolumeActionTimeout; i++ {
vol, err := volumes.Get(blockStorateClient, volumeID).Extract()
switch {
case vol == nil && state == "nil":
return nil
case vol == nil || err != nil:
return fmt.Errorf("failed on getting volume Status: %s", err)
case vol.Status == state:
return nil
case vol.Status == lvm.VMError || vol.Status == volumeStateErrorDeleting:
return fmt.Errorf("failed to bring the volume to state %s, ended up at state %s", state, vol.Status)
}
time.Sleep(1 * time.Second)
}
return ErrActionTimeout
} | [
"func",
"waitUntilVolume",
"(",
"blockStorateClient",
"*",
"gophercloud",
".",
"ServiceClient",
",",
"volumeID",
"string",
",",
"state",
"string",
")",
"error",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"VolumeActionTimeout",
";",
"i",
"++",
"{",
"vol",
",",
"err",
":=",
"volumes",
".",
"Get",
"(",
"blockStorateClient",
",",
"volumeID",
")",
".",
"Extract",
"(",
")",
"\n",
"switch",
"{",
"case",
"vol",
"==",
"nil",
"&&",
"state",
"==",
"\"",
"\"",
":",
"return",
"nil",
"\n",
"case",
"vol",
"==",
"nil",
"||",
"err",
"!=",
"nil",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"case",
"vol",
".",
"Status",
"==",
"state",
":",
"return",
"nil",
"\n",
"case",
"vol",
".",
"Status",
"==",
"lvm",
".",
"VMError",
"||",
"vol",
".",
"Status",
"==",
"volumeStateErrorDeleting",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"state",
",",
"vol",
".",
"Status",
")",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"return",
"ErrActionTimeout",
"\n",
"}"
] | // waitUntilVolume waits until the given volume turns into given state under given VolumeActionTimeout seconds | [
"waitUntilVolume",
"waits",
"until",
"the",
"given",
"volume",
"turns",
"into",
"given",
"state",
"under",
"given",
"VolumeActionTimeout",
"seconds"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/util.go#L551-L567 | train |
apcera/libretto | virtualmachine/aws/util.go | ValidCredentials | func ValidCredentials(region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
_, err = svc.DescribeInstances(nil)
awsErr, isAWS := err.(awserr.Error)
if !isAWS {
return err
}
switch awsErr.Code() {
case noCredsCode:
return ErrNoCreds
case noRegionCode:
return ErrNoRegion
}
return nil
} | go | func ValidCredentials(region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
_, err = svc.DescribeInstances(nil)
awsErr, isAWS := err.(awserr.Error)
if !isAWS {
return err
}
switch awsErr.Code() {
case noCredsCode:
return ErrNoCreds
case noRegionCode:
return ErrNoRegion
}
return nil
} | [
"func",
"ValidCredentials",
"(",
"region",
"string",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"svc",
".",
"DescribeInstances",
"(",
"nil",
")",
"\n",
"awsErr",
",",
"isAWS",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
"\n",
"if",
"!",
"isAWS",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"switch",
"awsErr",
".",
"Code",
"(",
")",
"{",
"case",
"noCredsCode",
":",
"return",
"ErrNoCreds",
"\n",
"case",
"noRegionCode",
":",
"return",
"ErrNoRegion",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ValidCredentials sends a dummy request to AWS to check if credentials are
// valid. An error is returned if credentials are missing or region is missing. | [
"ValidCredentials",
"sends",
"a",
"dummy",
"request",
"to",
"AWS",
"to",
"check",
"if",
"credentials",
"are",
"valid",
".",
"An",
"error",
"is",
"returned",
"if",
"credentials",
"are",
"missing",
"or",
"region",
"is",
"missing",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/util.go#L36-L56 | train |
apcera/libretto | virtualmachine/aws/util.go | UploadKeyPair | func UploadKeyPair(publicKey []byte, name string, region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
_, err = svc.ImportKeyPair(&ec2.ImportKeyPairInput{
KeyName: aws.String(name),
PublicKeyMaterial: publicKey,
DryRun: aws.Bool(false),
})
if awsErr, isAWS := err.(awserr.Error); isAWS {
if awsErr.Code() != "InvalidKeyPair.Duplicate" {
return err
}
} else if err != nil {
return err
}
return nil
} | go | func UploadKeyPair(publicKey []byte, name string, region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
_, err = svc.ImportKeyPair(&ec2.ImportKeyPairInput{
KeyName: aws.String(name),
PublicKeyMaterial: publicKey,
DryRun: aws.Bool(false),
})
if awsErr, isAWS := err.(awserr.Error); isAWS {
if awsErr.Code() != "InvalidKeyPair.Duplicate" {
return err
}
} else if err != nil {
return err
}
return nil
} | [
"func",
"UploadKeyPair",
"(",
"publicKey",
"[",
"]",
"byte",
",",
"name",
"string",
",",
"region",
"string",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"svc",
".",
"ImportKeyPair",
"(",
"&",
"ec2",
".",
"ImportKeyPairInput",
"{",
"KeyName",
":",
"aws",
".",
"String",
"(",
"name",
")",
",",
"PublicKeyMaterial",
":",
"publicKey",
",",
"DryRun",
":",
"aws",
".",
"Bool",
"(",
"false",
")",
",",
"}",
")",
"\n",
"if",
"awsErr",
",",
"isAWS",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"isAWS",
"{",
"if",
"awsErr",
".",
"Code",
"(",
")",
"!=",
"\"",
"\"",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UploadKeyPair uploads the public key to AWS with a given name.
// If the public key already exists, then no error is returned. | [
"UploadKeyPair",
"uploads",
"the",
"public",
"key",
"to",
"AWS",
"with",
"a",
"given",
"name",
".",
"If",
"the",
"public",
"key",
"already",
"exists",
"then",
"no",
"error",
"is",
"returned",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/util.go#L247-L267 | train |
apcera/libretto | virtualmachine/aws/util.go | DeleteKeyPair | func DeleteKeyPair(name string, region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if name == "" {
return errors.New("Missing key pair name")
}
_, err = svc.DeleteKeyPair(&ec2.DeleteKeyPairInput{
KeyName: aws.String(name),
DryRun: aws.Bool(false),
})
if err != nil {
return fmt.Errorf("Failed to delete key pair: %s", err)
}
return nil
} | go | func DeleteKeyPair(name string, region string) error {
svc, err := getService(region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if name == "" {
return errors.New("Missing key pair name")
}
_, err = svc.DeleteKeyPair(&ec2.DeleteKeyPairInput{
KeyName: aws.String(name),
DryRun: aws.Bool(false),
})
if err != nil {
return fmt.Errorf("Failed to delete key pair: %s", err)
}
return nil
} | [
"func",
"DeleteKeyPair",
"(",
"name",
"string",
",",
"region",
"string",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"svc",
".",
"DeleteKeyPair",
"(",
"&",
"ec2",
".",
"DeleteKeyPairInput",
"{",
"KeyName",
":",
"aws",
".",
"String",
"(",
"name",
")",
",",
"DryRun",
":",
"aws",
".",
"Bool",
"(",
"false",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // DeleteKeyPair deletes the given key pair from the given region. | [
"DeleteKeyPair",
"deletes",
"the",
"given",
"key",
"pair",
"from",
"the",
"given",
"region",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/util.go#L270-L289 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | getBridgedDeviceKV | func getBridgedDeviceKV(keyname, propname string) ([]ifKeyValue, error) {
kvs := []ifKeyValue{}
if keyname == "" || propname == "" {
return kvs, nil
}
stdout, _, err := runner.Run("list", "bridgedifs")
if err != nil {
return kvs, err
}
matches := networkRegexp.FindAllString(stdout, -1)
if len(matches) < 1 {
return kvs, nil
}
keyid := strings.TrimSuffix(keyname, ":") + ":"
propid := strings.TrimSuffix(propname, ":") + ":"
// Each match is a device
for _, device := range matches {
var kv ifKeyValue
// Find the record that contains keyname and retrieve propname value.
for _, line := range strings.Split(device, "\n") {
if strings.Contains(line, keyid) {
kv.k = strings.TrimSpace(strings.TrimPrefix(line, keyid))
} else if strings.Contains(line, propid) {
kv.v = strings.TrimSpace(strings.TrimPrefix(line, propid))
}
if kv.k != "" && kv.v != "" {
kvs = append(kvs, kv)
break
}
}
}
return kvs, nil
} | go | func getBridgedDeviceKV(keyname, propname string) ([]ifKeyValue, error) {
kvs := []ifKeyValue{}
if keyname == "" || propname == "" {
return kvs, nil
}
stdout, _, err := runner.Run("list", "bridgedifs")
if err != nil {
return kvs, err
}
matches := networkRegexp.FindAllString(stdout, -1)
if len(matches) < 1 {
return kvs, nil
}
keyid := strings.TrimSuffix(keyname, ":") + ":"
propid := strings.TrimSuffix(propname, ":") + ":"
// Each match is a device
for _, device := range matches {
var kv ifKeyValue
// Find the record that contains keyname and retrieve propname value.
for _, line := range strings.Split(device, "\n") {
if strings.Contains(line, keyid) {
kv.k = strings.TrimSpace(strings.TrimPrefix(line, keyid))
} else if strings.Contains(line, propid) {
kv.v = strings.TrimSpace(strings.TrimPrefix(line, propid))
}
if kv.k != "" && kv.v != "" {
kvs = append(kvs, kv)
break
}
}
}
return kvs, nil
} | [
"func",
"getBridgedDeviceKV",
"(",
"keyname",
",",
"propname",
"string",
")",
"(",
"[",
"]",
"ifKeyValue",
",",
"error",
")",
"{",
"kvs",
":=",
"[",
"]",
"ifKeyValue",
"{",
"}",
"\n",
"if",
"keyname",
"==",
"\"",
"\"",
"||",
"propname",
"==",
"\"",
"\"",
"{",
"return",
"kvs",
",",
"nil",
"\n",
"}",
"\n\n",
"stdout",
",",
"_",
",",
"err",
":=",
"runner",
".",
"Run",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"kvs",
",",
"err",
"\n",
"}",
"\n",
"matches",
":=",
"networkRegexp",
".",
"FindAllString",
"(",
"stdout",
",",
"-",
"1",
")",
"\n",
"if",
"len",
"(",
"matches",
")",
"<",
"1",
"{",
"return",
"kvs",
",",
"nil",
"\n",
"}",
"\n\n",
"keyid",
":=",
"strings",
".",
"TrimSuffix",
"(",
"keyname",
",",
"\"",
"\"",
")",
"+",
"\"",
"\"",
"\n",
"propid",
":=",
"strings",
".",
"TrimSuffix",
"(",
"propname",
",",
"\"",
"\"",
")",
"+",
"\"",
"\"",
"\n",
"// Each match is a device",
"for",
"_",
",",
"device",
":=",
"range",
"matches",
"{",
"var",
"kv",
"ifKeyValue",
"\n",
"// Find the record that contains keyname and retrieve propname value.",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"device",
",",
"\"",
"\\n",
"\"",
")",
"{",
"if",
"strings",
".",
"Contains",
"(",
"line",
",",
"keyid",
")",
"{",
"kv",
".",
"k",
"=",
"strings",
".",
"TrimSpace",
"(",
"strings",
".",
"TrimPrefix",
"(",
"line",
",",
"keyid",
")",
")",
"\n",
"}",
"else",
"if",
"strings",
".",
"Contains",
"(",
"line",
",",
"propid",
")",
"{",
"kv",
".",
"v",
"=",
"strings",
".",
"TrimSpace",
"(",
"strings",
".",
"TrimPrefix",
"(",
"line",
",",
"propid",
")",
")",
"\n",
"}",
"\n",
"if",
"kv",
".",
"k",
"!=",
"\"",
"\"",
"&&",
"kv",
".",
"v",
"!=",
"\"",
"\"",
"{",
"kvs",
"=",
"append",
"(",
"kvs",
",",
"kv",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"kvs",
",",
"nil",
"\n",
"}"
] | // getBridgedDeviceKV returns a list of key and value pairs of chosen key and value names
// from VBoxManage list bridgedifs results. | [
"getBridgedDeviceKV",
"returns",
"a",
"list",
"of",
"key",
"and",
"value",
"pairs",
"of",
"chosen",
"key",
"and",
"value",
"names",
"from",
"VBoxManage",
"list",
"bridgedifs",
"results",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L21-L55 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | GetBridgedDeviceNameIPMap | func GetBridgedDeviceNameIPMap() (map[string]string, error) {
m := map[string]string{}
kvs, err := getBridgedDeviceKV("Name", "IPAddress")
if err != nil {
return m, err
}
for _, kv := range kvs {
if kv.k != "" {
m[kv.k] = kv.v
}
}
return m, nil
} | go | func GetBridgedDeviceNameIPMap() (map[string]string, error) {
m := map[string]string{}
kvs, err := getBridgedDeviceKV("Name", "IPAddress")
if err != nil {
return m, err
}
for _, kv := range kvs {
if kv.k != "" {
m[kv.k] = kv.v
}
}
return m, nil
} | [
"func",
"GetBridgedDeviceNameIPMap",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"kvs",
",",
"err",
":=",
"getBridgedDeviceKV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"m",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"kv",
":=",
"range",
"kvs",
"{",
"if",
"kv",
".",
"k",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"kv",
".",
"k",
"]",
"=",
"kv",
".",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // GetBridgedDeviceNameIPMap returns a map of network device
// name and its IP address from the list of bridgedifs reported
// by VirtualBox manager. | [
"GetBridgedDeviceNameIPMap",
"returns",
"a",
"map",
"of",
"network",
"device",
"name",
"and",
"its",
"IP",
"address",
"from",
"the",
"list",
"of",
"bridgedifs",
"reported",
"by",
"VirtualBox",
"manager",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L60-L72 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | GetBridgedDeviceName | func GetBridgedDeviceName(macAddr string) (string, error) {
stdout, _, err := runner.Run("list", "bridgedifs")
if err != nil {
return "", err
}
if matches := networkRegexp.FindAllString(stdout, -1); len(matches) > 0 {
// Each match is a device
for _, device := range matches {
var mac, name string
// Find the mac address and the name
for _, line := range strings.Split(device, "\n") {
if strings.Contains(line, "HardwareAddress") {
mac = strings.TrimSpace(strings.TrimPrefix(line, "HardwareAddress:"))
}
if strings.Contains(line, "Name:") {
name = strings.TrimSpace(strings.TrimPrefix(line, "Name:"))
}
}
if strings.Contains(macAddr, mac) {
return name, nil
}
}
}
return "", nil
} | go | func GetBridgedDeviceName(macAddr string) (string, error) {
stdout, _, err := runner.Run("list", "bridgedifs")
if err != nil {
return "", err
}
if matches := networkRegexp.FindAllString(stdout, -1); len(matches) > 0 {
// Each match is a device
for _, device := range matches {
var mac, name string
// Find the mac address and the name
for _, line := range strings.Split(device, "\n") {
if strings.Contains(line, "HardwareAddress") {
mac = strings.TrimSpace(strings.TrimPrefix(line, "HardwareAddress:"))
}
if strings.Contains(line, "Name:") {
name = strings.TrimSpace(strings.TrimPrefix(line, "Name:"))
}
}
if strings.Contains(macAddr, mac) {
return name, nil
}
}
}
return "", nil
} | [
"func",
"GetBridgedDeviceName",
"(",
"macAddr",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"stdout",
",",
"_",
",",
"err",
":=",
"runner",
".",
"Run",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"matches",
":=",
"networkRegexp",
".",
"FindAllString",
"(",
"stdout",
",",
"-",
"1",
")",
";",
"len",
"(",
"matches",
")",
">",
"0",
"{",
"// Each match is a device",
"for",
"_",
",",
"device",
":=",
"range",
"matches",
"{",
"var",
"mac",
",",
"name",
"string",
"\n",
"// Find the mac address and the name",
"for",
"_",
",",
"line",
":=",
"range",
"strings",
".",
"Split",
"(",
"device",
",",
"\"",
"\\n",
"\"",
")",
"{",
"if",
"strings",
".",
"Contains",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"mac",
"=",
"strings",
".",
"TrimSpace",
"(",
"strings",
".",
"TrimPrefix",
"(",
"line",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"name",
"=",
"strings",
".",
"TrimSpace",
"(",
"strings",
".",
"TrimPrefix",
"(",
"line",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"macAddr",
",",
"mac",
")",
"{",
"return",
"name",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}"
] | // GetBridgedDeviceName takes the mac address of a network device as a string
// and returns the name of the network device corresponding to it as seen by
// Virtualbox | [
"GetBridgedDeviceName",
"takes",
"the",
"mac",
"address",
"of",
"a",
"network",
"device",
"as",
"a",
"string",
"and",
"returns",
"the",
"name",
"of",
"the",
"network",
"device",
"corresponding",
"to",
"it",
"as",
"seen",
"by",
"Virtualbox"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L77-L101 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | GetBridgedDevices | func GetBridgedDevices() ([]string, error) {
deviceNames := []string{}
ifAndMac, err := getBridgedDeviceKV("Name", "HardwareAddress")
if err != nil {
return deviceNames, err
}
for _, kv := range ifAndMac {
if kv.k != "" && kv.v != "" {
deviceNames = append(deviceNames, kv.k)
}
}
return deviceNames, nil
} | go | func GetBridgedDevices() ([]string, error) {
deviceNames := []string{}
ifAndMac, err := getBridgedDeviceKV("Name", "HardwareAddress")
if err != nil {
return deviceNames, err
}
for _, kv := range ifAndMac {
if kv.k != "" && kv.v != "" {
deviceNames = append(deviceNames, kv.k)
}
}
return deviceNames, nil
} | [
"func",
"GetBridgedDevices",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"deviceNames",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"ifAndMac",
",",
"err",
":=",
"getBridgedDeviceKV",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"deviceNames",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"kv",
":=",
"range",
"ifAndMac",
"{",
"if",
"kv",
".",
"k",
"!=",
"\"",
"\"",
"&&",
"kv",
".",
"v",
"!=",
"\"",
"\"",
"{",
"deviceNames",
"=",
"append",
"(",
"deviceNames",
",",
"kv",
".",
"k",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"deviceNames",
",",
"nil",
"\n",
"}"
] | // GetBridgedDevices returns a slice of network devices that can be connected to VMs in bridged mode | [
"GetBridgedDevices",
"returns",
"a",
"slice",
"of",
"network",
"devices",
"that",
"can",
"be",
"connected",
"to",
"VMs",
"in",
"bridged",
"mode"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L104-L116 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | DeleteNIC | func DeleteNIC(vm *VM, nic NIC) error {
if nic.Backing == Disabled {
return lvm.ErrNICAlreadyDisabled
}
_, _, err := runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), "null")
return err
} | go | func DeleteNIC(vm *VM, nic NIC) error {
if nic.Backing == Disabled {
return lvm.ErrNICAlreadyDisabled
}
_, _, err := runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), "null")
return err
} | [
"func",
"DeleteNIC",
"(",
"vm",
"*",
"VM",
",",
"nic",
"NIC",
")",
"error",
"{",
"if",
"nic",
".",
"Backing",
"==",
"Disabled",
"{",
"return",
"lvm",
".",
"ErrNICAlreadyDisabled",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
":=",
"runner",
".",
"Run",
"(",
"\"",
"\"",
",",
"vm",
".",
"Name",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"nic",
".",
"Idx",
")",
",",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // DeleteNIC deletes the specified network interface on the vm. | [
"DeleteNIC",
"deletes",
"the",
"specified",
"network",
"interface",
"on",
"the",
"vm",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L228-L234 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | AddNIC | func AddNIC(vm *VM, nic NIC) error {
var err error
switch nic.Backing {
case Nat:
_, _, err = runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), getStringFromBacking(nic.Backing))
case Bridged:
_, _, err = runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), getStringFromBacking(nic.Backing), fmt.Sprintf("--bridgeadapter%d", nic.Idx), nic.BackingDevice)
}
return err
} | go | func AddNIC(vm *VM, nic NIC) error {
var err error
switch nic.Backing {
case Nat:
_, _, err = runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), getStringFromBacking(nic.Backing))
case Bridged:
_, _, err = runner.Run("modifyvm", vm.Name, fmt.Sprintf("--nic%d", nic.Idx), getStringFromBacking(nic.Backing), fmt.Sprintf("--bridgeadapter%d", nic.Idx), nic.BackingDevice)
}
return err
} | [
"func",
"AddNIC",
"(",
"vm",
"*",
"VM",
",",
"nic",
"NIC",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"switch",
"nic",
".",
"Backing",
"{",
"case",
"Nat",
":",
"_",
",",
"_",
",",
"err",
"=",
"runner",
".",
"Run",
"(",
"\"",
"\"",
",",
"vm",
".",
"Name",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"nic",
".",
"Idx",
")",
",",
"getStringFromBacking",
"(",
"nic",
".",
"Backing",
")",
")",
"\n",
"case",
"Bridged",
":",
"_",
",",
"_",
",",
"err",
"=",
"runner",
".",
"Run",
"(",
"\"",
"\"",
",",
"vm",
".",
"Name",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"nic",
".",
"Idx",
")",
",",
"getStringFromBacking",
"(",
"nic",
".",
"Backing",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"nic",
".",
"Idx",
")",
",",
"nic",
".",
"BackingDevice",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // AddNIC adds a NIC to the VM. | [
"AddNIC",
"adds",
"a",
"NIC",
"to",
"the",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L247-L256 | train |
apcera/libretto | virtualmachine/virtualbox/util.go | DeleteNICs | func DeleteNICs(vm *VM) error {
nics, err := vm.GetInterfaces()
if err != nil {
return lvm.ErrFailedToGetNICS
}
for _, nic := range nics {
if nic.Backing != Disabled {
err := DeleteNIC(vm, nic)
if err != nil {
return err
}
}
}
return nil
} | go | func DeleteNICs(vm *VM) error {
nics, err := vm.GetInterfaces()
if err != nil {
return lvm.ErrFailedToGetNICS
}
for _, nic := range nics {
if nic.Backing != Disabled {
err := DeleteNIC(vm, nic)
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"DeleteNICs",
"(",
"vm",
"*",
"VM",
")",
"error",
"{",
"nics",
",",
"err",
":=",
"vm",
".",
"GetInterfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"lvm",
".",
"ErrFailedToGetNICS",
"\n",
"}",
"\n",
"for",
"_",
",",
"nic",
":=",
"range",
"nics",
"{",
"if",
"nic",
".",
"Backing",
"!=",
"Disabled",
"{",
"err",
":=",
"DeleteNIC",
"(",
"vm",
",",
"nic",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteNICs disables all the network interfaces on the vm. | [
"DeleteNICs",
"disables",
"all",
"the",
"network",
"interfaces",
"on",
"the",
"vm",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/virtualbox/util.go#L259-L273 | train |
apcera/libretto | ssh/keys.go | NewKeyPair | func NewKeyPair() (keyPair *KeyPair, err error) {
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return nil, ErrKeyGeneration
}
if err := priv.Validate(); err != nil {
return nil, ErrValidation
}
privDer := x509.MarshalPKCS1PrivateKey(priv)
privateKey := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Headers: nil, Bytes: privDer})
pubSSH, err := gossh.NewPublicKey(&priv.PublicKey)
if err != nil {
return nil, ErrPublicKey
}
return &KeyPair{
PrivateKey: privateKey,
PublicKey: gossh.MarshalAuthorizedKey(pubSSH),
}, nil
} | go | func NewKeyPair() (keyPair *KeyPair, err error) {
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return nil, ErrKeyGeneration
}
if err := priv.Validate(); err != nil {
return nil, ErrValidation
}
privDer := x509.MarshalPKCS1PrivateKey(priv)
privateKey := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Headers: nil, Bytes: privDer})
pubSSH, err := gossh.NewPublicKey(&priv.PublicKey)
if err != nil {
return nil, ErrPublicKey
}
return &KeyPair{
PrivateKey: privateKey,
PublicKey: gossh.MarshalAuthorizedKey(pubSSH),
}, nil
} | [
"func",
"NewKeyPair",
"(",
")",
"(",
"keyPair",
"*",
"KeyPair",
",",
"err",
"error",
")",
"{",
"priv",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"2048",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrKeyGeneration",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"priv",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrValidation",
"\n",
"}",
"\n\n",
"privDer",
":=",
"x509",
".",
"MarshalPKCS1PrivateKey",
"(",
"priv",
")",
"\n",
"privateKey",
":=",
"pem",
".",
"EncodeToMemory",
"(",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Headers",
":",
"nil",
",",
"Bytes",
":",
"privDer",
"}",
")",
"\n",
"pubSSH",
",",
"err",
":=",
"gossh",
".",
"NewPublicKey",
"(",
"&",
"priv",
".",
"PublicKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrPublicKey",
"\n",
"}",
"\n\n",
"return",
"&",
"KeyPair",
"{",
"PrivateKey",
":",
"privateKey",
",",
"PublicKey",
":",
"gossh",
".",
"MarshalAuthorizedKey",
"(",
"pubSSH",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewKeyPair generates a new SSH keypair. This will return a private & public key encoded as DER. | [
"NewKeyPair",
"generates",
"a",
"new",
"SSH",
"keypair",
".",
"This",
"will",
"return",
"a",
"private",
"&",
"public",
"key",
"encoded",
"as",
"DER",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/keys.go#L22-L43 | train |
apcera/libretto | ssh/keys.go | ReadFromFile | func (kp *KeyPair) ReadFromFile(privateKeyPath string, publicKeyPath string) error {
b, err := ioutil.ReadFile(privateKeyPath)
if err != nil {
return err
}
kp.PrivateKey = b
b, err = ioutil.ReadFile(publicKeyPath)
if err != nil {
return err
}
kp.PublicKey = b
return nil
} | go | func (kp *KeyPair) ReadFromFile(privateKeyPath string, publicKeyPath string) error {
b, err := ioutil.ReadFile(privateKeyPath)
if err != nil {
return err
}
kp.PrivateKey = b
b, err = ioutil.ReadFile(publicKeyPath)
if err != nil {
return err
}
kp.PublicKey = b
return nil
} | [
"func",
"(",
"kp",
"*",
"KeyPair",
")",
"ReadFromFile",
"(",
"privateKeyPath",
"string",
",",
"publicKeyPath",
"string",
")",
"error",
"{",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"privateKeyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"kp",
".",
"PrivateKey",
"=",
"b",
"\n\n",
"b",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"publicKeyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"kp",
".",
"PublicKey",
"=",
"b",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ReadFromFile reads a keypair from files. | [
"ReadFromFile",
"reads",
"a",
"keypair",
"from",
"files",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/keys.go#L52-L66 | train |
apcera/libretto | ssh/keys.go | WriteToFile | func (kp *KeyPair) WriteToFile(privateKeyPath string, publicKeyPath string) error {
files := []struct {
File string
Type string
Value []byte
}{
{
File: privateKeyPath,
Value: kp.PrivateKey,
},
{
File: publicKeyPath,
Value: kp.PublicKey,
},
}
for _, v := range files {
f, err := os.Create(v.File)
if err != nil {
return ErrUnableToWriteFile
}
if _, err := f.Write(v.Value); err != nil {
return ErrUnableToWriteFile
}
// windows does not support chmod
switch runtime.GOOS {
case "darwin", "linux":
if err := f.Chmod(0600); err != nil {
return err
}
}
}
return nil
} | go | func (kp *KeyPair) WriteToFile(privateKeyPath string, publicKeyPath string) error {
files := []struct {
File string
Type string
Value []byte
}{
{
File: privateKeyPath,
Value: kp.PrivateKey,
},
{
File: publicKeyPath,
Value: kp.PublicKey,
},
}
for _, v := range files {
f, err := os.Create(v.File)
if err != nil {
return ErrUnableToWriteFile
}
if _, err := f.Write(v.Value); err != nil {
return ErrUnableToWriteFile
}
// windows does not support chmod
switch runtime.GOOS {
case "darwin", "linux":
if err := f.Chmod(0600); err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"kp",
"*",
"KeyPair",
")",
"WriteToFile",
"(",
"privateKeyPath",
"string",
",",
"publicKeyPath",
"string",
")",
"error",
"{",
"files",
":=",
"[",
"]",
"struct",
"{",
"File",
"string",
"\n",
"Type",
"string",
"\n",
"Value",
"[",
"]",
"byte",
"\n",
"}",
"{",
"{",
"File",
":",
"privateKeyPath",
",",
"Value",
":",
"kp",
".",
"PrivateKey",
",",
"}",
",",
"{",
"File",
":",
"publicKeyPath",
",",
"Value",
":",
"kp",
".",
"PublicKey",
",",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"files",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"v",
".",
"File",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ErrUnableToWriteFile",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"f",
".",
"Write",
"(",
"v",
".",
"Value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ErrUnableToWriteFile",
"\n",
"}",
"\n\n",
"// windows does not support chmod",
"switch",
"runtime",
".",
"GOOS",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"err",
":=",
"f",
".",
"Chmod",
"(",
"0600",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // WriteToFile writes a keypair to files | [
"WriteToFile",
"writes",
"a",
"keypair",
"to",
"files"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/keys.go#L69-L105 | train |
apcera/libretto | virtualmachine/aws/wait.go | Error | func (e ReadyError) Error() string {
return fmt.Sprintf(
"failed waiting for instance (%s) to be ready, reason was: %s",
e.InstanceID,
e.StateReason,
)
} | go | func (e ReadyError) Error() string {
return fmt.Sprintf(
"failed waiting for instance (%s) to be ready, reason was: %s",
e.InstanceID,
e.StateReason,
)
} | [
"func",
"(",
"e",
"ReadyError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"InstanceID",
",",
"e",
".",
"StateReason",
",",
")",
"\n",
"}"
] | // Error returns a summarized string version of ReadyError. More details about
// the failed instance can be accessed through the struct. | [
"Error",
"returns",
"a",
"summarized",
"string",
"version",
"of",
"ReadyError",
".",
"More",
"details",
"about",
"the",
"failed",
"instance",
"can",
"be",
"accessed",
"through",
"the",
"struct",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/wait.go#L31-L37 | train |
apcera/libretto | util/util.go | Random | func Random(min, max int) int {
if min == max {
return min
}
if max < min {
panic("max cannot be less than min")
}
rand.Seed(time.Now().UTC().UnixNano())
return rand.Intn(max-min+1) + min
} | go | func Random(min, max int) int {
if min == max {
return min
}
if max < min {
panic("max cannot be less than min")
}
rand.Seed(time.Now().UTC().UnixNano())
return rand.Intn(max-min+1) + min
} | [
"func",
"Random",
"(",
"min",
",",
"max",
"int",
")",
"int",
"{",
"if",
"min",
"==",
"max",
"{",
"return",
"min",
"\n",
"}",
"\n",
"if",
"max",
"<",
"min",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"rand",
".",
"Seed",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
"\n",
"return",
"rand",
".",
"Intn",
"(",
"max",
"-",
"min",
"+",
"1",
")",
"+",
"min",
"\n",
"}"
] | // Random generates a random number in between min and max
// If min equals max then min is returned. If max is less than min
// then the function panics. | [
"Random",
"generates",
"a",
"random",
"number",
"in",
"between",
"min",
"and",
"max",
"If",
"min",
"equals",
"max",
"then",
"min",
"is",
"returned",
".",
"If",
"max",
"is",
"less",
"than",
"min",
"then",
"the",
"function",
"panics",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/util/util.go#L19-L28 | train |
apcera/libretto | util/util.go | GetVMIPs | func GetVMIPs(vm lvm.VirtualMachine, options ssh.Options) ([]net.IP, error) {
ips := options.IPs
if len(ips) == 0 {
var err error
ips, err = vm.GetIPs()
if err != nil {
return nil, fmt.Errorf("Error getting IPs for the VM: %s", err)
}
if len(ips) == 0 {
return nil, lvm.ErrVMNoIP
}
}
return ips, nil
} | go | func GetVMIPs(vm lvm.VirtualMachine, options ssh.Options) ([]net.IP, error) {
ips := options.IPs
if len(ips) == 0 {
var err error
ips, err = vm.GetIPs()
if err != nil {
return nil, fmt.Errorf("Error getting IPs for the VM: %s", err)
}
if len(ips) == 0 {
return nil, lvm.ErrVMNoIP
}
}
return ips, nil
} | [
"func",
"GetVMIPs",
"(",
"vm",
"lvm",
".",
"VirtualMachine",
",",
"options",
"ssh",
".",
"Options",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"ips",
":=",
"options",
".",
"IPs",
"\n",
"if",
"len",
"(",
"ips",
")",
"==",
"0",
"{",
"var",
"err",
"error",
"\n",
"ips",
",",
"err",
"=",
"vm",
".",
"GetIPs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"ips",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"lvm",
".",
"ErrVMNoIP",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ips",
",",
"nil",
"\n",
"}"
] | // GetVMIPs returns the IPs associated with the given VM. If the IPs are present
// in options, they will be returned. Otherwise, an API call will be made to
// get the list of IPs. An error is returned if the API call fails or returns
// nothing. | [
"GetVMIPs",
"returns",
"the",
"IPs",
"associated",
"with",
"the",
"given",
"VM",
".",
"If",
"the",
"IPs",
"are",
"present",
"in",
"options",
"they",
"will",
"be",
"returned",
".",
"Otherwise",
"an",
"API",
"call",
"will",
"be",
"made",
"to",
"get",
"the",
"list",
"of",
"IPs",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"API",
"call",
"fails",
"or",
"returns",
"nothing",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/util/util.go#L34-L47 | train |
apcera/libretto | util/util.go | CombineErrors | func CombineErrors(delimiter string, errs ...error) error {
var formatStrs = []string{}
for _, e := range errs {
if e == nil {
continue
}
formatStrs = append(formatStrs, e.Error())
}
return fmt.Errorf(strings.Join(formatStrs, delimiter))
} | go | func CombineErrors(delimiter string, errs ...error) error {
var formatStrs = []string{}
for _, e := range errs {
if e == nil {
continue
}
formatStrs = append(formatStrs, e.Error())
}
return fmt.Errorf(strings.Join(formatStrs, delimiter))
} | [
"func",
"CombineErrors",
"(",
"delimiter",
"string",
",",
"errs",
"...",
"error",
")",
"error",
"{",
"var",
"formatStrs",
"=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"errs",
"{",
"if",
"e",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"formatStrs",
"=",
"append",
"(",
"formatStrs",
",",
"e",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"strings",
".",
"Join",
"(",
"formatStrs",
",",
"delimiter",
")",
")",
"\n",
"}"
] | // CombineErrors converts all the errors from slice into a single error | [
"CombineErrors",
"converts",
"all",
"the",
"errors",
"from",
"slice",
"into",
"a",
"single",
"error"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/util/util.go#L50-L61 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Progress | func (v VMwareLease) Progress(p int) {
v.Lease.Progress(v.Ctx, int32(p))
} | go | func (v VMwareLease) Progress(p int) {
v.Lease.Progress(v.Ctx, int32(p))
} | [
"func",
"(",
"v",
"VMwareLease",
")",
"Progress",
"(",
"p",
"int",
")",
"{",
"v",
".",
"Lease",
".",
"Progress",
"(",
"v",
".",
"Ctx",
",",
"int32",
"(",
"p",
")",
")",
"\n",
"}"
] | // Progress takes a percentage as an int and sets that percentage as the
// completed percent. | [
"Progress",
"takes",
"a",
"percentage",
"as",
"an",
"int",
"and",
"sets",
"that",
"percentage",
"as",
"the",
"completed",
"percent",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L51-L53 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Wait | func (v VMwareLease) Wait() (*nfc.LeaseInfo, error) {
return v.Lease.Wait(v.Ctx, nil)
} | go | func (v VMwareLease) Wait() (*nfc.LeaseInfo, error) {
return v.Lease.Wait(v.Ctx, nil)
} | [
"func",
"(",
"v",
"VMwareLease",
")",
"Wait",
"(",
")",
"(",
"*",
"nfc",
".",
"LeaseInfo",
",",
"error",
")",
"{",
"return",
"v",
".",
"Lease",
".",
"Wait",
"(",
"v",
".",
"Ctx",
",",
"nil",
")",
"\n",
"}"
] | // Wait waits for the underlying lease to finish. | [
"Wait",
"waits",
"for",
"the",
"underlying",
"lease",
"to",
"finish",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L56-L58 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Read | func (r ReadProgress) Read(p []byte) (n int, err error) {
n, err = r.Reader.Read(p)
if err != nil {
return
}
r.ch <- int64(n)
return
} | go | func (r ReadProgress) Read(p []byte) (n int, err error) {
n, err = r.Reader.Read(p)
if err != nil {
return
}
r.ch <- int64(n)
return
} | [
"func",
"(",
"r",
"ReadProgress",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"n",
",",
"err",
"=",
"r",
".",
"Reader",
".",
"Read",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"r",
".",
"ch",
"<-",
"int64",
"(",
"n",
")",
"\n",
"return",
"\n",
"}"
] | // Read implements the Reader interface. | [
"Read",
"implements",
"the",
"Reader",
"interface",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L96-L103 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | StartProgress | func (r ReadProgress) StartProgress() {
r.wg.Add(1)
go func() {
var bytesReceived int64
var percent int
tick := time.NewTicker(5 * time.Second)
defer tick.Stop()
defer r.wg.Done()
for {
select {
case b := <-r.ch:
bytesReceived += b
percent = int((float32(bytesReceived) / float32(r.TotalBytes)) * 100)
case <-tick.C:
// TODO: Preet This can return an error as well, should return it
r.Lease.Progress(percent)
if percent == 100 {
return
}
}
}
}()
} | go | func (r ReadProgress) StartProgress() {
r.wg.Add(1)
go func() {
var bytesReceived int64
var percent int
tick := time.NewTicker(5 * time.Second)
defer tick.Stop()
defer r.wg.Done()
for {
select {
case b := <-r.ch:
bytesReceived += b
percent = int((float32(bytesReceived) / float32(r.TotalBytes)) * 100)
case <-tick.C:
// TODO: Preet This can return an error as well, should return it
r.Lease.Progress(percent)
if percent == 100 {
return
}
}
}
}()
} | [
"func",
"(",
"r",
"ReadProgress",
")",
"StartProgress",
"(",
")",
"{",
"r",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"var",
"bytesReceived",
"int64",
"\n",
"var",
"percent",
"int",
"\n",
"tick",
":=",
"time",
".",
"NewTicker",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"tick",
".",
"Stop",
"(",
")",
"\n",
"defer",
"r",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"b",
":=",
"<-",
"r",
".",
"ch",
":",
"bytesReceived",
"+=",
"b",
"\n",
"percent",
"=",
"int",
"(",
"(",
"float32",
"(",
"bytesReceived",
")",
"/",
"float32",
"(",
"r",
".",
"TotalBytes",
")",
")",
"*",
"100",
")",
"\n",
"case",
"<-",
"tick",
".",
"C",
":",
"// TODO: Preet This can return an error as well, should return it",
"r",
".",
"Lease",
".",
"Progress",
"(",
"percent",
")",
"\n",
"if",
"percent",
"==",
"100",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // StartProgress starts a goroutine that updates local progress on the lease as
// well as pass it down to the underlying lease. | [
"StartProgress",
"starts",
"a",
"goroutine",
"that",
"updates",
"local",
"progress",
"on",
"the",
"lease",
"as",
"well",
"as",
"pass",
"it",
"down",
"to",
"the",
"underlying",
"lease",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L107-L129 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | NewErrorParsingURL | func NewErrorParsingURL(u string, e error) ErrorParsingURL {
return ErrorParsingURL{uri: u, err: e}
} | go | func NewErrorParsingURL(u string, e error) ErrorParsingURL {
return ErrorParsingURL{uri: u, err: e}
} | [
"func",
"NewErrorParsingURL",
"(",
"u",
"string",
",",
"e",
"error",
")",
"ErrorParsingURL",
"{",
"return",
"ErrorParsingURL",
"{",
"uri",
":",
"u",
",",
"err",
":",
"e",
"}",
"\n",
"}"
] | // NewErrorParsingURL returns an ErrorParsingURL error. | [
"NewErrorParsingURL",
"returns",
"an",
"ErrorParsingURL",
"error",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L216-L218 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | NewErrorInvalidHost | func NewErrorInvalidHost(h string, d string, n map[string]string) ErrorInvalidHost {
return ErrorInvalidHost{host: h, ds: d, nw: n}
} | go | func NewErrorInvalidHost(h string, d string, n map[string]string) ErrorInvalidHost {
return ErrorInvalidHost{host: h, ds: d, nw: n}
} | [
"func",
"NewErrorInvalidHost",
"(",
"h",
"string",
",",
"d",
"string",
",",
"n",
"map",
"[",
"string",
"]",
"string",
")",
"ErrorInvalidHost",
"{",
"return",
"ErrorInvalidHost",
"{",
"host",
":",
"h",
",",
"ds",
":",
"d",
",",
"nw",
":",
"n",
"}",
"\n",
"}"
] | // NewErrorInvalidHost returns an ErrorInvalidHost error. | [
"NewErrorInvalidHost",
"returns",
"an",
"ErrorInvalidHost",
"error",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L221-L223 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | NewErrorObjectNotFound | func NewErrorObjectNotFound(e error, o string) ErrorObjectNotFound {
return ErrorObjectNotFound{err: e, obj: o}
} | go | func NewErrorObjectNotFound(e error, o string) ErrorObjectNotFound {
return ErrorObjectNotFound{err: e, obj: o}
} | [
"func",
"NewErrorObjectNotFound",
"(",
"e",
"error",
",",
"o",
"string",
")",
"ErrorObjectNotFound",
"{",
"return",
"ErrorObjectNotFound",
"{",
"err",
":",
"e",
",",
"obj",
":",
"o",
"}",
"\n",
"}"
] | // NewErrorObjectNotFound returns an ErrorObjectNotFound error. | [
"NewErrorObjectNotFound",
"returns",
"an",
"ErrorObjectNotFound",
"error",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L231-L233 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | NewErrorPropertyRetrieval | func NewErrorPropertyRetrieval(m types.ManagedObjectReference, p []string, e error) ErrorPropertyRetrieval {
return ErrorPropertyRetrieval{err: e, mor: m, ps: p}
} | go | func NewErrorPropertyRetrieval(m types.ManagedObjectReference, p []string, e error) ErrorPropertyRetrieval {
return ErrorPropertyRetrieval{err: e, mor: m, ps: p}
} | [
"func",
"NewErrorPropertyRetrieval",
"(",
"m",
"types",
".",
"ManagedObjectReference",
",",
"p",
"[",
"]",
"string",
",",
"e",
"error",
")",
"ErrorPropertyRetrieval",
"{",
"return",
"ErrorPropertyRetrieval",
"{",
"err",
":",
"e",
",",
"mor",
":",
"m",
",",
"ps",
":",
"p",
"}",
"\n",
"}"
] | // NewErrorPropertyRetrieval returns an ErrorPropertyRetrieval error. | [
"NewErrorPropertyRetrieval",
"returns",
"an",
"ErrorPropertyRetrieval",
"error",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L236-L238 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Provision | func (vm *VM) Provision() (err error) {
if err := SetupSession(vm); err != nil {
return fmt.Errorf("Error setting up vSphere session: %s", err)
}
// Cancel the sdk context
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return fmt.Errorf("Failed to retrieve datacenter: %s", err)
}
// Upload a template to all the datastores if `UseLocalTemplates` is set.
// Otherwise pick a random datastore out of the list that was passed in.
var datastores = vm.Datastores
if !vm.UseLocalTemplates {
n := util.Random(1, len(vm.Datastores))
datastores = []string{vm.Datastores[n-1]}
}
usableDatastores := []string{}
for _, d := range datastores {
template := createTemplateName(vm.Template, d)
// Does the VM template already exist?
e, err := Exists(vm, dcMo, template)
if err != nil {
return fmt.Errorf("failed to check if the template already exists: %s", err)
}
// If it does exist, return an error if the skip existing flag is not set
if e {
if !vm.SkipExisting {
return fmt.Errorf("template already exists: %s", vm.Template)
}
} else {
// Upload the template if it does not exist. If it exists and SkipExisting is true,
// use the existing template
if err := uploadTemplate(vm, dcMo, d); err != nil {
return err
}
}
// Upload successful or the template was found with the SkipExisting flag set to true
usableDatastores = append(usableDatastores, d)
}
// Does the VM already exist?
e, err := Exists(vm, dcMo, vm.Name)
if err != nil {
return fmt.Errorf("failed to check if the vm already exists: %s", err)
}
if e {
return ErrorVMExists
}
err = cloneFromTemplate(vm, dcMo, usableDatastores)
if err != nil {
return fmt.Errorf("error while cloning vm from template: %s", err)
}
return
} | go | func (vm *VM) Provision() (err error) {
if err := SetupSession(vm); err != nil {
return fmt.Errorf("Error setting up vSphere session: %s", err)
}
// Cancel the sdk context
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return fmt.Errorf("Failed to retrieve datacenter: %s", err)
}
// Upload a template to all the datastores if `UseLocalTemplates` is set.
// Otherwise pick a random datastore out of the list that was passed in.
var datastores = vm.Datastores
if !vm.UseLocalTemplates {
n := util.Random(1, len(vm.Datastores))
datastores = []string{vm.Datastores[n-1]}
}
usableDatastores := []string{}
for _, d := range datastores {
template := createTemplateName(vm.Template, d)
// Does the VM template already exist?
e, err := Exists(vm, dcMo, template)
if err != nil {
return fmt.Errorf("failed to check if the template already exists: %s", err)
}
// If it does exist, return an error if the skip existing flag is not set
if e {
if !vm.SkipExisting {
return fmt.Errorf("template already exists: %s", vm.Template)
}
} else {
// Upload the template if it does not exist. If it exists and SkipExisting is true,
// use the existing template
if err := uploadTemplate(vm, dcMo, d); err != nil {
return err
}
}
// Upload successful or the template was found with the SkipExisting flag set to true
usableDatastores = append(usableDatastores, d)
}
// Does the VM already exist?
e, err := Exists(vm, dcMo, vm.Name)
if err != nil {
return fmt.Errorf("failed to check if the vm already exists: %s", err)
}
if e {
return ErrorVMExists
}
err = cloneFromTemplate(vm, dcMo, usableDatastores)
if err != nil {
return fmt.Errorf("error while cloning vm from template: %s", err)
}
return
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Provision",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Cancel the sdk context",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Get a reference to the datacenter with host and vm folders populated",
"dcMo",
",",
"err",
":=",
"GetDatacenter",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Upload a template to all the datastores if `UseLocalTemplates` is set.",
"// Otherwise pick a random datastore out of the list that was passed in.",
"var",
"datastores",
"=",
"vm",
".",
"Datastores",
"\n",
"if",
"!",
"vm",
".",
"UseLocalTemplates",
"{",
"n",
":=",
"util",
".",
"Random",
"(",
"1",
",",
"len",
"(",
"vm",
".",
"Datastores",
")",
")",
"\n",
"datastores",
"=",
"[",
"]",
"string",
"{",
"vm",
".",
"Datastores",
"[",
"n",
"-",
"1",
"]",
"}",
"\n",
"}",
"\n\n",
"usableDatastores",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"d",
":=",
"range",
"datastores",
"{",
"template",
":=",
"createTemplateName",
"(",
"vm",
".",
"Template",
",",
"d",
")",
"\n",
"// Does the VM template already exist?",
"e",
",",
"err",
":=",
"Exists",
"(",
"vm",
",",
"dcMo",
",",
"template",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// If it does exist, return an error if the skip existing flag is not set",
"if",
"e",
"{",
"if",
"!",
"vm",
".",
"SkipExisting",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vm",
".",
"Template",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Upload the template if it does not exist. If it exists and SkipExisting is true,",
"// use the existing template",
"if",
"err",
":=",
"uploadTemplate",
"(",
"vm",
",",
"dcMo",
",",
"d",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"// Upload successful or the template was found with the SkipExisting flag set to true",
"usableDatastores",
"=",
"append",
"(",
"usableDatastores",
",",
"d",
")",
"\n",
"}",
"\n\n",
"// Does the VM already exist?",
"e",
",",
"err",
":=",
"Exists",
"(",
"vm",
",",
"dcMo",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"e",
"{",
"return",
"ErrorVMExists",
"\n",
"}",
"\n\n",
"err",
"=",
"cloneFromTemplate",
"(",
"vm",
",",
"dcMo",
",",
"usableDatastores",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Provision provisions this VM. | [
"Provision",
"provisions",
"this",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L355-L419 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | GetIPs | func (vm *VM) GetIPs() ([]net.IP, error) {
if err := SetupSession(vm); err != nil {
return nil, err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return nil, err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return nil, err
}
// Lazy initialized when there is an IP address later.
var ips []net.IP
for _, nic := range vmMo.Guest.Net {
for _, ip := range nic.IpAddress {
netIP := net.ParseIP(ip)
if netIP == nil {
continue
}
if ips == nil {
ips = make([]net.IP, 0, 1)
}
ips = append(ips, netIP)
}
}
if ips == nil && vmMo.Guest.IpAddress != "" {
ip := net.ParseIP(vmMo.Guest.IpAddress)
if ip != nil {
ips = append(ips, ip)
}
}
return ips, nil
} | go | func (vm *VM) GetIPs() ([]net.IP, error) {
if err := SetupSession(vm); err != nil {
return nil, err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return nil, err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return nil, err
}
// Lazy initialized when there is an IP address later.
var ips []net.IP
for _, nic := range vmMo.Guest.Net {
for _, ip := range nic.IpAddress {
netIP := net.ParseIP(ip)
if netIP == nil {
continue
}
if ips == nil {
ips = make([]net.IP, 0, 1)
}
ips = append(ips, netIP)
}
}
if ips == nil && vmMo.Guest.IpAddress != "" {
ip := net.ParseIP(vmMo.Guest.IpAddress)
if ip != nil {
ips = append(ips, ip)
}
}
return ips, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetIPs",
"(",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Get a reference to the datacenter with host and vm folders populated",
"dcMo",
",",
"err",
":=",
"GetDatacenter",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"vmMo",
",",
"err",
":=",
"findVM",
"(",
"vm",
",",
"dcMo",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// Lazy initialized when there is an IP address later.",
"var",
"ips",
"[",
"]",
"net",
".",
"IP",
"\n",
"for",
"_",
",",
"nic",
":=",
"range",
"vmMo",
".",
"Guest",
".",
"Net",
"{",
"for",
"_",
",",
"ip",
":=",
"range",
"nic",
".",
"IpAddress",
"{",
"netIP",
":=",
"net",
".",
"ParseIP",
"(",
"ip",
")",
"\n",
"if",
"netIP",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"ips",
"==",
"nil",
"{",
"ips",
"=",
"make",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"0",
",",
"1",
")",
"\n",
"}",
"\n",
"ips",
"=",
"append",
"(",
"ips",
",",
"netIP",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"ips",
"==",
"nil",
"&&",
"vmMo",
".",
"Guest",
".",
"IpAddress",
"!=",
"\"",
"\"",
"{",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"vmMo",
".",
"Guest",
".",
"IpAddress",
")",
"\n",
"if",
"ip",
"!=",
"nil",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ips",
",",
"nil",
"\n",
"}"
] | // GetIPs returns the IPs of this VM. Returns all the IPs known to the API for
// the different network cards for this VM. Includes IPV4 and IPV6 addresses. | [
"GetIPs",
"returns",
"the",
"IPs",
"of",
"this",
"VM",
".",
"Returns",
"all",
"the",
"IPs",
"known",
"to",
"the",
"API",
"for",
"the",
"different",
"network",
"cards",
"for",
"this",
"VM",
".",
"Includes",
"IPV4",
"and",
"IPV6",
"addresses",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L428-L467 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Destroy | func (vm *VM) Destroy() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
state, err := getState(vm)
if err != nil {
return err
}
// Can't destroy a suspended VM, power it on and update the state
if state == "standby" {
err = start(vm)
if err != nil {
return err
}
}
if state != "notRunning" {
// Only possible states are running, shuttingDown, resetting or notRunning
timer := time.NewTimer(time.Second * 90)
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
defer timer.Stop()
defer wg.Done()
Outerloop:
for {
state, e := getState(vm)
if e != nil {
err = e
break
}
if state == "notRunning" {
break
}
if state == "running" {
e = halt(vm)
if e != nil {
err = e
break
}
}
select {
case <-timer.C:
err = fmt.Errorf("timed out waiting for VM to power off")
break Outerloop
default:
// No action
}
time.Sleep(time.Second)
}
}()
wg.Wait()
if err != nil {
return err
}
}
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return err
}
vmo := object.NewVirtualMachine(vm.client.Client, vmMo.Reference())
destroyTask, err := vmo.Destroy(vm.ctx)
if err != nil {
return fmt.Errorf("error creating a destroy task on the vm: %s", err)
}
tInfo, err := destroyTask.WaitForResult(vm.ctx, nil)
if err != nil {
return fmt.Errorf("error waiting for destroy task: %s", err)
}
if tInfo.Error != nil {
return fmt.Errorf("destroy task returned an error: %s", err)
}
return nil
} | go | func (vm *VM) Destroy() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
state, err := getState(vm)
if err != nil {
return err
}
// Can't destroy a suspended VM, power it on and update the state
if state == "standby" {
err = start(vm)
if err != nil {
return err
}
}
if state != "notRunning" {
// Only possible states are running, shuttingDown, resetting or notRunning
timer := time.NewTimer(time.Second * 90)
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
defer timer.Stop()
defer wg.Done()
Outerloop:
for {
state, e := getState(vm)
if e != nil {
err = e
break
}
if state == "notRunning" {
break
}
if state == "running" {
e = halt(vm)
if e != nil {
err = e
break
}
}
select {
case <-timer.C:
err = fmt.Errorf("timed out waiting for VM to power off")
break Outerloop
default:
// No action
}
time.Sleep(time.Second)
}
}()
wg.Wait()
if err != nil {
return err
}
}
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return err
}
vmo := object.NewVirtualMachine(vm.client.Client, vmMo.Reference())
destroyTask, err := vmo.Destroy(vm.ctx)
if err != nil {
return fmt.Errorf("error creating a destroy task on the vm: %s", err)
}
tInfo, err := destroyTask.WaitForResult(vm.ctx, nil)
if err != nil {
return fmt.Errorf("error waiting for destroy task: %s", err)
}
if tInfo.Error != nil {
return fmt.Errorf("destroy task returned an error: %s", err)
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Destroy",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"state",
",",
"err",
":=",
"getState",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Can't destroy a suspended VM, power it on and update the state",
"if",
"state",
"==",
"\"",
"\"",
"{",
"err",
"=",
"start",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"state",
"!=",
"\"",
"\"",
"{",
"// Only possible states are running, shuttingDown, resetting or notRunning",
"timer",
":=",
"time",
".",
"NewTimer",
"(",
"time",
".",
"Second",
"*",
"90",
")",
"\n",
"wg",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n",
"wg",
".",
"Add",
"(",
"1",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"defer",
"timer",
".",
"Stop",
"(",
")",
"\n",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n",
"Outerloop",
":",
"for",
"{",
"state",
",",
"e",
":=",
"getState",
"(",
"vm",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"err",
"=",
"e",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"state",
"==",
"\"",
"\"",
"{",
"break",
"\n",
"}",
"\n\n",
"if",
"state",
"==",
"\"",
"\"",
"{",
"e",
"=",
"halt",
"(",
"vm",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"err",
"=",
"e",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"<-",
"timer",
".",
"C",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"break",
"Outerloop",
"\n",
"default",
":",
"// No action",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Get a reference to the datacenter with host and vm folders populated",
"dcMo",
",",
"err",
":=",
"GetDatacenter",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vmMo",
",",
"err",
":=",
"findVM",
"(",
"vm",
",",
"dcMo",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vmo",
":=",
"object",
".",
"NewVirtualMachine",
"(",
"vm",
".",
"client",
".",
"Client",
",",
"vmMo",
".",
"Reference",
"(",
")",
")",
"\n",
"destroyTask",
",",
"err",
":=",
"vmo",
".",
"Destroy",
"(",
"vm",
".",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tInfo",
",",
"err",
":=",
"destroyTask",
".",
"WaitForResult",
"(",
"vm",
".",
"ctx",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"tInfo",
".",
"Error",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Destroy deletes this VM from vSphere. | [
"Destroy",
"deletes",
"this",
"VM",
"from",
"vSphere",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L470-L558 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | GetState | func (vm *VM) GetState() (state string, err error) {
if err := SetupSession(vm); err != nil {
return "", lvm.ErrVMInfoFailed
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
state, err = getState(vm)
if err != nil {
return "", err
}
if state == "running" {
return lvm.VMRunning, nil
} else if state == "standby" {
return lvm.VMSuspended, nil
} else if state == "shuttingDown" || state == "resetting" || state == "notRunning" {
return lvm.VMHalted, nil
}
// VM state "unknown"
return "", lvm.ErrVMInfoFailed
} | go | func (vm *VM) GetState() (state string, err error) {
if err := SetupSession(vm); err != nil {
return "", lvm.ErrVMInfoFailed
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
state, err = getState(vm)
if err != nil {
return "", err
}
if state == "running" {
return lvm.VMRunning, nil
} else if state == "standby" {
return lvm.VMSuspended, nil
} else if state == "shuttingDown" || state == "resetting" || state == "notRunning" {
return lvm.VMHalted, nil
}
// VM state "unknown"
return "", lvm.ErrVMInfoFailed
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetState",
"(",
")",
"(",
"state",
"string",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"lvm",
".",
"ErrVMInfoFailed",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"state",
",",
"err",
"=",
"getState",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"state",
"==",
"\"",
"\"",
"{",
"return",
"lvm",
".",
"VMRunning",
",",
"nil",
"\n",
"}",
"else",
"if",
"state",
"==",
"\"",
"\"",
"{",
"return",
"lvm",
".",
"VMSuspended",
",",
"nil",
"\n",
"}",
"else",
"if",
"state",
"==",
"\"",
"\"",
"||",
"state",
"==",
"\"",
"\"",
"||",
"state",
"==",
"\"",
"\"",
"{",
"return",
"lvm",
".",
"VMHalted",
",",
"nil",
"\n",
"}",
"\n",
"// VM state \"unknown\"",
"return",
"\"",
"\"",
",",
"lvm",
".",
"ErrVMInfoFailed",
"\n",
"}"
] | // GetState returns the power state of this VM. | [
"GetState",
"returns",
"the",
"power",
"state",
"of",
"this",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L561-L583 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Suspend | func (vm *VM) Suspend() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return err
}
vmo := object.NewVirtualMachine(vm.client.Client, vmMo.Reference())
suspendTask, err := vmo.Suspend(vm.ctx)
if err != nil {
return fmt.Errorf("error creating a suspend task on the vm: %s", err)
}
tInfo, err := suspendTask.WaitForResult(vm.ctx, nil)
if err != nil {
return fmt.Errorf("error waiting for suspend task: %s", err)
}
if tInfo.Error != nil {
return fmt.Errorf("suspend task returned an error: %s", err)
}
return nil
} | go | func (vm *VM) Suspend() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
// Get a reference to the datacenter with host and vm folders populated
dcMo, err := GetDatacenter(vm)
if err != nil {
return err
}
vmMo, err := findVM(vm, dcMo, vm.Name)
if err != nil {
return err
}
vmo := object.NewVirtualMachine(vm.client.Client, vmMo.Reference())
suspendTask, err := vmo.Suspend(vm.ctx)
if err != nil {
return fmt.Errorf("error creating a suspend task on the vm: %s", err)
}
tInfo, err := suspendTask.WaitForResult(vm.ctx, nil)
if err != nil {
return fmt.Errorf("error waiting for suspend task: %s", err)
}
if tInfo.Error != nil {
return fmt.Errorf("suspend task returned an error: %s", err)
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Suspend",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Get a reference to the datacenter with host and vm folders populated",
"dcMo",
",",
"err",
":=",
"GetDatacenter",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vmMo",
",",
"err",
":=",
"findVM",
"(",
"vm",
",",
"dcMo",
",",
"vm",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"vmo",
":=",
"object",
".",
"NewVirtualMachine",
"(",
"vm",
".",
"client",
".",
"Client",
",",
"vmMo",
".",
"Reference",
"(",
")",
")",
"\n",
"suspendTask",
",",
"err",
":=",
"vmo",
".",
"Suspend",
"(",
"vm",
".",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tInfo",
",",
"err",
":=",
"suspendTask",
".",
"WaitForResult",
"(",
"vm",
".",
"ctx",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"tInfo",
".",
"Error",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Suspend suspends this VM. | [
"Suspend",
"suspends",
"this",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L586-L618 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Halt | func (vm *VM) Halt() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
return halt(vm)
} | go | func (vm *VM) Halt() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
return halt(vm)
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Halt",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"halt",
"(",
"vm",
")",
"\n",
"}"
] | // Halt halts this VM. | [
"Halt",
"halts",
"this",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L621-L631 | train |
apcera/libretto | virtualmachine/vsphere/vm.go | Start | func (vm *VM) Start() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
return start(vm)
} | go | func (vm *VM) Start() (err error) {
if err := SetupSession(vm); err != nil {
return err
}
defer func() {
vm.client.Logout(vm.ctx)
vm.cancel()
}()
return start(vm)
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Start",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"SetupSession",
"(",
"vm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"vm",
".",
"client",
".",
"Logout",
"(",
"vm",
".",
"ctx",
")",
"\n",
"vm",
".",
"cancel",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"start",
"(",
"vm",
")",
"\n",
"}"
] | // Start powers on this VM. | [
"Start",
"powers",
"on",
"this",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/vsphere/vm.go#L634-L644 | train |
apcera/libretto | virtualmachine/mockprovider/vm.go | GetSSH | func (vm *VM) GetSSH(options libssh.Options) (libssh.Client, error) {
if vm.MockGetSSH != nil {
return vm.MockGetSSH(options)
}
return nil, lvm.ErrNotImplemented
} | go | func (vm *VM) GetSSH(options libssh.Options) (libssh.Client, error) {
if vm.MockGetSSH != nil {
return vm.MockGetSSH(options)
}
return nil, lvm.ErrNotImplemented
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetSSH",
"(",
"options",
"libssh",
".",
"Options",
")",
"(",
"libssh",
".",
"Client",
",",
"error",
")",
"{",
"if",
"vm",
".",
"MockGetSSH",
"!=",
"nil",
"{",
"return",
"vm",
".",
"MockGetSSH",
"(",
"options",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"lvm",
".",
"ErrNotImplemented",
"\n",
"}"
] | // GetSSH returns an ssh client for the the vm. | [
"GetSSH",
"returns",
"an",
"ssh",
"client",
"for",
"the",
"the",
"vm",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/mockprovider/vm.go#L37-L42 | train |
apcera/libretto | virtualmachine/mockprovider/vm.go | Resume | func (vm *VM) Resume() error {
if vm.MockResume != nil {
return vm.MockResume()
}
return lvm.ErrNotImplemented
} | go | func (vm *VM) Resume() error {
if vm.MockResume != nil {
return vm.MockResume()
}
return lvm.ErrNotImplemented
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Resume",
"(",
")",
"error",
"{",
"if",
"vm",
".",
"MockResume",
"!=",
"nil",
"{",
"return",
"vm",
".",
"MockResume",
"(",
")",
"\n",
"}",
"\n",
"return",
"lvm",
".",
"ErrNotImplemented",
"\n",
"}"
] | // Resume suspends the active state of the VM. | [
"Resume",
"suspends",
"the",
"active",
"state",
"of",
"the",
"VM",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/mockprovider/vm.go#L69-L74 | train |
apcera/libretto | virtualmachine/mockprovider/vm.go | GetIPs | func (vm *VM) GetIPs() ([]net.IP, error) {
if vm.MockGetIPs != nil {
return vm.MockGetIPs()
}
return []net.IP{}, nil
} | go | func (vm *VM) GetIPs() ([]net.IP, error) {
if vm.MockGetIPs != nil {
return vm.MockGetIPs()
}
return []net.IP{}, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetIPs",
"(",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"if",
"vm",
".",
"MockGetIPs",
"!=",
"nil",
"{",
"return",
"vm",
".",
"MockGetIPs",
"(",
")",
"\n",
"}",
"\n",
"return",
"[",
"]",
"net",
".",
"IP",
"{",
"}",
",",
"nil",
"\n",
"}"
] | // GetIPs returns a list of ip addresses associated with the vm through VMware tools | [
"GetIPs",
"returns",
"a",
"list",
"of",
"ip",
"addresses",
"associated",
"with",
"the",
"vm",
"through",
"VMware",
"tools"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/mockprovider/vm.go#L85-L90 | train |
apcera/libretto | virtualmachine/mockprovider/vm.go | Provision | func (vm *VM) Provision() error {
if vm.MockProvision != nil {
return vm.MockProvision()
}
return lvm.ErrNotImplemented
} | go | func (vm *VM) Provision() error {
if vm.MockProvision != nil {
return vm.MockProvision()
}
return lvm.ErrNotImplemented
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Provision",
"(",
")",
"error",
"{",
"if",
"vm",
".",
"MockProvision",
"!=",
"nil",
"{",
"return",
"vm",
".",
"MockProvision",
"(",
")",
"\n",
"}",
"\n",
"return",
"lvm",
".",
"ErrNotImplemented",
"\n",
"}"
] | // Provision clones this VM and powers it on, while waiting for it to get an IP address. | [
"Provision",
"clones",
"this",
"VM",
"and",
"powers",
"it",
"on",
"while",
"waiting",
"for",
"it",
"to",
"get",
"an",
"IP",
"address",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/mockprovider/vm.go#L101-L106 | train |
apcera/libretto | ssh/ssh.go | Connect | func (client *SSHClient) Connect() error {
var (
auth cssh.AuthMethod
err error
)
if err = client.Validate(); err != nil {
return err
}
if client.Creds.SSHPrivateKey != "" {
auth, err = getAuth(client.Creds, KeyAuth)
if err != nil {
return err
}
} else {
auth, err = getAuth(client.Creds, PasswordAuth)
if err != nil {
return err
}
}
config := &cssh.ClientConfig{
User: client.Creds.SSHUser,
Auth: []cssh.AuthMethod{
auth,
},
HostKeyCallback: cssh.InsecureIgnoreHostKey(),
}
port := sshPort
if client.Port != 0 {
port = client.Port
}
c, err := dial("tcp", fmt.Sprintf("%s:%d", client.IP, port), config)
if err != nil {
return err
}
client.cryptoClient = c
client.close = make(chan bool, 1)
if client.Options.KeepAlive > 0 {
go client.keepAlive()
}
return nil
} | go | func (client *SSHClient) Connect() error {
var (
auth cssh.AuthMethod
err error
)
if err = client.Validate(); err != nil {
return err
}
if client.Creds.SSHPrivateKey != "" {
auth, err = getAuth(client.Creds, KeyAuth)
if err != nil {
return err
}
} else {
auth, err = getAuth(client.Creds, PasswordAuth)
if err != nil {
return err
}
}
config := &cssh.ClientConfig{
User: client.Creds.SSHUser,
Auth: []cssh.AuthMethod{
auth,
},
HostKeyCallback: cssh.InsecureIgnoreHostKey(),
}
port := sshPort
if client.Port != 0 {
port = client.Port
}
c, err := dial("tcp", fmt.Sprintf("%s:%d", client.IP, port), config)
if err != nil {
return err
}
client.cryptoClient = c
client.close = make(chan bool, 1)
if client.Options.KeepAlive > 0 {
go client.keepAlive()
}
return nil
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"Connect",
"(",
")",
"error",
"{",
"var",
"(",
"auth",
"cssh",
".",
"AuthMethod",
"\n",
"err",
"error",
"\n",
")",
"\n\n",
"if",
"err",
"=",
"client",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"client",
".",
"Creds",
".",
"SSHPrivateKey",
"!=",
"\"",
"\"",
"{",
"auth",
",",
"err",
"=",
"getAuth",
"(",
"client",
".",
"Creds",
",",
"KeyAuth",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"auth",
",",
"err",
"=",
"getAuth",
"(",
"client",
".",
"Creds",
",",
"PasswordAuth",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"config",
":=",
"&",
"cssh",
".",
"ClientConfig",
"{",
"User",
":",
"client",
".",
"Creds",
".",
"SSHUser",
",",
"Auth",
":",
"[",
"]",
"cssh",
".",
"AuthMethod",
"{",
"auth",
",",
"}",
",",
"HostKeyCallback",
":",
"cssh",
".",
"InsecureIgnoreHostKey",
"(",
")",
",",
"}",
"\n\n",
"port",
":=",
"sshPort",
"\n",
"if",
"client",
".",
"Port",
"!=",
"0",
"{",
"port",
"=",
"client",
".",
"Port",
"\n",
"}",
"\n\n",
"c",
",",
"err",
":=",
"dial",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"client",
".",
"IP",
",",
"port",
")",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"client",
".",
"cryptoClient",
"=",
"c",
"\n\n",
"client",
".",
"close",
"=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n\n",
"if",
"client",
".",
"Options",
".",
"KeepAlive",
">",
"0",
"{",
"go",
"client",
".",
"keepAlive",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Connect connects to a machine using SSH. | [
"Connect",
"connects",
"to",
"a",
"machine",
"using",
"SSH",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L98-L146 | train |
apcera/libretto | ssh/ssh.go | Run | func (client *SSHClient) Run(command string, stdout io.Writer, stderr io.Writer) error {
session, err := client.cryptoClient.NewSession()
if err != nil {
return err
}
defer session.Close()
session.Stdout = stdout
session.Stderr = stderr
if client.Options.Pty {
modes := cssh.TerminalModes{
cssh.ECHO: 0,
cssh.TTY_OP_ISPEED: 14400,
cssh.TTY_OP_OSPEED: 14400,
}
// Request pseudo terminal
if err := session.RequestPty(os.Getenv("TERM"), 80, 40, modes); err != nil {
return err
}
}
return session.Run(command)
} | go | func (client *SSHClient) Run(command string, stdout io.Writer, stderr io.Writer) error {
session, err := client.cryptoClient.NewSession()
if err != nil {
return err
}
defer session.Close()
session.Stdout = stdout
session.Stderr = stderr
if client.Options.Pty {
modes := cssh.TerminalModes{
cssh.ECHO: 0,
cssh.TTY_OP_ISPEED: 14400,
cssh.TTY_OP_OSPEED: 14400,
}
// Request pseudo terminal
if err := session.RequestPty(os.Getenv("TERM"), 80, 40, modes); err != nil {
return err
}
}
return session.Run(command)
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"Run",
"(",
"command",
"string",
",",
"stdout",
"io",
".",
"Writer",
",",
"stderr",
"io",
".",
"Writer",
")",
"error",
"{",
"session",
",",
"err",
":=",
"client",
".",
"cryptoClient",
".",
"NewSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"session",
".",
"Stdout",
"=",
"stdout",
"\n",
"session",
".",
"Stderr",
"=",
"stderr",
"\n\n",
"if",
"client",
".",
"Options",
".",
"Pty",
"{",
"modes",
":=",
"cssh",
".",
"TerminalModes",
"{",
"cssh",
".",
"ECHO",
":",
"0",
",",
"cssh",
".",
"TTY_OP_ISPEED",
":",
"14400",
",",
"cssh",
".",
"TTY_OP_OSPEED",
":",
"14400",
",",
"}",
"\n",
"// Request pseudo terminal",
"if",
"err",
":=",
"session",
".",
"RequestPty",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"80",
",",
"40",
",",
"modes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"session",
".",
"Run",
"(",
"command",
")",
"\n",
"}"
] | // Run runs a command via SSH. | [
"Run",
"runs",
"a",
"command",
"via",
"SSH",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L265-L289 | train |
apcera/libretto | ssh/ssh.go | Validate | func (client *SSHClient) Validate() error {
if client.Creds.SSHUser == "" {
return ErrInvalidUsername
}
if client.Creds.SSHPrivateKey == "" && client.Creds.SSHPassword == "" {
return ErrInvalidAuth
}
return nil
} | go | func (client *SSHClient) Validate() error {
if client.Creds.SSHUser == "" {
return ErrInvalidUsername
}
if client.Creds.SSHPrivateKey == "" && client.Creds.SSHPassword == "" {
return ErrInvalidAuth
}
return nil
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"client",
".",
"Creds",
".",
"SSHUser",
"==",
"\"",
"\"",
"{",
"return",
"ErrInvalidUsername",
"\n",
"}",
"\n\n",
"if",
"client",
".",
"Creds",
".",
"SSHPrivateKey",
"==",
"\"",
"\"",
"&&",
"client",
".",
"Creds",
".",
"SSHPassword",
"==",
"\"",
"\"",
"{",
"return",
"ErrInvalidAuth",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Validate verifies that SSH connection credentials were properly configured. | [
"Validate",
"verifies",
"that",
"SSH",
"connection",
"credentials",
"were",
"properly",
"configured",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L350-L360 | train |
apcera/libretto | ssh/ssh.go | WaitForSSH | func (client *SSHClient) WaitForSSH(maxWait time.Duration) error {
start := time.Now()
for {
if err := client.Connect(); err == nil {
defer client.Disconnect()
return nil
}
timePassed := time.Since(start)
if timePassed >= maxWait {
break
}
time.Sleep(5 * time.Second)
}
return ErrTimeout
} | go | func (client *SSHClient) WaitForSSH(maxWait time.Duration) error {
start := time.Now()
for {
if err := client.Connect(); err == nil {
defer client.Disconnect()
return nil
}
timePassed := time.Since(start)
if timePassed >= maxWait {
break
}
time.Sleep(5 * time.Second)
}
return ErrTimeout
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"WaitForSSH",
"(",
"maxWait",
"time",
".",
"Duration",
")",
"error",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"for",
"{",
"if",
"err",
":=",
"client",
".",
"Connect",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"defer",
"client",
".",
"Disconnect",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"timePassed",
":=",
"time",
".",
"Since",
"(",
"start",
")",
"\n",
"if",
"timePassed",
">=",
"maxWait",
"{",
"break",
"\n",
"}",
"\n\n",
"time",
".",
"Sleep",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n\n",
"return",
"ErrTimeout",
"\n",
"}"
] | // WaitForSSH will try to connect to an SSH server. If it fails, then it'll
// sleep for 5 seconds. | [
"WaitForSSH",
"will",
"try",
"to",
"connect",
"to",
"an",
"SSH",
"server",
".",
"If",
"it",
"fails",
"then",
"it",
"ll",
"sleep",
"for",
"5",
"seconds",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L364-L382 | train |
apcera/libretto | ssh/ssh.go | SetSSHPrivateKey | func (client *SSHClient) SetSSHPrivateKey(s string) {
client.Creds.mu.Lock()
client.Creds.SSHPrivateKey = s
client.Creds.mu.Unlock()
} | go | func (client *SSHClient) SetSSHPrivateKey(s string) {
client.Creds.mu.Lock()
client.Creds.SSHPrivateKey = s
client.Creds.mu.Unlock()
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"SetSSHPrivateKey",
"(",
"s",
"string",
")",
"{",
"client",
".",
"Creds",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"client",
".",
"Creds",
".",
"SSHPrivateKey",
"=",
"s",
"\n",
"client",
".",
"Creds",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // SetSSHPrivateKey sets the private key on the clients credentials. | [
"SetSSHPrivateKey",
"sets",
"the",
"private",
"key",
"on",
"the",
"clients",
"credentials",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L385-L389 | train |
apcera/libretto | ssh/ssh.go | GetSSHPrivateKey | func (client *SSHClient) GetSSHPrivateKey() string {
client.Creds.mu.Lock()
defer client.Creds.mu.Unlock()
return client.Creds.SSHPrivateKey
} | go | func (client *SSHClient) GetSSHPrivateKey() string {
client.Creds.mu.Lock()
defer client.Creds.mu.Unlock()
return client.Creds.SSHPrivateKey
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"GetSSHPrivateKey",
"(",
")",
"string",
"{",
"client",
".",
"Creds",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"client",
".",
"Creds",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"client",
".",
"Creds",
".",
"SSHPrivateKey",
"\n",
"}"
] | // GetSSHPrivateKey gets the private key on the clients credentials. | [
"GetSSHPrivateKey",
"gets",
"the",
"private",
"key",
"on",
"the",
"clients",
"credentials",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L392-L396 | train |
apcera/libretto | ssh/ssh.go | SetSSHPassword | func (client *SSHClient) SetSSHPassword(s string) {
client.Creds.mu.Lock()
client.Creds.SSHPassword = s
client.Creds.mu.Unlock()
} | go | func (client *SSHClient) SetSSHPassword(s string) {
client.Creds.mu.Lock()
client.Creds.SSHPassword = s
client.Creds.mu.Unlock()
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"SetSSHPassword",
"(",
"s",
"string",
")",
"{",
"client",
".",
"Creds",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"client",
".",
"Creds",
".",
"SSHPassword",
"=",
"s",
"\n",
"client",
".",
"Creds",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // SetSSHPassword sets the SSH password on the clients credentials. | [
"SetSSHPassword",
"sets",
"the",
"SSH",
"password",
"on",
"the",
"clients",
"credentials",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L399-L403 | train |
apcera/libretto | ssh/ssh.go | GetSSHPassword | func (client *SSHClient) GetSSHPassword() string {
client.Creds.mu.Lock()
defer client.Creds.mu.Unlock()
return client.Creds.SSHPassword
} | go | func (client *SSHClient) GetSSHPassword() string {
client.Creds.mu.Lock()
defer client.Creds.mu.Unlock()
return client.Creds.SSHPassword
} | [
"func",
"(",
"client",
"*",
"SSHClient",
")",
"GetSSHPassword",
"(",
")",
"string",
"{",
"client",
".",
"Creds",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"client",
".",
"Creds",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"client",
".",
"Creds",
".",
"SSHPassword",
"\n",
"}"
] | // GetSSHPassword gets the SSH password on the clients credentials. | [
"GetSSHPassword",
"gets",
"the",
"SSH",
"password",
"on",
"the",
"clients",
"credentials",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/ssh/ssh.go#L406-L410 | train |
apcera/libretto | virtualmachine/azure/management/util.go | getClient | func (vm *VM) getClient() (management.Client, error) {
mu.Lock()
defer mu.Unlock()
if client != nil {
return client, nil
}
var err error
client, err = management.ClientFromPublishSettingsFile(vm.PublishSettings, "")
if err != nil {
return nil, err
}
return client, nil
} | go | func (vm *VM) getClient() (management.Client, error) {
mu.Lock()
defer mu.Unlock()
if client != nil {
return client, nil
}
var err error
client, err = management.ClientFromPublishSettingsFile(vm.PublishSettings, "")
if err != nil {
return nil, err
}
return client, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"getClient",
"(",
")",
"(",
"management",
".",
"Client",
",",
"error",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"client",
"!=",
"nil",
"{",
"return",
"client",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"client",
",",
"err",
"=",
"management",
".",
"ClientFromPublishSettingsFile",
"(",
"vm",
".",
"PublishSettings",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"client",
",",
"nil",
"\n",
"}"
] | // getClient instantiates an Azure client if necessary and returns a copy of the
// client. It returns an error if there is a problem reading or unmarshaling the
// .publishSettings file. | [
"getClient",
"instantiates",
"an",
"Azure",
"client",
"if",
"necessary",
"and",
"returns",
"a",
"copy",
"of",
"the",
"client",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"is",
"a",
"problem",
"reading",
"or",
"unmarshaling",
"the",
".",
"publishSettings",
"file",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L27-L41 | train |
apcera/libretto | virtualmachine/azure/management/util.go | getVMClient | func (vm *VM) getVMClient() (virtualmachine.VirtualMachineClient, error) {
c, err := vm.getClient()
if err != nil {
return virtualmachine.VirtualMachineClient{}, err
}
return virtualmachine.NewClient(c), nil
} | go | func (vm *VM) getVMClient() (virtualmachine.VirtualMachineClient, error) {
c, err := vm.getClient()
if err != nil {
return virtualmachine.VirtualMachineClient{}, err
}
return virtualmachine.NewClient(c), nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"getVMClient",
"(",
")",
"(",
"virtualmachine",
".",
"VirtualMachineClient",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"vm",
".",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"virtualmachine",
".",
"VirtualMachineClient",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"virtualmachine",
".",
"NewClient",
"(",
"c",
")",
",",
"nil",
"\n",
"}"
] | // getVMClient returns a new Azure virtual machine client. | [
"getVMClient",
"returns",
"a",
"new",
"Azure",
"virtual",
"machine",
"client",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L44-L51 | train |
apcera/libretto | virtualmachine/azure/management/util.go | getServiceClient | func (vm *VM) getServiceClient() (hostedservice.HostedServiceClient, error) {
c, err := vm.getClient()
if err != nil {
return hostedservice.HostedServiceClient{}, err
}
return hostedservice.NewClient(c), nil
} | go | func (vm *VM) getServiceClient() (hostedservice.HostedServiceClient, error) {
c, err := vm.getClient()
if err != nil {
return hostedservice.HostedServiceClient{}, err
}
return hostedservice.NewClient(c), nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"getServiceClient",
"(",
")",
"(",
"hostedservice",
".",
"HostedServiceClient",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"vm",
".",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"hostedservice",
".",
"HostedServiceClient",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"hostedservice",
".",
"NewClient",
"(",
"c",
")",
",",
"nil",
"\n",
"}"
] | // getServiceClient returns a new Azure hosted service client. | [
"getServiceClient",
"returns",
"a",
"new",
"Azure",
"hosted",
"service",
"client",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L54-L61 | train |
apcera/libretto | virtualmachine/azure/management/util.go | getVirtualNetworkClient | func (vm *VM) getVirtualNetworkClient() (virtualnetwork.VirtualNetworkClient, error) {
c, err := vm.getClient()
if err != nil {
return virtualnetwork.VirtualNetworkClient{}, err
}
return virtualnetwork.NewClient(c), nil
} | go | func (vm *VM) getVirtualNetworkClient() (virtualnetwork.VirtualNetworkClient, error) {
c, err := vm.getClient()
if err != nil {
return virtualnetwork.VirtualNetworkClient{}, err
}
return virtualnetwork.NewClient(c), nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"getVirtualNetworkClient",
"(",
")",
"(",
"virtualnetwork",
".",
"VirtualNetworkClient",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"vm",
".",
"getClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"virtualnetwork",
".",
"VirtualNetworkClient",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"virtualnetwork",
".",
"NewClient",
"(",
"c",
")",
",",
"nil",
"\n",
"}"
] | // getVirtualNetworkClient returns a new virtual network client. | [
"getVirtualNetworkClient",
"returns",
"a",
"new",
"virtual",
"network",
"client",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L64-L71 | train |
apcera/libretto | virtualmachine/azure/management/util.go | createHostedService | func (vm *VM) createHostedService() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
// create hosted service
if err := sc.CreateHostedService(hostedservice.CreateHostedServiceParameters{
ServiceName: vm.ServiceName,
Location: vm.Location,
Label: base64.StdEncoding.EncodeToString([]byte(vm.Label))}); err != nil {
return err
}
if vm.Cert.Data != nil {
err = vm.addAddCertificate()
if err != nil {
return err
}
}
return nil
} | go | func (vm *VM) createHostedService() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
// create hosted service
if err := sc.CreateHostedService(hostedservice.CreateHostedServiceParameters{
ServiceName: vm.ServiceName,
Location: vm.Location,
Label: base64.StdEncoding.EncodeToString([]byte(vm.Label))}); err != nil {
return err
}
if vm.Cert.Data != nil {
err = vm.addAddCertificate()
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"createHostedService",
"(",
")",
"error",
"{",
"sc",
",",
"err",
":=",
"vm",
".",
"getServiceClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"errGetClient",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// create hosted service",
"if",
"err",
":=",
"sc",
".",
"CreateHostedService",
"(",
"hostedservice",
".",
"CreateHostedServiceParameters",
"{",
"ServiceName",
":",
"vm",
".",
"ServiceName",
",",
"Location",
":",
"vm",
".",
"Location",
",",
"Label",
":",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"[",
"]",
"byte",
"(",
"vm",
".",
"Label",
")",
")",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"Cert",
".",
"Data",
"!=",
"nil",
"{",
"err",
"=",
"vm",
".",
"addAddCertificate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // createHostedService creates a hosted service on Azure. | [
"createHostedService",
"creates",
"a",
"hosted",
"service",
"on",
"Azure",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L74-L97 | train |
apcera/libretto | virtualmachine/azure/management/util.go | deleteHostedService | func (vm *VM) deleteHostedService() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
// Delete hosted service
_, err = sc.DeleteHostedService(vm.ServiceName, true)
return err
} | go | func (vm *VM) deleteHostedService() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
// Delete hosted service
_, err = sc.DeleteHostedService(vm.ServiceName, true)
return err
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"deleteHostedService",
"(",
")",
"error",
"{",
"sc",
",",
"err",
":=",
"vm",
".",
"getServiceClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"errGetClient",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Delete hosted service",
"_",
",",
"err",
"=",
"sc",
".",
"DeleteHostedService",
"(",
"vm",
".",
"ServiceName",
",",
"true",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // deleteHostedService deletes a hosted service on Azure. | [
"deleteHostedService",
"deletes",
"a",
"hosted",
"service",
"on",
"Azure",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L100-L109 | train |
apcera/libretto | virtualmachine/azure/management/util.go | listHostedServices | func (vm *VM) listHostedServices() ([]hostedservice.HostedService, error) {
sc, err := vm.getServiceClient()
if err != nil {
return nil, fmt.Errorf(errGetClient, err)
}
resp, err := sc.ListHostedServices()
if err != nil {
return nil, err
}
return resp.HostedServices, nil
} | go | func (vm *VM) listHostedServices() ([]hostedservice.HostedService, error) {
sc, err := vm.getServiceClient()
if err != nil {
return nil, fmt.Errorf(errGetClient, err)
}
resp, err := sc.ListHostedServices()
if err != nil {
return nil, err
}
return resp.HostedServices, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"listHostedServices",
"(",
")",
"(",
"[",
"]",
"hostedservice",
".",
"HostedService",
",",
"error",
")",
"{",
"sc",
",",
"err",
":=",
"vm",
".",
"getServiceClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"errGetClient",
",",
"err",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"sc",
".",
"ListHostedServices",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"resp",
".",
"HostedServices",
",",
"nil",
"\n",
"}"
] | // listHostedServices lists all the hosted services under the current account. | [
"listHostedServices",
"lists",
"all",
"the",
"hosted",
"services",
"under",
"the",
"current",
"account",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L112-L124 | train |
apcera/libretto | virtualmachine/azure/management/util.go | addAddCertificate | func (vm *VM) addAddCertificate() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
_, err = sc.AddCertificate(vm.Name, vm.Cert.Data, hostedservice.CertificateFormat(vm.Cert.Format), vm.SSHCreds.SSHPassword)
return err
} | go | func (vm *VM) addAddCertificate() error {
sc, err := vm.getServiceClient()
if err != nil {
return fmt.Errorf(errGetClient, err)
}
_, err = sc.AddCertificate(vm.Name, vm.Cert.Data, hostedservice.CertificateFormat(vm.Cert.Format), vm.SSHCreds.SSHPassword)
return err
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"addAddCertificate",
"(",
")",
"error",
"{",
"sc",
",",
"err",
":=",
"vm",
".",
"getServiceClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"errGetClient",
",",
"err",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"sc",
".",
"AddCertificate",
"(",
"vm",
".",
"Name",
",",
"vm",
".",
"Cert",
".",
"Data",
",",
"hostedservice",
".",
"CertificateFormat",
"(",
"vm",
".",
"Cert",
".",
"Format",
")",
",",
"vm",
".",
"SSHCreds",
".",
"SSHPassword",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // addAddCertificate adds certs to a hosted service. | [
"addAddCertificate",
"adds",
"certs",
"to",
"a",
"hosted",
"service",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L127-L135 | train |
apcera/libretto | virtualmachine/azure/management/util.go | serviceExist | func (vm *VM) serviceExist(services []hostedservice.HostedService) bool {
for _, srv := range services {
if srv.ServiceName == vm.ServiceName {
return true
}
}
return false
} | go | func (vm *VM) serviceExist(services []hostedservice.HostedService) bool {
for _, srv := range services {
if srv.ServiceName == vm.ServiceName {
return true
}
}
return false
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"serviceExist",
"(",
"services",
"[",
"]",
"hostedservice",
".",
"HostedService",
")",
"bool",
"{",
"for",
"_",
",",
"srv",
":=",
"range",
"services",
"{",
"if",
"srv",
".",
"ServiceName",
"==",
"vm",
".",
"ServiceName",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] | // serviceExist checks if the desired service name already exists. | [
"serviceExist",
"checks",
"if",
"the",
"desired",
"service",
"name",
"already",
"exists",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L138-L146 | train |
apcera/libretto | virtualmachine/azure/management/util.go | getFirstSubnet | func (vm *VM) getFirstSubnet() (string, error) {
vc, err := vm.getVirtualNetworkClient()
if err != nil {
return "", fmt.Errorf(errGetClient, err)
}
nc, err := vc.GetVirtualNetworkConfiguration()
if err != nil {
return "", fmt.Errorf("Error to get VirtualNetwork Configuration : %s", err)
}
for _, vns := range nc.Configuration.VirtualNetworkSites {
if vns.Name == vm.DeployOptions.VirtualNetworkName {
if len(vns.Subnets) == 0 {
return "", fmt.Errorf("No subnet in the virtual network")
}
return vns.Subnets[0].Name, nil
}
}
return "", fmt.Errorf("VirtualNetwork %s is not found", vm.DeployOptions.VirtualNetworkName)
} | go | func (vm *VM) getFirstSubnet() (string, error) {
vc, err := vm.getVirtualNetworkClient()
if err != nil {
return "", fmt.Errorf(errGetClient, err)
}
nc, err := vc.GetVirtualNetworkConfiguration()
if err != nil {
return "", fmt.Errorf("Error to get VirtualNetwork Configuration : %s", err)
}
for _, vns := range nc.Configuration.VirtualNetworkSites {
if vns.Name == vm.DeployOptions.VirtualNetworkName {
if len(vns.Subnets) == 0 {
return "", fmt.Errorf("No subnet in the virtual network")
}
return vns.Subnets[0].Name, nil
}
}
return "", fmt.Errorf("VirtualNetwork %s is not found", vm.DeployOptions.VirtualNetworkName)
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"getFirstSubnet",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"vc",
",",
"err",
":=",
"vm",
".",
"getVirtualNetworkClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"errGetClient",
",",
"err",
")",
"\n",
"}",
"\n\n",
"nc",
",",
"err",
":=",
"vc",
".",
"GetVirtualNetworkConfiguration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"vns",
":=",
"range",
"nc",
".",
"Configuration",
".",
"VirtualNetworkSites",
"{",
"if",
"vns",
".",
"Name",
"==",
"vm",
".",
"DeployOptions",
".",
"VirtualNetworkName",
"{",
"if",
"len",
"(",
"vns",
".",
"Subnets",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"vns",
".",
"Subnets",
"[",
"0",
"]",
".",
"Name",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"vm",
".",
"DeployOptions",
".",
"VirtualNetworkName",
")",
"\n",
"}"
] | // getFirstSubnet gets the name of the first subnet within the VM's virtual
// network. | [
"getFirstSubnet",
"gets",
"the",
"name",
"of",
"the",
"first",
"subnet",
"within",
"the",
"VM",
"s",
"virtual",
"network",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/azure/management/util.go#L158-L180 | train |
apcera/libretto | virtualmachine/digitalocean/util.go | BuildRequest | func BuildRequest(token, method, url string, body io.Reader) (*http.Request, error) {
req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)
return req, nil
} | go | func BuildRequest(token, method, url string, body io.Reader) (*http.Request, error) {
req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)
return req, nil
} | [
"func",
"BuildRequest",
"(",
"token",
",",
"method",
",",
"url",
"string",
",",
"body",
"io",
".",
"Reader",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"url",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"token",
")",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] | // BuildRequest builds an http request for this provider. | [
"BuildRequest",
"builds",
"an",
"http",
"request",
"for",
"this",
"provider",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/util.go#L14-L23 | train |
apcera/libretto | virtualmachine/digitalocean/util.go | GetDroplets | func GetDroplets(token string) (*DropletsResponse, error) {
client := &http.Client{}
req, err := BuildRequest(token, "GET", apiBaseURL+apiDropletURL, nil)
if err != nil {
return nil, err
}
rsp, err := client.Do(req)
if err != nil {
return nil, err
}
defer rsp.Body.Close()
b, err := ioutil.ReadAll(rsp.Body)
if err != nil {
return nil, err
}
if rsp.Status[0] != StatusOk {
return nil, fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
r := &DropletsResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return nil, err
}
return r, nil
} | go | func GetDroplets(token string) (*DropletsResponse, error) {
client := &http.Client{}
req, err := BuildRequest(token, "GET", apiBaseURL+apiDropletURL, nil)
if err != nil {
return nil, err
}
rsp, err := client.Do(req)
if err != nil {
return nil, err
}
defer rsp.Body.Close()
b, err := ioutil.ReadAll(rsp.Body)
if err != nil {
return nil, err
}
if rsp.Status[0] != StatusOk {
return nil, fmt.Errorf("Error: %s: %s", rsp.Status, string(b))
}
r := &DropletsResponse{}
err = json.Unmarshal(b, r)
if err != nil {
return nil, err
}
return r, nil
} | [
"func",
"GetDroplets",
"(",
"token",
"string",
")",
"(",
"*",
"DropletsResponse",
",",
"error",
")",
"{",
"client",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n",
"req",
",",
"err",
":=",
"BuildRequest",
"(",
"token",
",",
"\"",
"\"",
",",
"apiBaseURL",
"+",
"apiDropletURL",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"rsp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"rsp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"rsp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"rsp",
".",
"Status",
"[",
"0",
"]",
"!=",
"StatusOk",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rsp",
".",
"Status",
",",
"string",
"(",
"b",
")",
")",
"\n",
"}",
"\n\n",
"r",
":=",
"&",
"DropletsResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // GetDroplets returns and array of droplets | [
"GetDroplets",
"returns",
"and",
"array",
"of",
"droplets"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/util.go#L61-L86 | train |
apcera/libretto | virtualmachine/digitalocean/util.go | PrintDroplet | func PrintDroplet(droplet *Droplet) {
fmt.Println("ID:", droplet.ID)
fmt.Println("Name:", droplet.Name)
fmt.Println("Status:", droplet.Status)
fmt.Println("Locked:", fmt.Sprintf("%t", droplet.Locked))
fmt.Println("CreatedAt:", droplet.CreatedAt.Format("2006-01-02 15:04:05"))
fmt.Println("SizeSlug:", droplet.Size.Slug)
fmt.Println("Region:", droplet.Region.Name)
fmt.Println("Image:", droplet.Image.Name)
for i, ip := range droplet.Networks.V4 {
fmt.Println(fmt.Sprintf("IP: %d", i+1), ip.IPAddress, ip.Type)
}
for i, ip := range droplet.Networks.V6 {
fmt.Println(fmt.Sprintf("IP: %d", i+1), ip.IPAddress, ip.Type)
}
} | go | func PrintDroplet(droplet *Droplet) {
fmt.Println("ID:", droplet.ID)
fmt.Println("Name:", droplet.Name)
fmt.Println("Status:", droplet.Status)
fmt.Println("Locked:", fmt.Sprintf("%t", droplet.Locked))
fmt.Println("CreatedAt:", droplet.CreatedAt.Format("2006-01-02 15:04:05"))
fmt.Println("SizeSlug:", droplet.Size.Slug)
fmt.Println("Region:", droplet.Region.Name)
fmt.Println("Image:", droplet.Image.Name)
for i, ip := range droplet.Networks.V4 {
fmt.Println(fmt.Sprintf("IP: %d", i+1), ip.IPAddress, ip.Type)
}
for i, ip := range droplet.Networks.V6 {
fmt.Println(fmt.Sprintf("IP: %d", i+1), ip.IPAddress, ip.Type)
}
} | [
"func",
"PrintDroplet",
"(",
"droplet",
"*",
"Droplet",
")",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"ID",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Name",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Status",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Locked",
")",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"CreatedAt",
".",
"Format",
"(",
"\"",
"\"",
")",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Size",
".",
"Slug",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Region",
".",
"Name",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"droplet",
".",
"Image",
".",
"Name",
")",
"\n",
"for",
"i",
",",
"ip",
":=",
"range",
"droplet",
".",
"Networks",
".",
"V4",
"{",
"fmt",
".",
"Println",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
"+",
"1",
")",
",",
"ip",
".",
"IPAddress",
",",
"ip",
".",
"Type",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"ip",
":=",
"range",
"droplet",
".",
"Networks",
".",
"V6",
"{",
"fmt",
".",
"Println",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
"+",
"1",
")",
",",
"ip",
".",
"IPAddress",
",",
"ip",
".",
"Type",
")",
"\n",
"}",
"\n",
"}"
] | // PrintDroplet prints the basic droplet values | [
"PrintDroplet",
"prints",
"the",
"basic",
"droplet",
"values"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/digitalocean/util.go#L89-L104 | train |
apcera/libretto | virtualmachine/aws/vm.go | SetTag | func (vm *VM) SetTag(key, value string) error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
return ErrNoInstanceID
}
volIDs, err := getInstanceVolumeIDs(svc, vm.InstanceID)
if err != nil {
return fmt.Errorf("Failed to get instance's volumes IDs: %s", err)
}
ids := make([]*string, 0, len(volIDs)+1)
ids = append(ids, aws.String(vm.InstanceID))
for _, v := range volIDs {
ids = append(ids, aws.String(v))
}
_, err = svc.CreateTags(&ec2.CreateTagsInput{
Resources: ids,
Tags: []*ec2.Tag{
{Key: aws.String(key),
Value: aws.String(value)},
},
})
if err != nil {
return fmt.Errorf("Failed to create tag on VM: %v", err)
}
return nil
} | go | func (vm *VM) SetTag(key, value string) error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
return ErrNoInstanceID
}
volIDs, err := getInstanceVolumeIDs(svc, vm.InstanceID)
if err != nil {
return fmt.Errorf("Failed to get instance's volumes IDs: %s", err)
}
ids := make([]*string, 0, len(volIDs)+1)
ids = append(ids, aws.String(vm.InstanceID))
for _, v := range volIDs {
ids = append(ids, aws.String(v))
}
_, err = svc.CreateTags(&ec2.CreateTagsInput{
Resources: ids,
Tags: []*ec2.Tag{
{Key: aws.String(key),
Value: aws.String(value)},
},
})
if err != nil {
return fmt.Errorf("Failed to create tag on VM: %v", err)
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"SetTag",
"(",
"key",
",",
"value",
"string",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"vm",
".",
"Region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"volIDs",
",",
"err",
":=",
"getInstanceVolumeIDs",
"(",
"svc",
",",
"vm",
".",
"InstanceID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"ids",
":=",
"make",
"(",
"[",
"]",
"*",
"string",
",",
"0",
",",
"len",
"(",
"volIDs",
")",
"+",
"1",
")",
"\n",
"ids",
"=",
"append",
"(",
"ids",
",",
"aws",
".",
"String",
"(",
"vm",
".",
"InstanceID",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"volIDs",
"{",
"ids",
"=",
"append",
"(",
"ids",
",",
"aws",
".",
"String",
"(",
"v",
")",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"svc",
".",
"CreateTags",
"(",
"&",
"ec2",
".",
"CreateTagsInput",
"{",
"Resources",
":",
"ids",
",",
"Tags",
":",
"[",
"]",
"*",
"ec2",
".",
"Tag",
"{",
"{",
"Key",
":",
"aws",
".",
"String",
"(",
"key",
")",
",",
"Value",
":",
"aws",
".",
"String",
"(",
"value",
")",
"}",
",",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SetTag adds a tag to the VM and its attached volumes. | [
"SetTag",
"adds",
"a",
"tag",
"to",
"the",
"VM",
"and",
"its",
"attached",
"volumes",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L109-L142 | train |
apcera/libretto | virtualmachine/aws/vm.go | SetTags | func (vm *VM) SetTags(tags map[string]string) error {
for k, v := range tags {
if err := vm.SetTag(k, v); err != nil {
return err
}
}
return nil
} | go | func (vm *VM) SetTags(tags map[string]string) error {
for k, v := range tags {
if err := vm.SetTag(k, v); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"SetTags",
"(",
"tags",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"tags",
"{",
"if",
"err",
":=",
"vm",
".",
"SetTag",
"(",
"k",
",",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetTags takes in a map of tags to set to the provisioned instance. This is
// essentially a shorter way than calling SetTag many times. | [
"SetTags",
"takes",
"in",
"a",
"map",
"of",
"tags",
"to",
"set",
"to",
"the",
"provisioned",
"instance",
".",
"This",
"is",
"essentially",
"a",
"shorter",
"way",
"than",
"calling",
"SetTag",
"many",
"times",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L146-L153 | train |
apcera/libretto | virtualmachine/aws/vm.go | Provision | func (vm *VM) Provision() error {
wait() // Avoid the AWS rate limit.
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
resp, err := svc.RunInstances(instanceInfo(vm))
if err != nil {
return fmt.Errorf("Failed to create instance: %v", err)
}
if hasInstanceID(resp.Instances[0]) {
vm.InstanceID = *resp.Instances[0].InstanceId
} else {
return ErrNoInstanceID
}
if err := waitUntilReady(svc, vm.InstanceID); err != nil {
return err
}
if vm.DeleteNonRootVolumeOnDestroy {
return setNonRootDeleteOnDestroy(svc, vm.InstanceID, true)
}
if vm.Name != "" {
if err := vm.SetTag("Name", vm.GetName()); err != nil {
return err
}
}
return nil
} | go | func (vm *VM) Provision() error {
wait() // Avoid the AWS rate limit.
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
resp, err := svc.RunInstances(instanceInfo(vm))
if err != nil {
return fmt.Errorf("Failed to create instance: %v", err)
}
if hasInstanceID(resp.Instances[0]) {
vm.InstanceID = *resp.Instances[0].InstanceId
} else {
return ErrNoInstanceID
}
if err := waitUntilReady(svc, vm.InstanceID); err != nil {
return err
}
if vm.DeleteNonRootVolumeOnDestroy {
return setNonRootDeleteOnDestroy(svc, vm.InstanceID, true)
}
if vm.Name != "" {
if err := vm.SetTag("Name", vm.GetName()); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Provision",
"(",
")",
"error",
"{",
"wait",
"(",
")",
"// Avoid the AWS rate limit.",
"\n\n",
"svc",
",",
"err",
":=",
"getService",
"(",
"vm",
".",
"Region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"svc",
".",
"RunInstances",
"(",
"instanceInfo",
"(",
"vm",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"hasInstanceID",
"(",
"resp",
".",
"Instances",
"[",
"0",
"]",
")",
"{",
"vm",
".",
"InstanceID",
"=",
"*",
"resp",
".",
"Instances",
"[",
"0",
"]",
".",
"InstanceId",
"\n",
"}",
"else",
"{",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"waitUntilReady",
"(",
"svc",
",",
"vm",
".",
"InstanceID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"DeleteNonRootVolumeOnDestroy",
"{",
"return",
"setNonRootDeleteOnDestroy",
"(",
"svc",
",",
"vm",
".",
"InstanceID",
",",
"true",
")",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"vm",
".",
"SetTag",
"(",
"\"",
"\"",
",",
"vm",
".",
"GetName",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Provision creates a virtual machine on AWS. It returns an error if
// there was a problem during creation, if there was a problem adding a tag, or
// if the VM takes too long to enter "running" state. | [
"Provision",
"creates",
"a",
"virtual",
"machine",
"on",
"AWS",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"was",
"a",
"problem",
"during",
"creation",
"if",
"there",
"was",
"a",
"problem",
"adding",
"a",
"tag",
"or",
"if",
"the",
"VM",
"takes",
"too",
"long",
"to",
"enter",
"running",
"state",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L158-L192 | train |
apcera/libretto | virtualmachine/aws/vm.go | wait | func wait() {
const maxWait = 1 * time.Minute
now := time.Now().UTC()
mu.Lock()
wait := getWaitTime(now, maxWait)
mu.Unlock()
time.Sleep(wait)
interval := 500 * time.Millisecond
if wait == maxWait {
interval = maxWait
}
mu.Lock()
defer mu.Unlock()
if now.Before(nextProvision) {
nextProvision = nextProvision.Add(interval)
return
}
now = time.Now().UTC()
nextProvision = now.Add(interval)
} | go | func wait() {
const maxWait = 1 * time.Minute
now := time.Now().UTC()
mu.Lock()
wait := getWaitTime(now, maxWait)
mu.Unlock()
time.Sleep(wait)
interval := 500 * time.Millisecond
if wait == maxWait {
interval = maxWait
}
mu.Lock()
defer mu.Unlock()
if now.Before(nextProvision) {
nextProvision = nextProvision.Add(interval)
return
}
now = time.Now().UTC()
nextProvision = now.Add(interval)
} | [
"func",
"wait",
"(",
")",
"{",
"const",
"maxWait",
"=",
"1",
"*",
"time",
".",
"Minute",
"\n\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"mu",
".",
"Lock",
"(",
")",
"\n",
"wait",
":=",
"getWaitTime",
"(",
"now",
",",
"maxWait",
")",
"\n",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"time",
".",
"Sleep",
"(",
"wait",
")",
"\n\n",
"interval",
":=",
"500",
"*",
"time",
".",
"Millisecond",
"\n",
"if",
"wait",
"==",
"maxWait",
"{",
"interval",
"=",
"maxWait",
"\n",
"}",
"\n\n",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"now",
".",
"Before",
"(",
"nextProvision",
")",
"{",
"nextProvision",
"=",
"nextProvision",
".",
"Add",
"(",
"interval",
")",
"\n",
"return",
"\n",
"}",
"\n",
"now",
"=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"nextProvision",
"=",
"now",
".",
"Add",
"(",
"interval",
")",
"\n",
"}"
] | // wait implements a rate limiter that prevents more than one call every
// 0.5s. The maximum time that the caller can be delayed is 1m. | [
"wait",
"implements",
"a",
"rate",
"limiter",
"that",
"prevents",
"more",
"than",
"one",
"call",
"every",
"0",
".",
"5s",
".",
"The",
"maximum",
"time",
"that",
"the",
"caller",
"can",
"be",
"delayed",
"is",
"1m",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L196-L219 | train |
apcera/libretto | virtualmachine/aws/vm.go | Destroy | func (vm *VM) Destroy() error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
_, err = svc.TerminateInstances(&ec2.TerminateInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
})
if err != nil {
return err
}
if !vm.DeleteKeysOnDestroy {
return nil
}
vm.ResetKeyPair()
return nil
} | go | func (vm *VM) Destroy() error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
_, err = svc.TerminateInstances(&ec2.TerminateInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
})
if err != nil {
return err
}
if !vm.DeleteKeysOnDestroy {
return nil
}
vm.ResetKeyPair()
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Destroy",
"(",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"vm",
".",
"Region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"svc",
".",
"TerminateInstances",
"(",
"&",
"ec2",
".",
"TerminateInstancesInput",
"{",
"InstanceIds",
":",
"[",
"]",
"*",
"string",
"{",
"aws",
".",
"String",
"(",
"vm",
".",
"InstanceID",
")",
",",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"vm",
".",
"DeleteKeysOnDestroy",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"vm",
".",
"ResetKeyPair",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Destroy terminates the VM on AWS. It returns an error if AWS credentials are
// missing or if there is no instance ID. | [
"Destroy",
"terminates",
"the",
"VM",
"on",
"AWS",
".",
"It",
"returns",
"an",
"error",
"if",
"AWS",
"credentials",
"are",
"missing",
"or",
"if",
"there",
"is",
"no",
"instance",
"ID",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L281-L306 | train |
apcera/libretto | virtualmachine/aws/vm.go | GetState | func (vm *VM) GetState() (string, error) {
svc, err := getService(vm.Region)
if err != nil {
return "", fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return "", ErrNoInstanceID
}
stat, err := svc.DescribeInstances(&ec2.DescribeInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
})
if err != nil {
return "", fmt.Errorf("Failed to describe instance: %s", err)
}
if n := len(stat.Reservations); n < 1 {
return "", ErrNoInstance
}
if n := len(stat.Reservations[0].Instances); n < 1 {
return "", ErrNoInstance
}
return *stat.Reservations[0].Instances[0].State.Name, nil
} | go | func (vm *VM) GetState() (string, error) {
svc, err := getService(vm.Region)
if err != nil {
return "", fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return "", ErrNoInstanceID
}
stat, err := svc.DescribeInstances(&ec2.DescribeInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
})
if err != nil {
return "", fmt.Errorf("Failed to describe instance: %s", err)
}
if n := len(stat.Reservations); n < 1 {
return "", ErrNoInstance
}
if n := len(stat.Reservations[0].Instances); n < 1 {
return "", ErrNoInstance
}
return *stat.Reservations[0].Instances[0].State.Name, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetState",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"vm",
".",
"Region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"\"",
"\"",
",",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"stat",
",",
"err",
":=",
"svc",
".",
"DescribeInstances",
"(",
"&",
"ec2",
".",
"DescribeInstancesInput",
"{",
"InstanceIds",
":",
"[",
"]",
"*",
"string",
"{",
"aws",
".",
"String",
"(",
"vm",
".",
"InstanceID",
")",
",",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"n",
":=",
"len",
"(",
"stat",
".",
"Reservations",
")",
";",
"n",
"<",
"1",
"{",
"return",
"\"",
"\"",
",",
"ErrNoInstance",
"\n",
"}",
"\n",
"if",
"n",
":=",
"len",
"(",
"stat",
".",
"Reservations",
"[",
"0",
"]",
".",
"Instances",
")",
";",
"n",
"<",
"1",
"{",
"return",
"\"",
"\"",
",",
"ErrNoInstance",
"\n",
"}",
"\n\n",
"return",
"*",
"stat",
".",
"Reservations",
"[",
"0",
"]",
".",
"Instances",
"[",
"0",
"]",
".",
"State",
".",
"Name",
",",
"nil",
"\n",
"}"
] | // GetState returns the state of the VM, such as "running". An error is
// returned if the instance ID is missing, if there was a problem querying AWS,
// or if there are no instances. | [
"GetState",
"returns",
"the",
"state",
"of",
"the",
"VM",
"such",
"as",
"running",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"instance",
"ID",
"is",
"missing",
"if",
"there",
"was",
"a",
"problem",
"querying",
"AWS",
"or",
"if",
"there",
"are",
"no",
"instances",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L331-L359 | train |
apcera/libretto | virtualmachine/aws/vm.go | Halt | func (vm *VM) Halt() error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
_, err = svc.StopInstances(&ec2.StopInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
DryRun: aws.Bool(false),
Force: aws.Bool(true),
})
if err != nil {
return fmt.Errorf("Failed to stop instance: %v", err)
}
return nil
} | go | func (vm *VM) Halt() error {
svc, err := getService(vm.Region)
if err != nil {
return fmt.Errorf("failed to get AWS service: %v", err)
}
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
_, err = svc.StopInstances(&ec2.StopInstancesInput{
InstanceIds: []*string{
aws.String(vm.InstanceID),
},
DryRun: aws.Bool(false),
Force: aws.Bool(true),
})
if err != nil {
return fmt.Errorf("Failed to stop instance: %v", err)
}
return nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Halt",
"(",
")",
"error",
"{",
"svc",
",",
"err",
":=",
"getService",
"(",
"vm",
".",
"Region",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"svc",
".",
"StopInstances",
"(",
"&",
"ec2",
".",
"StopInstancesInput",
"{",
"InstanceIds",
":",
"[",
"]",
"*",
"string",
"{",
"aws",
".",
"String",
"(",
"vm",
".",
"InstanceID",
")",
",",
"}",
",",
"DryRun",
":",
"aws",
".",
"Bool",
"(",
"false",
")",
",",
"Force",
":",
"aws",
".",
"Bool",
"(",
"true",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Halt shuts down the VM on AWS. | [
"Halt",
"shuts",
"down",
"the",
"VM",
"on",
"AWS",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L362-L385 | train |
apcera/libretto | virtualmachine/aws/vm.go | SetKeyPair | func (vm *VM) SetKeyPair(privateKey string, name string) {
vm.SSHCreds.SSHPrivateKey = privateKey
vm.KeyPair = name
} | go | func (vm *VM) SetKeyPair(privateKey string, name string) {
vm.SSHCreds.SSHPrivateKey = privateKey
vm.KeyPair = name
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"SetKeyPair",
"(",
"privateKey",
"string",
",",
"name",
"string",
")",
"{",
"vm",
".",
"SSHCreds",
".",
"SSHPrivateKey",
"=",
"privateKey",
"\n",
"vm",
".",
"KeyPair",
"=",
"name",
"\n",
"}"
] | // SetKeyPair sets the given private key and AWS key name for this vm | [
"SetKeyPair",
"sets",
"the",
"given",
"private",
"key",
"and",
"AWS",
"key",
"name",
"for",
"this",
"vm"
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/aws/vm.go#L423-L426 | train |
apcera/libretto | virtualmachine/openstack/vm.go | Destroy | func (vm *VM) Destroy() error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
// Delete the floating IP first before destroying the VM
var errors []error
if vm.FloatingIP != nil {
err = floatingips.DisassociateInstance(client, vm.InstanceID, floatingips.DisassociateOpts{FloatingIP: vm.FloatingIP.IP}).ExtractErr()
if err != nil {
errors = append(errors, fmt.Errorf("unable to disassociate floating ip from instance: %s", err))
} else {
err = floatingips.Delete(client, vm.FloatingIP.ID).ExtractErr()
if err != nil {
errors = append(errors, fmt.Errorf("unable to delete floating ip: %s", err))
}
}
}
// De-attach and delete the volume, if there is an attached one
if vm.Volume.ID != "" {
err = deattachAndDeleteVolume(vm)
if err != nil {
errors = append(errors, err)
}
}
// Delete the instance
err = deleteVM(client, vm.InstanceID)
if err != nil {
errors = append(errors, err)
}
// Return all the errors
var returnedErr error
if len(errors) > 0 {
for i, err := range errors {
if i == 0 {
returnedErr = err
continue
}
returnedErr = fmt.Errorf("%s, %s", returnedErr, err)
}
}
vm.computeClient = nil
return returnedErr
} | go | func (vm *VM) Destroy() error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
// Delete the floating IP first before destroying the VM
var errors []error
if vm.FloatingIP != nil {
err = floatingips.DisassociateInstance(client, vm.InstanceID, floatingips.DisassociateOpts{FloatingIP: vm.FloatingIP.IP}).ExtractErr()
if err != nil {
errors = append(errors, fmt.Errorf("unable to disassociate floating ip from instance: %s", err))
} else {
err = floatingips.Delete(client, vm.FloatingIP.ID).ExtractErr()
if err != nil {
errors = append(errors, fmt.Errorf("unable to delete floating ip: %s", err))
}
}
}
// De-attach and delete the volume, if there is an attached one
if vm.Volume.ID != "" {
err = deattachAndDeleteVolume(vm)
if err != nil {
errors = append(errors, err)
}
}
// Delete the instance
err = deleteVM(client, vm.InstanceID)
if err != nil {
errors = append(errors, err)
}
// Return all the errors
var returnedErr error
if len(errors) > 0 {
for i, err := range errors {
if i == 0 {
returnedErr = err
continue
}
returnedErr = fmt.Errorf("%s, %s", returnedErr, err)
}
}
vm.computeClient = nil
return returnedErr
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Destroy",
"(",
")",
"error",
"{",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"client",
",",
"err",
":=",
"getComputeClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Delete the floating IP first before destroying the VM",
"var",
"errors",
"[",
"]",
"error",
"\n",
"if",
"vm",
".",
"FloatingIP",
"!=",
"nil",
"{",
"err",
"=",
"floatingips",
".",
"DisassociateInstance",
"(",
"client",
",",
"vm",
".",
"InstanceID",
",",
"floatingips",
".",
"DisassociateOpts",
"{",
"FloatingIP",
":",
"vm",
".",
"FloatingIP",
".",
"IP",
"}",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"floatingips",
".",
"Delete",
"(",
"client",
",",
"vm",
".",
"FloatingIP",
".",
"ID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// De-attach and delete the volume, if there is an attached one",
"if",
"vm",
".",
"Volume",
".",
"ID",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"deattachAndDeleteVolume",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Delete the instance",
"err",
"=",
"deleteVM",
"(",
"client",
",",
"vm",
".",
"InstanceID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Return all the errors",
"var",
"returnedErr",
"error",
"\n",
"if",
"len",
"(",
"errors",
")",
">",
"0",
"{",
"for",
"i",
",",
"err",
":=",
"range",
"errors",
"{",
"if",
"i",
"==",
"0",
"{",
"returnedErr",
"=",
"err",
"\n",
"continue",
"\n",
"}",
"\n\n",
"returnedErr",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"returnedErr",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"vm",
".",
"computeClient",
"=",
"nil",
"\n",
"return",
"returnedErr",
"\n",
"}"
] | // Destroy terminates the VM on Openstack. It returns an error if there is no instance ID. | [
"Destroy",
"terminates",
"the",
"VM",
"on",
"Openstack",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"is",
"no",
"instance",
"ID",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/vm.go#L425-L480 | train |
apcera/libretto | virtualmachine/openstack/vm.go | GetState | func (vm *VM) GetState() (string, error) {
server, err := getServer(vm)
if err != nil {
return "", err
}
if server == nil {
// VM state "unknown"
return "", lvm.ErrVMInfoFailed
}
if server.Status == StateActive {
return lvm.VMRunning, nil
} else if server.Status == StateShutOff {
return lvm.VMHalted, nil
} else if server.Status == StateError {
return lvm.VMError, nil
}
return lvm.VMUnknown, nil
} | go | func (vm *VM) GetState() (string, error) {
server, err := getServer(vm)
if err != nil {
return "", err
}
if server == nil {
// VM state "unknown"
return "", lvm.ErrVMInfoFailed
}
if server.Status == StateActive {
return lvm.VMRunning, nil
} else if server.Status == StateShutOff {
return lvm.VMHalted, nil
} else if server.Status == StateError {
return lvm.VMError, nil
}
return lvm.VMUnknown, nil
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"GetState",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"server",
",",
"err",
":=",
"getServer",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"server",
"==",
"nil",
"{",
"// VM state \"unknown\"",
"return",
"\"",
"\"",
",",
"lvm",
".",
"ErrVMInfoFailed",
"\n",
"}",
"\n\n",
"if",
"server",
".",
"Status",
"==",
"StateActive",
"{",
"return",
"lvm",
".",
"VMRunning",
",",
"nil",
"\n",
"}",
"else",
"if",
"server",
".",
"Status",
"==",
"StateShutOff",
"{",
"return",
"lvm",
".",
"VMHalted",
",",
"nil",
"\n",
"}",
"else",
"if",
"server",
".",
"Status",
"==",
"StateError",
"{",
"return",
"lvm",
".",
"VMError",
",",
"nil",
"\n",
"}",
"\n",
"return",
"lvm",
".",
"VMUnknown",
",",
"nil",
"\n",
"}"
] | // GetState returns the state of the VM, such as "ACTIVE". An error is returned
// if the instance ID is missing, if there was a problem querying Openstack, or if
// there are no instances. | [
"GetState",
"returns",
"the",
"state",
"of",
"the",
"VM",
"such",
"as",
"ACTIVE",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"instance",
"ID",
"is",
"missing",
"if",
"there",
"was",
"a",
"problem",
"querying",
"Openstack",
"or",
"if",
"there",
"are",
"no",
"instances",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/vm.go#L497-L516 | train |
apcera/libretto | virtualmachine/openstack/vm.go | Halt | func (vm *VM) Halt() error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
// Take a look at the initial state of the VM. Make sure it is in ACTIVE state
state, err := vm.GetState()
if err != nil {
return err
}
if state != lvm.VMRunning {
return fmt.Errorf("the VM is not active, so cannot be halted")
}
// Stop the VM (instance)
err = ss.Stop(client, vm.InstanceID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to stop the instance: %s", err)
}
// Wait until VM halts
return waitUntil(vm, lvm.VMHalted)
} | go | func (vm *VM) Halt() error {
if vm.InstanceID == "" {
// Probably need to call Provision first.
return ErrNoInstanceID
}
client, err := getComputeClient(vm)
if err != nil {
return fmt.Errorf("compute client is not set for the VM, %s", err)
}
// Take a look at the initial state of the VM. Make sure it is in ACTIVE state
state, err := vm.GetState()
if err != nil {
return err
}
if state != lvm.VMRunning {
return fmt.Errorf("the VM is not active, so cannot be halted")
}
// Stop the VM (instance)
err = ss.Stop(client, vm.InstanceID).ExtractErr()
if err != nil {
return fmt.Errorf("failed to stop the instance: %s", err)
}
// Wait until VM halts
return waitUntil(vm, lvm.VMHalted)
} | [
"func",
"(",
"vm",
"*",
"VM",
")",
"Halt",
"(",
")",
"error",
"{",
"if",
"vm",
".",
"InstanceID",
"==",
"\"",
"\"",
"{",
"// Probably need to call Provision first.",
"return",
"ErrNoInstanceID",
"\n",
"}",
"\n\n",
"client",
",",
"err",
":=",
"getComputeClient",
"(",
"vm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Take a look at the initial state of the VM. Make sure it is in ACTIVE state",
"state",
",",
"err",
":=",
"vm",
".",
"GetState",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"state",
"!=",
"lvm",
".",
"VMRunning",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Stop the VM (instance)",
"err",
"=",
"ss",
".",
"Stop",
"(",
"client",
",",
"vm",
".",
"InstanceID",
")",
".",
"ExtractErr",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Wait until VM halts",
"return",
"waitUntil",
"(",
"vm",
",",
"lvm",
".",
"VMHalted",
")",
"\n",
"}"
] | // Halt shuts down the insance on Openstack. | [
"Halt",
"shuts",
"down",
"the",
"insance",
"on",
"Openstack",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/openstack/vm.go#L519-L548 | train |
apcera/libretto | virtualmachine/gcp/util.go | getInstance | func (svc *googleService) getInstance() (*googlecloud.Instance, error) {
return svc.service.Instances.Get(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
} | go | func (svc *googleService) getInstance() (*googlecloud.Instance, error) {
return svc.service.Instances.Get(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"getInstance",
"(",
")",
"(",
"*",
"googlecloud",
".",
"Instance",
",",
"error",
")",
"{",
"return",
"svc",
".",
"service",
".",
"Instances",
".",
"Get",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"svc",
".",
"vm",
".",
"Name",
")",
".",
"Do",
"(",
")",
"\n",
"}"
] | // get instance from current VM definition. | [
"get",
"instance",
"from",
"current",
"VM",
"definition",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L76-L78 | train |
apcera/libretto | virtualmachine/gcp/util.go | waitForOperation | func waitForOperation(timeout int, funcOperation func() (*googlecloud.Operation, error)) error {
var op *googlecloud.Operation
var err error
for i := 0; i < timeout; i++ {
op, err = funcOperation()
if err != nil {
return err
}
if op.Status == "DONE" {
if op.Error != nil {
return fmt.Errorf("operation error: %v", *op.Error.Errors[0])
}
return nil
}
time.Sleep(1 * time.Second)
}
return fmt.Errorf("operation timeout, operations status: %v", op.Status)
} | go | func waitForOperation(timeout int, funcOperation func() (*googlecloud.Operation, error)) error {
var op *googlecloud.Operation
var err error
for i := 0; i < timeout; i++ {
op, err = funcOperation()
if err != nil {
return err
}
if op.Status == "DONE" {
if op.Error != nil {
return fmt.Errorf("operation error: %v", *op.Error.Errors[0])
}
return nil
}
time.Sleep(1 * time.Second)
}
return fmt.Errorf("operation timeout, operations status: %v", op.Status)
} | [
"func",
"waitForOperation",
"(",
"timeout",
"int",
",",
"funcOperation",
"func",
"(",
")",
"(",
"*",
"googlecloud",
".",
"Operation",
",",
"error",
")",
")",
"error",
"{",
"var",
"op",
"*",
"googlecloud",
".",
"Operation",
"\n",
"var",
"err",
"error",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"timeout",
";",
"i",
"++",
"{",
"op",
",",
"err",
"=",
"funcOperation",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"op",
".",
"Status",
"==",
"\"",
"\"",
"{",
"if",
"op",
".",
"Error",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"*",
"op",
".",
"Error",
".",
"Errors",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"op",
".",
"Status",
")",
"\n",
"}"
] | // waitForOperation pulls to wait for the operation to finish. | [
"waitForOperation",
"pulls",
"to",
"wait",
"for",
"the",
"operation",
"to",
"finish",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L81-L101 | train |
apcera/libretto | virtualmachine/gcp/util.go | waitForOperationReady | func (svc *googleService) waitForOperationReady(operation string) error {
return waitForOperation(OperationTimeout, func() (*googlecloud.Operation, error) {
return svc.service.ZoneOperations.Get(svc.vm.Project, svc.vm.Zone, operation).Do()
})
} | go | func (svc *googleService) waitForOperationReady(operation string) error {
return waitForOperation(OperationTimeout, func() (*googlecloud.Operation, error) {
return svc.service.ZoneOperations.Get(svc.vm.Project, svc.vm.Zone, operation).Do()
})
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"waitForOperationReady",
"(",
"operation",
"string",
")",
"error",
"{",
"return",
"waitForOperation",
"(",
"OperationTimeout",
",",
"func",
"(",
")",
"(",
"*",
"googlecloud",
".",
"Operation",
",",
"error",
")",
"{",
"return",
"svc",
".",
"service",
".",
"ZoneOperations",
".",
"Get",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"operation",
")",
".",
"Do",
"(",
")",
"\n",
"}",
")",
"\n",
"}"
] | // waitForOperationReady waits for the regional operation to finish. | [
"waitForOperationReady",
"waits",
"for",
"the",
"regional",
"operation",
"to",
"finish",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L104-L108 | train |
apcera/libretto | virtualmachine/gcp/util.go | createDisks | func (svc *googleService) createDisks() (disks []*googlecloud.AttachedDisk, err error) {
if len(svc.vm.Disks) == 0 {
return nil, errors.New("no disks were found")
}
image, err := svc.getImage()
if err != nil {
return nil, err
}
for i, disk := range svc.vm.Disks {
if i == 0 {
// First one is booted device, it will created in VM provision stage
disks = append(disks, &googlecloud.AttachedDisk{
Type: "PERSISTENT",
Mode: "READ_WRITE",
Kind: "compute#attachedDisk",
Boot: true,
AutoDelete: disk.AutoDelete,
InitializeParams: &googlecloud.AttachedDiskInitializeParams{
SourceImage: image.SelfLink,
DiskSizeGb: int64(disk.DiskSizeGb),
DiskType: fmt.Sprintf("zones/%s/diskTypes/%s", svc.vm.Zone, disk.DiskType),
},
})
continue
}
// Reuse the existing disk, create non-booted devices if it does not exist
searchDisk, _ := svc.getDisk(disk.Name)
if searchDisk == nil {
d := &googlecloud.Disk{
Name: disk.Name,
SizeGb: int64(disk.DiskSizeGb),
Type: fmt.Sprintf("zones/%s/diskTypes/%s", svc.vm.Zone, disk.DiskType),
}
op, err := svc.service.Disks.Insert(svc.vm.Project, svc.vm.Zone, d).Do()
if err != nil {
return disks, fmt.Errorf("error while creating disk %s: %v", disk.Name, err)
}
err = svc.waitForOperationReady(op.Name)
if err != nil {
return disks, fmt.Errorf("error while waiting for the disk %s ready, error: %v", disk.Name, err)
}
}
disks = append(disks, &googlecloud.AttachedDisk{
DeviceName: disk.Name,
Type: "PERSISTENT",
Mode: "READ_WRITE",
Boot: false,
AutoDelete: disk.AutoDelete,
Source: fmt.Sprintf("projects/%s/zones/%s/disks/%s", svc.vm.Project, svc.vm.Zone, disk.Name),
})
}
return disks, nil
} | go | func (svc *googleService) createDisks() (disks []*googlecloud.AttachedDisk, err error) {
if len(svc.vm.Disks) == 0 {
return nil, errors.New("no disks were found")
}
image, err := svc.getImage()
if err != nil {
return nil, err
}
for i, disk := range svc.vm.Disks {
if i == 0 {
// First one is booted device, it will created in VM provision stage
disks = append(disks, &googlecloud.AttachedDisk{
Type: "PERSISTENT",
Mode: "READ_WRITE",
Kind: "compute#attachedDisk",
Boot: true,
AutoDelete: disk.AutoDelete,
InitializeParams: &googlecloud.AttachedDiskInitializeParams{
SourceImage: image.SelfLink,
DiskSizeGb: int64(disk.DiskSizeGb),
DiskType: fmt.Sprintf("zones/%s/diskTypes/%s", svc.vm.Zone, disk.DiskType),
},
})
continue
}
// Reuse the existing disk, create non-booted devices if it does not exist
searchDisk, _ := svc.getDisk(disk.Name)
if searchDisk == nil {
d := &googlecloud.Disk{
Name: disk.Name,
SizeGb: int64(disk.DiskSizeGb),
Type: fmt.Sprintf("zones/%s/diskTypes/%s", svc.vm.Zone, disk.DiskType),
}
op, err := svc.service.Disks.Insert(svc.vm.Project, svc.vm.Zone, d).Do()
if err != nil {
return disks, fmt.Errorf("error while creating disk %s: %v", disk.Name, err)
}
err = svc.waitForOperationReady(op.Name)
if err != nil {
return disks, fmt.Errorf("error while waiting for the disk %s ready, error: %v", disk.Name, err)
}
}
disks = append(disks, &googlecloud.AttachedDisk{
DeviceName: disk.Name,
Type: "PERSISTENT",
Mode: "READ_WRITE",
Boot: false,
AutoDelete: disk.AutoDelete,
Source: fmt.Sprintf("projects/%s/zones/%s/disks/%s", svc.vm.Project, svc.vm.Zone, disk.Name),
})
}
return disks, nil
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"createDisks",
"(",
")",
"(",
"disks",
"[",
"]",
"*",
"googlecloud",
".",
"AttachedDisk",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"svc",
".",
"vm",
".",
"Disks",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"image",
",",
"err",
":=",
"svc",
".",
"getImage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"disk",
":=",
"range",
"svc",
".",
"vm",
".",
"Disks",
"{",
"if",
"i",
"==",
"0",
"{",
"// First one is booted device, it will created in VM provision stage",
"disks",
"=",
"append",
"(",
"disks",
",",
"&",
"googlecloud",
".",
"AttachedDisk",
"{",
"Type",
":",
"\"",
"\"",
",",
"Mode",
":",
"\"",
"\"",
",",
"Kind",
":",
"\"",
"\"",
",",
"Boot",
":",
"true",
",",
"AutoDelete",
":",
"disk",
".",
"AutoDelete",
",",
"InitializeParams",
":",
"&",
"googlecloud",
".",
"AttachedDiskInitializeParams",
"{",
"SourceImage",
":",
"image",
".",
"SelfLink",
",",
"DiskSizeGb",
":",
"int64",
"(",
"disk",
".",
"DiskSizeGb",
")",
",",
"DiskType",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"disk",
".",
"DiskType",
")",
",",
"}",
",",
"}",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// Reuse the existing disk, create non-booted devices if it does not exist",
"searchDisk",
",",
"_",
":=",
"svc",
".",
"getDisk",
"(",
"disk",
".",
"Name",
")",
"\n",
"if",
"searchDisk",
"==",
"nil",
"{",
"d",
":=",
"&",
"googlecloud",
".",
"Disk",
"{",
"Name",
":",
"disk",
".",
"Name",
",",
"SizeGb",
":",
"int64",
"(",
"disk",
".",
"DiskSizeGb",
")",
",",
"Type",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"disk",
".",
"DiskType",
")",
",",
"}",
"\n\n",
"op",
",",
"err",
":=",
"svc",
".",
"service",
".",
"Disks",
".",
"Insert",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"d",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"disks",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"disk",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"svc",
".",
"waitForOperationReady",
"(",
"op",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"disks",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"disk",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"disks",
"=",
"append",
"(",
"disks",
",",
"&",
"googlecloud",
".",
"AttachedDisk",
"{",
"DeviceName",
":",
"disk",
".",
"Name",
",",
"Type",
":",
"\"",
"\"",
",",
"Mode",
":",
"\"",
"\"",
",",
"Boot",
":",
"false",
",",
"AutoDelete",
":",
"disk",
".",
"AutoDelete",
",",
"Source",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"disk",
".",
"Name",
")",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"disks",
",",
"nil",
"\n",
"}"
] | // createDisks creates non-booted disk. | [
"createDisks",
"creates",
"non",
"-",
"booted",
"disk",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L124-L183 | train |
apcera/libretto | virtualmachine/gcp/util.go | getDisk | func (svc *googleService) getDisk(name string) (*googlecloud.Disk, error) {
return svc.service.Disks.Get(svc.vm.Project, svc.vm.Zone, name).Do()
} | go | func (svc *googleService) getDisk(name string) (*googlecloud.Disk, error) {
return svc.service.Disks.Get(svc.vm.Project, svc.vm.Zone, name).Do()
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"getDisk",
"(",
"name",
"string",
")",
"(",
"*",
"googlecloud",
".",
"Disk",
",",
"error",
")",
"{",
"return",
"svc",
".",
"service",
".",
"Disks",
".",
"Get",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"name",
")",
".",
"Do",
"(",
")",
"\n",
"}"
] | // getDisk retrieves the Disk object. | [
"getDisk",
"retrieves",
"the",
"Disk",
"object",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L186-L188 | train |
apcera/libretto | virtualmachine/gcp/util.go | deleteDisk | func (svc *googleService) deleteDisk(name string) error {
op, err := svc.service.Disks.Delete(svc.vm.Project, svc.vm.Zone, name).Do()
if err != nil {
return err
}
return svc.waitForOperationReady(op.Name)
} | go | func (svc *googleService) deleteDisk(name string) error {
op, err := svc.service.Disks.Delete(svc.vm.Project, svc.vm.Zone, name).Do()
if err != nil {
return err
}
return svc.waitForOperationReady(op.Name)
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"deleteDisk",
"(",
"name",
"string",
")",
"error",
"{",
"op",
",",
"err",
":=",
"svc",
".",
"service",
".",
"Disks",
".",
"Delete",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"name",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"svc",
".",
"waitForOperationReady",
"(",
"op",
".",
"Name",
")",
"\n",
"}"
] | // deleteDisk deletes the persistent disk. | [
"deleteDisk",
"deletes",
"the",
"persistent",
"disk",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L191-L198 | train |
apcera/libretto | virtualmachine/gcp/util.go | deleteDisks | func (svc *googleService) deleteDisks() (errs []error) {
for _, disk := range svc.vm.Disks {
err := svc.deleteDisk(disk.Name)
if err != nil {
errs = append(errs, err)
}
}
return errs
} | go | func (svc *googleService) deleteDisks() (errs []error) {
for _, disk := range svc.vm.Disks {
err := svc.deleteDisk(disk.Name)
if err != nil {
errs = append(errs, err)
}
}
return errs
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"deleteDisks",
"(",
")",
"(",
"errs",
"[",
"]",
"error",
")",
"{",
"for",
"_",
",",
"disk",
":=",
"range",
"svc",
".",
"vm",
".",
"Disks",
"{",
"err",
":=",
"svc",
".",
"deleteDisk",
"(",
"disk",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"errs",
"\n",
"}"
] | // deleteDisks deletes all the persistent disk. | [
"deleteDisks",
"deletes",
"all",
"the",
"persistent",
"disk",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L201-L209 | train |
apcera/libretto | virtualmachine/gcp/util.go | getIPs | func (svc *googleService) getIPs() ([]net.IP, error) {
instance, err := svc.service.Instances.Get(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
if err != nil {
return nil, err
}
ips := make([]net.IP, 2)
nic := instance.NetworkInterfaces[0]
publicIP := nic.AccessConfigs[0].NatIP
if publicIP == "" {
return nil, errors.New("error while retrieving public IP")
}
privateIP := nic.NetworkIP
if privateIP == "" {
return nil, errors.New("error while retrieving private IP")
}
ips[PublicIP] = net.ParseIP(publicIP)
ips[PrivateIP] = net.ParseIP(privateIP)
return ips, nil
} | go | func (svc *googleService) getIPs() ([]net.IP, error) {
instance, err := svc.service.Instances.Get(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
if err != nil {
return nil, err
}
ips := make([]net.IP, 2)
nic := instance.NetworkInterfaces[0]
publicIP := nic.AccessConfigs[0].NatIP
if publicIP == "" {
return nil, errors.New("error while retrieving public IP")
}
privateIP := nic.NetworkIP
if privateIP == "" {
return nil, errors.New("error while retrieving private IP")
}
ips[PublicIP] = net.ParseIP(publicIP)
ips[PrivateIP] = net.ParseIP(privateIP)
return ips, nil
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"getIPs",
"(",
")",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"error",
")",
"{",
"instance",
",",
"err",
":=",
"svc",
".",
"service",
".",
"Instances",
".",
"Get",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"svc",
".",
"vm",
".",
"Name",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ips",
":=",
"make",
"(",
"[",
"]",
"net",
".",
"IP",
",",
"2",
")",
"\n",
"nic",
":=",
"instance",
".",
"NetworkInterfaces",
"[",
"0",
"]",
"\n\n",
"publicIP",
":=",
"nic",
".",
"AccessConfigs",
"[",
"0",
"]",
".",
"NatIP",
"\n",
"if",
"publicIP",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"privateIP",
":=",
"nic",
".",
"NetworkIP",
"\n",
"if",
"privateIP",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ips",
"[",
"PublicIP",
"]",
"=",
"net",
".",
"ParseIP",
"(",
"publicIP",
")",
"\n",
"ips",
"[",
"PrivateIP",
"]",
"=",
"net",
".",
"ParseIP",
"(",
"privateIP",
")",
"\n\n",
"return",
"ips",
",",
"nil",
"\n",
"}"
] | // getIPs returns the IP addresses of the GCE instance. | [
"getIPs",
"returns",
"the",
"IP",
"addresses",
"of",
"the",
"GCE",
"instance",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L212-L235 | train |
apcera/libretto | virtualmachine/gcp/util.go | start | func (svc *googleService) start() error {
instance, err := svc.getInstance()
if err != nil {
if !strings.Contains(err.Error(), "no instance found") {
return err
}
}
if instance == nil {
return errors.New("no instance found")
}
op, err := svc.service.Instances.Start(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
if err != nil {
return err
}
return svc.waitForOperationReady(op.Name)
} | go | func (svc *googleService) start() error {
instance, err := svc.getInstance()
if err != nil {
if !strings.Contains(err.Error(), "no instance found") {
return err
}
}
if instance == nil {
return errors.New("no instance found")
}
op, err := svc.service.Instances.Start(svc.vm.Project, svc.vm.Zone, svc.vm.Name).Do()
if err != nil {
return err
}
return svc.waitForOperationReady(op.Name)
} | [
"func",
"(",
"svc",
"*",
"googleService",
")",
"start",
"(",
")",
"error",
"{",
"instance",
",",
"err",
":=",
"svc",
".",
"getInstance",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"instance",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"op",
",",
"err",
":=",
"svc",
".",
"service",
".",
"Instances",
".",
"Start",
"(",
"svc",
".",
"vm",
".",
"Project",
",",
"svc",
".",
"vm",
".",
"Zone",
",",
"svc",
".",
"vm",
".",
"Name",
")",
".",
"Do",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"svc",
".",
"waitForOperationReady",
"(",
"op",
".",
"Name",
")",
"\n",
"}"
] | // start starts a stopped GCE instance. | [
"start",
"starts",
"a",
"stopped",
"GCE",
"instance",
"."
] | 3178799fbb1e39c74b02e3ecf46330b3ef0ed486 | https://github.com/apcera/libretto/blob/3178799fbb1e39c74b02e3ecf46330b3ef0ed486/virtualmachine/gcp/util.go#L335-L353 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.