id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c4400 |
config.HubName,
config.MuxName,
},
Start: config.start,
Output: transportOutput,
}
} | |
c4401 | "APIRequestDuration", reflect.TypeOf((*MockMetricsCollector)(nil).APIRequestDuration))
} | |
c4402 | m.ctrl.Call(m, "DeprecatedAPIRequestDuration")
ret0, _ := ret[0].(metricobserver.SummaryVec)
return ret0
} | |
c4403 | {
ret := m.ctrl.Call(m, "DeprecatedAPIRequestsTotal")
ret0, _ := ret[0].(metricobserver.CounterVec)
return ret0
} | |
c4404 | mock.recorder = &MockCounterVecMockRecorder{mock}
return mock
} | |
c4405 | mock.recorder = &MockSummaryVecMockRecorder{mock}
return mock
} | |
c4406 |
}
reader := r.Body
// Don't associate content with a placeholder resource.
if isPlaceholder(query) {
reader = nil
}
outRes, err := setResource(isUnit, target, userID, res, reader, rSt)
if err != nil {
return empty, errors.Annotate(err, "resource upload failed")
}
return outRes, nil
} | |
c4407 | c, err := net.DialTimeout("tcp", addr, opts.Timeout)
if err != nil {
logger.Warningf("mongodb connection failed, will retry: %v", err)
return nil, err
}
if tlsConfig != nil {
cc := tls.Client(c, tlsConfig)
if err := cc.Handshake(); err != nil {
logger.Warningf("TLS handshake failed: %v", err)
... | |
c4408 | return nil, errors.Annotate(err, "PostDial failed")
}
}
if info.Tag != nil || info.Password != "" {
user := AdminUser
if info.Tag != nil {
user = info.Tag.String()
}
if err := Login(session, user, info.Password); err != nil {
session.Close()
return nil, errors.Trace(err)
}
}
return session, ni... | |
c4409 | return MaybeUnauthorizedf(err, "cannot log in to admin database as %q", user)
}
return nil
} | |
c4410 | = errors.Unauthorizedf("unauthorized mongo access: %s", err)
}
return errors.Annotatef(err, message, args...)
} | |
c4411 | return p.VolumeSourceFunc(providerConfig)
}
return nil, errors.NotSupportedf("volumes")
} | |
c4412 | return p.FilesystemSourceFunc(providerConfig)
}
return nil, errors.NotSupportedf("filesystems")
} | |
c4413 | p.ValidateConfigFunc != nil {
return p.ValidateConfigFunc(providerConfig)
}
return nil
} | |
c4414 | p.SupportsFunc != nil {
return p.SupportsFunc(kind)
}
return true
} | |
c4415 | {
p.MethodCall(p, "Scope")
return p.StorageScope
} | |
c4416 | {
p.MethodCall(p, "DefaultPools")
return p.DefaultPools_
} | |
c4417 | ctrl}
mock.recorder = &MockRbacV1InterfaceMockRecorder{mock}
return mock
} | |
c4418 | {
ret := m.ctrl.Call(m, "ClusterRoleBindings")
ret0, _ := ret[0].(v11.ClusterRoleBindingInterface)
return ret0
} | |
c4419 | := ret[0].(v11.ClusterRoleInterface)
return ret0
} | |
c4420 | {
ret := m.ctrl.Call(m, "RoleBindings", arg0)
ret0, _ := ret[0].(v11.RoleBindingInterface)
return ret0
} | |
c4421 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleBindings", reflect.TypeOf((*MockRbacV1Interface)(nil).RoleBindings), arg0)
} | |
c4422 | {
ret := m.ctrl.Call(m, "Roles", arg0)
ret0, _ := ret[0].(v11.RoleInterface)
return ret0
} | |
c4423 | {
mock := &MockClusterRoleBindingInterface{ctrl: ctrl}
mock.recorder = &MockClusterRoleBindingInterfaceMockRecorder{mock}
return mock
} | |
c4424 | {
mock := &MockClusterRoleInterface{ctrl: ctrl}
mock.recorder = &MockClusterRoleInterfaceMockRecorder{mock}
return mock
} | |
c4425 | mock.recorder = &MockDatabaseMockRecorder{mock}
return mock
} | |
c4426 | "Copy")
ret0, _ := ret[0].(state.Database)
ret1, _ := ret[1].(state.SessionCloser)
return ret0, ret1
} | |
c4427 | := m.ctrl.Call(m, "CopyForModel", arg0)
ret0, _ := ret[0].(state.Database)
ret1, _ := ret[1].(state.SessionCloser)
return ret0, ret1
} | |
c4428 | ret[0].(mongo.Collection)
ret1, _ := ret[1].(state.SessionCloser)
return ret0, ret1
} | |
c4429 | := m.ctrl.Call(m, "GetRawCollection", arg0)
ret0, _ := ret[0].(*mgo_v2.Collection)
ret1, _ := ret[1].(state.SessionCloser)
return ret0, ret1
} | |
c4430 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunRawTransaction", reflect.TypeOf((*MockDatabase)(nil).RunRawTransaction), arg0)
} | |
c4431 | m.ctrl.Call(m, "RunTransactionFor", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | |
c4432 | := m.ctrl.Call(m, "Schema")
ret0, _ := ret[0].(state.CollectionSchema)
return ret0
} | |
c4433 | _ := ret[0].(txn.Runner)
ret1, _ := ret[1].(state.SessionCloser)
return ret0, ret1
} | |
c4434 | "TransactionRunner", reflect.TypeOf((*MockDatabase)(nil).TransactionRunner))
} | |
c4435 | err
}
metadata, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
dataToSign := metadata
if dataToSign[0] == '\n' {
dataToSign = dataToSign[1:]
}
_, err = plaintext.Write(dataToSign)
if err != nil {
return nil, err
}
err = plaintext.Close()
if err != nil {
return nil, err
}
return buf.By... | |
c4436 | be nil, but we shouldn't continue creating
return errors.Trace(err)
}
np.createBridgeFromInterface(bridgeName, deviceId, ðernet.Interface)
np.Network.Ethernets[deviceId] = ethernet
return nil
} | |
c4437 | be nil, but we shouldn't continue creating
return errors.Trace(err)
}
np.createBridgeFromInterface(bridgeName, deviceId, &vlan.Interface)
np.Network.VLANs[deviceId] = vlan
return nil
} | |
c4438 | be nil, but we shouldn't continue creating
return errors.Trace(err)
}
np.createBridgeFromInterface(bridgeName, deviceId, &bond.Interface)
np.Network.Bonds[deviceId] = bond
return nil
} | |
c4439 | }
}
}
if bridgeName == bName {
return false, errors.AlreadyExistsf(
"cannot create bridge %q with device %q - bridge %q w/ interfaces %q",
bridgeName, deviceId, bridgeName, strings.Join(bridge.Interfaces, ", "))
}
}
return true, nil
} | |
c4440 | = Bridge{
Interfaces: []string{deviceId},
Interface: *intf,
}
*intf = Interface{MTU: intf.MTU}
} | |
c4441 | np.sourceFiles = append(np.sourceFiles, fileInfo.Name())
}
}
for _, fileName := range np.sourceFiles {
err := np.readYamlFile(path.Join(np.sourceDirectory, fileName))
if err != nil {
return np, err
}
}
return np, nil
} | |
c4442 | } else {
filePath = inPath
}
tmpFilePath := fmt.Sprintf("%s.tmp.%d", filePath, time.Now().UnixNano())
out, err := Marshal(np)
if err != nil {
return "", err
}
err = ioutil.WriteFile(tmpFilePath, out, 0644)
if err != nil {
return "", err
}
err = os.Rename(tmpFilePath, filePath)
if err != nil {
return ... | |
c4443 | rename %s to %s - %q", newFile, oldFile, err.Error())
}
}
np.backedFiles = nil
np.writtenFile = ""
return nil
} | |
c4444 | return "", "", errors.Trace(err)
}
vlan, err := np.FindVLANByMAC(mac)
if err == nil {
return vlan, TypeVLAN, nil
}
ethernet, err := np.FindEthernetByMAC(mac)
if err == nil {
return ethernet, TypeEthernet, nil
}
}
return "", "", errors.NotFoundf("device - name %q MAC %q", name, mac)
} | |
c4445 | st,
resources: resources,
authorizer: authorizer,
}
} | |
c4446 |
// have no state to transmit.
if _, ok := <-watch.Changes(); ok {
result.NotifyWatcherId = m.resources.Register(watch)
} else {
return result, watcher.EnsureErr(watch)
}
return result, nil
} | |
c4447 | nil {
return result, err
}
result.Config = config.AllAttrs()
return result, nil
} | |
c4448 |
err := w.config.Raft.BootstrapCluster(configuration).Error()
if err != nil {
return errors.Annotate(err, "re-bootstrapping cluster")
}
return nil
} | |
c4449 | Application {
return stateApplicationShim{app, st}
} | |
c4450 | },
&upgradeStep{
description: "update lxd cloud/credentials",
targets: []Target{DatabaseMaster},
run: func(context Context) error {
return updateLXDCloudCredentials(context.State())
},
},
}
} | |
c4451 |
payloads: make(map[string]payload.Payload),
updates: make(map[string]payload.Payload),
}
} | |
c4452 | pl := result.Payload
// TODO(ericsnow) Use id instead of pl.FullID().
ctx.payloads[pl.FullID()] = pl.Payload
}
return ctx, nil
} | |
c4453 | }
if compCtx == nil {
return nil, errors.Errorf("component %q disabled", payload.ComponentName)
}
return compCtx, nil
} | |
c4454 | = c.payloads[fullID]
if !ok {
return nil, errors.NotFoundf("%s", fullID)
}
}
return &actual, nil
} | |
c4455 | nil, nil
}
var ids []string
for _, wl := range payloads {
ids = append(ids, wl.FullID())
}
sort.Strings(ids)
return ids, nil
} | |
c4456 | likely missing mechanism for local persistence.
id := pl.FullID()
c.updates[id] = pl
return nil
} | |
c4457 | should not ignore a 0-len result.
if len(res) > 0 && res[0].Error != nil {
return errors.Trace(res[0].Error)
}
delete(c.payloads, id)
return nil
} | |
c4458 | the state of the charm. So returning an error
// here in the "missing" case makes less sense than in other
// places. We could simply ignore any error that surfaces for
// that case. However, returning the error communicates to the
// charm author that what they're trying to communicate doesn't
// make sense... | |
c4459 | base.NewFacadeCaller(caller, "MachineUndertaker"),
modelTag: modelTag,
newWatcher: newWatcher,
}
return &api, nil
} | |
c4460 | return nil, errors.Errorf("expected one result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, errors.Trace(result.Error)
}
machines := make([]names.MachineTag, len(result.Entities))
for i, entity := range result.Entities {
tag, err := names.ParseMachineTag... | |
c4461 |
}
infos := make([]network.ProviderInterfaceInfo, len(item.Interfaces))
for i, info := range item.Interfaces {
infos[i].InterfaceName = info.InterfaceName
infos[i].MACAddress = info.MACAddress
infos[i].ProviderId = network.Id(info.ProviderId)
}
return infos, nil
} | |
c4462 | return api.facade.FacadeCall("CompleteMachineRemovals", &args, nil)
} | |
c4463 | nil, errors.Errorf("expected one result, got %d", len(results.Results))
}
result := results.Results[0]
if err := result.Error; err != nil {
return nil, errors.Trace(result.Error)
}
w := api.newWatcher(api.facade.RawAPICaller(), result)
return w, nil
} | |
c4464 | return errors.Trace(err)
}
if result.Error != nil {
return errors.Trace(result.Error)
}
return nil
} | |
c4465 | &result)
if err != nil {
return 0, errors.Trace(err)
}
if result.Error != nil {
return 0, errors.Trace(result.Error)
}
return result.Result, nil
} | |
c4466 | &result)
if err != nil {
return false, errors.Trace(err)
}
if result.Error != nil {
return false, errors.Trace(result.Error)
}
return result.Result, nil
} | |
c4467 | != nil {
return nil, errors.Trace(err)
}
if result.Error != nil {
return nil, errors.Trace(result.Error)
}
return generationInfoFromResult(result, detailed, formatTime), nil
} | |
c4468 | 16]uint16)(unsafe.Pointer(s.name))[:])
}
return ""
} | |
c4469 | need to stop using
// series.HostSeries inside Create.
s, err := mgr.Connect()
if err != nil {
return nil, err
}
defer s.Disconnect()
return s.CreateService(name, exepath, c, args...)
} | |
c4470 | return nil, err
}
defer s.Disconnect()
return s.OpenService(name)
} | |
c4471 | windows.CloseServiceHandle(handle)
} | |
c4472 |
return errors.Trace(err)
}
defer service.Close()
err = service.Start()
if err != nil {
return err
}
return nil
} | |
c4473 |
}
defer service.Close()
_, err = service.Control(svc.Stop)
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c4474 | = service.Delete()
if err == c_ERROR_SERVICE_DOES_NOT_EXIST {
return nil
} else if err != nil {
return errors.Trace(err)
}
return nil
} | |
c4475 | Status %v", name, status)
if status == svc.Running {
return true, nil
}
return false, nil
} | |
c4476 | {
return mgr.Config{}, c_ERROR_SERVICE_DOES_NOT_EXIST
}
service, err := s.getService(name)
if err != nil {
return mgr.Config{}, errors.Trace(err)
}
defer service.Close()
return service.Config()
} | |
c4477 | newPassword
service, err := s.getService(svcName)
if err != nil {
return errors.Trace(err)
}
defer service.Close()
err = service.UpdateConfig(currentConfig)
if err != nil {
return errors.Trace(err)
}
}
if err != nil {
return errors.Trace(err)
}
return nil
} | |
c4478 | {
return errors.Trace(err)
}
if result.Error != nil {
return errors.Trace(result.Error)
}
return nil
} | |
c4479 | duplicated zone %q", zone.Name)
continue
}
if zone.Available {
cache.availableZones.Add(zone.Name)
}
cache.allZones.Add(zone.Name)
}
logger.Tracef(
"%d known and %d available zones cached: %v",
cache.allZones.Size(), cache.availableZones.Size(), cache.allZones.SortedValues(),
)
if cache.allZones... | |
c4480 |
cache := NewAddSubnetsCache(api)
for i, arg := range args.Subnets {
err := addOneSubnet(ctx, api, arg, cache)
if err != nil {
results.Results[i].Error = common.ServerError(err)
}
}
return results, nil
} | |
c4481 | stateStorage{modelUUID, session}
} | |
c4482 | fmt.Sprintf("juju-%s-%s", envName, tag)
} | |
c4483 | a.Next(); {
c(status.Allocating, fmt.Sprintf("Start instance attempt %d", try), nil)
resp, err = e.RunInstances(ri)
if err == nil || !isNotFoundError(err) {
break
}
try++
}
return resp, maybeConvertCredentialError(err, ctx)
} | |
c4484 | maybeConvertCredentialError(err, ctx)
}
if len(resp.Groups) != 1 {
return ec2.SecurityGroupInfo{}, errors.NewNotFound(fmt.Errorf(
"expected one security group named %q, got %v",
groupName, resp.Groups,
), "")
}
return resp.Groups[0], nil
} | |
c4485 | (ec2.SecurityGroup, error) {
groupInfo, err := e.groupInfoByName(ctx, groupName)
return groupInfo.SecurityGroup, err
} | |
c4486 |
for i, id := range ids {
if insts[i] != nil {
n++
continue
}
for j := range resp.Reservations {
r := &resp.Reservations[j]
for k := range r.Instances {
if r.Instances[k].InstanceId != string(id) {
continue
}
inst := r.Instances[k]
// TODO(wallyworld): lookup the details to fill ... | |
c4487 | err != nil {
return nil, errors.Annotatef(maybeConvertCredentialError(err, ctx), "failed to retrieve subnet %q info", iface.SubnetId)
}
if len(resp.Subnets) != 1 {
return nil, errors.Errorf("expected 1 subnet, got %d", len(resp.Subnets))
}
subnet := resp.Subnets[0]
cidr := subnet.CIDRBlock
result[i]... | |
c4488 | return nil, errors.NotSupportedf("Spaces")
} | |
c4489 | iface.AvailabilityZones)
if err != nil {
// Error will already have been logged.
continue
}
results = append(results, info)
}
} else {
resp, _, err := e.subnetsForVPC(ctx)
if err != nil {
return nil, errors.Annotatef(err, "failed to retrieve subnets")
}
if len(subnetIds) == 0 {
for _,... | |
c4490 | return e.AllInstancesByState(ctx, "pending", "running")
} | |
c4491 | not confident enough to
// change this fundamental right now.
//
// An EC2 API call is required to resolve the group name to an id, as
// VPC enabled accounts do not support name based filtering.
groupName := e.jujuGroupName()
group, err := e.groupByName(ctx, groupName)
if isNotFoundError(err) {
// If there's... | |
c4492 | {
filter := ec2.NewFilter()
filter.Add("instance-state-name", aliveInstanceStates...)
e.addControllerFilter(filter, controllerUUID)
return e.allInstanceIDs(ctx, filter)
} | |
c4493 | // we will return first one...The same logic happens on detach..?...
return errors.Annotatef(err, "destroying volume %q", volIds[i])
}
// Delete security groups managed by the controller.
groups, err := e.controllerSecurityGroups(ctx, controllerUUID)
if err != nil {
return errors.Trace(err)
}
for _, g := ra... | |
c4494 |
groups := make([]ec2.SecurityGroup, len(resp.Groups))
for i, info := range resp.Groups {
groups[i] = ec2.SecurityGroup{Id: info.Id, Name: info.Name}
}
return groups, nil
} | |
c4495 | %q", jujuGroup)
}
if err := deleteSecurityGroupInsistently(e.ec2, ctx, g, clock.WallClock); err != nil {
return errors.Annotate(err, "cannot delete default security group")
}
return nil
} | |
c4496 | nil, err
}
var machineGroup ec2.SecurityGroup
switch e.Config().FirewallMode() {
case config.FwInstance:
machineGroup, err = e.ensureGroup(ctx, controllerUUID, e.machineGroupName(machineId), nil)
case config.FwGlobal:
machineGroup, err = e.ensureGroup(ctx, controllerUUID, e.globalGroupName(), nil)
}
if err... | |
c4497 | len(p.SourceIPs) > 0 {
for _, ip := range p.SourceIPs {
k.ipAddr = ip
m[k] = true
}
} else {
k.groupId = group.Id
m[k] = true
}
}
return m
} | |
c4498 | if p.ipAddr != "" {
ipp.SourceIPs = []string{p.ipAddr}
} else {
ipp.SourceGroups = []ec2.UserSecurityGroup{{Id: p.groupId}}
}
ps = append(ps, ipp)
}
return
} | |
c4499 | default VPC, then we will receive an error
// if the AZ does not have a default subnet. Until we have proper
// support for networks, we'll skip over these.
return strings.HasPrefix(err.Message, "No default subnet for availability zone")
case "VolumeTypeNotAvailableInZone":
return true
}
}
return fal... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.