_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q3800 | InstanceStatus | train | func (m *Machine) InstanceStatus() (status.Status, string, error) {
var results params.StatusResults
args := params.Entities{Entities: []params.Entity{
{Tag: m.tag.String()},
}}
err := m.st.facade.FacadeCall("InstanceStatus", args, &results)
if err != nil {
return "", "", err
}
if len(results.Results) != 1 {... | go | {
"resource": ""
} |
q3801 | SetModificationStatus | train | func (m *Machine) SetModificationStatus(status status.Status, info string, data map[string]interface{}) error {
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{
{Tag: m.tag.String(), Status: status.String(), Info: info, Data: data},
},
}
err := m.st.facade.FacadeC... | go | {
"resource": ""
} |
q3802 | AvailabilityZone | train | func (m *Machine) AvailabilityZone() (string, error) {
var results params.StringResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag.String()}},
}
err := m.st.facade.FacadeCall("AvailabilityZone", args, &results)
if err != nil {
return "", err
}
if len(results.Results) != 1 {
return "", f... | go | {
"resource": ""
} |
q3803 | SetInstanceInfo | train | func (m *Machine) SetInstanceInfo(
id instance.Id, displayName string, nonce string, characteristics *instance.HardwareCharacteristics,
networkConfig []params.NetworkConfig, volumes []params.Volume,
volumeAttachments map[string]params.VolumeAttachmentInfo, charmProfiles []string,
) error {
var result params.ErrorRe... | go | {
"resource": ""
} |
q3804 | WatchContainers | train | func (m *Machine) WatchContainers(ctype instance.ContainerType) (watcher.StringsWatcher, error) {
if string(ctype) == "" {
return nil, fmt.Errorf("container type must be specified")
}
supported := false
for _, c := range instance.ContainerTypes {
if ctype == c {
supported = true
break
}
}
if !supporte... | go | {
"resource": ""
} |
q3805 | WatchAllContainers | train | func (m *Machine) WatchAllContainers() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("WatchContainers", args, &results)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q3806 | SetSupportedContainers | train | func (m *Machine) SetSupportedContainers(containerTypes ...instance.ContainerType) error {
var results params.ErrorResults
args := params.MachineContainersParams{
Params: []params.MachineContainers{
{MachineTag: m.tag.String(), ContainerTypes: containerTypes},
},
}
err := m.st.facade.FacadeCall("SetSupported... | go | {
"resource": ""
} |
q3807 | SupportedContainers | train | func (m *Machine) SupportedContainers() ([]instance.ContainerType, bool, error) {
var results params.MachineContainerResults
args := params.Entities{
Entities: []params.Entity{
{Tag: m.tag.String()},
},
}
err := m.st.facade.FacadeCall("SupportedContainers", args, &results)
if err != nil {
return nil, fals... | go | {
"resource": ""
} |
q3808 | SetCharmProfiles | train | func (m *Machine) SetCharmProfiles(profiles []string) error {
var results params.ErrorResults
args := params.SetProfileArgs{
Args: []params.SetProfileArg{
{
Entity: params.Entity{Tag: m.tag.String()},
Profiles: profiles,
},
},
}
err := m.st.facade.FacadeCall("SetCharmProfiles", args, &results)
... | go | {
"resource": ""
} |
q3809 | Init | train | func (c *agreeCommand) Init(args []string) error {
if len(args) < 1 {
return errors.New("missing arguments")
}
for _, t := range args {
termId, err := charm.ParseTerm(t)
if err != nil {
return errors.Annotate(err, "invalid term format")
}
if termId.Revision == 0 {
return errors.Errorf("must specify ... | go | {
"resource": ""
} |
q3810 | LeadershipClaimer | train | func (st *State) LeadershipClaimer() leadership.Claimer {
return leadershipClaimer{
lazyLeaseClaimer{func() (lease.Claimer, error) {
manager := st.workers.leadershipManager()
return manager.Claimer(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | go | {
"resource": ""
} |
q3811 | LeadershipChecker | train | func (st *State) LeadershipChecker() leadership.Checker {
return leadershipChecker{
lazyLeaseChecker{func() (lease.Checker, error) {
manager := st.workers.leadershipManager()
return manager.Checker(applicationLeadershipNamespace, st.modelUUID())
}},
}
} | go | {
"resource": ""
} |
q3812 | buildTxnWithLeadership | train | func buildTxnWithLeadership(buildTxn jujutxn.TransactionSource, token leadership.Token) jujutxn.TransactionSource {
return func(attempt int) ([]txn.Op, error) {
var prereqs []txn.Op
if err := token.Check(attempt, &prereqs); err != nil {
return nil, errors.Annotatef(err, "prerequisites failed")
}
ops, err :=... | go | {
"resource": ""
} |
q3813 | InitDbLogs | train | func InitDbLogs(session *mgo.Session, modelUUID string) error {
logsColl := session.DB(logsDB).C(logCollectionName(modelUUID))
for _, key := range logIndexes {
err := logsColl.EnsureIndex(mgo.Index{Key: key})
if err != nil {
return errors.Annotate(err, "cannot create index for logs collection")
}
}
return ... | go | {
"resource": ""
} |
q3814 | NewLastSentLogTracker | train | func NewLastSentLogTracker(st ModelSessioner, modelUUID, sink string) *LastSentLogTracker {
session := st.MongoSession().Copy()
return &LastSentLogTracker{
id: fmt.Sprintf("%s#%s", modelUUID, sink),
model: modelUUID,
sink: sink,
session: session,
}
} | go | {
"resource": ""
} |
q3815 | Set | train | func (logger *LastSentLogTracker) Set(recID, recTimestamp int64) error {
collection := logger.session.DB(logsDB).C(forwardedC)
_, err := collection.UpsertId(
logger.id,
lastSentDoc{
ID: logger.id,
ModelUUID: logger.model,
Sink: logger.sink,
RecordID: recID,
Reco... | go | {
"resource": ""
} |
q3816 | Get | train | func (logger *LastSentLogTracker) Get() (int64, int64, error) {
collection := logger.session.DB(logsDB).C(forwardedC)
var doc lastSentDoc
err := collection.FindId(logger.id).One(&doc)
if err != nil {
if err == mgo.ErrNotFound {
return 0, 0, errors.Trace(ErrNeverForwarded)
}
return 0, 0, errors.Trace(err)
... | go | {
"resource": ""
} |
q3817 | Log | train | func (logger *DbLogger) Log(records []LogRecord) error {
for _, r := range records {
if err := validateInputLogRecord(r); err != nil {
return errors.Annotate(err, "validating input log record")
}
}
bulk := logger.logsColl.Bulk()
for _, r := range records {
var versionString string
if r.Version != version... | go | {
"resource": ""
} |
q3818 | Close | train | func (logger *DbLogger) Close() {
if logger.logsColl != nil {
logger.logsColl.Database.Session.Close()
}
} | go | {
"resource": ""
} |
q3819 | NewLogTailer | train | func NewLogTailer(st LogTailerState, params LogTailerParams) (LogTailer, error) {
session := st.MongoSession().Copy()
t := &logTailer{
modelUUID: st.ModelUUID(),
session: session,
logsColl: session.DB(logsDB).C(logCollectionName(st.ModelUUID())).With(session),
params: params,
l... | go | {
"resource": ""
} |
q3820 | Stop | train | func (t *logTailer) Stop() error {
t.tomb.Kill(nil)
return t.tomb.Wait()
} | go | {
"resource": ""
} |
q3821 | initLogsSession | train | func initLogsSession(st ModelSessioner) (*mgo.Session, *mgo.Collection) {
session, db := initLogsSessionDB(st)
return session, db.C(logCollectionName(st.ModelUUID()))
} | go | {
"resource": ""
} |
q3822 | getCollectionTotalMB | train | func getCollectionTotalMB(colls map[string]*mgo.Collection) (int, error) {
total := 0
for _, coll := range colls {
size, err := getCollectionMB(coll)
if err != nil {
return 0, errors.Trace(err)
}
total += size
}
return total, nil
} | go | {
"resource": ""
} |
q3823 | getLogCollections | train | func getLogCollections(db *mgo.Database) (map[string]*mgo.Collection, error) {
result := make(map[string]*mgo.Collection)
names, err := db.CollectionNames()
if err != nil {
return nil, errors.Trace(err)
}
for _, name := range names {
if !strings.HasPrefix(name, logsCPrefix) {
continue
}
uuid := name[len... | go | {
"resource": ""
} |
q3824 | findModelWithMostLogs | train | func findModelWithMostLogs(colls map[string]*mgo.Collection) (string, int, error) {
var maxModelUUID string
var maxCount int
for modelUUID, coll := range colls {
count, err := getRowCountForCollection(coll)
if err != nil {
return "", -1, errors.Trace(err)
}
if count > maxCount {
maxModelUUID = modelUUI... | go | {
"resource": ""
} |
q3825 | getRowCountForCollection | train | func getRowCountForCollection(coll *mgo.Collection) (int, error) {
count, err := coll.Count()
if err != nil {
return -1, errors.Annotate(err, "failed to get log count")
}
return count, nil
} | go | {
"resource": ""
} |
q3826 | SetUpGroups | train | func (c *legacyNovaFirewaller) SetUpGroups(ctx context.ProviderCallContext, controllerUUID, machineId string, apiPort int) ([]string, error) {
jujuGroup, err := c.setUpGlobalGroup(ctx, c.jujuGroupName(controllerUUID), apiPort)
if err != nil {
return nil, errors.Trace(err)
}
var machineGroup nova.SecurityGroup
sw... | go | {
"resource": ""
} |
q3827 | ensureGroup | train | func (c *legacyNovaFirewaller) ensureGroup(ctx context.ProviderCallContext, name string, rules []nova.RuleInfo) (nova.SecurityGroup, error) {
novaClient := c.environ.nova()
// First attempt to look up an existing group by name.
group, err := novaClient.SecurityGroupByName(name)
if err == nil {
common.HandleCreden... | go | {
"resource": ""
} |
q3828 | DeleteAllModelGroups | train | func (c *legacyNovaFirewaller) DeleteAllModelGroups(ctx context.ProviderCallContext) error {
return deleteSecurityGroupsMatchingName(ctx, c.deleteSecurityGroups, c.jujuGroupRegexp())
} | go | {
"resource": ""
} |
q3829 | DeleteGroups | train | func (c *legacyNovaFirewaller) DeleteGroups(ctx context.ProviderCallContext, names ...string) error {
return deleteSecurityGroupsOneOfNames(ctx, c.deleteSecurityGroups, names...)
} | go | {
"resource": ""
} |
q3830 | legacyRuleMatchesPortRange | train | func legacyRuleMatchesPortRange(rule nova.SecurityGroupRule, portRange network.IngressRule) bool {
if rule.IPProtocol == nil || rule.FromPort == nil || rule.ToPort == nil {
return false
}
return *rule.IPProtocol == portRange.Protocol &&
*rule.FromPort == portRange.FromPort &&
*rule.ToPort == portRange.ToPort
} | go | {
"resource": ""
} |
q3831 | List | train | func (a *API) List(args params.BackupsListArgs) (params.BackupsListResult, error) {
var result params.BackupsListResult
backups, closer := newBackups(a.backend)
defer closer.Close()
metaList, err := backups.List()
if err != nil {
return result, errors.Trace(err)
}
result.List = make([]params.BackupsMetadata... | go | {
"resource": ""
} |
q3832 | AuthorisedKeys | train | func (st *State) AuthorisedKeys(tag names.MachineTag) ([]string, error) {
var results params.StringsResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("AuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly tested
return nil, err
}
... | go | {
"resource": ""
} |
q3833 | WatchAuthorisedKeys | train | func (st *State) WatchAuthorisedKeys(tag names.MachineTag) (watcher.NotifyWatcher, error) {
var results params.NotifyWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: tag.String()}},
}
err := st.facade.FacadeCall("WatchAuthorisedKeys", args, &results)
if err != nil {
// TODO: Not directly t... | go | {
"resource": ""
} |
q3834 | precheckInstance | train | func (st *State) precheckInstance(
series string,
cons constraints.Value,
placement string,
volumeAttachments []storage.VolumeAttachmentParams,
) error {
if st.policy == nil {
return nil
}
prechecker, err := st.policy.Prechecker()
if errors.IsNotImplemented(err) {
return nil
} else if err != nil {
return... | go | {
"resource": ""
} |
q3835 | ResolveConstraints | train | func (st *State) ResolveConstraints(cons constraints.Value) (constraints.Value, error) {
validator, err := st.constraintsValidator()
if err != nil {
return constraints.Value{}, err
}
modelCons, err := st.ModelConstraints()
if err != nil {
return constraints.Value{}, err
}
return validator.Merge(modelCons, co... | go | {
"resource": ""
} |
q3836 | validateConstraints | train | func (st *State) validateConstraints(cons constraints.Value) ([]string, error) {
validator, err := st.constraintsValidator()
if err != nil {
return nil, err
}
return validator.Validate(cons)
} | go | {
"resource": ""
} |
q3837 | validate | train | func (st *State) validate(cfg, old *config.Config) (valid *config.Config, err error) {
if st.policy == nil {
return cfg, nil
}
configValidator, err := st.policy.ConfigValidator()
if errors.IsNotImplemented(err) {
return cfg, nil
} else if err != nil {
return nil, err
}
if configValidator == nil {
return ... | go | {
"resource": ""
} |
q3838 | Id | train | func (m *Machine) Id() string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.Id
} | go | {
"resource": ""
} |
q3839 | InstanceId | train | func (m *Machine) InstanceId() (instance.Id, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.details.InstanceId == "" {
return "", errors.NotProvisionedf("machine %v", m.details.Id)
}
return instance.Id(m.details.InstanceId), nil
} | go | {
"resource": ""
} |
q3840 | CharmProfiles | train | func (m *Machine) CharmProfiles() []string {
m.mu.Lock()
defer m.mu.Unlock()
return m.details.CharmProfiles
} | go | {
"resource": ""
} |
q3841 | Units | train | func (m *Machine) Units() ([]*Unit, error) {
m.mu.Lock()
defer m.mu.Unlock()
result := make([]*Unit, 0)
for unitName, unit := range m.model.units {
if unit.details.MachineId == m.details.Id {
result = append(result, unit)
}
if unit.details.Subordinate {
principalUnit, found := m.model.units[unit.detail... | go | {
"resource": ""
} |
q3842 | newInstanceType | train | func newInstanceType(size compute.VirtualMachineSize) instances.InstanceType {
// We're not doing real costs for now; just made-up, relative
// costs, to ensure we choose the right VMs given matching
// constraints. This was based on the pricing for West US,
// and assumes that all regions have the same relative co... | go | {
"resource": ""
} |
q3843 | defaultToBaselineSpec | train | func defaultToBaselineSpec(constraint constraints.Value) constraints.Value {
result := constraint
if !result.HasInstanceType() && result.Mem == nil {
var value uint64 = defaultMem
result.Mem = &value
}
return result
} | go | {
"resource": ""
} |
q3844 | NewFirewallerFacade | train | func NewFirewallerFacade(apiCaller base.APICaller) (FirewallerAPI, error) {
facade, err := firewaller.NewClient(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
return facade, nil
} | go | {
"resource": ""
} |
q3845 | NewWorker | train | func NewWorker(cfg Config) (worker.Worker, error) {
w, err := NewFirewaller(cfg)
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
} | go | {
"resource": ""
} |
q3846 | crossmodelFirewallerFacadeFunc | train | func crossmodelFirewallerFacadeFunc(
connectionFunc apicaller.NewExternalControllerConnectionFunc,
) newCrossModelFacadeFunc {
return func(apiInfo *api.Info) (CrossModelFirewallerFacadeCloser, error) {
apiInfo.Tag = names.NewUserTag(api.AnonymousUsername)
conn, err := connectionFunc(apiInfo)
if err != nil {
... | go | {
"resource": ""
} |
q3847 | NewWorker | train | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Annotate(err, "validating config")
}
updater, err := config.NewUpdater()
if err != nil {
return nil, errors.Annotate(err, "getting new updater")
}
w := &updaterWorker{
config: config,
updat... | go | {
"resource": ""
} |
q3848 | SetStatus | train | func (r *Relation) SetStatus(status relation.Status) error {
return r.st.setRelationStatus(r.id, status)
} | go | {
"resource": ""
} |
q3849 | Endpoint | train | func (r *Relation) Endpoint() (*Endpoint, error) {
// NOTE: This differs from state.Relation.Endpoint(), because when
// talking to the API, there's already an authenticated entity - the
// unit, and we can find out its application name.
result, err := r.st.relation(r.tag, r.st.unitTag)
if err != nil {
return ni... | go | {
"resource": ""
} |
q3850 | NewListCommand | train | func NewListCommand(deps ListDeps) modelcmd.ModelCommand {
return modelcmd.Wrap(&ListCommand{deps: deps})
} | go | {
"resource": ""
} |
q3851 | NewMachinerAPI | train | func NewMachinerAPI(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*MachinerAPI, error) {
if !authorizer.AuthMachineAgent() {
return nil, common.ErrPerm
}
getCanModify := func() (common.AuthFunc, error) {
return authorizer.AuthOwner, nil
}
getCanRead := func() (common.AuthFunc, err... | go | {
"resource": ""
} |
q3852 | Jobs | train | func (api *MachinerAPI) Jobs(args params.Entities) (params.JobsResults, error) {
result := params.JobsResults{
Results: make([]params.JobsResult, len(args.Entities)),
}
canRead, err := api.getCanRead()
if err != nil {
return result, err
}
for i, agent := range args.Entities {
tag, err := names.ParseMachin... | go | {
"resource": ""
} |
q3853 | GetCollection | train | func (m *environMongo) GetCollection(name string) (mongo.Collection, func()) {
return m.state.db().GetCollection(name)
} | go | {
"resource": ""
} |
q3854 | RunTransaction | train | func (m *environMongo) RunTransaction(buildTxn jujutxn.TransactionSource) error {
return m.state.db().Run(buildTxn)
} | go | {
"resource": ""
} |
q3855 | SetUpgradeMongoMode | train | func (st *State) SetUpgradeMongoMode(v mongo.Version) (UpgradeMongoParams, error) {
currentInfo, err := st.ControllerInfo()
if err != nil {
return UpgradeMongoParams{}, errors.Annotate(err, "could not obtain current controller information")
}
result := UpgradeMongoParams{}
machines := []*Machine{}
for _, mID :=... | go | {
"resource": ""
} |
q3856 | ResumeReplication | train | func (st *State) ResumeReplication(members []replicaset.Member) error {
return replicaset.Add(st.session, members...)
} | go | {
"resource": ""
} |
q3857 | NewCleanerAPI | train | func NewCleanerAPI(
st *state.State,
res facade.Resources,
authorizer facade.Authorizer,
) (*CleanerAPI, error) {
if !authorizer.AuthController() {
return nil, common.ErrPerm
}
return &CleanerAPI{
st: getState(st),
resources: res,
}, nil
} | go | {
"resource": ""
} |
q3858 | WatchCleanups | train | func (api *CleanerAPI) WatchCleanups() (params.NotifyWatchResult, error) {
watch := api.st.WatchCleanups()
if _, ok := <-watch.Changes(); ok {
return params.NotifyWatchResult{
NotifyWatcherId: api.resources.Register(watch),
}, nil
}
return params.NotifyWatchResult{
Error: common.ServerError(watcher.EnsureE... | go | {
"resource": ""
} |
q3859 | ChangeAgentTools | train | func (e *UpgradeReadyError) ChangeAgentTools() error {
agentTools, err := tools.ChangeAgentTools(e.DataDir, e.AgentName, e.NewTools)
if err != nil {
return err
}
logger.Infof("upgraded from %v to %v (%q)", e.OldTools, agentTools.Version, agentTools.URL)
return nil
} | go | {
"resource": ""
} |
q3860 | IsAuthorisationFailure | train | func IsAuthorisationFailure(err error) bool {
if err == nil {
return false
}
serviceError, ok := err.(ociCommon.ServiceError)
if !ok {
// Just to double check, also try the SDK's
// implementation. This isn't checked first, because
// it is hard to test.
serviceError, ok = ociCommon.IsServiceError(err)
... | go | {
"resource": ""
} |
q3861 | HandleCredentialError | train | func HandleCredentialError(err error, ctx context.ProviderCallContext) {
common.HandleCredentialError(IsAuthorisationFailure, err, ctx)
} | go | {
"resource": ""
} |
q3862 | Manifold | train | func Manifold(config ManifoldConfig) dependency.Manifold {
openLogStream := config.OpenLogStream
if openLogStream == nil {
openLogStream = func(caller base.APICaller, cfg params.LogStreamConfig, controllerUUID string) (LogStream, error) {
return logstream.Open(caller, cfg, controllerUUID)
}
}
openForwarder ... | go | {
"resource": ""
} |
q3863 | Open | train | func (e *EnvironProvider) Open(params environs.OpenParams) (environs.Environ, error) {
logger.Infof("opening model %q", params.Config.Name())
if err := validateCloudSpec(params.Cloud); err != nil {
return nil, errors.Trace(err)
}
creds := params.Cloud.Credential.Attributes()
jujuConfig := common.JujuConfigProv... | go | {
"resource": ""
} |
q3864 | Validate | train | func (e EnvironProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
newAttrs, err := cfg.ValidateUnknownAttrs(
configFields, configDefaults,
)
if err != nil {
return nil, err
}
return cfg.Apply(newAttrs)
} | go | {
"resource": ""
} |
q3865 | NewMockLinkLayerDevice | train | func NewMockLinkLayerDevice(ctrl *gomock.Controller) *MockLinkLayerDevice {
mock := &MockLinkLayerDevice{ctrl: ctrl}
mock.recorder = &MockLinkLayerDeviceMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3866 | Addresses | train | func (m *MockLinkLayerDevice) Addresses() ([]*state.Address, error) {
ret := m.ctrl.Call(m, "Addresses")
ret0, _ := ret[0].([]*state.Address)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3867 | Addresses | train | func (mr *MockLinkLayerDeviceMockRecorder) Addresses() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addresses", reflect.TypeOf((*MockLinkLayerDevice)(nil).Addresses))
} | go | {
"resource": ""
} |
q3868 | EthernetDeviceForBridge | train | func (m *MockLinkLayerDevice) EthernetDeviceForBridge(arg0 string) (state.LinkLayerDeviceArgs, error) {
ret := m.ctrl.Call(m, "EthernetDeviceForBridge", arg0)
ret0, _ := ret[0].(state.LinkLayerDeviceArgs)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3869 | EthernetDeviceForBridge | train | func (mr *MockLinkLayerDeviceMockRecorder) EthernetDeviceForBridge(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthernetDeviceForBridge", reflect.TypeOf((*MockLinkLayerDevice)(nil).EthernetDeviceForBridge), arg0)
} | go | {
"resource": ""
} |
q3870 | IsUp | train | func (m *MockLinkLayerDevice) IsUp() bool {
ret := m.ctrl.Call(m, "IsUp")
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q3871 | MTU | train | func (m *MockLinkLayerDevice) MTU() uint {
ret := m.ctrl.Call(m, "MTU")
ret0, _ := ret[0].(uint)
return ret0
} | go | {
"resource": ""
} |
q3872 | ParentDevice | train | func (m *MockLinkLayerDevice) ParentDevice() (containerizer.LinkLayerDevice, error) {
ret := m.ctrl.Call(m, "ParentDevice")
ret0, _ := ret[0].(containerizer.LinkLayerDevice)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3873 | NewMockUnit | train | func NewMockUnit(ctrl *gomock.Controller) *MockUnit {
mock := &MockUnit{ctrl: ctrl}
mock.recorder = &MockUnitMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3874 | NewMockApplication | train | func NewMockApplication(ctrl *gomock.Controller) *MockApplication {
mock := &MockApplication{ctrl: ctrl}
mock.recorder = &MockApplicationMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3875 | NewMockCharm | train | func NewMockCharm(ctrl *gomock.Controller) *MockCharm {
mock := &MockCharm{ctrl: ctrl}
mock.recorder = &MockCharmMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3876 | AddFlags | train | func (c *agentConf) AddFlags(f *gnuflag.FlagSet) {
// TODO(dimitern) 2014-02-19 bug 1282025
// We need to pass a config location here instead and
// use it to locate the conf and the infer the data-dir
// from there instead of passing it like that.
f.StringVar(&c.dataDir, "data-dir", util.DataDir, "directory for j... | go | {
"resource": ""
} |
q3877 | CheckArgs | train | func (c *agentConf) CheckArgs(args []string) error {
if c.dataDir == "" {
return util.RequiredError("data-dir")
}
return cmd.CheckEmpty(args)
} | go | {
"resource": ""
} |
q3878 | ReadConfig | train | func (c *agentConf) ReadConfig(tag string) error {
t, err := names.ParseTag(tag)
if err != nil {
return errors.Trace(err)
}
c.mu.Lock()
defer c.mu.Unlock()
conf, err := agent.ReadConfig(agent.ConfigPath(c.dataDir, t))
if err != nil {
return errors.Trace(err)
}
c._config = conf
return nil
} | go | {
"resource": ""
} |
q3879 | ChangeConfig | train | func (c *agentConf) ChangeConfig(change agent.ConfigMutator) error {
c.mu.Lock()
defer c.mu.Unlock()
if err := change(c._config); err != nil {
return errors.Trace(err)
}
if err := c._config.Write(); err != nil {
return errors.Annotate(err, "cannot write agent configuration")
}
return nil
} | go | {
"resource": ""
} |
q3880 | CurrentConfig | train | func (c *agentConf) CurrentConfig() agent.Config {
c.mu.Lock()
defer c.mu.Unlock()
return c._config.Clone()
} | go | {
"resource": ""
} |
q3881 | GetJujuVersion | train | func GetJujuVersion(machineAgent string, dataDir string) (version.Number, error) {
agentConf := NewAgentConf(dataDir)
if err := agentConf.ReadConfig(machineAgent); err != nil {
err = errors.Annotate(err, "failed to read agent config file.")
return version.Number{}, err
}
config := agentConf.CurrentConfig()
if ... | go | {
"resource": ""
} |
q3882 | NewMockRunner | train | func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
mock := &MockRunner{ctrl: ctrl}
mock.recorder = &MockRunnerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3883 | MaybePruneTransactions | train | func (m *MockRunner) MaybePruneTransactions(arg0 txn.PruneOptions) error {
ret := m.ctrl.Call(m, "MaybePruneTransactions", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3884 | ResumeTransactions | train | func (m *MockRunner) ResumeTransactions() error {
ret := m.ctrl.Call(m, "ResumeTransactions")
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3885 | ResumeTransactions | train | func (mr *MockRunnerMockRecorder) ResumeTransactions() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeTransactions", reflect.TypeOf((*MockRunner)(nil).ResumeTransactions))
} | go | {
"resource": ""
} |
q3886 | Run | train | func (m *MockRunner) Run(arg0 txn.TransactionSource) error {
ret := m.ctrl.Call(m, "Run", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3887 | Run | train | func (mr *MockRunnerMockRecorder) Run(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRunner)(nil).Run), arg0)
} | go | {
"resource": ""
} |
q3888 | NewMockEnviron | train | func NewMockEnviron(ctrl *gomock.Controller) *MockEnviron {
mock := &MockEnviron{ctrl: ctrl}
mock.recorder = &MockEnvironMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q3889 | AllInstances | train | func (m *MockEnviron) AllInstances(arg0 context.ProviderCallContext) ([]instances.Instance, error) {
ret := m.ctrl.Call(m, "AllInstances", arg0)
ret0, _ := ret[0].([]instances.Instance)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3890 | Bootstrap | train | func (m *MockEnviron) Bootstrap(arg0 environs.BootstrapContext, arg1 context.ProviderCallContext, arg2 environs.BootstrapParams) (*environs.BootstrapResult, error) {
ret := m.ctrl.Call(m, "Bootstrap", arg0, arg1, arg2)
ret0, _ := ret[0].(*environs.BootstrapResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3891 | ControllerInstances | train | func (m *MockEnviron) ControllerInstances(arg0 context.ProviderCallContext, arg1 string) ([]instance.Id, error) {
ret := m.ctrl.Call(m, "ControllerInstances", arg0, arg1)
ret0, _ := ret[0].([]instance.Id)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3892 | DestroyController | train | func (mr *MockEnvironMockRecorder) DestroyController(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyController", reflect.TypeOf((*MockEnviron)(nil).DestroyController), arg0, arg1)
} | go | {
"resource": ""
} |
q3893 | Provider | train | func (mr *MockEnvironMockRecorder) Provider() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provider", reflect.TypeOf((*MockEnviron)(nil).Provider))
} | go | {
"resource": ""
} |
q3894 | NewK8sBroker | train | func NewK8sBroker(
controllerUUID string,
k8sRestConfig *rest.Config,
cfg *config.Config,
newClient NewK8sClientFunc,
newWatcher NewK8sWatcherFunc,
clock jujuclock.Clock,
) (*kubernetesClient, error) {
k8sClient, apiextensionsClient, err := newClient(k8sRestConfig)
if err != nil {
return nil, errors.Trace(er... | go | {
"resource": ""
} |
q3895 | addAnnotations | train | func (k *kubernetesClient) addAnnotations(key, value string) k8sannotations.Annotation {
return k.annotations.Add(key, value)
} | go | {
"resource": ""
} |
q3896 | Config | train | func (k *kubernetesClient) Config() *config.Config {
k.lock.Lock()
defer k.lock.Unlock()
cfg := k.envCfgUnlocked
return cfg
} | go | {
"resource": ""
} |
q3897 | PrepareForBootstrap | train | func (k *kubernetesClient) PrepareForBootstrap(ctx environs.BootstrapContext, controllerName string) error {
alreadyExistErr := errors.NewAlreadyExists(nil,
fmt.Sprintf(`a controller called %q already exists on this k8s cluster.
Please bootstrap again and choose a different controller name.`, controllerName),
)
k... | go | {
"resource": ""
} |
q3898 | Create | train | func (k *kubernetesClient) Create(context.ProviderCallContext, environs.CreateParams) error {
// must raise errors.AlreadyExistsf if it's already exist.
return k.createNamespace(k.namespace)
} | go | {
"resource": ""
} |
q3899 | Bootstrap | train | func (k *kubernetesClient) Bootstrap(
ctx environs.BootstrapContext,
callCtx context.ProviderCallContext,
args environs.BootstrapParams,
) (*environs.BootstrapResult, error) {
if args.BootstrapSeries != "" {
return nil, errors.NotSupportedf("set series for bootstrapping to kubernetes")
}
storageClass, err := ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.