_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5200 | NewCertificate | train | func NewCertificate(certPEM, keyPEM []byte) *Certificate {
return &Certificate{
CertPEM: certPEM,
KeyPEM: keyPEM,
}
} | go | {
"resource": ""
} |
q5201 | Validate | train | func (c *Certificate) Validate() error {
if len(c.CertPEM) == 0 {
return errors.NotValidf("missing cert PEM")
}
if len(c.KeyPEM) == 0 {
return errors.NotValidf("missing key PEM")
}
return nil
} | go | {
"resource": ""
} |
q5202 | WriteCertPEM | train | func (c *Certificate) WriteCertPEM(out io.Writer) error {
_, err := out.Write(c.CertPEM)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q5203 | WriteKeyPEM | train | func (c *Certificate) WriteKeyPEM(out io.Writer) error {
_, err := out.Write(c.KeyPEM)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q5204 | Fingerprint | train | func (c *Certificate) Fingerprint() (string, error) {
x509Cert, err := c.X509()
if err != nil {
return "", errors.Trace(err)
}
data := sha256.Sum256(x509Cert.Raw)
return fmt.Sprintf("%x", data), nil
} | go | {
"resource": ""
} |
q5205 | X509 | train | func (c *Certificate) X509() (*x509.Certificate, error) {
block, _ := pem.Decode(c.CertPEM)
if block == nil {
return nil, errors.Errorf("invalid cert PEM (%d bytes)", len(c.CertPEM))
}
x509Cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, errors.Trace(err)
}
return x509Cert, nil
} | go | {
"resource": ""
} |
q5206 | AsCreateRequest | train | func (c *Certificate) AsCreateRequest() (api.CertificatesPost, error) {
block, _ := pem.Decode(c.CertPEM)
if block == nil {
return api.CertificatesPost{}, errors.New("failed to decode certificate PEM")
}
return api.CertificatesPost{
Certificate: base64.StdEncoding.EncodeToString(block.Bytes),
CertificatePut:... | go | {
"resource": ""
} |
q5207 | stateStepsFor253 | train | func stateStepsFor253() []Step {
return []Step{
&upgradeStep{
description: "update inherited controller config global key",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return context.State().UpdateInheritedControllerConfig()
},
},
}
} | go | {
"resource": ""
} |
q5208 | SetPodSpec | train | func (m *CAASModel) SetPodSpec(appTag names.ApplicationTag, spec string) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
var prereqOps []txn.Op
app, err := m.State().Application(appTag.Id())
if err != nil {
return nil, errors.Trace(err)
}
if app.Life() != Alive {
return nil, errors.Errorf("ap... | go | {
"resource": ""
} |
q5209 | PodSpec | train | func (m *CAASModel) PodSpec(appTag names.ApplicationTag) (string, error) {
coll, cleanup := m.mb.db().GetCollection(podSpecsC)
defer cleanup()
var doc containerSpecDoc
if err := coll.FindId(applicationGlobalKey(appTag.Id())).One(&doc); err != nil {
if err == mgo.ErrNotFound {
return "", errors.NotFoundf(
"... | go | {
"resource": ""
} |
q5210 | addNetworkDevice | train | func (c *Client) addNetworkDevice(
ctx context.Context,
spec *types.VirtualMachineConfigSpec,
network *mo.Network,
mac string,
dvportgroupConfig map[types.ManagedObjectReference]types.DVPortgroupConfigInfo,
) (*types.VirtualVmxnet3, error) {
var networkBacking types.BaseVirtualDeviceBackingInfo
if dvportgroupCon... | go | {
"resource": ""
} |
q5211 | VerifyMAC | train | func VerifyMAC(mac string) bool {
parts := strings.Split(mac, ":")
if len(parts) != 6 {
return false
}
if parts[0] != "00" || parts[1] != "50" || parts[2] != "56" {
return false
}
for i, part := range parts[3:] {
v, err := strconv.ParseUint(part, 16, 8)
if err != nil {
return false
}
if i == 0 && v... | go | {
"resource": ""
} |
q5212 | computeResourceNetworks | train | func (c *Client) computeResourceNetworks(
ctx context.Context,
computeResource *mo.ComputeResource,
) ([]mo.Network, map[types.ManagedObjectReference]types.DVPortgroupConfigInfo, error) {
refsByType := make(map[string][]types.ManagedObjectReference)
for _, network := range computeResource.Network {
refsByType[net... | go | {
"resource": ""
} |
q5213 | Init | train | func (c *showMachineCommand) Init(args []string) error {
c.machineIds = args
return nil
} | go | {
"resource": ""
} |
q5214 | DiscoverService | train | func DiscoverService(name string, conf common.Conf) (Service, error) {
hostSeries := series.MustHostSeries()
initName, err := discoverInitSystem(hostSeries)
if err != nil {
return nil, errors.Trace(err)
}
service, err := newService(name, conf, initName, hostSeries)
if err != nil {
return nil, errors.Trace(er... | go | {
"resource": ""
} |
q5215 | VersionInitSystem | train | func VersionInitSystem(series string) (string, error) {
initName, err := versionInitSystem(series)
if err != nil {
return "", errors.Trace(err)
}
logger.Debugf("discovered init system %q from series %q", initName, series)
return initName, nil
} | go | {
"resource": ""
} |
q5216 | DiscoverInitSystemScript | train | func DiscoverInitSystemScript() string {
renderer := shell.BashRenderer{}
tests := []string{
discoverSystemd,
discoverUpstart,
"exit 1",
}
data := renderer.RenderScript(tests)
return string(data)
} | go | {
"resource": ""
} |
q5217 | newShellSelectCommand | train | func newShellSelectCommand(envVarName, defaultCase string, handler func(string) (string, bool)) string {
var cases []string
const shellCaseStatement = `
case "$%s" in
%s
*)
%s
;;
esac`
for _, initSystem := range linuxInitSystems {
cmd, ok := handler(initSystem)
if !ok {
continue
}
cases = append... | go | {
"resource": ""
} |
q5218 | ContainerManagerConfig | train | func (m *MockState) ContainerManagerConfig(arg0 params.ContainerManagerConfigParams) (params.ContainerManagerConfig, error) {
ret := m.ctrl.Call(m, "ContainerManagerConfig", arg0)
ret0, _ := ret[0].(params.ContainerManagerConfig)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5219 | HostChangesForContainer | train | func (mr *MockStateMockRecorder) HostChangesForContainer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostChangesForContainer", reflect.TypeOf((*MockState)(nil).HostChangesForContainer), arg0)
} | go | {
"resource": ""
} |
q5220 | Machines | train | func (m *MockState) Machines(arg0 ...names_v2.MachineTag) ([]provisioner.MachineResult, error) {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Machines", varargs...)
ret0, _ := ret[0].([]provisioner.MachineResult)
ret1, _ := ret[1].(error)
return ret0... | go | {
"resource": ""
} |
q5221 | ResolveFilename | train | func (c *downloadCommand) ResolveFilename() string {
filename := c.Filename
if filename == "" {
filename = backups.FilenamePrefix + c.ID + ".tar.gz"
}
return filename
} | go | {
"resource": ""
} |
q5222 | UnknownOrigin | train | func UnknownOrigin() Origin {
return Origin{
Model: UnknownString,
Machine: UnknownString,
Hostname: UnknownString,
Version: UnknownVersion,
}
} | go | {
"resource": ""
} |
q5223 | NewMetadata | train | func NewMetadata() *Metadata {
return &Metadata{
FileMetadata: filestorage.NewMetadata(),
// TODO(fwereade): 2016-03-17 lp:1558657
Started: time.Now().UTC(),
Origin: Origin{
Version: jujuversion.Current,
},
}
} | go | {
"resource": ""
} |
q5224 | NewMetadataState | train | func NewMetadataState(db DB, machine, series string) (*Metadata, error) {
// hostname could be derived from the model...
hostname, err := os.Hostname()
if err != nil {
// If os.Hostname() is not working, something is woefully wrong.
// Run for the hills.
return nil, errors.Annotate(err, "could not get hostname... | go | {
"resource": ""
} |
q5225 | MarkComplete | train | func (m *Metadata) MarkComplete(size int64, checksum string) error {
if size == 0 {
return errors.New("missing size")
}
if checksum == "" {
return errors.New("missing checksum")
}
format := checksumFormat
// TODO(fwereade): 2016-03-17 lp:1558657
finished := time.Now().UTC()
if err := m.SetFileInfo(size, ch... | go | {
"resource": ""
} |
q5226 | NewMetadataJSONReader | train | func NewMetadataJSONReader(in io.Reader) (*Metadata, error) {
var flat flatMetadata
if err := json.NewDecoder(in).Decode(&flat); err != nil {
return nil, errors.Trace(err)
}
meta := NewMetadata()
meta.SetID(flat.ID)
err := meta.SetFileInfo(flat.Size, flat.Checksum, flat.ChecksumFormat)
if err != nil {
retu... | go | {
"resource": ""
} |
q5227 | BuildMetadata | train | func BuildMetadata(file *os.File) (*Metadata, error) {
// Extract the file size.
fi, err := file.Stat()
if err != nil {
return nil, errors.Trace(err)
}
size := fi.Size()
// Extract the timestamp.
timestamp := fileTimestamp(fi)
// Get the checksum.
hasher := sha1.New()
_, err = io.Copy(hasher, file)
if e... | go | {
"resource": ""
} |
q5228 | ControllerInfo | train | func (rc *externalController) ControllerInfo() crossmodel.ControllerInfo {
return crossmodel.ControllerInfo{
ControllerTag: names.NewControllerTag(rc.doc.Id),
Alias: rc.doc.Alias,
Addrs: rc.doc.Addrs,
CACert: rc.doc.CACert,
}
} | go | {
"resource": ""
} |
q5229 | Save | train | func (ec *externalControllers) Save(controller crossmodel.ControllerInfo, modelUUIDs ...string) (ExternalController, error) {
if err := controller.Validate(); err != nil {
return nil, errors.Trace(err)
}
doc := externalControllerDoc{
Id: controller.ControllerTag.Id(),
Alias: controller.Alias,
Addrs: co... | go | {
"resource": ""
} |
q5230 | Remove | train | func (ec *externalControllers) Remove(controllerUUID string) error {
ops := []txn.Op{{
C: externalControllersC,
Id: controllerUUID,
Remove: true,
}}
err := ec.st.db().RunTransaction(ops)
return errors.Annotate(err, "failed to remove external controller")
} | go | {
"resource": ""
} |
q5231 | Controller | train | func (ec *externalControllers) Controller(controllerUUID string) (ExternalController, error) {
doc, err := ec.controller(controllerUUID)
if err != nil {
return nil, errors.Trace(err)
}
return &externalController{*doc}, nil
} | go | {
"resource": ""
} |
q5232 | ControllerForModel | train | func (ec *externalControllers) ControllerForModel(modelUUID string) (ExternalController, error) {
coll, closer := ec.st.db().GetCollection(externalControllersC)
defer closer()
var doc []externalControllerDoc
err := coll.Find(bson.M{"models": bson.M{"$in": []string{modelUUID}}}).All(&doc)
if err != nil {
return ... | go | {
"resource": ""
} |
q5233 | WatchController | train | func (ec *externalControllers) WatchController(controllerUUID string) NotifyWatcher {
return newEntityWatcher(ec.st, externalControllersC, controllerUUID)
} | go | {
"resource": ""
} |
q5234 | NewMacaroonCache | train | func NewMacaroonCache(clock clock.Clock) *MacaroonCache {
c := &cacheInternal{clock: clock, macaroons: make(map[string]*macaroonEntry)}
cache := &MacaroonCache{c}
// The interval to run the expiry worker is somewhat arbitrary.
// Expired macaroons will be re-issued as needed; we just want to ensure
// that those w... | go | {
"resource": ""
} |
q5235 | Upsert | train | func (c *cacheInternal) Upsert(token string, ms macaroon.Slice) {
c.Lock()
defer c.Unlock()
var et *time.Time
if expiryTime, ok := checkers.MacaroonsExpiryTime(ms); ok {
et = &expiryTime
}
c.macaroons[token] = &macaroonEntry{
ms: ms,
expiryTime: et,
}
} | go | {
"resource": ""
} |
q5236 | Get | train | func (c *cacheInternal) Get(k string) (macaroon.Slice, bool) {
c.Lock()
defer c.Unlock()
entry, found := c.macaroons[k]
if !found {
return nil, false
}
if entry.expired(c.clock) {
delete(c.macaroons, k)
return nil, false
}
return entry.ms, true
} | go | {
"resource": ""
} |
q5237 | NewImageMetadataAPI | train | func (c *cloudImageMetadataCommandBase) NewImageMetadataAPI() (*imagemetadatamanager.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return imagemetadatamanager.NewClient(root), nil
} | go | {
"resource": ""
} |
q5238 | NewMockFacade | train | func NewMockFacade(ctrl *gomock.Controller) *MockFacade {
mock := &MockFacade{ctrl: ctrl}
mock.recorder = &MockFacadeMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q5239 | FinishUpgradeSeries | train | func (mr *MockFacadeMockRecorder) FinishUpgradeSeries(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishUpgradeSeries", reflect.TypeOf((*MockFacade)(nil).FinishUpgradeSeries), arg0)
} | go | {
"resource": ""
} |
q5240 | MachineStatus | train | func (m *MockFacade) MachineStatus() (model.UpgradeSeriesStatus, error) {
ret := m.ctrl.Call(m, "MachineStatus")
ret0, _ := ret[0].(model.UpgradeSeriesStatus)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5241 | SetMachineStatus | train | func (m *MockFacade) SetMachineStatus(arg0 model.UpgradeSeriesStatus, arg1 string) error {
ret := m.ctrl.Call(m, "SetMachineStatus", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q5242 | StartUnitCompletion | train | func (m *MockFacade) StartUnitCompletion(arg0 string) error {
ret := m.ctrl.Call(m, "StartUnitCompletion", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q5243 | TargetSeries | train | func (m *MockFacade) TargetSeries() (string, error) {
ret := m.ctrl.Call(m, "TargetSeries")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5244 | UnitsCompleted | train | func (m *MockFacade) UnitsCompleted() ([]names_v2.UnitTag, error) {
ret := m.ctrl.Call(m, "UnitsCompleted")
ret0, _ := ret[0].([]names_v2.UnitTag)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5245 | UnpinMachineApplications | train | func (mr *MockFacadeMockRecorder) UnpinMachineApplications() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpinMachineApplications", reflect.TypeOf((*MockFacade)(nil).UnpinMachineApplications))
} | go | {
"resource": ""
} |
q5246 | Infof | train | func (m *MockLogger) Infof(arg0 string, arg1 ...interface{}) {
varargs := []interface{}{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
m.ctrl.Call(m, "Infof", varargs...)
} | go | {
"resource": ""
} |
q5247 | Infof | train | func (mr *MockLoggerMockRecorder) Infof(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
varargs := append([]interface{}{arg0}, arg1...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockLogger)(nil).Infof), varargs...)
} | go | {
"resource": ""
} |
q5248 | NewMockAgentService | train | func NewMockAgentService(ctrl *gomock.Controller) *MockAgentService {
mock := &MockAgentService{ctrl: ctrl}
mock.recorder = &MockAgentServiceMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q5249 | Running | train | func (m *MockAgentService) Running() (bool, error) {
ret := m.ctrl.Call(m, "Running")
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5250 | Running | train | func (mr *MockAgentServiceMockRecorder) Running() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Running", reflect.TypeOf((*MockAgentService)(nil).Running))
} | go | {
"resource": ""
} |
q5251 | NewMockServiceAccess | train | func NewMockServiceAccess(ctrl *gomock.Controller) *MockServiceAccess {
mock := &MockServiceAccess{ctrl: ctrl}
mock.recorder = &MockServiceAccessMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q5252 | DiscoverService | train | func (m *MockServiceAccess) DiscoverService(arg0 string) (upgradeseries.AgentService, error) {
ret := m.ctrl.Call(m, "DiscoverService", arg0)
ret0, _ := ret[0].(upgradeseries.AgentService)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5253 | DiscoverService | train | func (mr *MockServiceAccessMockRecorder) DiscoverService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverService", reflect.TypeOf((*MockServiceAccess)(nil).DiscoverService), arg0)
} | go | {
"resource": ""
} |
q5254 | ListServices | train | func (m *MockServiceAccess) ListServices() ([]string, error) {
ret := m.ctrl.Call(m, "ListServices")
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q5255 | ListServices | train | func (mr *MockServiceAccessMockRecorder) ListServices() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockServiceAccess)(nil).ListServices))
} | go | {
"resource": ""
} |
q5256 | NewMockUpgrader | train | func NewMockUpgrader(ctrl *gomock.Controller) *MockUpgrader {
mock := &MockUpgrader{ctrl: ctrl}
mock.recorder = &MockUpgraderMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q5257 | PerformUpgrade | train | func (m *MockUpgrader) PerformUpgrade() error {
ret := m.ctrl.Call(m, "PerformUpgrade")
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q5258 | PerformUpgrade | train | func (mr *MockUpgraderMockRecorder) PerformUpgrade() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PerformUpgrade", reflect.TypeOf((*MockUpgrader)(nil).PerformUpgrade))
} | go | {
"resource": ""
} |
q5259 | get | train | func (cfo cacheForOperations) get(name string) (resource.Resource, io.ReadCloser, error) {
if cfo.EntityCache == nil {
return resource.Resource{}, nil, errors.NotFoundf("resource %q", name)
}
res, reader, err := cfo.OpenResource(name)
if errors.IsNotFound(err) {
reader = nil
res, err = cfo.GetResource(name)
... | go | {
"resource": ""
} |
q5260 | set | train | func (cfo cacheForOperations) set(chRes charmresource.Resource, reader io.ReadCloser) (resource.Resource, io.ReadCloser, error) {
if cfo.EntityCache == nil {
res := resource.Resource{
Resource: chRes,
}
return res, reader, nil // a no-op
}
defer reader.Close()
res, err := cfo.SetResource(chRes, reader)
i... | go | {
"resource": ""
} |
q5261 | Archive | train | func Archive(w io.Writer, dir string) error {
entries, err := ioutil.ReadDir(dir)
if err != nil {
return err
}
gzw := gzip.NewWriter(w)
defer closeErrorCheck(&err, gzw)
tarw := tar.NewWriter(gzw)
defer closeErrorCheck(&err, tarw)
for _, ent := range entries {
h := tarHeader(ent)
logger.Debugf("adding e... | go | {
"resource": ""
} |
q5262 | archiveAndSHA256 | train | func archiveAndSHA256(w io.Writer, dir string) (sha256hash string, err error) {
h := sha256.New()
if err := Archive(io.MultiWriter(h, w), dir); err != nil {
return "", err
}
return fmt.Sprintf("%x", h.Sum(nil)), err
} | go | {
"resource": ""
} |
q5263 | copyFile | train | func copyFile(w io.Writer, file string) error {
f, err := os.Open(file)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(w, f)
return err
} | go | {
"resource": ""
} |
q5264 | tarHeader | train | func tarHeader(i os.FileInfo) *tar.Header {
return &tar.Header{
Typeflag: tar.TypeReg,
Name: i.Name(),
Size: i.Size(),
Mode: int64(i.Mode() & 0777),
ModTime: i.ModTime(),
AccessTime: i.ModTime(),
ChangeTime: i.ModTime(),
Uname: "ubuntu",
Gname: "ubuntu",
}
} | go | {
"resource": ""
} |
q5265 | closeErrorCheck | train | func closeErrorCheck(errp *error, c io.Closer) {
err := c.Close()
if *errp == nil {
*errp = err
}
} | go | {
"resource": ""
} |
q5266 | ExistingJujudLocation | train | func ExistingJujudLocation() (string, error) {
jujuLocation, err := findExecutable(os.Args[0])
if err != nil {
logger.Infof("%v", err)
return "", err
}
jujuDir := filepath.Dir(jujuLocation)
return jujuDir, nil
} | go | {
"resource": ""
} |
q5267 | bundleTools | train | func bundleTools(build bool, w io.Writer, forceVersion *version.Number) (_ version.Binary, official bool, sha256hash string, _ error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, false, "", err
}
defer os.RemoveAll(dir)
if err := packageLocalTools(dir, build); err != ni... | go | {
"resource": ""
} |
q5268 | JujudVersion | train | func JujudVersion(dir string) (version.Binary, bool, error) {
tvers, err := getVersionFromFile(dir)
official := err == nil
if err != nil && !errors.IsNotFound(err) && !isNoMatchingToolsChecksum(err) {
return version.Binary{}, false, errors.Trace(err)
}
if errors.IsNotFound(err) || isNoMatchingToolsChecksum(err) ... | go | {
"resource": ""
} |
q5269 | AgentConf | train | func AgentConf(info AgentInfo, renderer shell.Renderer) common.Conf {
conf := common.Conf{
Desc: fmt.Sprintf("juju agent for %s", info.name),
ExecStart: info.cmd(renderer),
Logfile: info.logFile(renderer),
Env: osenv.FeatureFlags(),
Timeout: agentServiceTimeout,
ServiceBi... | go | {
"resource": ""
} |
q5270 | ShutdownAfterConf | train | func ShutdownAfterConf(serviceName string) (common.Conf, error) {
if serviceName == "" {
return common.Conf{}, errors.New(`missing "after" service name`)
}
desc := "juju shutdown job"
return shutdownAfterConf(serviceName, desc), nil
} | go | {
"resource": ""
} |
q5271 | instInfo | train | func (a *aggregator) instInfo(id instance.Id, inst instances.Instance) (instanceInfo, error) {
if inst == nil {
return instanceInfo{}, errors.NotFoundf("instance %v", id)
}
addr, err := inst.Addresses(a.callContext)
if err != nil {
return instanceInfo{}, err
}
return instanceInfo{
addr,
inst.Status(a.call... | go | {
"resource": ""
} |
q5272 | Reset | train | func (t *Timer) Reset(d time.Duration) bool {
return t.timer.Reset(d)
} | go | {
"resource": ""
} |
q5273 | InitiateMongoServer | train | func InitiateMongoServer(p InitiateMongoParams) error {
logger.Debugf("Initiating mongo replicaset; dialInfo %#v; memberHostport %q; user %q; password %q", p.DialInfo, p.MemberHostPort, p.User, p.Password)
defer logger.Infof("finished InitiateMongoServer")
if len(p.DialInfo.Addrs) > 1 {
logger.Infof("more than on... | go | {
"resource": ""
} |
q5274 | attemptInitiateMongoServer | train | func attemptInitiateMongoServer(dialInfo *mgo.DialInfo, memberHostPort string) error {
session, err := mgo.DialWithInfo(dialInfo)
if err != nil {
return errors.Annotatef(err, "cannot dial mongo to initiate replicaset")
}
defer session.Close()
session.SetSocketTimeout(mongo.SocketTimeout)
return replicaset.Init... | go | {
"resource": ""
} |
q5275 | resetReplicaSet | train | func resetReplicaSet(dialInfo *mgo.DialInfo, memberHostPort string) error {
params := peergrouper.InitiateMongoParams{
DialInfo: dialInfo,
MemberHostPort: memberHostPort,
User: dialInfo.Username,
Password: dialInfo.Password,
}
return peergrouper.InitiateMongoServer(params)
} | go | {
"resource": ""
} |
q5276 | tagUserCredentials | train | func tagUserCredentials(conf agent.Config) (string, string, error) {
username := conf.Tag().String()
var password string
// TODO(perrito) we might need an accessor for the actual state password
// just in case it ever changes from the same as api password.
apiInfo, ok := conf.APIInfo()
if ok {
password = apiInf... | go | {
"resource": ""
} |
q5277 | newDialInfo | train | func newDialInfo(privateAddr string, conf agent.Config) (*mgo.DialInfo, error) {
dialOpts := mongo.DialOpts{Direct: true}
ssi, ok := conf.StateServingInfo()
if !ok {
return nil, errors.Errorf("cannot get state serving info to dial")
}
info := mongo.Info{
Addrs: []string{net.JoinHostPort(privateAddr, strconv.I... | go | {
"resource": ""
} |
q5278 | updateMachineAddresses | train | func updateMachineAddresses(machine *state.Machine, privateAddress, publicAddress string) error {
privateAddressAddress := network.Address{
Value: privateAddress,
Type: network.DeriveAddressType(privateAddress),
}
publicAddressAddress := network.Address{
Value: publicAddress,
Type: network.DeriveAddressTyp... | go | {
"resource": ""
} |
q5279 | connectToDB | train | func connectToDB(controllerTag names.ControllerTag, modelTag names.ModelTag, info *mongo.MongoInfo) (*state.StatePool, error) {
// We need to retry here to allow mongo to come up on the restored controller.
// The connection might succeed due to the mongo dial retries but there may still
// be a problem issuing data... | go | {
"resource": ""
} |
q5280 | updateAllMachines | train | func updateAllMachines(privateAddress, publicAddress string, machines []machineModel) error {
var machineUpdating sync.WaitGroup
for _, item := range machines {
machine := item.machine
// A newly resumed controller requires no updating, and more
// than one controller is not yet supported by this code.
if mac... | go | {
"resource": ""
} |
q5281 | setAgentAddressScript | train | func setAgentAddressScript(stateAddr, statePubAddr string) string {
var buf bytes.Buffer
err := agentAddressAndRelationsTemplate.Execute(&buf, struct {
Address string
PubAddress string
}{stateAddr, statePubAddr})
if err != nil {
panic(errors.Annotate(err, "template error"))
}
return buf.String()
} | go | {
"resource": ""
} |
q5282 | runMachineUpdate | train | func runMachineUpdate(machine *state.Machine, sshArg string) error {
addr, err := machine.PublicAddress()
if err != nil {
if network.IsNoAddressError(err) {
return errors.Annotatef(err, "no appropriate public address found")
}
return errors.Trace(err)
}
return runViaSSH(addr.Value, sshArg)
} | go | {
"resource": ""
} |
q5283 | runViaSSH | train | func runViaSSH(addr string, script string) error {
sshOptions := ssh.Options{}
sshOptions.SetIdentities("/var/lib/juju/system-identity")
// Disable host key checking. We're not pushing across anything
// sensitive, and there's no guarantee that the machine would
// have published up-to-date host key information.
... | go | {
"resource": ""
} |
q5284 | ParsePlacement | train | func ParsePlacement(directive string) (*Placement, error) {
if directive == "" {
return nil, nil
}
if colon := strings.IndexRune(directive, ':'); colon != -1 {
scope, directive := directive[:colon], directive[colon+1:]
if scope == "" {
return nil, ErrPlacementScopeMissing
}
// Sanity check: machine/cont... | go | {
"resource": ""
} |
q5285 | MustParsePlacement | train | func MustParsePlacement(directive string) *Placement {
placement, err := ParsePlacement(directive)
if err != nil {
panic(err)
}
return placement
} | go | {
"resource": ""
} |
q5286 | SetMinUnits | train | func (a *Application) SetMinUnits(minUnits int) (err error) {
defer errors.DeferredAnnotatef(&err, "cannot set minimum units for application %q", a)
defer func() {
if err == nil {
a.doc.MinUnits = minUnits
}
}()
if minUnits < 0 {
return errors.New("cannot set a negative minimum number of units")
}
app :=... | go | {
"resource": ""
} |
q5287 | doesMinUnitsExist | train | func doesMinUnitsExist(unit *Unit) (bool, error) {
minUnits, closer := unit.st.db().GetCollection(minUnitsC)
defer closer()
var result bson.D
err := minUnits.FindId(unit.ApplicationName()).Select(bson.M{"_id": 1}).One(&result)
if err == nil {
return true, nil
} else if err == mgo.ErrNotFound {
return false, n... | go | {
"resource": ""
} |
q5288 | minUnitsRemoveOp | train | func minUnitsRemoveOp(st *State, applicationname string) txn.Op {
return txn.Op{
C: minUnitsC,
Id: st.docID(applicationname),
Remove: true,
}
} | go | {
"resource": ""
} |
q5289 | EnsureMinUnits | train | func (a *Application) EnsureMinUnits() (err error) {
defer errors.DeferredAnnotatef(&err, "cannot ensure minimum units for application %q", a)
app := &Application{st: a.st, doc: a.doc}
for {
// Ensure the application is alive.
if app.doc.Life != Alive {
return errors.New("application is not alive")
}
// E... | go | {
"resource": ""
} |
q5290 | aliveUnitsCount | train | func aliveUnitsCount(app *Application) (int, error) {
units, closer := app.st.db().GetCollection(unitsC)
defer closer()
query := bson.D{{"application", app.doc.Name}, {"life", Alive}}
return units.Find(query).Count()
} | go | {
"resource": ""
} |
q5291 | ensureMinUnitsOps | train | func ensureMinUnitsOps(app *Application) (string, []txn.Op, error) {
asserts := bson.D{{"txn-revno", app.doc.TxnRevno}}
return app.addUnitOps("", AddUnitParams{}, asserts)
} | go | {
"resource": ""
} |
q5292 | AutoConfigureContainerNetworking | train | func (m *Model) AutoConfigureContainerNetworking(environ environs.BootstrapEnviron) error {
updateAttrs := make(map[string]interface{})
modelConfig, err := m.ModelConfig()
if err != nil {
return err
}
fanConfigured, err := m.discoverFan(environ, modelConfig, updateAttrs)
if err != nil {
return err
}
if mod... | go | {
"resource": ""
} |
q5293 | NewFacade | train | func NewFacade(backend Backend, claimer lease.Claimer, auth facade.Authorizer) (*Facade, error) {
if !auth.AuthController() {
return nil, common.ErrPerm
}
return &Facade{
auth: auth,
modelTag: backend.ModelTag(),
controllerTag: backend.ControllerTag(),
singularClaimer: claimer,
}, nil
... | go | {
"resource": ""
} |
q5294 | addPackageSourceCmds | train | func addPackageSourceCmds(cfg CloudConfig, src packaging.PackageSource) []string {
cmds := []string{}
// if keyfile is required, add it first
if src.Key != "" {
keyFilePath := config.YumKeyfileDir + src.KeyFileName()
cmds = append(cmds, addFileCmds(keyFilePath, []byte(src.Key), 0644, false)...)
}
repoPath :=... | go | {
"resource": ""
} |
q5295 | removeStringFromSlice | train | func removeStringFromSlice(slice []string, val string) []string {
for i, str := range slice {
if str == val {
slice = append(slice[:i], slice[i+1:]...)
}
}
return slice
} | go | {
"resource": ""
} |
q5296 | machineName | train | func (s machineStatus) machineName() string {
if s.DisplayName == "" {
return string(s.InstanceId)
}
return s.DisplayName
} | go | {
"resource": ""
} |
q5297 | NewDestroyCommand | train | func NewDestroyCommand() cmd.Command {
destroyCmd := &destroyCommand{
clock: jujuclock.WallClock,
}
destroyCmd.CanClearCurrentModel = true
return modelcmd.Wrap(
destroyCmd,
modelcmd.WrapSkipDefaultModel,
modelcmd.WrapSkipModelFlags,
)
} | go | {
"resource": ""
} |
q5298 | DestroyContainer | train | func (m *containerManager) DestroyContainer(id instance.Id) error {
return errors.Trace(m.server.RemoveContainer(string(id)))
} | go | {
"resource": ""
} |
q5299 | CreateContainer | train | func (m *containerManager) CreateContainer(
instanceConfig *instancecfg.InstanceConfig,
cons constraints.Value,
series string,
networkConfig *container.NetworkConfig,
storageConfig *container.StorageConfig,
callback environs.StatusCallbackFunc,
) (instances.Instance, *instance.HardwareCharacteristics, error) {
c... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.