_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q4600 | Exists | train | func (d *StateDir) Exists() bool {
_, err := os.Stat(d.path)
return err == nil
} | go | {
"resource": ""
} |
q4601 | Write | train | func (d *StateDir) Write(hi hook.Info) (err error) {
defer errors.DeferredAnnotatef(&err, "failed to write %q hook info for %q on state directory", hi.Kind, hi.RemoteUnit)
if hi.Kind == hooks.RelationBroken {
return d.Remove()
}
name := strings.Replace(hi.RemoteUnit, "/", "-", 1)
path := filepath.Join(d.path, na... | go | {
"resource": ""
} |
q4602 | start | train | func (config ManifoldConfig) start(apiCaller base.APICaller) (worker.Worker, error) {
facade, err := config.NewFacade(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
return config.NewWorker(Config{
Facade: facade,
})
} | go | {
"resource": ""
} |
q4603 | Manifold | train | func Manifold(config ManifoldConfig) dependency.Manifold {
return engine.APIManifold(
engine.APIManifoldConfig{config.APICallerName},
config.start,
)
} | go | {
"resource": ""
} |
q4604 | ResourceTags | train | func ResourceTags(modelTag names.ModelTag, controllerTag names.ControllerTag, taggers ...ResourceTagger) map[string]string {
allTags := make(map[string]string)
for _, tagger := range taggers {
tags, ok := tagger.ResourceTags()
if !ok {
continue
}
for k, v := range tags {
allTags[k] = v
}
}
allTags[J... | go | {
"resource": ""
} |
q4605 | Validate | train | func (ot OriginType) Validate() error {
// As noted above, typedef'ing int means that the use of int
// literals or explicit type conversion could result in unsupported
// "enum" values. Otherwise OriginType would not need this method.
if _, ok := originTypes[ot]; !ok {
return errors.NewNotValid(nil, "unsupported... | go | {
"resource": ""
} |
q4606 | ValidateName | train | func (ot OriginType) ValidateName(name string) error {
switch ot {
case OriginTypeUnknown:
if name != "" {
return errors.NewNotValid(nil, "origin name must not be set if type is unknown")
}
case OriginTypeUser:
if !names.IsValidUser(name) {
return errors.NewNotValid(nil, "bad user name")
}
case Origin... | go | {
"resource": ""
} |
q4607 | OriginForMachineAgent | train | func OriginForMachineAgent(tag names.MachineTag, controller, model string, ver version.Number) Origin {
return originForAgent(OriginTypeMachine, tag, controller, model, ver)
} | go | {
"resource": ""
} |
q4608 | OriginForUnitAgent | train | func OriginForUnitAgent(tag names.UnitTag, controller, model string, ver version.Number) Origin {
return originForAgent(OriginTypeUnit, tag, controller, model, ver)
} | go | {
"resource": ""
} |
q4609 | OriginForJuju | train | func OriginForJuju(tag names.Tag, controller, model string, ver version.Number) (Origin, error) {
oType, err := ParseOriginType(tag.Kind())
if err != nil {
return Origin{}, errors.Annotate(err, "invalid tag")
}
return originForJuju(oType, tag.Id(), controller, model, ver), nil
} | go | {
"resource": ""
} |
q4610 | Validate | train | func (o Origin) Validate() error {
if o.ControllerUUID == "" {
return errors.NewNotValid(nil, "empty ControllerUUID")
}
if !names.IsValidModel(o.ControllerUUID) {
return errors.NewNotValid(nil, fmt.Sprintf("ControllerUUID %q not a valid UUID", o.ControllerUUID))
}
if o.ModelUUID == "" {
return errors.NewNot... | go | {
"resource": ""
} |
q4611 | Validate | train | func (sw Software) Validate() error {
if sw.PrivateEnterpriseNumber <= 0 {
return errors.NewNotValid(nil, "missing PrivateEnterpriseNumber")
}
if sw.Name == "" {
return errors.NewNotValid(nil, "empty Name")
}
if sw.Version == version.Zero {
return errors.NewNotValid(nil, "empty Version")
}
return nil
} | go | {
"resource": ""
} |
q4612 | Handle | train | func (c *APIAddressUpdater) Handle(_ <-chan struct{}) error {
hpsToSet, err := c.getAddresses()
if err != nil {
return err
}
logger.Debugf("updating API hostPorts to %+v", hpsToSet)
c.mu.Lock()
c.current = hpsToSet
c.mu.Unlock()
if err := c.setter.SetAPIHostPorts(hpsToSet); err != nil {
return fmt.Errorf("e... | go | {
"resource": ""
} |
q4613 | AllInstances | train | func (broker *lxdBroker) AllInstances(ctx context.ProviderCallContext) (result []instances.Instance, err error) {
return broker.manager.ListContainers()
} | go | {
"resource": ""
} |
q4614 | MaintainInstance | train | func (broker *lxdBroker) MaintainInstance(ctx context.ProviderCallContext, args environs.StartInstanceParams) error {
machineID := args.InstanceConfig.MachineId
// There's no InterfaceInfo we expect to get below.
_, err := prepareOrGetContainerInterfaceInfo(
broker.api,
machineID,
false, // maintain, do not a... | go | {
"resource": ""
} |
q4615 | LXDProfileNames | train | func (broker *lxdBroker) LXDProfileNames(containerName string) ([]string, error) {
nameRetriever, ok := broker.manager.(container.LXDProfileNameRetriever)
if !ok {
return make([]string, 0), nil
}
return nameRetriever.LXDProfileNames(containerName)
} | go | {
"resource": ""
} |
q4616 | coreChange | train | func (c *itemChange) coreChange() settings.ItemChange {
return settings.ItemChange{
Type: c.Type,
Key: utils.UnescapeKey(c.Key),
OldValue: c.OldValue,
NewValue: c.NewValue,
}
} | go | {
"resource": ""
} |
q4617 | Config | train | func (g *Generation) Config() map[string]settings.ItemChanges {
changes := make(map[string]settings.ItemChanges, len(g.doc.Config))
for appName, appCfg := range g.doc.Config {
appChanges := make(settings.ItemChanges, len(appCfg))
for i, ch := range appCfg {
appChanges[i] = ch.coreChange()
}
sort.Sort(appCh... | go | {
"resource": ""
} |
q4618 | AssignApplication | train | func (g *Generation) AssignApplication(appName string) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := g.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if _, ok := g.doc.AssignedUnits[appName]; ok {
return nil, jujutxn.ErrNoOperations
}
if err := g... | go | {
"resource": ""
} |
q4619 | AssignAllUnits | train | func (g *Generation) AssignAllUnits(appName string) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := g.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if err := g.CheckNotComplete(); err != nil {
return nil, errors.Trace(err)
}
unitNames, err := appU... | go | {
"resource": ""
} |
q4620 | AssignUnit | train | func (g *Generation) AssignUnit(unitName string) error {
appName, err := names.UnitApplication(unitName)
if err != nil {
return errors.Trace(err)
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := g.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if err := g.... | go | {
"resource": ""
} |
q4621 | UpdateCharmConfig | train | func (g *Generation) UpdateCharmConfig(appName string, master *Settings, validChanges charm.Settings) error {
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := g.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if err := g.CheckNotComplete(); err != nil {
return n... | go | {
"resource": ""
} |
q4622 | Commit | train | func (g *Generation) Commit(userName string) (int, error) {
var newGenId int
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := g.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if g.IsCompleted() {
if g.GenerationId() == 0 {
return nil, errors.New("branch w... | go | {
"resource": ""
} |
q4623 | Refresh | train | func (g *Generation) Refresh() error {
col, closer := g.st.db().GetCollection(generationsC)
defer closer()
var doc generationDoc
if err := col.FindId(g.doc.DocId).One(&doc); err != nil {
return errors.Trace(err)
}
g.doc = doc
return nil
} | go | {
"resource": ""
} |
q4624 | AddBranch | train | func (m *Model) AddBranch(branchName, userName string) error {
return errors.Trace(m.st.AddBranch(branchName, userName))
} | go | {
"resource": ""
} |
q4625 | AddBranch | train | func (st *State) AddBranch(branchName, userName string) error {
id, err := sequence(st, "branch")
if err != nil {
return errors.Trace(err)
}
buildTxn := func(attempt int) ([]txn.Op, error) {
if _, err := st.Branch(branchName); err != nil {
if !errors.IsNotFound(err) {
return nil, errors.Annotatef(err, "... | go | {
"resource": ""
} |
q4626 | Branches | train | func (m *Model) Branches() ([]*Generation, error) {
b, err := m.st.Branches()
return b, errors.Trace(err)
} | go | {
"resource": ""
} |
q4627 | Branches | train | func (st *State) Branches() ([]*Generation, error) {
col, closer := st.db().GetCollection(generationsC)
defer closer()
var docs []generationDoc
if err := col.Find(bson.M{"completed": 0}).All(&docs); err != nil {
return nil, errors.Trace(err)
}
branches := make([]*Generation, len(docs))
for i, d := range docs... | go | {
"resource": ""
} |
q4628 | makeItemChanges | train | func makeItemChanges(coreChanges settings.ItemChanges) []itemChange {
changes := make([]itemChange, len(coreChanges))
for i, c := range coreChanges {
changes[i] = itemChange{
Type: c.Type,
Key: utils.EscapeKey(c.Key),
OldValue: c.OldValue,
NewValue: c.NewValue,
}
}
return changes
} | go | {
"resource": ""
} |
q4629 | NewPodSpecSetCommand | train | func NewPodSpecSetCommand(ctx Context) (cmd.Command, error) {
return &PodSpecSetCommand{ctx: ctx}, nil
} | go | {
"resource": ""
} |
q4630 | Id | train | func (m *machineTracker) Id() string {
m.mu.Lock()
defer m.mu.Unlock()
return m.id
} | go | {
"resource": ""
} |
q4631 | Addresses | train | func (m *machineTracker) Addresses() []network.Address {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]network.Address, len(m.addresses))
copy(out, m.addresses)
return out
} | go | {
"resource": ""
} |
q4632 | SelectMongoAddressFromSpace | train | func (m *machineTracker) SelectMongoAddressFromSpace(port int, space network.SpaceName) (string, error) {
if space == "" {
return "", fmt.Errorf("empty space supplied as an argument for selecting Mongo address for machine %q", m.id)
}
m.mu.Lock()
hostPorts := network.AddressesWithPort(m.addresses, port)
m.mu.Un... | go | {
"resource": ""
} |
q4633 | GetPotentialMongoHostPorts | train | func (m *machineTracker) GetPotentialMongoHostPorts(port int) []network.HostPort {
m.mu.Lock()
defer m.mu.Unlock()
return network.AddressesWithPort(m.addresses, port)
} | go | {
"resource": ""
} |
q4634 | AllLinkLayerDevices | train | func (m *MockMachine) AllLinkLayerDevices() ([]containerizer.LinkLayerDevice, error) {
ret := m.ctrl.Call(m, "AllLinkLayerDevices")
ret0, _ := ret[0].([]containerizer.LinkLayerDevice)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4635 | AllSpaces | train | func (m *MockMachine) AllSpaces() (set.Strings, error) {
ret := m.ctrl.Call(m, "AllSpaces")
ret0, _ := ret[0].(set.Strings)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4636 | ContainerType | train | func (m *MockMachine) ContainerType() instance.ContainerType {
ret := m.ctrl.Call(m, "ContainerType")
ret0, _ := ret[0].(instance.ContainerType)
return ret0
} | go | {
"resource": ""
} |
q4637 | IsManual | train | func (m *MockMachine) IsManual() (bool, error) {
ret := m.ctrl.Call(m, "IsManual")
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4638 | LinkLayerDevicesForSpaces | train | func (m *MockMachine) LinkLayerDevicesForSpaces(arg0 []string) (map[string][]containerizer.LinkLayerDevice, error) {
ret := m.ctrl.Call(m, "LinkLayerDevicesForSpaces", arg0)
ret0, _ := ret[0].(map[string][]containerizer.LinkLayerDevice)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4639 | Raw | train | func (m *MockMachine) Raw() *state.Machine {
ret := m.ctrl.Call(m, "Raw")
ret0, _ := ret[0].(*state.Machine)
return ret0
} | go | {
"resource": ""
} |
q4640 | Raw | train | func (mr *MockMachineMockRecorder) Raw() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Raw", reflect.TypeOf((*MockMachine)(nil).Raw))
} | go | {
"resource": ""
} |
q4641 | RemoveAllAddresses | train | func (m *MockMachine) RemoveAllAddresses() error {
ret := m.ctrl.Call(m, "RemoveAllAddresses")
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4642 | SetConstraints | train | func (m *MockMachine) SetConstraints(arg0 constraints.Value) error {
ret := m.ctrl.Call(m, "SetConstraints", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4643 | SetConstraints | train | func (mr *MockMachineMockRecorder) SetConstraints(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConstraints", reflect.TypeOf((*MockMachine)(nil).SetConstraints), arg0)
} | go | {
"resource": ""
} |
q4644 | SetDevicesAddresses | train | func (m *MockMachine) SetDevicesAddresses(arg0 ...state.LinkLayerDeviceAddress) error {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SetDevicesAddresses", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4645 | SetLinkLayerDevices | train | func (m *MockMachine) SetLinkLayerDevices(arg0 ...state.LinkLayerDeviceArgs) error {
varargs := []interface{}{}
for _, a := range arg0 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SetLinkLayerDevices", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4646 | SetParentLinkLayerDevicesBeforeTheirChildren | train | func (m *MockMachine) SetParentLinkLayerDevicesBeforeTheirChildren(arg0 []state.LinkLayerDeviceArgs) error {
ret := m.ctrl.Call(m, "SetParentLinkLayerDevicesBeforeTheirChildren", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4647 | NewExecutor | train | func NewExecutor(stateFilePath string, initialState State, acquireLock func(string) (func(), error)) (Executor, error) {
file := NewStateFile(stateFilePath)
state, err := file.Read()
if err == ErrNoStateFile {
state = &initialState
} else if err != nil {
return nil, err
}
return &executor{
file: ... | go | {
"resource": ""
} |
q4648 | Run | train | func (x *executor) Run(op Operation) error {
logger.Debugf("running operation %v", op)
if op.NeedsGlobalMachineLock() {
releaser, err := x.acquireMachineLock(op.String())
if err != nil {
return errors.Annotate(err, "could not acquire lock")
}
defer logger.Debugf("lock released")
defer releaser()
}
sw... | go | {
"resource": ""
} |
q4649 | Skip | train | func (x *executor) Skip(op Operation) error {
logger.Debugf("skipping operation %v", op)
return x.do(op, stepCommit)
} | go | {
"resource": ""
} |
q4650 | ensureModelUUID | train | func ensureModelUUID(modelUUID, id string) string {
prefix := modelUUID + ":"
if strings.HasPrefix(id, prefix) {
return id
}
return prefix + id
} | go | {
"resource": ""
} |
q4651 | ensureModelUUIDIfString | train | func ensureModelUUIDIfString(modelUUID string, id interface{}) interface{} {
if id, ok := id.(string); ok {
return ensureModelUUID(modelUUID, id)
}
return id
} | go | {
"resource": ""
} |
q4652 | splitDocID | train | func splitDocID(id string) (string, string, bool) {
parts := strings.SplitN(id, ":", 2)
if len(parts) != 2 {
return "", "", false
}
return parts[0], parts[1], true
} | go | {
"resource": ""
} |
q4653 | toBsonD | train | func toBsonD(doc interface{}) (bson.D, error) {
bytes, err := bson.Marshal(doc)
if err != nil {
return nil, errors.Annotate(err, "bson marshaling failed")
}
var out bson.D
err = bson.Unmarshal(bytes, &out)
if err != nil {
return nil, errors.Annotate(err, "bson unmarshaling failed")
}
return out, nil
} | go | {
"resource": ""
} |
q4654 | addAddress | train | func addAddress(servers [][]network.HostPort, addr string) ([][]network.HostPort, error) {
for i, server := range servers {
for j, hostPort := range server {
if hostPort.NetAddr() == addr {
slideAddressToFront(servers, i, j)
return servers, nil
}
}
}
host, portString, err := net.SplitHostPort(addr)... | go | {
"resource": ""
} |
q4655 | Client | train | func (st *state) Client() *Client {
frontend, backend := base.NewClientFacade(st, "Client")
return &Client{ClientFacade: frontend, facade: backend, st: st}
} | go | {
"resource": ""
} |
q4656 | Uniter | train | func (st *state) Uniter() (*uniter.State, error) {
unitTag, ok := st.authTag.(names.UnitTag)
if !ok {
return nil, errors.Errorf("expected UnitTag, got %T %v", st.authTag, st.authTag)
}
return uniter.NewState(st, unitTag), nil
} | go | {
"resource": ""
} |
q4657 | Reboot | train | func (st *state) Reboot() (reboot.State, error) {
switch tag := st.authTag.(type) {
case names.MachineTag:
return reboot.NewState(st, tag), nil
default:
return nil, errors.Errorf("expected names.MachineTag, got %T", tag)
}
} | go | {
"resource": ""
} |
q4658 | ServerVersion | train | func (st *state) ServerVersion() (version.Number, bool) {
return st.serverVersion, st.serverVersion != version.Zero
} | go | {
"resource": ""
} |
q4659 | Config | train | func (j JujuConfigProvider) Config() (ociCommon.ConfigurationProvider, error) {
if err := j.Validate(); err != nil {
return nil, err
}
return &j, nil
} | go | {
"resource": ""
} |
q4660 | NewValidator | train | func NewValidator() Validator {
return &validator{
conflicts: make(map[string]set.Strings),
vocab: make(map[string][]interface{}),
}
} | go | {
"resource": ""
} |
q4661 | RegisterConflicts | train | func (v *validator) RegisterConflicts(reds, blues []string) {
for _, red := range reds {
v.conflicts[red] = set.NewStrings(blues...)
}
for _, blue := range blues {
v.conflicts[blue] = set.NewStrings(reds...)
}
} | go | {
"resource": ""
} |
q4662 | RegisterUnsupported | train | func (v *validator) RegisterUnsupported(unsupported []string) {
v.unsupported = set.NewStrings(unsupported...)
} | go | {
"resource": ""
} |
q4663 | RegisterVocabulary | train | func (v *validator) RegisterVocabulary(attributeName string, allowedValues interface{}) {
v.vocab[resolveAlias(attributeName)] = convertToSlice(allowedValues)
} | go | {
"resource": ""
} |
q4664 | UpdateVocabulary | train | func (v *validator) UpdateVocabulary(attributeName string, allowedValues interface{}) {
attributeName = resolveAlias(attributeName)
// If this attribute is not registered, delegate to RegisterVocabulary()
currentValues, ok := v.vocab[attributeName]
if !ok {
v.RegisterVocabulary(attributeName, allowedValues)
}
... | go | {
"resource": ""
} |
q4665 | checkConflicts | train | func (v *validator) checkConflicts(cons Value) error {
attrValues := cons.attributesWithValues()
attrSet := make(set.Strings)
for attrTag := range attrValues {
attrSet.Add(attrTag)
}
for _, attrTag := range attrSet.SortedValues() {
conflicts, ok := v.conflicts[attrTag]
if !ok {
continue
}
for _, confl... | go | {
"resource": ""
} |
q4666 | checkUnsupported | train | func (v *validator) checkUnsupported(cons Value) []string {
return cons.hasAny(v.unsupported.Values()...)
} | go | {
"resource": ""
} |
q4667 | checkValidValues | train | func (v *validator) checkValidValues(cons Value) error {
for attrTag, attrValue := range cons.attributesWithValues() {
k := reflect.TypeOf(attrValue).Kind()
if k == reflect.Slice || k == reflect.Array {
// For slices we check that all values are valid.
val := reflect.ValueOf(attrValue)
for i := 0; i < val... | go | {
"resource": ""
} |
q4668 | checkInVocab | train | func (v *validator) checkInVocab(attributeName string, attributeValue interface{}) error {
validValues, ok := v.vocab[resolveAlias(attributeName)]
if !ok {
return nil
}
for _, validValue := range validValues {
if coerce(validValue) == coerce(attributeValue) {
return nil
}
}
return fmt.Errorf(
"invalid ... | go | {
"resource": ""
} |
q4669 | withFallbacks | train | func withFallbacks(v Value, vFallback Value) Value {
vAttr := v.attributesWithValues()
fbAttr := vFallback.attributesWithValues()
for k, v := range fbAttr {
if _, ok := vAttr[k]; !ok {
vAttr[k] = v
}
}
return fromAttributes(vAttr)
} | go | {
"resource": ""
} |
q4670 | Validate | train | func (v *validator) Validate(cons Value) ([]string, error) {
unsupported := v.checkUnsupported(cons)
if err := v.checkConflicts(cons); err != nil {
return unsupported, err
}
if err := v.checkValidValues(cons); err != nil {
return unsupported, err
}
return unsupported, nil
} | go | {
"resource": ""
} |
q4671 | Merge | train | func (v *validator) Merge(consFallback, cons Value) (Value, error) {
// First ensure both constraints are valid. We don't care if there
// are constraint attributes that are unsupported.
if _, err := v.Validate(consFallback); err != nil {
return Value{}, err
}
if _, err := v.Validate(cons); err != nil {
return... | go | {
"resource": ""
} |
q4672 | createAPI | train | func createAPI(
st metadataAccess,
newEnviron func() (environs.Environ, error),
resources facade.Resources,
authorizer facade.Authorizer,
) (*API, error) {
if !authorizer.AuthClient() {
return nil, common.ErrPerm
}
admin, err := authorizer.HasPermission(permission.SuperuserAccess, st.ControllerTag())
if err !... | go | {
"resource": ""
} |
q4673 | List | train | func (api *API) List(filter params.ImageMetadataFilter) (params.ListCloudImageMetadataResult, error) {
found, err := api.metadata.FindMetadata(cloudimagemetadata.MetadataFilter{
Region: filter.Region,
Series: filter.Series,
Arches: filter.Arches,
Stream: filter.Stream,
Vir... | go | {
"resource": ""
} |
q4674 | Save | train | func (api *API) Save(metadata params.MetadataSaveParams) (params.ErrorResults, error) {
all, err := imagecommon.Save(api.metadata, metadata)
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
return params.ErrorResults{Results: all}, nil
} | go | {
"resource": ""
} |
q4675 | Delete | train | func (api *API) Delete(images params.MetadataImageIds) (params.ErrorResults, error) {
all := make([]params.ErrorResult, len(images.Ids))
for i, imageId := range images.Ids {
err := api.metadata.DeleteMetadata(imageId)
all[i] = params.ErrorResult{common.ServerError(err)}
}
return params.ErrorResults{Results: all... | go | {
"resource": ""
} |
q4676 | CreateFilesystems | train | func (s *lxdFilesystemSource) CreateFilesystems(ctx context.ProviderCallContext, args []storage.FilesystemParams) (_ []storage.CreateFilesystemsResult, err error) {
results := make([]storage.CreateFilesystemsResult, len(args))
for i, arg := range args {
if err := s.ValidateFilesystemParams(arg); err != nil {
res... | go | {
"resource": ""
} |
q4677 | parseFilesystemId | train | func parseFilesystemId(id string) (lxdPool, volumeName string, _ error) {
fields := strings.SplitN(id, ":", 2)
if len(fields) < 2 {
return "", "", errors.Errorf(
"invalid filesystem ID %q; expected ID in format <lxd-pool>:<volume-name>", id,
)
}
return fields[0], fields[1], nil
} | go | {
"resource": ""
} |
q4678 | ReleaseFilesystems | train | func (s *lxdFilesystemSource) ReleaseFilesystems(ctx context.ProviderCallContext, filesystemIds []string) ([]error, error) {
results := make([]error, len(filesystemIds))
for i, filesystemId := range filesystemIds {
results[i] = s.releaseFilesystem(filesystemId)
common.HandleCredentialError(IsAuthorisationFailure,... | go | {
"resource": ""
} |
q4679 | AttachFilesystems | train | func (s *lxdFilesystemSource) AttachFilesystems(ctx context.ProviderCallContext, args []storage.FilesystemAttachmentParams) ([]storage.AttachFilesystemsResult, error) {
var instanceIds []instance.Id
instanceIdsSeen := make(set.Strings)
for _, arg := range args {
if instanceIdsSeen.Contains(string(arg.InstanceId)) ... | go | {
"resource": ""
} |
q4680 | ImportFilesystem | train | func (s *lxdFilesystemSource) ImportFilesystem(
callCtx context.ProviderCallContext,
filesystemId string,
tags map[string]string,
) (storage.FilesystemInfo, error) {
lxdPool, volumeName, err := parseFilesystemId(filesystemId)
if err != nil {
return storage.FilesystemInfo{}, errors.Trace(err)
}
volume, eTag, er... | go | {
"resource": ""
} |
q4681 | newConstraints | train | func newConstraints(bootstrap bool, jc constraints.Value, img *imagemetadata.ImageMetadata) *sigmaConstraints {
var sc = sigmaConstraints{
driveTemplate: img.Id,
}
if size := jc.RootDisk; bootstrap && size == nil {
sc.driveSize = defaultDriveGB * gosigma.Gigabyte
} else if size != nil {
sc.driveSize = *size ... | go | {
"resource": ""
} |
q4682 | GenerateContent | train | func GenerateContent(reader io.ReadSeeker) (Content, error) {
var sizer utils.SizeTracker
sizingReader := io.TeeReader(reader, &sizer)
fp, err := charmresource.GenerateFingerprint(sizingReader)
if err != nil {
return Content{}, errors.Trace(err)
}
if _, err := reader.Seek(0, os.SEEK_SET); err != nil {
return ... | go | {
"resource": ""
} |
q4683 | CreateDisks | train | func (gce *Connection) CreateDisks(zone string, disks []DiskSpec) ([]*Disk, error) {
results := make([]*Disk, len(disks))
for i, disk := range disks {
d, err := disk.newDetached()
if err != nil {
return []*Disk{}, errors.Annotate(err, "cannot create disk spec")
}
if err := gce.createDisk(zone, d); err != n... | go | {
"resource": ""
} |
q4684 | Disks | train | func (gce *Connection) Disks() ([]*Disk, error) {
computeDisks, err := gce.raw.ListDisks(gce.projectID)
if err != nil {
return nil, errors.Annotate(err, "cannot list disks")
}
disks := make([]*Disk, len(computeDisks))
for i, disk := range computeDisks {
disks[i] = NewDisk(disk)
}
return disks, nil
} | go | {
"resource": ""
} |
q4685 | Disk | train | func (gce *Connection) Disk(zone, name string) (*Disk, error) {
d, err := gce.raw.GetDisk(gce.projectID, zone, name)
if err != nil {
return nil, errors.Annotatef(err, "cannot get disk %q in zone %q", name, zone)
}
return NewDisk(d), nil
} | go | {
"resource": ""
} |
q4686 | SetDiskLabels | train | func (gce *Connection) SetDiskLabels(zone, name, labelFingerprint string, labels map[string]string) error {
err := gce.raw.SetDiskLabels(gce.projectID, zone, name, labelFingerprint, labels)
return errors.Annotatef(err, "cannot update labels for disk %q in zone %q", name, zone)
} | go | {
"resource": ""
} |
q4687 | AttachDisk | train | func (gce *Connection) AttachDisk(zone, volumeName, instanceId string, mode DiskMode) (*AttachedDisk, error) {
disk, err := gce.raw.GetDisk(gce.projectID, zone, volumeName)
if err != nil {
return nil, errors.Annotatef(err, "cannot obtain disk %q to attach it", volumeName)
}
attachedDisk := &compute.AttachedDisk{
... | go | {
"resource": ""
} |
q4688 | DetachDisk | train | func (gce *Connection) DetachDisk(zone, instanceId, volumeName string) error {
disk, err := gce.raw.GetDisk(gce.projectID, zone, volumeName)
if err != nil {
return errors.Annotatef(err, "cannot obtain disk %q to detach it", volumeName)
}
dn := deviceName(zone, disk.Id)
err = gce.raw.DetachDisk(gce.projectID, zon... | go | {
"resource": ""
} |
q4689 | InstanceDisks | train | func (gce *Connection) InstanceDisks(zone, instanceId string) ([]*AttachedDisk, error) {
disks, err := gce.raw.InstanceDisks(gce.projectID, zone, instanceId)
if err != nil {
return nil, errors.Annotatef(err, "cannot get disks from instance")
}
att := make([]*AttachedDisk, len(disks))
for i, disk := range disks {... | go | {
"resource": ""
} |
q4690 | NetworkInfo | train | func (*RestrictedContext) NetworkInfo(bindingNames []string, relationId int) (map[string]params.NetworkInfoResult, error) {
return map[string]params.NetworkInfoResult{}, ErrRestrictedContext
} | go | {
"resource": ""
} |
q4691 | AddMetricLabels | train | func (*RestrictedContext) AddMetricLabels(string, string, time.Time, map[string]string) error {
return ErrRestrictedContext
} | go | {
"resource": ""
} |
q4692 | ControllerTag | train | func (m *MockState) ControllerTag() names_v2.ControllerTag {
ret := m.ctrl.Call(m, "ControllerTag")
ret0, _ := ret[0].(names_v2.ControllerTag)
return ret0
} | go | {
"resource": ""
} |
q4693 | NewMockModel | train | func NewMockModel(ctrl *gomock.Controller) *MockModel {
mock := &MockModel{ctrl: ctrl}
mock.recorder = &MockModelMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q4694 | Branch | train | func (m *MockModel) Branch(arg0 string) (modelgeneration.Generation, error) {
ret := m.ctrl.Call(m, "Branch", arg0)
ret0, _ := ret[0].(modelgeneration.Generation)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4695 | Branches | train | func (m *MockModel) Branches() ([]modelgeneration.Generation, error) {
ret := m.ctrl.Call(m, "Branches")
ret0, _ := ret[0].([]modelgeneration.Generation)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4696 | ModelTag | train | func (mr *MockModelMockRecorder) ModelTag() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModelTag", reflect.TypeOf((*MockModel)(nil).ModelTag))
} | go | {
"resource": ""
} |
q4697 | NewMockGeneration | train | func NewMockGeneration(ctrl *gomock.Controller) *MockGeneration {
mock := &MockGeneration{ctrl: ctrl}
mock.recorder = &MockGenerationMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q4698 | AssignAllUnits | train | func (m *MockGeneration) AssignAllUnits(arg0 string) error {
ret := m.ctrl.Call(m, "AssignAllUnits", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4699 | AssignUnit | train | func (mr *MockGenerationMockRecorder) AssignUnit(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignUnit", reflect.TypeOf((*MockGeneration)(nil).AssignUnit), arg0)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.