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)
if err := c.Close(); err != nil {
logger.Warningf("failed to close connection: %v", err)
}
return nil, err
}
c = cc
}
logger.Debugf("dialled mongodb server at %q", addr)
return c, nil
}
return &mgo.DialInfo{
Addrs: info.Addrs,
Timeout: opts.Timeout,
DialServer: dial,
Direct: opts.Direct,
PoolLimit: opts.PoolLimit,
}, nil
}
| |
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, nil
}
| |
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.Bytes(), nil
}
| |
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 "", err
}
np.writtenFile = filePath
return filePath, nil
}
| |
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.
return errors.Trace(res[0].Error)
}
return nil
}
| |
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(entity.Tag)
if err != nil {
return nil, errors.Trace(err)
}
machines[i] = tag
}
return machines, nil
}
| |
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.IsEmpty() {
cache.allZones = nil
// Cached an empty list.
return errors.Errorf("no zones defined")
}
return nil
}
| |
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 in the instance type data
insts[i] = &ec2Instance{e: e, Instance: &inst}
n++
}
}
}
if n < len(ids) {
return environs.ErrPartialInstances
}
return nil
}
| |
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] = network.InterfaceInfo{
DeviceIndex: iface.Attachment.DeviceIndex,
MACAddress: iface.MACAddress,
CIDR: cidr,
ProviderId: network.Id(iface.Id),
ProviderSubnetId: network.Id(iface.SubnetId),
AvailabilityZones: []string{subnet.AvailZone},
VLANTag: 0, // Not supported on EC2.
// Getting the interface name is not supported on EC2, so fake it.
InterfaceName: fmt.Sprintf("unsupported%d", iface.Attachment.DeviceIndex),
Disabled: false,
NoAutoStart: false,
ConfigType: network.ConfigDHCP,
InterfaceType: network.EthernetInterface,
Address: network.NewScopedAddress(iface.PrivateIPAddress, network.ScopeCloudLocal),
}
}
return result, nil
}
| |
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 _, subnet := range resp.Subnets {
subIdSet[subnet.Id] = false
}
}
for _, subnet := range resp.Subnets {
_, ok := subIdSet[subnet.Id]
if !ok {
logger.Tracef("subnet %q not in %v, skipping", subnet.Id, subnetIds)
continue
}
subIdSet[subnet.Id] = true
cidr := subnet.CIDRBlock
info, err := makeSubnetInfo(cidr, network.Id(subnet.Id), network.Id(subnet.VPCId), []string{subnet.AvailZone})
if err != nil {
// Error will already have been logged.
continue
}
results = append(results, info)
}
}
notFound := []string{}
for subId, found := range subIdSet {
if !found {
notFound = append(notFound, subId)
}
}
if len(notFound) != 0 {
return nil, errors.Errorf("failed to find the following subnet ids: %v", notFound)
}
return results, nil
}
| |
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 no group, then there cannot be any instances.
return nil, nil
} else if err != nil {
return nil, errors.Trace(maybeConvertCredentialError(err, ctx))
}
filter := ec2.NewFilter()
filter.Add("instance-state-name", states...)
filter.Add("instance.group-id", group.Id)
return e.allInstances(ctx, filter)
}
| |
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 := range groups {
if err := deleteSecurityGroupInsistently(e.ec2, ctx, g, clock.WallClock); err != nil {
return errors.Annotatef(
err, "cannot delete security group %q (%q)",
g.Name, g.Id,
)
}
}
return nil
}
| |
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 != nil {
return nil, err
}
return []ec2.SecurityGroup{jujuGroup, machineGroup}, nil
}
| |
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 false
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.