id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5200 |
CertPEM: certPEM,
KeyPEM: keyPEM,
}
} | |
c5201 | {
return errors.NotValidf("missing key PEM")
}
return nil
} | |
c5202 | err := out.Write(c.CertPEM)
return errors.Trace(err)
} | |
c5203 | err := out.Write(c.KeyPEM)
return errors.Trace(err)
} | |
c5204 |
}
data := sha256.Sum256(x509Cert.Raw)
return fmt.Sprintf("%x", data), nil
} | |
c5205 | x509Cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, errors.Trace(err)
}
return x509Cert, nil
} | |
c5206 | return api.CertificatesPost{
Certificate: base64.StdEncoding.EncodeToString(block.Bytes),
CertificatePut: api.CertificatePut{
Name: c.Name,
Type: "client",
},
}, nil
} | |
c5207 | key",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().UpdateInheritedControllerConfig()
},
},
}
} | |
c5208 | nil, jujutxn.ErrNoOperations
}
op.Assert = txn.DocExists
op.Update = bson.D{{"$set", bson.D{{"spec", spec}}}}
} else if errors.IsNotFound(err) {
op.Assert = txn.DocMissing
op.Insert = containerSpecDoc{Spec: spec}
} else {
return nil, err
}
return append(prereqOps, op), nil
}
return m.mb.db(... | |
c5209 | errors.NotFoundf(
"pod spec for %s",
names.ReadableString(appTag),
)
}
return "", errors.Trace(err)
}
return doc.Spec, nil
} | |
c5210 | PortgroupKey: dvportgroupConfig.Key,
},
}
}
var networkDevice types.VirtualVmxnet3
wakeOnLan := true
networkDevice.WakeOnLanEnabled = &wakeOnLan
networkDevice.Backing = networkBacking
if mac != "" {
if !VerifyMAC(mac) {
return nil, fmt.Errorf("Invalid MAC address: %q", mac)
}
networkDevice.Addre... | |
c5211 | v, err := strconv.ParseUint(part, 16, 8)
if err != nil {
return false
}
if i == 0 && v > 0x3f {
// 4th byte must be <= 0x3f
return false
}
}
return true
} | |
c5212 | c.client.Retrieve(ctx, refs, nil, &dvportgroups); err != nil {
return nil, nil, errors.Annotate(err, "retrieving distributed virtual portgroup details")
}
dvportgroupConfig = make(map[types.ManagedObjectReference]types.DVPortgroupConfigInfo)
allnetworks := make([]mo.Network, len(dvportgroups)+len(networks))
... | |
c5213 | c.machineIds = args
return nil
} | |
c5214 | newService(name, conf, initName, hostSeries)
if err != nil {
return nil, errors.Trace(err)
}
return service, nil
} | |
c5215 | errors.Trace(err)
}
logger.Debugf("discovered init system %q from series %q", initName, series)
return initName, nil
} | |
c5216 | "exit 1",
}
data := renderer.RenderScript(tests)
return string(data)
} | |
c5217 | := range linuxInitSystems {
cmd, ok := handler(initSystem)
if !ok {
continue
}
cases = append(cases, initSystem+")", " "+cmd, " ;;")
}
if len(cases) == 0 {
return ""
}
return fmt.Sprintf(shellCaseStatement[1:], envVarName, strings.Join(cases, "\n"), defaultCase)
} | |
c5218 | ret0, _ := ret[0].(params.ContainerManagerConfig)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5219 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostChangesForContainer", reflect.TypeOf((*MockState)(nil).HostChangesForContainer), arg0)
} | |
c5220 | varargs...)
ret0, _ := ret[0].([]provisioner.MachineResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5221 | = backups.FilenamePrefix + c.ID + ".tar.gz"
}
return filename
} | |
c5222 |
Machine: UnknownString,
Hostname: UnknownString,
Version: UnknownVersion,
}
} | |
c5223 | time.Now().UTC(),
Origin: Origin{
Version: jujuversion.Current,
},
}
} | |
c5224 | return nil, errors.Annotate(err, "could not get server secrets")
}
controllerCfg, err := db.ControllerConfig()
if err != nil {
return nil, errors.Annotate(err, "could not get controller config")
}
meta.CACert, _ = controllerCfg.CACert()
meta.CAPrivateKey = si.CAPrivateKey
return meta, nil
} | |
c5225 | err := m.SetFileInfo(size, checksum, format); err != nil {
return errors.Annotate(err, "unexpected failure")
}
m.Finished = &finished
return nil
} | |
c5226 |
Model: flat.Environment,
Machine: flat.Machine,
Hostname: flat.Hostname,
Version: flat.Version,
Series: flat.Series,
}
// TODO(wallyworld) - put these in a separate file.
meta.CACert = flat.CACert
meta.CAPrivateKey = flat.CAPrivateKey
return meta, nil
} | |
c5227 | NewMetadata()
meta.Started = time.Time{}
meta.Origin = UnknownOrigin()
err = meta.MarkComplete(size, checksum)
if err != nil {
return nil, errors.Trace(err)
}
meta.Finished = ×tamp
return meta, nil
} | |
c5228 | ControllerTag: names.NewControllerTag(rc.doc.Id),
Alias: rc.doc.Alias,
Addrs: rc.doc.Addrs,
CACert: rc.doc.CACert,
}
} | |
c5229 | Assert: txn.DocExists,
Update: bson.D{
{"$set",
bson.D{{"addresses", doc.Addrs},
{"alias", doc.Alias},
{"cacert", doc.CACert},
{"models", models.Values()}},
},
},
}, model.assertActiveOp()}
} else {
doc.Models = modelUUIDs
ops = []txn.Op{{
C: externalCon... | |
c5230 | Id: controllerUUID,
Remove: true,
}}
err := ec.st.db().RunTransaction(ops)
return errors.Annotate(err, "failed to remove external controller")
} | |
c5231 | != nil {
return nil, errors.Trace(err)
}
return &externalController{*doc}, nil
} | |
c5232 | {
case 0:
return nil, errors.NotFoundf("external controller with model %v", modelUUID)
case 1:
return &externalController{
doc: doc[0],
}, nil
}
return nil, errors.Errorf("expected 1 controller with model %v, got %d", modelUUID, len(doc))
} | |
c5233 | newEntityWatcher(ec.st, externalControllersC, controllerUUID)
} | |
c5234 | ensure
// that those which fall out of use are eventually cleaned up.
c.runExpiryWorker(10 * time.Minute)
runtime.SetFinalizer(cache, stopMacaroonCacheExpiryWorker)
return cache
} | |
c5235 | et = &expiryTime
}
c.macaroons[token] = &macaroonEntry{
ms: ms,
expiryTime: et,
}
} | |
c5236 | c.macaroons[k]
if !found {
return nil, false
}
if entry.expired(c.clock) {
delete(c.macaroons, k)
return nil, false
}
return entry.ms, true
} | |
c5237 | {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return imagemetadatamanager.NewClient(root), nil
} | |
c5238 | mock.recorder = &MockFacadeMockRecorder{mock}
return mock
} | |
c5239 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishUpgradeSeries", reflect.TypeOf((*MockFacade)(nil).FinishUpgradeSeries), arg0)
} | |
c5240 | := ret[0].(model.UpgradeSeriesStatus)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5241 | string) error {
ret := m.ctrl.Call(m, "SetMachineStatus", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c5242 | arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c5243 | := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5244 | := ret[0].([]names_v2.UnitTag)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5245 | "UnpinMachineApplications", reflect.TypeOf((*MockFacade)(nil).UnpinMachineApplications))
} | |
c5246 | varargs = append(varargs, a)
}
m.ctrl.Call(m, "Infof", varargs...)
} | |
c5247 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockLogger)(nil).Infof), varargs...)
} | |
c5248 |
mock.recorder = &MockAgentServiceMockRecorder{mock}
return mock
} | |
c5249 | := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5250 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Running", reflect.TypeOf((*MockAgentService)(nil).Running))
} | |
c5251 |
mock.recorder = &MockServiceAccessMockRecorder{mock}
return mock
} | |
c5252 | ret[0].(upgradeseries.AgentService)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5253 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverService", reflect.TypeOf((*MockServiceAccess)(nil).DiscoverService), arg0)
} | |
c5254 | := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c5255 | "ListServices", reflect.TypeOf((*MockServiceAccess)(nil).ListServices))
} | |
c5256 | mock.recorder = &MockUpgraderMockRecorder{mock}
return mock
} | |
c5257 | ret0, _ := ret[0].(error)
return ret0
} | |
c5258 | "PerformUpgrade", reflect.TypeOf((*MockUpgrader)(nil).PerformUpgrade))
} | |
c5259 | = nil
res, err = cfo.GetResource(name)
}
if err != nil {
return resource.Resource{}, nil, errors.Trace(err)
}
return res, reader, nil
} | |
c5260 | }
defer reader.Close()
res, err := cfo.SetResource(chRes, reader)
if err != nil {
return resource.Resource{}, nil, errors.Trace(err)
}
// Make sure to use the potentially updated resource details.
res, reader, err = cfo.OpenResource(res.Name)
if err != nil {
return resource.Resource{}, nil, errors.Trace(e... | |
c5261 | {
h.Mode = 0644
}
err := tarw.WriteHeader(h)
if err != nil {
return err
}
fileName := filepath.Join(dir, ent.Name())
if err := copyFile(tarw, fileName); err != nil {
return err
}
}
return nil
} | |
c5262 | nil {
return "", err
}
return fmt.Sprintf("%x", h.Sum(nil)), err
} | |
c5263 | err
}
defer f.Close()
_, err = io.Copy(w, f)
return err
} | |
c5264 |
ModTime: i.ModTime(),
AccessTime: i.ModTime(),
ChangeTime: i.ModTime(),
Uname: "ubuntu",
Gname: "ubuntu",
}
} | |
c5265 | {
err := c.Close()
if *errp == nil {
*errp = err
}
} | |
c5266 | err)
return "", err
}
jujuDir := filepath.Dir(jujuLocation)
return jujuDir, nil
} | |
c5267 | {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, false, "", err
}
}
sha256hash, err = archiveAndSHA256(w, dir)
if err != nil {
return version.Binary{}, false,... | |
c5268 | {
// No signature file found.
// Extract the version number that the jujud binary was built with.
// This is used to check compatibility with the version of the client
// being used to bootstrap.
tvers, err = getVersionFromJujud(dir)
if err != nil {
return version.Binary{}, false, errors.Trace(err)
}
... | |
c5269 | switch info.Kind {
case AgentKindMachine:
conf.Limit = map[string]string{
"nofile": "64000",
}
case AgentKindUnit:
conf.Desc = "juju unit agent for " + info.ID
}
return conf
} | |
c5270 | := "juju shutdown job"
return shutdownAfterConf(serviceName, desc), nil
} | |
c5271 | %v", id)
}
addr, err := inst.Addresses(a.callContext)
if err != nil {
return instanceInfo{}, err
}
return instanceInfo{
addr,
inst.Status(a.callContext),
}, nil
} | |
c5272 | bool {
return t.timer.Reset(d)
} | |
c5273 |
for attempt := initiateAttemptStrategy.Start(); attempt.Next(); {
err = attemptInitiateMongoServer(p.DialInfo, p.MemberHostPort)
if err == nil {
logger.Infof("replica set initiated")
return err
}
if attempt.HasNext() {
logger.Debugf("replica set initiation failed, will retry: %v", err)
}
}
return... | |
c5274 | mongo to initiate replicaset")
}
defer session.Close()
session.SetSocketTimeout(mongo.SocketTimeout)
return replicaset.Initiate(
session,
memberHostPort,
mongo.ReplicaSetName,
map[string]string{
jujuMachineKey: agent.BootstrapMachineId,
},
)
} | |
c5275 | dialInfo.Username,
Password: dialInfo.Password,
}
return peergrouper.InitiateMongoServer(params)
} | |
c5276 | I find
// no reasonable way to reach this state, yet since APIInfo has it as a
// possibility I prefer to handle it, we cannot recover from this since
// it would mean that the agent.conf is corrupted.
return "", "", errors.New("cannot obtain password to access the controller")
}
return username, password, n... | |
c5277 | oldPassword != "" {
dialInfo.Username = "admin"
dialInfo.Password = conf.OldPassword()
} else {
dialInfo.Username, dialInfo.Password, err = tagUserCredentials(conf)
if err != nil {
return nil, errors.Trace(err)
}
}
return dialInfo, nil
} | |
c5278 | }
publicAddressAddress := network.Address{
Value: publicAddress,
Type: network.DeriveAddressType(publicAddress),
}
if err := machine.SetProviderAddresses(publicAddressAddress, privateAddressAddress); err != nil {
return errors.Trace(err)
}
return nil
} | |
c5279 | := attempt.Start(); a.Next(); {
pool, err = state.OpenStatePool(state.OpenParams{
Clock: clock.WallClock,
ControllerTag: controllerTag,
ControllerModelTag: modelTag,
MongoSession: session,
NewPolicy: environsGetNewPolicyFunc(),
})
if err == nil {
return pool, ni... | |
c5280 | // runMachineUpdate only handles linux machines, what about windows?
err := runMachineUpdate(machine, setAgentAddressScript(privateAddress, publicAddress))
if err != nil {
logger.Errorf("failed updating machine: %v", err)
}
}(machine, item.model)
}
machineUpdating.Wait()
// We should return errors ... | |
c5281 | {
Address string
PubAddress string
}{stateAddr, statePubAddr})
if err != nil {
panic(errors.Annotate(err, "template error"))
}
return buf.String()
} | |
c5282 | errors.Annotatef(err, "no appropriate public address found")
}
return errors.Trace(err)
}
return runViaSSH(addr.Value, sshArg)
} | |
c5283 | userAddr := "ubuntu@" + addr
userCmd := sshCommand(userAddr, []string{"sudo", "-n", "bash", "-c " + utils.ShQuote(script)}, &sshOptions)
var stdoutBuf bytes.Buffer
var stderrBuf bytes.Buffer
userCmd.Stdout = &stdoutBuf
userCmd.Stderr = &stderrBuf
logger.Debugf("updating %s, script:\n%s", addr, script)
if err :=... | |
c5284 | return &Placement{Scope: scope, Directive: directive}, nil
}
if names.IsValidMachine(directive) {
return &Placement{Scope: MachineScope, Directive: directive}, nil
}
if isContainerType(directive) {
return &Placement{Scope: directive}, nil
}
return nil, ErrPlacementScopeMissing
} | |
c5285 | if err != nil {
panic(err)
}
return placement
} | |
c5286 | // If one client tries to update the document, and a racing client removes
// it, the former should be able to re-create the document in the second
// attempt. If the referred-to application advanced its life cycle to a not
// alive state, an error is returned after the first failing attempt.
buildTxn := func(atte... | |
c5287 |
return true, nil
} else if err == mgo.ErrNotFound {
return false, nil
} else {
return false, errors.Trace(err)
}
} | |
c5288 | st.docID(applicationname),
Remove: true,
}
} | |
c5289 |
switch err := a.st.db().RunTransaction(ops); err {
case nil:
// Assign the new unit.
unit, err := a.st.Unit(name)
if err != nil {
return err
}
if err := app.st.AssignUnit(unit, AssignNew); err != nil {
return err
}
// No need to proceed and refresh the application if this was the
//... | |
c5290 |
defer closer()
query := bson.D{{"application", app.doc.Name}, {"life", Alive}}
return units.Find(query).Count()
} | |
c5291 | return app.addUnitOps("", AddUnitParams{}, asserts)
} | |
c5292 | what to do
} else if environs.SupportsContainerAddresses(CallContext(m.st), environ) {
updateAttrs["container-networking-method"] = "provider"
} else if fanConfigured {
updateAttrs["container-networking-method"] = "fan"
} else {
updateAttrs["container-networking-method"] = "local"
}
err = m.UpdateModelConfi... | |
c5293 | common.ErrPerm
}
return &Facade{
auth: auth,
modelTag: backend.ModelTag(),
controllerTag: backend.ControllerTag(),
singularClaimer: claimer,
}, nil
} | |
c5294 | sourceFile, _ := cfg.getPackagingConfigurer().RenderSource(src)
data := []byte(sourceFile)
cmds = append(cmds, addFileCmds(repoPath, data, 0644, false)...)
return cmds
} | |
c5295 | := range slice {
if str == val {
slice = append(slice[:i], slice[i+1:]...)
}
}
return slice
} | |
c5296 | return string(s.InstanceId)
}
return s.DisplayName
} | |
c5297 |
destroyCmd,
modelcmd.WrapSkipDefaultModel,
modelcmd.WrapSkipModelFlags,
)
} | |
c5298 | errors.Trace(m.server.RemoveContainer(string(id)))
} | |
c5299 | err := m.server.CreateContainerFromSpec(spec)
if err != nil {
callback(status.ProvisioningError, fmt.Sprintf("Creating container: %v", err), nil)
return nil, nil, errors.Trace(err)
}
callback(status.Running, "Container started", nil)
return &lxdInstance{c.Name, m.server.ContainerServer},
&instance.HardwareC... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.