id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5000 | = p.updateAddressesFromSpace()
}
return errors.Annotate(err, "updating member addresses")
} | |
c5001 | }
return errors.Trace(err)
}
if addr != p.desired.members[id].Address {
p.desired.members[id].Address = addr
p.desired.isChanged = true
}
}
if len(noAddresses) > 0 {
ids := strings.Join(noAddresses, ", ")
return fmt.Errorf("no usable Mongo addresses found in configured juju-ha-space %q for mach... | |
c5002 | memberIds = append(memberIds, id)
}
sortAsInts(memberIds)
return memberIds
} | |
c5003 | filepath.Abs(p); err != nil {
return nil, err
}
fi, err := os.Stat(p)
if err != nil {
return nil, err
}
if !fi.Mode().IsDir() {
return nil, fmt.Errorf("specified source path is not a directory: %s", path)
}
return &fileStorageReader{p}, nil
} | |
c5004 | {
return nil, errors.NotFoundf("no such file with name %q", name)
}
file, err := os.Open(filename)
if err != nil {
return nil, err
}
return file, nil
} | |
c5005 | info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.IsDir() && strings.HasPrefix(path, prefix) {
names = append(names, path[len(f.path)+1:])
}
return nil
})
if err != nil && !os.IsNotExist(err) {
return nil, err
}
sort.Strings(names)
return names, nil
} | |
c5006 | utils.MakeFileURL(filepath.Join(f.path, name)), nil
} | |
c5007 | backend: backend,
pool: pool,
providers: providers,
entityWatcher: entityWatcher,
statusSetter: statusSetter,
}, nil
} | |
c5008 | if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
result.Results[i].Result = v
}
return result, nil
} | |
c5009 | len(args.Models)),
}
for i, arg := range args.Models {
err := f.setModelEnvironVersion(arg)
if err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
} | |
c5010 | return f.statusSetter.SetStatus(args)
} | |
c5011 | }
c.Tags = make([]string, len(args))
for i, arg := range args {
if names.IsValidUnit(arg) {
c.Tags[i] = names.NewUnitTag(arg).String()
} else if names.IsValidApplication(arg) {
c.Tags[i] = names.NewApplicationTag(arg).String()
} else {
return errors.Errorf("%q is not a valid unit or application", args... | |
c5012 | renderLabels(slice[i].Labels) < renderLabels(slice[j].Labels)
}
return slice[i].Metric < slice[j].Metric
} | |
c5013 | slice[j] = slice[j], slice[i]
} | |
c5014 |
for _, col := range []int{1, 2, 3, 4} {
table.RightAlign(col)
}
table.AddRow("UNIT", "TIMESTAMP", "METRIC", "VALUE", "LABELS")
for _, m := range metrics {
table.AddRow(m.Unit, m.Timestamp.Format(time.RFC3339), m.Metric, m.Value, renderLabels(m.Labels))
}
_, err := fmt.Fprint(writer, table.String())
return e... | |
c5015 | {
err := errors.Errorf("expected 1 result, got %d", len(results.Results))
return params.StatusResult{}, err
}
result := results.Results[0]
if result.Error != nil {
return params.StatusResult{}, result.Error
}
return result, nil
} | |
c5016 | != 1 {
err := errors.Errorf("expected 1 result, got %d", len(results.Results))
return false, err
}
result := results.Results[0]
if result.Error != nil {
return false, result.Error
}
return result.Result, nil
} | |
c5017 | != 1 {
err := errors.Errorf("expected 1 result, got %d", len(results.Results))
return nil, err
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
return params.NetworkAddresses(result.Addresses...), nil
} | |
c5018 | }}}
err := m.facade.FacadeCall("SetProviderAddresses", args, &result)
if err != nil {
return err
}
return result.OneError()
} | |
c5019 | mongo.Collection, expireAfter time.Duration) bakery.Storage {
return rootKeys.NewStorage(coll.Writeable().Underlying(), mgostorage.Policy{
ExpiryDuration: expireAfter,
})
},
})
} | |
c5020 | := stateenvirons.NewStorageProviderRegistry(broker)
pm := poolmanager.New(state.NewStateSettings(ctx.State()), registry)
return NewCAASOperatorProvisionerAPI(resources, authorizer, stateShim{ctx.State()}, pm, registry)
} | |
c5021 | common.NewLifeGetter(st, common.AuthFuncForTagKind(names.ApplicationTagKind)),
APIAddresser: common.NewAPIAddresser(st, resources),
auth: authorizer,
resources: resources,
state: st,
storagePoolManager: storagePoolManager,
registry: registry,
}, nil
} | |
c5022 | {
maybePoolName = storageClassName
}
providerType, attrs, err := poolStorageProvider(poolManager, registry, maybePoolName)
if err != nil && (!errors.IsNotFound(err) || poolName != "") {
return params.KubernetesFilesystemParams{}, errors.Trace(err)
}
if err == nil {
result.Provider = string(providerType)
... | |
c5023 | error {
MaybeInvalidateCredential(err, ctx)
return err
} | |
c5024 | ReadOnly: "yes",
Type: "pflash",
},
}
default:
return OS{Type: OSType{Text: "hvm"}}
}
} | |
c5025 | p.Arch() == arch.ARM64 {
return &Features{GIC: &GIC{Version: "host"}}
}
return nil
} | |
c5026 | errors.Errorf("got %d but only support devices 0-25", i)
}
return fmt.Sprintf("vd%s", string('a'+i)), nil
} | |
c5027 | "closing last-sent tracker",
)
s.releaser()
return err
} | |
c5028 |
if config.GetMachineWatcher == nil {
return errors.NotValidf("nil GetMachineWatcher")
}
if config.GetRequiredLXDProfiles == nil {
return errors.NotValidf("nil GetRequiredLXDProfiles")
}
return nil
} | |
c5029 |
config.GetRequiredLXDProfiles = func(modelName string) []string {
return []string{"default", "juju-" + modelName}
}
return newWorker(config)
} | |
c5030 | {
return nil, errors.Trace(err)
}
config.GetRequiredLXDProfiles = func(_ string) []string { return []string{"default"} }
config.GetMachineWatcher = m.WatchContainers
return newWorker(config)
} | |
c5031 | err := w.facade.Machine(tag)
return m, err
} | |
c5032 | error {
return w.catacomb.Add(new)
} | |
c5033 |
}
logger.Infof("marking agent ready for uninstall")
return ioutil.WriteFile(uninstallFile(a), nil, 0644)
} | |
c5034 |
}
logger.Infof("agent already marked ready for uninstall")
return true
} | |
c5035 | config.GateUnlocker,
targetVersion: targetVersion,
}
if err := catacomb.Invoke(catacomb.Plan{
Site: &ww.catacomb,
Init: []worker.Worker{watcher},
Work: ww.loop,
}); err != nil {
return nil, errors.Trace(err)
}
return &ww, nil
} | |
c5036 | }
}
if err := runEnvironUpgradeSteps(
config.Environ,
config.ControllerTag,
config.ModelTag,
currentVersion,
targetVersion,
setVersion,
common.NewCloudCallContext(config.CredentialAPI, nil),
); err != nil {
info := fmt.Sprintf("failed to upgrade environ: %s", err)
if err := setStatus(s... | |
c5037 | &result)
if err != nil {
return params.ErrorResults{}, err
}
if len(result.Results) != len(args.Changes) {
return params.ErrorResults{}, errors.Errorf("expected %d result(s), got %d", len(args.Changes), len(result.Results))
}
return result, nil
} | |
c5038 | return &commandsResolver{commands, commandCompleted}
} | |
c5039 | {
return nil, err
}
commandCompleted := func() {
s.commands.RemoveCommand(id)
s.commandCompleted(id)
}
return &commandCompleter{op, commandCompleted}, nil
} | |
c5040 | _, inst := range instances {
oInst := inst.(*ociInstance)
zones = append(zones, oInst.availabilityZone())
}
if len(zones) < len(ids) {
return zones, environs.ErrPartialInstances
}
return zones, nil
} | |
c5041 | args environs.StartInstanceParams) ([]string, error) {
return nil, nil
} | |
c5042 |
ret := []instances.Instance{}
for _, val := range ociInstances {
ret = append(ret, val)
}
if len(ret) < len(ids) {
return ret, environs.ErrPartialInstances
}
return ret, nil
} | |
c5043 | string, fromVersion version.Number) error {
return errors.NotImplementedf("AdoptResources")
} | |
c5044 | constraints.VirtType,
constraints.Tags,
}
validator := constraints.NewValidator()
validator.RegisterUnsupported(unsupportedConstraints)
validator.RegisterVocabulary(constraints.Arch, []string{arch.AMD64})
logger.Infof("Returning constraints validator: %v", validator)
return validator, nil
} | |
c5045 | if err != nil {
return err
}
e.ecfgMutex.Lock()
defer e.ecfgMutex.Unlock()
e.ecfgObj = ecfg
return nil
} | |
c5046 | providerCommon.HandleCredentialError(err, ctx)
return nil, errors.Trace(err)
}
ids := []instance.Id{}
for _, val := range instances {
ids = append(ids, val.Id())
}
return ids, nil
} | |
c5047 | error {
return common.Destroy(e, ctx)
} | |
c5048 | ids[i] = val.Id()
}
err = e.StopInstances(ctx, ids...)
if err != nil {
providerCommon.HandleCredentialError(err, ctx)
return errors.Trace(err)
}
logger.Debugf("Cleaning up network resources")
err = e.cleanupNetworksAndSubnets(controllerUUID, "")
if err != nil {
providerCommon.HandleCredentialError(err, c... | |
c5049 | --dport %d -j ACCEPT", apiPort)
cloudcfg.AddRunCmd(fwCmd)
cloudcfg.AddScripts("/etc/init.d/netfilter-persistent save")
case os.CentOS:
fwCmd := fmt.Sprintf("firewall-cmd --zone=public --add-port=%d/tcp --permanent", apiPort)
cloudcfg.AddRunCmd(fwCmd)
cloudcfg.AddRunCmd("firewall-cmd --reload")
}
return cl... | |
c5050 | args environs.StartInstanceParams) error {
return nil
} | |
c5051 |
defer e.ecfgMutex.Unlock()
if e.ecfgObj == nil {
return nil
}
return e.ecfgObj.Config
} | |
c5052 | instances.InstanceTypesWithCostMetadata{}, errors.NotImplementedf("InstanceTypes")
} | |
c5053 | {
hc, err := ParseHardware(args...)
if err != nil {
panic(err)
}
return hc
} | |
c5054 |
for _, raw := range raws {
if raw == "" {
continue
}
if err := hc.setRaw(raw); err != nil {
return HardwareCharacteristics{}, err
}
}
}
return hc, nil
} | |
c5055 | := strings.Split(s, ",")
return &tags
} | |
c5056 | "%s", p[:len(p)-1]) // omit trailing newline
return len(p), nil
} | |
c5057 | "dummy-endpoint",
IdentityEndpoint: "dummy-identity-endpoint",
Region: "dummy-region",
StorageEndpoint: "dummy-storage-endpoint",
Credential: &cred,
}
} | |
c5058 | Info: mongo.Info{
Addrs: addrs,
CACert: testing.CACert,
DisableTLS: !gitjujutesting.MgoServer.SSLEnabled(),
},
}
} | |
c5059 | API server, which
// may require waiting on RPC calls that interact with the
// EnvironProvider (e.g. EnvironProvider.Open).
for _, s := range oldState {
if s.httpServer != nil {
logger.Debugf("closing httpServer")
s.httpServer.Close()
}
s.destroy()
}
if mongoAlive() {
err := retry.Call(retry.CallAr... | |
c5060 | != nil {
panic(err)
}
return st.apiState
} | |
c5061 | != nil {
panic(err)
}
return st.apiStatePool
} | |
c5062 | != nil {
panic(err)
}
return st.hub
} | |
c5063 | != nil {
panic(err)
}
return st.leaseManager
} | |
c5064 | nil {
panic(err)
}
return st.controller
} | |
c5065 | newStatePolicy: newStatePolicy,
insts: make(map[instance.Id]*dummyInstance),
creator: string(buf),
}
return s
} | |
c5066 | apiserverhttp.NewMux()
s.httpServer = httptest.NewUnstartedServer(s.mux)
s.httpServer.TLS = tlsConfig
return s.httpServer.Listener.Addr().(*net.TCPAddr).Port
} | |
c5067 | dummy.supportsSpaces
dummy.supportsSpaces = supports
return current
} | |
c5068 |
dummy.supportsSpaceDiscovery = supports
return current
} | |
c5069 | != "valid" {
return fmt.Errorf("%s placement is invalid", args.Placement)
}
return nil
} | |
c5070 | != nil {
return false, err
}
dummy.mu.Lock()
defer dummy.mu.Unlock()
if !dummy.supportsSpaceDiscovery {
return false, nil
}
return true, nil
} | |
c5071 | network.Id("2"),
AvailabilityZones: []string{"zone1"},
}}}, {
Name: "Another Foo 99!",
ProviderId: "1",
Subnets: []network.SubnetInfo{{
ProviderId: network.Id("3"),
AvailabilityZones: []string{"zone1"},
}}}, {
Name: "foo-",
ProviderId: "2",
Subnets: []network.SubnetInfo{{... | |
c5072 | true},
azShim{"zone2", false},
azShim{"zone3", true},
azShim{"zone4", true},
}, nil
} | |
c5073 | returnValue[i] = availabilityZones[azIndex].Name()
} else {
// Based on knowledge of how the AZs are setup above
// in AvailabilityZones()
azIndex += 1
returnValue[i] = availabilityZones[azIndex].Name()
}
azIndex += 1
if azIndex == azMaxIndex {
azIndex = 0
}
}
return returnValue, nil
} | |
c5074 | result = append(result, allSubnets[1])
}
}
if len(subnetIds) == 0 {
result = append([]network.SubnetInfo{}, allSubnets...)
}
if len(result) == 0 {
// No results, so just return them now.
estate.ops <- OpSubnets{
Env: env.name,
InstanceId: instId,
SubnetIds: subnetIds,
Info: resu... | |
c5075 | inst0.mu.Lock()
inst0.addresses = append(inst0.addresses[:0], addrs...)
logger.Debugf("setting instance %q addresses to %v", inst0.Id(), addrs)
inst0.mu.Unlock()
} | |
c5076 | inst.(*dummyInstance)
inst0.mu.Lock()
inst0.status = status
inst0.mu.Unlock()
} | |
c5077 | inst.(*dummyInstance)
inst0.mu.Lock()
inst0.broken = methods
inst0.mu.Unlock()
} | |
c5078 | {
var rv []network.Address
for _, addr := range addresses {
if addr.Value != "100.100.100.100" {
rv = append(rv, addr)
}
}
return rv, nil
} | |
c5079 | != nil {
panic(err)
}
estate.presence.agent[agent] = status
} | |
c5080 | sku = "2012-R2-Datacenter"
default:
return nil, errors.NotSupportedf("deploying %s", series)
}
case os.CentOS:
publisher = centOSPublisher
offering = centOSOffering
switch series {
case "centos7":
sku = "7.3"
default:
return nil, errors.NotSupportedf("deploying %s", series)
}
default:
... | |
c5081 | return nil, err
}
if len(allAddresses) == 0 {
return nil, errors.New("no controller machines found")
}
apiAddrs := make([]string, 0, len(allAddresses))
for _, addrs := range allAddresses {
naddrs := networkAddresses(addrs.Addresses)
addr, ok := network.SelectControllerAddress(naddrs, false)
if ok {
ap... | |
c5082 | errors.Trace(err)
}
config, err := st.ControllerConfig()
if err != nil {
return nil, errors.Trace(err)
}
return appendPort(addrs, config.StatePort()), nil
} | |
c5083 | i := range apiHostPorts {
if filtered, ok := network.SelectHostPortsBySpaceNames(apiHostPorts[i], sp); ok {
hostPortsForAgents[i] = filtered
} else {
hostPortsForAgents[i] = apiHostPorts[i]
}
}
} else {
hostPortsForAgents = apiHostPorts
}
return hostPortsForAgents, nil
} | |
c5084 | nil {
if err == mgo.ErrNotFound {
logger.Debugf("No document for %s; using %s", apiHostPortsForAgentsKey, apiHostPortsKey)
return st.APIHostPortsForClients()
}
return nil, errors.Trace(err)
}
return hps, nil
} | |
c5085 |
defer closer()
err := controllers.Find(bson.D{{"_id", key}}).One(&doc)
if err != nil {
return nil, err
}
return networkHostsPorts(doc.APIHostPorts), nil
} | |
c5086 | string(netAddr.Scope),
Origin: string(origin),
SpaceName: string(netAddr.SpaceName),
}
} | |
c5087 | Type: network.AddressType(addr.AddressType),
Scope: network.Scope(addr.Scope),
SpaceName: network.SpaceName(addr.SpaceName),
}
} | |
c5088 | {
addrs[i] = fromNetworkAddress(netAddr, origin)
}
return addrs
} | |
c5089 |
netAddrs[i] = addr.networkAddress()
}
return netAddrs
} | |
c5090 | string(netHostPort.Scope),
Port: netHostPort.Port,
SpaceName: string(netHostPort.SpaceName),
}
} | |
c5091 | Scope: network.Scope(hp.Scope),
SpaceName: network.SpaceName(hp.SpaceName),
},
Port: hp.Port,
}
} | |
c5092 | len(netHostPorts))
for j, netHostPort := range netHostPorts {
hsps[i][j] = fromNetworkHostPort(netHostPort)
}
}
return hsps
} | |
c5093 | hps := range hsps {
netHostsPorts[i] = make([]network.HostPort, len(hps))
for j, hp := range hps {
netHostsPorts[i][j] = hp.networkHostPort()
}
}
return netHostsPorts
} | |
c5094 | reflect.DeepEqual(a, b)
} | |
c5095 | aPrime := dupeAndSort(a)
bPrime := dupeAndSort(b)
return reflect.DeepEqual(aPrime, bPrime)
} | |
c5096 | }
index--
if index < 0 {
index = len(l.connAcceptTimes) - 1
}
}
if connCount < 2 {
return 0
}
// We use as a metric how many connections per 10ms
connRate := connCount * float64(time.Second) / (1.0 + float64(latestConnTime.Sub(*earliestConnTime)))
logger.Tracef("server listener has received %d connec... | |
c5097 | pauseFactor := float64(rate-l.lowerThreshold) / float64(l.upperThreshold-l.lowerThreshold)
return l.minPause + time.Duration(float64(l.maxPause-l.minPause)*pauseFactor)
} | |
c5098 | defer client.Close()
return block.ProcessBlockedError(client.Unexpose(c.ApplicationName), block.BlockChange)
} | |
c5099 | value pair: "+s)
}
name, value := vals[0], vals[1]
if _, ok := mapping[name]; ok {
return errors.Errorf("duplicate name specified: %q", name)
}
mapping[name] = value
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.