id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168100 | &drivers.BaseDriver{
MachineName: hostName,
StorePath: storePath,
},
}
} | |
c168101 | result = append(result, value)
}
result = append(result, values...)
return
} | |
c168102 | nil, fmt.Errorf("Unable to read TLS config: %s", err)
}
return dockerclient.NewDockerClient(url, tlsConfig)
} | |
c168103 | authConfig)
if err != nil {
return fmt.Errorf("Error while creating container: %s", err)
}
if err = docker.StartContainer(containerID, &config.HostConfig); err != nil {
return fmt.Errorf("Error while starting container: %s", err)
}
return nil
} | |
c168104 |
log.Debug(fmt.Sprintf("%s does not have any attached dependent resource.", r.ResourceType()), f)
log.Info(fmt.Sprintf("Removing %s resource...", r.ResourceType()), f)
return r.Delete(a)
}
log.Info(fmt.Sprintf("%s is still in use by other resources, skipping removal.", r.ResourceType()), f)
return nil
} | |
c168105 | defaultImage,
AvailabilityZone: defaultAvailabilityZone,
BaseDriver: &drivers.BaseDriver{
MachineName: machineName,
StorePath: storePath,
},
}
} | |
c168106 | }
if strings.Contains(name, "redhat") {
return "cloud-user"
}
if strings.Contains(name, "fedora") {
return "fedora"
}
if strings.Contains(name, "coreos") {
return "core"
}
if strings.Contains(name, "debian") {
return "debian"
}
return defaultSSHUser
}
return d.SSHUser
} | |
c168107 | &egoscale.StartVirtualMachine{
ID: d.ID,
})
return err
} | |
c168108 | &egoscale.StopVirtualMachine{
ID: d.ID,
})
return err
} | |
c168109 | &egoscale.RebootVirtualMachine{
ID: d.ID,
})
return err
} | |
c168110 | if err := client.DeleteWithContext(context.TODO(), vm); err != nil {
return err
}
}
log.Infof("The Anti-Affinity group and Security group were not removed")
return nil
} | |
c168111 | != "" {
d.UserData, err = ioutil.ReadFile(d.UserDataFile)
}
return d.UserData, err
} | |
c168112 |
certOut, err := os.Create(certFile)
if err != nil {
return err
}
pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
certOut.Close()
keyOut, err := os.OpenFile(keyFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
return err
}
pem.Encode(keyOut, &pem.Block{Type: "RSA PRI... | |
c168113 | nil {
return err
}
x509Cert, err := x509.ParseCertificate(tlsCert.Certificate[0])
if err != nil {
return err
}
derBytes, err := x509.CreateCertificate(rand.Reader, template, x509Cert, &priv.PublicKey, tlsCert.PrivateKey)
if err != nil {
return err
}
certOut, err := os.Create(opts.CertFile)
if err != ... | |
c168114 | return nil, err
}
log.Debugf("Reading client key from %s", clientKeyPath)
clientKey, err := ioutil.ReadFile(clientKeyPath)
if err != nil {
return nil, err
}
return xcg.getTLSConfig(caCert, clientCert, clientKey, false)
} | |
c168115 |
Timeout: time.Second * 20,
}
_, err = tls.DialWithDialer(dialer, "tcp", addr, tlsConfig)
if err != nil {
return false, err
}
return true, nil
} | |
c168116 | || cpuid.HasFeature(cpuid.SVM) {
return false
}
return true
} | |
c168117 | *exec.Cmd) error { return cmd.Run() },
}
} | |
c168118 |
return "docker-machine"
}
}
return fmt.Sprintf("docker-machine-driver-%s", driverName)
} | |
c168119 | it is 14
// days. Therefore user’s token will go stale every 14 days and we
// will delete the token file, re-initiate the device flow. Service
// Principal Account tokens are not subject to this limitation.
log.Debug("Validating the token.")
if err := validateToken(env, spt); err != nil {
... | |
c168120 | for azure environment: %v", err)
}
spt, err := azure.NewServicePrincipalToken(*oauthCfg, spID, spPassword, getScope(env))
if err != nil {
return nil, fmt.Errorf("Failed to create service principal token: %+v", err)
}
return spt, nil
} | |
c168121 | nil, fmt.Errorf("Failed to load token from file: %v", err)
}
spt, err := azure.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token, callback)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token: %v", err)
}
return spt, nil
} | |
c168122 | := azure.WaitForUserCompletion(&cl, deviceCode)
if err != nil {
return nil, fmt.Errorf("Failed to complete device auth: %v", err)
}
spt, err := azure.NewServicePrincipalTokenFromManualToken(oauthCfg, clientID, resource, *token)
if err != nil {
return nil, fmt.Errorf("Error constructing service principal token... | |
c168123 | filepath.Join(azureCredsPath(), fmt.Sprintf("%s.json", tenantID))
} | |
c168124 | filepath.Join(azureCredsPath(), fmt.Sprintf("%s.tenantid", subscriptionID))
} | |
c168125 | {
if err := azure.SaveToken(path, 0600, t); err != nil {
return err
}
log.Debug("Saved token to file.")
return nil
}
} | |
c168126 | debug: false,
history: NewHistoryRecorder(),
}
} | |
c168127 | useInternalIPOnly: driver.UseInternalIPOnly,
service: service,
zoneURL: apiURL + driver.Project + "/zones/" + driver.Zone,
globalURL: apiURL + driver.Project + "/global",
SwarmMaster: driver.SwarmMaster,
SwarmHost: driver.SwarmHost,
openPorts: driver.OpenP... | |
c168128 | {
return c.service.Disks.Get(c.project, c.zone, c.diskName()).Do()
} | |
c168129 | op, err := c.service.Disks.Delete(c.project, c.zone, c.diskName()).Do()
if err != nil {
return err
}
log.Infof("Waiting for disk to delete.")
return c.waitForRegionalOp(op.Name)
} | |
c168130 | return "", err
}
if !isName {
return c.address, nil
}
// resolve the address by name
externalAddress, err := c.service.Addresses.Get(c.project, c.region(), c.address).Do()
if err != nil {
return "", err
}
return externalAddress.Address, nil
} | |
c168131 | {
return nil
}
for proto, ports := range missingPorts {
rule.Allowed = append(rule.Allowed, &raw.FirewallAllowed{
IPProtocol: proto,
Ports: ports,
})
}
var op *raw.Operation
if create {
op, err = c.service.Firewalls.Insert(c.project, rule).Do()
} else {
op, err = c.service.Firewalls.Update(... | |
c168132 | {
return c.service.Instances.Get(c.project, c.zone, c.instanceName).Do()
} | |
c168133 | c.addFirewallTag(instance); err != nil {
return err
}
return c.uploadSSHKey(instance, d.GetSSHKeyPath())
} | |
c168134 | = append(tags.Items, firewallTargetTag)
op, err := c.service.Instances.SetTags(c.project, c.zone, instance.Name, tags).Do()
if err != nil {
return err
}
return c.waitForRegionalOp(op.Name)
} | |
c168135 | c.userName, strings.TrimSpace(string(sshKey)), c.userName)
op, err := c.service.Instances.SetMetadata(c.project, c.zone, c.instanceName, &raw.Metadata{
Fingerprint: instance.Metadata.Fingerprint,
Items: []*raw.MetadataItems{
{
Key: "sshKeys",
Value: &metaDataValue,
},
},
}).Do()
return c.wai... | |
c168136 | tags = append(tags, strings.Split(d.Tags, ",")...)
}
return tags
} | |
c168137 |
if err != nil {
return err
}
log.Infof("Waiting for instance to start.")
return c.waitForRegionalOp(op.Name)
} | |
c168138 | nil {
return fmt.Errorf("Operation error: %v", *op.Error.Errors[0])
}
break
}
time.Sleep(1 * time.Second)
}
return nil
} | |
c168139 | return c.service.ZoneOperations.Get(c.project, c.zone, name).Do()
})
} | |
c168140 | return c.service.GlobalOperations.Get(c.project, name).Do()
})
} | |
c168141 |
if c.useInternalIP {
return nic.NetworkIP, nil
}
return nic.AccessConfigs[0].NatIP, nil
} | |
c168142 | return "", err
}
log.Debugf("STDOUT:\n{\n%v}", string(stdout))
return string(stdout), nil
} | |
c168143 | }
return filepath.Join("/Applications/VMware Fusion.app/Contents/Library/", cmd)
} | |
c168144 | }
if registered {
log.Debugf("Already registered for %q", ns)
} else {
log.Info("Registering subscription to resource provider.", logutil.Fields{
"ns": ns,
"subs": a.subscriptionID,
})
if _, err := a.providersClient().Register(ns); err != nil {
return err
}
}
}
return nil
} | |
c168145 | name,
"location": location})
_, err := a.resourceGroupsClient().CreateOrUpdate(name,
resources.ResourceGroup{
Location: to.StringPtr(location),
})
return err
} | |
c168146 | return a.cleanupResourceIfExists(&vnetCleanup{rg: resourceGroup, name: name})
} | |
c168147 | Properties: &network.SubnetPropertiesFormat{
AddressPrefix: to.StringPtr(subnetPrefix),
},
}, nil)
if err != nil {
return err
}
subnet, err = a.subnetsClient().Get(resourceGroup, virtualNetwork, name, "")
ctx.SubnetID = to.String(subnet.ID)
return err
}
log.Warn("Create subnet operation... | |
c168148 | return a.cleanupResourceIfExists(&avSetCleanup{rg: resourceGroup, name: name})
} | |
c168149 | to return FQDN.", f)
if ip.Properties.DNSSettings == nil || ip.Properties.DNSSettings.Fqdn == nil {
return "", errors.New("FQDN not found on public IP address")
}
return to.String(ip.Properties.DNSSettings.Fqdn), nil
}
return to.String(ip.Properties.IPAddress), nil
} | |
c168150 | == nil || nic.Properties.IPConfigurations == nil ||
len(*nic.Properties.IPConfigurations) == 0 {
log.Debug("No IPConfigurations found on NIC", f)
return "", nil
}
return to.String((*nic.Properties.IPConfigurations)[0].Properties.PrivateIPAddress), nil
} | |
c168151 | else if !exists {
log.Info(fmt.Sprintf("%s does not exist. Skipping.", resourceType), f)
return nil
}
log.Info(fmt.Sprintf("Removing %s resource.", resourceType), f)
_, err := deleteFunc()
return err
} | |
c168152 | if err != nil {
ch <- err
return
}
if state != goalState {
log.Debug(fmt.Sprintf("Waiting %v...", powerStatePollingInterval),
logutil.Fields{
"goalState": goalState,
"state": state,
})
time.Sleep(powerStatePollingInterval)
} else {
log.Debug("Reached g... | |
c168153 | if ok && v.StatusCode == http.StatusNotFound {
return false, nil
}
return false, v
} | |
c168154 | osDiskStorageContainerURL(account, vmName) // has trailing slash
blobName := fmt.Sprintf(fmtOSDiskBlobName, vmName)
return containerURL + blobName
} | |
c168155 | fmt.Sprintf("%s%s/", to.String(account.PrimaryEndpoints.Blob), osDiskStorageContainerName(vmName))
} | |
c168156 | gossh.NewPublicKey(&priv.PublicKey)
if err != nil {
return nil, ErrPublicKey
}
return &KeyPair{
PrivateKey: privDer,
PublicKey: gossh.MarshalAuthorizedKey(pubSSH),
}, nil
} | |
c168157 |
io.WriteString(h, string(b))
return fmt.Sprintf("%x", h.Sum(nil))
} | |
c168158 | kp.WriteToFile(path, fmt.Sprintf("%s.pub", path)); err != nil {
return fmt.Errorf("Error writing keys to file(s): %s", err)
}
}
return nil
} | |
c168159 |
// Cache the result
if err := saveTenantID(fp, tenantID); err != nil {
return "", fmt.Errorf("Failed to save tenant ID: %v", err)
}
log.Debugf("Cached tenant ID to file: %s", fp)
}
log.Debug("Found AAD Tenant ID.", logutil.Fields{
"tenant": tenantID,
"subs": subscriptionID})
return tenantID, nil
} | |
c168160 | return "", fmt.Errorf("Header %v not found in Get Subscription response", hdrKey)
}
// Example value for hdr:
// Bearer authorization_uri="https://login.windows.net/996fe9d1-6171-40aa-945b-4c64b63bf655", error="invalid_token", error_description="The authentication failed because of missing 'Authorization' header... | |
c168161 | %v", err)
}
f.Close()
// atomic move by rename
if err := os.Rename(fp, path); err != nil {
return fmt.Errorf("Failed to rename file. src=%s dst=%s error=%v", fp, path, err)
}
if err := os.Chmod(path, perm); err != nil {
return fmt.Errorf("Failed to chmod the file %s: %v", path, err)
}
return nil
} | |
c168162 | version.FullVersion(),
Synchronous: true,
PanicHandler: func() {},
Logger: new(logger),
})
metaData := bugsnag.MetaData{}
metaData.Add("app", "compiler", fmt.Sprintf("%s (%s)", runtime.Compiler, runtime.Version()))
metaData.Add("device", "os", runtime.GOOS)
metaData.Add("device", "arch... | |
c168163 | d.Unlock()
return d.Driver.Create()
} | |
c168164 | defer d.Unlock()
return d.Driver.DriverName()
} | |
c168165 | defer d.Unlock()
return d.Driver.GetCreateFlags()
} | |
c168166 | {
d.Lock()
defer d.Unlock()
return d.Driver.GetMachineName()
} | |
c168167 |
defer d.Unlock()
return d.Driver.GetSSHHostname()
} | |
c168168 | {
d.Lock()
defer d.Unlock()
return d.Driver.GetSSHKeyPath()
} | |
c168169 | {
d.Lock()
defer d.Unlock()
return d.Driver.GetSSHUsername()
} | |
c168170 | d.Unlock()
return d.Driver.Kill()
} | |
c168171 | d.Unlock()
return d.Driver.Remove()
} | |
c168172 | d.Unlock()
return d.Driver.Start()
} | |
c168173 | d.Unlock()
return d.Driver.Stop()
} | |
c168174 | hostV0.SwarmHost,
Master: hostV0.SwarmMaster,
}
hostV1.HostOptions.AuthOptions = &AuthOptionsV1{
StorePath: hostV0.StorePath,
CaCertPath: hostV0.CaCertPath,
CaCertRemotePath: "",
ServerCertPath: hostV0.ServerCertPath,
ServerKeyPath: hostV0.ServerKeyPath,
Cli... | |
c168175 | m.ServerCertPath,
ServerKeyPath: m.ServerKeyPath,
ClientKeyPath: "",
ServerCertRemotePath: "",
ServerKeyRemotePath: "",
CaPrivateKeyPath: m.PrivateKeyPath,
ClientCertPath: m.ClientCertPath,
}
hostMetadata.ConfigVersion = m.ConfigVersion
return hostMetadata
} | |
c168176 | syscall.UTF16ToString(pe.ExeFile[:])
return name, int(pe.ParentProcessID), nil
} | |
c168177 | MachineImage: defaultImageName,
Network: defaultNetwork,
Subnetwork: defaultSubnetwork,
ServiceAccount: defaultServiceAccount,
Scopes: defaultScopes,
BaseDriver: &drivers.BaseDriver{
SSHUser: defaultUser,
MachineName: machineName,
StorePath: storePath,
},
}
} | |
c168178 | flags.Bool("google-use-internal-ip-only")
d.UseInternalIPOnly = flags.Bool("google-use-internal-ip-only")
d.ServiceAccount = flags.String("google-service-account")
d.Scopes = flags.String("google-scopes")
d.Tags = flags.String("google-tags")
d.OpenPorts = flags.StringSlice("google-open-port")
}
d.SSHUser =... | |
c168179 | if the instance already exists")
instance, _ := c.instance()
if d.UseExisting {
if instance == nil {
return fmt.Errorf("unable to find instance %q in zone %q", d.MachineName, d.Zone)
}
} else {
if instance != nil {
return fmt.Errorf("instance %q already exists in zone %q", d.MachineName, d.Zone)
}
}... | |
c168180 | }
if err := c.openFirewallPorts(d); err != nil {
return err
}
if d.UseExisting {
return c.configureInstance(d)
}
return c.createInstance(d)
} | |
c168181 | return "", err
}
if ip == "" {
return "", drivers.ErrHostIsNotRunning
}
return ip, nil
} | |
c168182 | state.Stopped, nil
}
switch instance.Status {
case "PROVISIONING", "STAGING":
return state.Starting, nil
case "RUNNING":
return state.Running, nil
case "STOPPING", "STOPPED", "TERMINATED":
return state.Stopped, nil
}
return state.None, nil
} | |
c168183 |
} else {
if err := c.startInstance(); err != nil {
return err
}
}
d.IPAddress, err = d.GetIP()
return err
} | |
c168184 | if err := c.stopInstance(); err != nil {
return err
}
d.IPAddress = ""
return nil
} | |
c168185 | err
}
}
if err := c.deleteDisk(); err != nil {
if isNotFound(err) {
log.Warn("Remote disk does not exist, proceeding")
} else {
return err
}
}
return nil
} | |
c168186 |
// piece of info.
d := &Driver{
BaseDriver: &drivers.BaseDriver{
SSHUser: defaultSSHUser,
MachineName: hostName,
StorePath: storePath,
},
}
return d
} | |
c168187 |
}
for _, f := range flags {
*f.target = fl.String(f.flag)
if *f.target == "" {
return requiredOptionError(f.flag)
}
}
// Optional flags or Flags of other types
d.Environment = fl.String(flAzureEnvironment)
d.OpenPorts = fl.StringSlice(flAzurePorts)
d.PrivateIPAddr = fl.String(flAzurePrivateIPAddr)
d.... | |
c168188 | // NOTE(ahmetalpbalkan) we could have done more checks here but Azure often
// returns meaningful error messages and it would be repeating the backend
// logic on the client side. Some examples:
// - Deployment of a machine to an existing Virtual Network fails if
// virtual network is in a different region.
... | |
c168189 | err := c.CreatePublicIPAddress(d.ctx, d.ResourceGroup, d.naming().IP(), d.Location, d.StaticPublicIP, d.DNSLabel); err != nil {
return err
}
}
if err := c.CreateNetworkInterface(d.ctx, d.ResourceGroup, d.naming().NIC(), d.Location,
d.ctx.PublicIPAddressID, d.ctx.SubnetID, d.ctx.NetworkSecurityGroupID, d.Priva... | |
c168190 | charges.")
c, err := d.newAzureClient()
if err != nil {
return err
}
if err := c.DeleteVirtualMachineIfExists(d.ResourceGroup, d.naming().VM()); err != nil {
return err
}
if err := c.DeleteNetworkInterfaceIfExists(d.ResourceGroup, d.naming().NIC()); err != nil {
return err
}
if err := c.DeletePublicIPAdd... | |
c168191 | return "", err
}
d.resolvedIP = ip
}
log.Debugf("Machine IP address resolved to: %s", d.resolvedIP)
return d.resolvedIP, nil
} | |
c168192 |
}
u := (&url.URL{
Scheme: "tcp",
Host: net.JoinHostPort(ip, fmt.Sprintf("%d", d.DockerPort)),
}).String()
log.Debugf("Machine URL is resolved to: %s", u)
return u, nil
} | |
c168193 |
}
machineState := machineStateForVMPowerState(powerState)
log.Debugf("Determined Azure PowerState=%q, docker-machine state=%q",
powerState, machineState)
return machineState, nil
} | |
c168194 | err
}
return c.StartVirtualMachine(d.ResourceGroup, d.naming().VM())
} | |
c168195 | remove the machine if you would like to avoid unexpected costs.")
return c.StopVirtualMachine(d.ResourceGroup, d.naming().VM())
} | |
c168196 | sure the reboot is waited upon.
c, err := d.newAzureClient()
if err != nil {
return err
}
return c.RestartVirtualMachine(d.ResourceGroup, d.naming().VM())
} | |
c168197 |
if err := client.Create(h); err != nil {
log.Error(err)
return
}
out, err := h.RunSSHCommand("df -h")
if err != nil {
log.Error(err)
return
}
fmt.Printf("Results of your disk space query:\n%s\n", out)
fmt.Println("Powering down machine now...")
if err := h.Stop(); err != nil {
log.Error(err)
re... | |
c168198 | _ = stderr.Close()
}()
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
if err := scanner.Err(); err != nil {
log.Error(err)
}
if err := sshClient.Wait(); err != nil {
log.Error(err)
}
fmt.Println("Powering down machine now...")
if err := h.Stop(); err != nil {
... | |
c168199 | defaultCPU,
DisableDynamicMemory: defaultDisableDynamicMemory,
BaseDriver: &drivers.BaseDriver{
MachineName: hostName,
StorePath: storePath,
},
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.