_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q4000 | setControllerAccess | train | func (st *State) setControllerAccess(access permission.Access, userGlobalKey string) error {
if err := permission.ValidateControllerAccess(access); err != nil {
return errors.Trace(err)
}
op := updatePermissionOp(controllerKey(st.ControllerUUID()), userGlobalKey, access)
err := st.db().RunTransaction([]txn.Op{op... | go | {
"resource": ""
} |
q4001 | controllerUser | train | func (st *State) controllerUser(user names.UserTag) (userAccessDoc, error) {
controllerUser := userAccessDoc{}
controllerUsers, closer := st.db().GetCollection(controllerUsersC)
defer closer()
username := strings.ToLower(user.Id())
err := controllerUsers.FindId(username).One(&controllerUser)
if err == mgo.ErrNot... | go | {
"resource": ""
} |
q4002 | removeControllerUser | train | func (st *State) removeControllerUser(user names.UserTag) error {
ops := removeControllerUserOps(st.ControllerUUID(), user)
err := st.db().RunTransaction(ops)
if err == txn.ErrAborted {
err = errors.NewNotFound(nil, fmt.Sprintf("controller user %q does not exist", user.Id()))
}
if err != nil {
return errors.Tr... | go | {
"resource": ""
} |
q4003 | Info | train | func (c *Client) Info(id string) (*params.BackupsMetadataResult, error) {
var result params.BackupsMetadataResult
args := params.BackupsInfoArgs{ID: id}
if err := c.facade.FacadeCall("Info", args, &result); err != nil {
return nil, errors.Trace(err)
}
return &result, nil
} | go | {
"resource": ""
} |
q4004 | Get | train | func (api *APIv5) Get(args params.ApplicationGet) (params.ApplicationGetResults, error) {
results, err := api.getConfig(args, describe)
if err != nil {
return params.ApplicationGetResults{}, err
}
results.ApplicationConfig = nil
return results, nil
} | go | {
"resource": ""
} |
q4005 | Get | train | func (api *APIv4) Get(args params.ApplicationGet) (params.ApplicationGetResults, error) {
results, err := api.getConfig(args, describeV4)
if err != nil {
return params.ApplicationGetResults{}, err
}
results.ApplicationConfig = nil
return results, nil
} | go | {
"resource": ""
} |
q4006 | AddUser | train | func (m *Model) AddUser(spec UserAccessSpec) (permission.UserAccess, error) {
if err := permission.ValidateModelAccess(spec.Access); err != nil {
return permission.UserAccess{}, errors.Annotate(err, "adding model user")
}
target := userAccessTarget{
uuid: m.UUID(),
globalKey: modelGlobalKey,
}
return m.... | go | {
"resource": ""
} |
q4007 | AddControllerUser | train | func (st *State) AddControllerUser(spec UserAccessSpec) (permission.UserAccess, error) {
if err := permission.ValidateControllerAccess(spec.Access); err != nil {
return permission.UserAccess{}, errors.Annotate(err, "adding controller user")
}
return st.addUserAccess(spec, userAccessTarget{globalKey: controllerGlob... | go | {
"resource": ""
} |
q4008 | userAccessID | train | func userAccessID(user names.UserTag) string {
username := user.Id()
return strings.ToLower(username)
} | go | {
"resource": ""
} |
q4009 | NewModelUserAccess | train | func NewModelUserAccess(st *State, userDoc userAccessDoc) (permission.UserAccess, error) {
perm, err := st.userPermission(modelKey(userDoc.ObjectUUID), userGlobalKey(strings.ToLower(userDoc.UserName)))
if err != nil {
return permission.UserAccess{}, errors.Annotate(err, "obtaining model permission")
}
return newU... | go | {
"resource": ""
} |
q4010 | NewControllerUserAccess | train | func NewControllerUserAccess(st *State, userDoc userAccessDoc) (permission.UserAccess, error) {
perm, err := st.userPermission(controllerKey(st.ControllerUUID()), userGlobalKey(strings.ToLower(userDoc.UserName)))
if err != nil {
return permission.UserAccess{}, errors.Annotate(err, "obtaining controller permission")... | go | {
"resource": ""
} |
q4011 | UserPermission | train | func (st *State) UserPermission(subject names.UserTag, target names.Tag) (permission.Access, error) {
if err := st.userMayHaveAccess(subject); err != nil {
return "", errors.Trace(err)
}
switch target.Kind() {
case names.ModelTagKind, names.ControllerTagKind:
access, err := st.UserAccess(subject, target)
if ... | go | {
"resource": ""
} |
q4012 | UserAccess | train | func (st *State) UserAccess(subject names.UserTag, target names.Tag) (permission.UserAccess, error) {
if err := st.userMayHaveAccess(subject); err != nil {
return permission.UserAccess{}, errors.Trace(err)
}
var (
userDoc userAccessDoc
err error
)
switch target.Kind() {
case names.ModelTagKind:
userD... | go | {
"resource": ""
} |
q4013 | RemoveUserAccess | train | func (st *State) RemoveUserAccess(subject names.UserTag, target names.Tag) error {
switch target.Kind() {
case names.ModelTagKind:
return errors.Trace(st.removeModelUser(subject))
case names.ControllerTagKind:
return errors.Trace(st.removeControllerUser(subject))
}
return errors.NotValidf("%q as a target", tar... | go | {
"resource": ""
} |
q4014 | populateMachineMaps | train | func (task *provisionerTask) populateMachineMaps(ids []string) error {
task.instances = make(map[instance.Id]instances.Instance)
instances, err := task.broker.AllInstances(task.cloudCallCtx)
if err != nil {
return errors.Annotate(err, "failed to get all instances from broker")
}
for _, i := range instances {
... | go | {
"resource": ""
} |
q4015 | pendingOrDeadOrMaintain | train | func (task *provisionerTask) pendingOrDeadOrMaintain(ids []string) (pending, dead, maintain []apiprovisioner.MachineProvisioner, err error) {
task.machinesMutex.RLock()
defer task.machinesMutex.RUnlock()
for _, id := range ids {
machine, found := task.machines[id]
if !found {
logger.Infof("machine %q not foun... | go | {
"resource": ""
} |
q4016 | findUnknownInstances | train | func (task *provisionerTask) findUnknownInstances(stopping []instances.Instance) ([]instances.Instance, error) {
// Make a copy of the instances we know about.
taskInstances := make(map[instance.Id]instances.Instance)
for k, v := range task.instances {
taskInstances[k] = v
}
task.machinesMutex.RLock()
defer ta... | go | {
"resource": ""
} |
q4017 | instancesForDeadMachines | train | func (task *provisionerTask) instancesForDeadMachines(deadMachines []apiprovisioner.MachineProvisioner) []instances.Instance {
var instances []instances.Instance
for _, machine := range deadMachines {
instId, err := machine.InstanceId()
if err == nil {
keep, _ := machine.KeepInstance()
if keep {
logger.... | go | {
"resource": ""
} |
q4018 | populateAvailabilityZoneMachines | train | func (task *provisionerTask) populateAvailabilityZoneMachines() error {
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
if len(task.availabilityZoneMachines) > 0 {
return nil
}
zonedEnv, ok := task.broker.(providercommon.ZonedEnviron)
if !ok {
return nil
}
// In this case, AvailabilityZoneAllo... | go | {
"resource": ""
} |
q4019 | populateDistributionGroupZoneMap | train | func (task *provisionerTask) populateDistributionGroupZoneMap(machineIds []string) []*AvailabilityZoneMachine {
var dgAvailabilityZoneMachines []*AvailabilityZoneMachine
dgSet := set.NewStrings(machineIds...)
for _, azm := range task.availabilityZoneMachines {
dgAvailabilityZoneMachines = append(dgAvailabilityZone... | go | {
"resource": ""
} |
q4020 | machineAvailabilityZoneDistribution | train | func (task *provisionerTask) machineAvailabilityZoneDistribution(
machineId string, distGroupMachineIds []string, cons constraints.Value,
) (string, error) {
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
if len(task.availabilityZoneMachines) == 0 {
return "", nil
}
// Assign an initial zone to a... | go | {
"resource": ""
} |
q4021 | FilterZones | train | func (a azMachineFilterSort) FilterZones(cons constraints.Value) azMachineFilterSort {
if !cons.HasZones() {
return a
}
logger.Debugf("applying availability zone constraints: %s", strings.Join(*cons.Zones, ", "))
filtered := a[:0]
for _, azm := range a {
for _, zone := range *cons.Zones {
if azm.ZoneName =... | go | {
"resource": ""
} |
q4022 | startMachines | train | func (task *provisionerTask) startMachines(machines []apiprovisioner.MachineProvisioner) error {
if len(machines) == 0 {
return nil
}
// Get the distributionGroups for each machine now to avoid
// successive calls to DistributionGroupByMachineId which will
// return the same data.
machineTags := make([]names.M... | go | {
"resource": ""
} |
q4023 | setupToStartMachine | train | func (task *provisionerTask) setupToStartMachine(machine apiprovisioner.MachineProvisioner, version *version.Number) (
environs.StartInstanceParams,
error,
) {
pInfo, err := machine.ProvisioningInfo()
if err != nil {
return environs.StartInstanceParams{}, errors.Annotatef(err, "fetching provisioning info for mach... | go | {
"resource": ""
} |
q4024 | populateExcludedMachines | train | func (task *provisionerTask) populateExcludedMachines(machineId string, startInstanceParams environs.StartInstanceParams) error {
zonedEnv, ok := task.broker.(providercommon.ZonedEnviron)
if !ok {
return nil
}
derivedZones, err := zonedEnv.DeriveAvailabilityZones(task.cloudCallCtx, startInstanceParams)
if err !=... | go | {
"resource": ""
} |
q4025 | gatherCharmLXDProfiles | train | func (task *provisionerTask) gatherCharmLXDProfiles(instanceId, machineTag string, machineProfiles []string) []string {
if names.IsContainerMachine(machineTag) {
if manager, ok := task.broker.(container.LXDProfileNameRetriever); ok {
if profileNames, err := manager.LXDProfileNames(instanceId); err == nil {
re... | go | {
"resource": ""
} |
q4026 | markMachineFailedInAZ | train | func (task *provisionerTask) markMachineFailedInAZ(machine apiprovisioner.MachineProvisioner, zone string) (bool, error) {
if zone == "" {
return false, errors.New("no zone provided")
}
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
azRemaining := false
for _, zoneMachines := range task.availabilit... | go | {
"resource": ""
} |
q4027 | removeMachineFromAZMap | train | func (task *provisionerTask) removeMachineFromAZMap(machine apiprovisioner.MachineProvisioner) {
machineId := machine.Id()
task.machinesMutex.Lock()
defer task.machinesMutex.Unlock()
for _, zoneMachines := range task.availabilityZoneMachines {
zoneMachines.MachineIds.Remove(machineId)
zoneMachines.FailedMachine... | go | {
"resource": ""
} |
q4028 | GetCredentials | train | func GetCredentials(
ctx *cmd.Context,
store jujuclient.CredentialGetter,
args GetCredentialsParams,
) (_ *cloud.Credential, chosenCredentialName, regionName string, _ error) {
credential, credentialName, defaultRegion, err := credentialByName(
store, args.Cloud.Name, args.CredentialName,
)
if err != nil {
r... | go | {
"resource": ""
} |
q4029 | FinalizeFileContent | train | func FinalizeFileContent(credential *cloud.Credential, provider environs.EnvironProvider) (*cloud.Credential, error) {
readFile := func(f string) ([]byte, error) {
f, err := utils.NormalizePath(f)
if err != nil {
return nil, errors.Trace(err)
}
return ioutil.ReadFile(f)
}
var err error
credential, err =... | go | {
"resource": ""
} |
q4030 | credentialByName | train | func credentialByName(
store jujuclient.CredentialGetter, cloudName, credentialName string,
) (_ *cloud.Credential, credentialNameUsed string, defaultRegion string, _ error) {
cloudCredentials, err := store.CredentialForCloud(cloudName)
if err != nil {
return nil, "", "", errors.Annotate(err, "loading credentials... | go | {
"resource": ""
} |
q4031 | DetectCredential | train | func DetectCredential(cloudName string, provider environs.EnvironProvider) (*cloud.CloudCredential, error) {
detected, err := provider.DetectCredentials()
if err != nil {
return nil, errors.Annotatef(
err, "detecting credentials for %q cloud provider", cloudName,
)
}
logger.Tracef("provider detected credenti... | go | {
"resource": ""
} |
q4032 | RegisterCredentials | train | func RegisterCredentials(provider environs.EnvironProvider, args RegisterCredentialsParams) (map[string]*cloud.CloudCredential, error) {
if register, ok := provider.(environs.ProviderCredentialsRegister); ok {
found, err := register.RegisterCredentials(args.Cloud)
if err != nil {
return nil, errors.Annotatef(
... | go | {
"resource": ""
} |
q4033 | NewMockAPICalls | train | func NewMockAPICalls(ctrl *gomock.Controller) *MockAPICalls {
mock := &MockAPICalls{ctrl: ctrl}
mock.recorder = &MockAPICallsMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q4034 | ContainerConfig | train | func (m *MockAPICalls) ContainerConfig() (params.ContainerConfig, error) {
ret := m.ctrl.Call(m, "ContainerConfig")
ret0, _ := ret[0].(params.ContainerConfig)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4035 | ContainerConfig | train | func (mr *MockAPICallsMockRecorder) ContainerConfig() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerConfig", reflect.TypeOf((*MockAPICalls)(nil).ContainerConfig))
} | go | {
"resource": ""
} |
q4036 | GetContainerInterfaceInfo | train | func (mr *MockAPICallsMockRecorder) GetContainerInterfaceInfo(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInterfaceInfo", reflect.TypeOf((*MockAPICalls)(nil).GetContainerInterfaceInfo), arg0)
} | go | {
"resource": ""
} |
q4037 | GetContainerProfileInfo | train | func (m *MockAPICalls) GetContainerProfileInfo(arg0 names_v2.MachineTag) ([]*provisioner.LXDProfileResult, error) {
ret := m.ctrl.Call(m, "GetContainerProfileInfo", arg0)
ret0, _ := ret[0].([]*provisioner.LXDProfileResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4038 | HostChangesForContainer | train | func (m *MockAPICalls) HostChangesForContainer(arg0 names_v2.MachineTag) ([]network.DeviceToBridge, int, error) {
ret := m.ctrl.Call(m, "HostChangesForContainer", arg0)
ret0, _ := ret[0].([]network.DeviceToBridge)
ret1, _ := ret[1].(int)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | {
"resource": ""
} |
q4039 | PrepareContainerInterfaceInfo | train | func (m *MockAPICalls) PrepareContainerInterfaceInfo(arg0 names_v2.MachineTag) ([]network.InterfaceInfo, error) {
ret := m.ctrl.Call(m, "PrepareContainerInterfaceInfo", arg0)
ret0, _ := ret[0].([]network.InterfaceInfo)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q4040 | ReleaseContainerAddresses | train | func (m *MockAPICalls) ReleaseContainerAddresses(arg0 names_v2.MachineTag) error {
ret := m.ctrl.Call(m, "ReleaseContainerAddresses", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4041 | SetHostMachineNetworkConfig | train | func (m *MockAPICalls) SetHostMachineNetworkConfig(arg0 names_v2.MachineTag, arg1 []params.NetworkConfig) error {
ret := m.ctrl.Call(m, "SetHostMachineNetworkConfig", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q4042 | sequence | train | func sequence(mb modelBackend, name string) (int, error) {
sequences, closer := mb.db().GetCollection(sequenceC)
defer closer()
query := sequences.FindId(name)
inc := mgo.Change{
Update: bson.M{
"$set": bson.M{
"name": name,
"model-uuid": mb.modelUUID(),
},
"$inc": bson.M{"counter": 1},
}... | go | {
"resource": ""
} |
q4043 | sequenceWithMin | train | func sequenceWithMin(mb modelBackend, name string, minVal int) (int, error) {
sequences, closer := mb.db().GetRawCollection(sequenceC)
defer closer()
updater := newDbSeqUpdater(sequences, mb.modelUUID(), name)
return updateSeqWithMin(updater, minVal)
} | go | {
"resource": ""
} |
q4044 | Sequences | train | func (st *State) Sequences() (map[string]int, error) {
sequences, closer := st.db().GetCollection(sequenceC)
defer closer()
var docs []sequenceDoc
if err := sequences.Find(nil).All(&docs); err != nil {
return nil, errors.Trace(err)
}
result := make(map[string]int)
for _, doc := range docs {
result[doc.Name... | go | {
"resource": ""
} |
q4045 | updateSeqWithMin | train | func updateSeqWithMin(sequence seqUpdater, minVal int) (int, error) {
for try := 0; try < maxSeqRetries; try++ {
curVal, err := sequence.read()
if err != nil {
return -1, errors.Annotate(err, "could not read sequence")
}
if curVal == 0 {
// No sequence document exists, create one.
ok, err := sequence.... | go | {
"resource": ""
} |
q4046 | EnsureSymlinks | train | func EnsureSymlinks(jujuDir, dir string, commands []string) (err error) {
logger.Infof("ensure jujuc symlinks in %s", dir)
defer func() {
if err != nil {
err = errors.Annotatef(err, "cannot initialize commands in %q", dir)
}
}()
isSymlink, err := symlink.IsSymlink(jujuDir)
if err != nil {
return err
}
i... | go | {
"resource": ""
} |
q4047 | Validate | train | func (p BootstrapParams) Validate() error {
if p.AdminSecret == "" {
return errors.New("admin-secret is empty")
}
if p.ControllerConfig.ControllerUUID() == "" {
return errors.New("controller configuration has no controller UUID")
}
if _, hasCACert := p.ControllerConfig.CACert(); !hasCACert {
return errors.Ne... | go | {
"resource": ""
} |
q4048 | withDefaultControllerConstraints | train | func withDefaultControllerConstraints(cons constraints.Value) constraints.Value {
if !cons.HasInstanceType() && !cons.HasCpuCores() && !cons.HasCpuPower() && !cons.HasMem() {
// A default of 3.5GiB will result in machines with up to 4GiB of memory, eg
// - 3.75GiB on AWS, Google
// - 3.5GiB on Azure
// - 4GiB ... | go | {
"resource": ""
} |
q4049 | Bootstrap | train | func Bootstrap(
ctx environs.BootstrapContext,
environ environs.BootstrapEnviron,
callCtx context.ProviderCallContext,
args BootstrapParams,
) error {
if err := args.Validate(); err != nil {
return errors.Annotate(err, "validating bootstrap parameters")
}
bootstrapParams := environs.BootstrapParams{
CloudNa... | go | {
"resource": ""
} |
q4050 | bootstrapImageMetadata | train | func bootstrapImageMetadata(
environ environs.BootstrapEnviron,
bootstrapSeries *string,
bootstrapArch string,
bootstrapImageId string,
customImageMetadata *[]*imagemetadata.ImageMetadata,
) ([]*imagemetadata.ImageMetadata, error) {
hasRegion, ok := environ.(simplestreams.HasRegion)
if !ok {
if bootstrapImage... | go | {
"resource": ""
} |
q4051 | getBootstrapToolsVersion | train | func getBootstrapToolsVersion(possibleTools coretools.List) (coretools.List, error) {
if len(possibleTools) == 0 {
return nil, errors.New("no bootstrap agent binaries available")
}
var newVersion version.Number
newVersion, toolsList := possibleTools.Newest()
logger.Infof("newest version: %s", newVersion)
bootst... | go | {
"resource": ""
} |
q4052 | setBootstrapToolsVersion | train | func setBootstrapToolsVersion(environ environs.Configer, toolsVersion version.Number) error {
cfg := environ.Config()
if agentVersion, _ := cfg.AgentVersion(); agentVersion != toolsVersion {
cfg, err := cfg.Apply(map[string]interface{}{
"agent-version": toolsVersion.String(),
})
if err == nil {
err = envi... | go | {
"resource": ""
} |
q4053 | findCompatibleTools | train | func findCompatibleTools(possibleTools coretools.List, version version.Number) (version.Number, coretools.List) {
var compatibleTools coretools.List
for _, tools := range possibleTools {
if isCompatibleVersion(tools.Version.Number, version) {
compatibleTools = append(compatibleTools, tools)
}
}
return compat... | go | {
"resource": ""
} |
q4054 | setPrivateMetadataSources | train | func setPrivateMetadataSources(metadataDir string) ([]*imagemetadata.ImageMetadata, error) {
if _, err := os.Stat(metadataDir); err != nil {
if !os.IsNotExist(err) {
return nil, errors.Annotate(err, "cannot access simplestreams metadata directory")
}
return nil, errors.NotFoundf("simplestreams metadata source... | go | {
"resource": ""
} |
q4055 | guiArchive | train | func guiArchive(dataSourceBaseURL string, logProgress func(string)) *coretools.GUIArchive {
// The environment variable is only used for development purposes.
path := os.Getenv("JUJU_GUI")
if path != "" {
vers, err := guiVersion(path)
if err != nil {
logProgress(fmt.Sprintf("Cannot use Juju GUI at %q: %s", pa... | go | {
"resource": ""
} |
q4056 | hashAndSize | train | func hashAndSize(path string) (hash string, size int64, err error) {
f, err := os.Open(path)
if err != nil {
return "", 0, errors.Mask(err)
}
defer f.Close()
h := sha256.New()
size, err = io.Copy(h, f)
if err != nil {
return "", 0, errors.Mask(err)
}
return fmt.Sprintf("%x", h.Sum(nil)), size, nil
} | go | {
"resource": ""
} |
q4057 | NewListEndpointsCommand | train | func NewListEndpointsCommand() cmd.Command {
listCmd := &listCommand{}
listCmd.newAPIFunc = func() (ListAPI, error) {
return listCmd.NewApplicationOffersAPI()
}
listCmd.refreshModels = listCmd.ModelCommandBase.RefreshModels
return modelcmd.Wrap(listCmd)
} | go | {
"resource": ""
} |
q4058 | convertCharmEndpoints | train | func convertCharmEndpoints(relations ...charm.Relation) map[string]RemoteEndpoint {
if len(relations) == 0 {
return nil
}
output := make(map[string]RemoteEndpoint, len(relations))
for _, one := range relations {
output[one.Name] = RemoteEndpoint{one.Name, one.Interface, string(one.Role)}
}
return output
} | go | {
"resource": ""
} |
q4059 | GetState | train | func (ctlr *Controller) GetState(modelTag names.ModelTag) (*PooledState, error) {
return ctlr.pool.Get(modelTag.Id())
} | go | {
"resource": ""
} |
q4060 | Ping | train | func (ctlr *Controller) Ping() error {
if ctlr.pool.SystemState() == nil {
return errors.New("pool is closed")
}
return ctlr.pool.SystemState().Ping()
} | go | {
"resource": ""
} |
q4061 | ControllerConfig | train | func (st *State) ControllerConfig() (jujucontroller.Config, error) {
settings, err := readSettings(st.db(), controllersC, controllerSettingsGlobalKey)
if err != nil {
return nil, errors.Annotatef(err, "controller %q", st.ControllerUUID())
}
return settings.Map(), nil
} | go | {
"resource": ""
} |
q4062 | checkSpaceIsAvailableToAllControllers | train | func (st *State) checkSpaceIsAvailableToAllControllers(configSpace string) error {
info, err := st.ControllerInfo()
if err != nil {
return errors.Annotate(err, "cannot get controller info")
}
var missing []string
spaceName := network.SpaceName(configSpace)
for _, id := range info.MachineIds {
m, err := st.Ma... | go | {
"resource": ""
} |
q4063 | Supports | train | func (s storageProvider) Supports(kind storage.StorageKind) bool {
return kind == storage.StorageKindBlock
} | go | {
"resource": ""
} |
q4064 | DefaultPools | train | func (s storageProvider) DefaultPools() []*storage.Config {
latencyPool, _ := storage.NewConfig("oracle-latency", oracleStorageProviderType, map[string]interface{}{
oracleVolumeType: latencyPool,
})
return []*storage.Config{latencyPool}
} | go | {
"resource": ""
} |
q4065 | ValidateBranchName | train | func ValidateBranchName(name string) error {
if name == "" {
return errors.NotValidf("empty branch name")
}
if name == GenerationMaster {
return errors.NotValidf("branch name %q", GenerationMaster)
}
return nil
} | go | {
"resource": ""
} |
q4066 | NewStorage | train | func NewStorage(
session *mgo.Session,
modelUUID string,
) Storage {
blobDb := session.DB(ImagesDB)
metadataCollection := blobDb.C(imagemetadataC)
return &imageStorage{
modelUUID,
metadataCollection,
blobDb,
}
} | go | {
"resource": ""
} |
q4067 | AddImage | train | func (s *imageStorage) AddImage(r io.Reader, metadata *Metadata) (resultErr error) {
session := s.blobDb.Session.Copy()
defer session.Close()
managedStorage := s.getManagedStorage(session)
path := imagePath(metadata.Kind, metadata.Series, metadata.Arch, metadata.SHA256)
if err := managedStorage.PutForBucket(s.mode... | go | {
"resource": ""
} |
q4068 | ListImages | train | func (s *imageStorage) ListImages(filter ImageFilter) ([]*Metadata, error) {
metadataDocs, err := s.listImageMetadataDocs(s.modelUUID, filter.Kind, filter.Series, filter.Arch)
if err != nil {
return nil, errors.Annotate(err, "cannot list image metadata")
}
result := make([]*Metadata, len(metadataDocs))
for i, me... | go | {
"resource": ""
} |
q4069 | DeleteImage | train | func (s *imageStorage) DeleteImage(metadata *Metadata) (resultErr error) {
session := s.blobDb.Session.Copy()
defer session.Close()
managedStorage := s.getManagedStorage(session)
path := imagePath(metadata.Kind, metadata.Series, metadata.Arch, metadata.SHA256)
if err := managedStorage.RemoveForBucket(s.modelUUID, ... | go | {
"resource": ""
} |
q4070 | Image | train | func (s *imageStorage) Image(kind, series, arch string) (*Metadata, io.ReadCloser, error) {
metadataDoc, err := s.imageMetadataDoc(s.modelUUID, kind, series, arch)
if err != nil {
return nil, nil, err
}
session := s.blobDb.Session.Copy()
managedStorage := s.getManagedStorage(session)
image, err := s.imageBlob(m... | go | {
"resource": ""
} |
q4071 | imagePath | train | func imagePath(kind, series, arch, checksum string) string {
return fmt.Sprintf("images/%s-%s-%s:%s", kind, series, arch, checksum)
} | go | {
"resource": ""
} |
q4072 | docId | train | func docId(metadata *Metadata) string {
return fmt.Sprintf("%s-%s-%s-%s", metadata.ModelUUID, metadata.Kind, metadata.Series, metadata.Arch)
} | go | {
"resource": ""
} |
q4073 | ReadCharmURL | train | func ReadCharmURL(path string) (*charm.URL, error) {
surl := ""
if err := utils.ReadYaml(path, &surl); err != nil {
return nil, err
}
return charm.ParseURL(surl)
} | go | {
"resource": ""
} |
q4074 | WriteCharmURL | train | func WriteCharmURL(path string, url *charm.URL) error {
return utils.WriteYaml(path, url.String())
} | go | {
"resource": ""
} |
q4075 | LXDProfile | train | func (c *Charm) LXDProfile() lxdprofile.Profile {
c.mu.Lock()
defer c.mu.Unlock()
return c.details.LXDProfile
} | go | {
"resource": ""
} |
q4076 | NewSetFirewallRuleCommand | train | func NewSetFirewallRuleCommand() cmd.Command {
cmd := &setFirewallRuleCommand{}
cmd.newAPIFunc = func() (SetFirewallRuleAPI, error) {
root, err := cmd.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return firewallrules.NewClient(root), nil
}
return modelcmd.Wrap(cmd)
} | go | {
"resource": ""
} |
q4077 | Use | train | func (c *tracker) Use() (*state.Controller, error) {
c.mu.Lock()
defer c.mu.Unlock()
if c.references == 0 {
return nil, ErrControllerClosed
}
c.references++
return c.st, nil
} | go | {
"resource": ""
} |
q4078 | Done | train | func (c *tracker) Done() error {
c.mu.Lock()
defer c.mu.Unlock()
if c.references == 0 {
return ErrControllerClosed
}
c.references--
if c.references == 0 {
err := c.st.Close()
if err != nil {
logger.Errorf("error when closing controller: %v", err)
}
}
return nil
} | go | {
"resource": ""
} |
q4079 | resourceID | train | func resourceID(id, subType, subID string) string {
if subType == "" {
return fmt.Sprintf("resource#%s", id)
}
return fmt.Sprintf("resource#%s#%s-%s", id, subType, subID)
} | go | {
"resource": ""
} |
q4080 | newResolvePendingResourceOps | train | func newResolvePendingResourceOps(pending storedResource, exists bool) []txn.Op {
oldID := pendingResourceID(pending.ID, pending.PendingID)
newRes := pending
newRes.PendingID = ""
// TODO(ericsnow) Update newRes.StoragePath? Doing so would require
// moving the resource in the blobstore to the correct path, which
... | go | {
"resource": ""
} |
q4081 | newCharmStoreResourceDoc | train | func newCharmStoreResourceDoc(res charmStoreResource) *resourceDoc {
fullID := charmStoreResourceID(res.id)
return charmStoreResource2Doc(fullID, res)
} | go | {
"resource": ""
} |
q4082 | newUnitResourceDoc | train | func newUnitResourceDoc(unitID string, stored storedResource) *resourceDoc {
fullID := unitResourceID(stored.ID, unitID)
return unitResource2Doc(fullID, unitID, stored)
} | go | {
"resource": ""
} |
q4083 | newResourceDoc | train | func newResourceDoc(stored storedResource) *resourceDoc {
fullID := applicationResourceID(stored.ID)
if stored.PendingID != "" {
fullID = pendingResourceID(stored.ID, stored.PendingID)
}
return resource2doc(fullID, stored)
} | go | {
"resource": ""
} |
q4084 | newStagedResourceDoc | train | func newStagedResourceDoc(stored storedResource) *resourceDoc {
stagedID := stagedResourceID(stored.ID)
return resource2doc(stagedID, stored)
} | go | {
"resource": ""
} |
q4085 | resources | train | func (p ResourcePersistence) resources(applicationID string) ([]resourceDoc, error) {
logger.Tracef("querying db for resources for %q", applicationID)
var docs []resourceDoc
query := bson.D{{"application-id", applicationID}}
if err := p.base.All(resourcesC, query, &docs); err != nil {
return nil, errors.Trace(err... | go | {
"resource": ""
} |
q4086 | getOne | train | func (p ResourcePersistence) getOne(resID string) (resourceDoc, error) {
logger.Tracef("querying db for resource %q", resID)
id := applicationResourceID(resID)
var doc resourceDoc
if err := p.base.One(resourcesC, id, &doc); err != nil {
return doc, errors.Trace(err)
}
return doc, nil
} | go | {
"resource": ""
} |
q4087 | getOnePending | train | func (p ResourcePersistence) getOnePending(resID, pendingID string) (resourceDoc, error) {
logger.Tracef("querying db for resource %q (pending %q)", resID, pendingID)
id := pendingResourceID(resID, pendingID)
var doc resourceDoc
if err := p.base.One(resourcesC, id, &doc); err != nil {
return doc, errors.Trace(err... | go | {
"resource": ""
} |
q4088 | resource2doc | train | func resource2doc(id string, stored storedResource) *resourceDoc {
res := stored.Resource
// TODO(ericsnow) We may need to limit the resolution of timestamps
// in order to avoid some conversion problems from Mongo.
return &resourceDoc{
DocID: id,
ID: res.ID,
PendingID: res.PendingID,
Applicatio... | go | {
"resource": ""
} |
q4089 | doc2resource | train | func doc2resource(doc resourceDoc) (storedResource, error) {
res, err := doc2basicResource(doc)
if err != nil {
return storedResource{}, errors.Trace(err)
}
stored := storedResource{
Resource: res,
storagePath: doc.StoragePath,
}
return stored, nil
} | go | {
"resource": ""
} |
q4090 | doc2basicResource | train | func doc2basicResource(doc resourceDoc) (resource.Resource, error) {
var res resource.Resource
resType, err := charmresource.ParseType(doc.Type)
if err != nil {
return res, errors.Annotate(err, "got invalid data from DB")
}
origin, err := charmresource.ParseOrigin(doc.Origin)
if err != nil {
return res, err... | go | {
"resource": ""
} |
q4091 | Close | train | func (ls *LogStream) Close() error {
ls.mu.Lock()
defer ls.mu.Unlock()
if ls.stream == nil {
return nil
}
if err := ls.stream.Close(); err != nil {
return errors.Trace(err)
}
ls.stream = nil
return nil
} | go | {
"resource": ""
} |
q4092 | Validate | train | func (config Config) Validate() error {
if config.Logger == nil {
return errors.NotValidf("nil Logger")
}
if config.Tag == nil {
return errors.NotValidf("nil machine tag")
}
k := config.Tag.Kind()
if k != names.MachineTagKind {
return errors.NotValidf("%q tag kind", k)
}
if config.FacadeFactory == nil {
... | go | {
"resource": ""
} |
q4093 | NewWorker | train | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
w := &upgradeSeriesWorker{
Facade: config.FacadeFactory(config.Tag),
facadeFactory: config.FacadeFactory,
logger: config.Logger,
service: config.Serv... | go | {
"resource": ""
} |
q4094 | handleUpgradeSeriesChange | train | func (w *upgradeSeriesWorker) handleUpgradeSeriesChange() error {
w.mu.Lock()
defer w.mu.Unlock()
var err error
if w.machineStatus, err = w.MachineStatus(); err != nil {
if errors.IsNotFound(err) {
// No upgrade-series lock. This can happen when:
// - The first watch call is made.
// - The lock is remov... | go | {
"resource": ""
} |
q4095 | handlePrepareStarted | train | func (w *upgradeSeriesWorker) handlePrepareStarted() error {
var err error
if !w.leadersPinned {
if err = w.pinLeaders(); err != nil {
return errors.Trace(err)
}
}
if w.preparedUnits, err = w.UnitsPrepared(); err != nil {
return errors.Trace(err)
}
unitServices, allConfirmed, err := w.compareUnitAgentS... | go | {
"resource": ""
} |
q4096 | transitionPrepareComplete | train | func (w *upgradeSeriesWorker) transitionPrepareComplete(unitServices map[string]string) error {
w.logger.Infof("preparing service units for series upgrade")
toSeries, err := w.TargetSeries()
if err != nil {
return errors.Trace(err)
}
upgrader, err := w.upgraderFactory(toSeries)
if err != nil {
return errors.T... | go | {
"resource": ""
} |
q4097 | transitionUnitsStarted | train | func (w *upgradeSeriesWorker) transitionUnitsStarted(unitServices map[string]string) error {
w.logger.Infof("ensuring units are up after series upgrade")
for unit, serviceName := range unitServices {
svc, err := w.service.DiscoverService(serviceName)
if err != nil {
return errors.Trace(err)
}
running, err... | go | {
"resource": ""
} |
q4098 | handleCompleted | train | func (w *upgradeSeriesWorker) handleCompleted() error {
s, err := hostSeries()
if err != nil {
return errors.Trace(err)
}
if err = w.FinishUpgradeSeries(s); err != nil {
return errors.Trace(err)
}
return errors.Trace(w.unpinLeaders())
} | go | {
"resource": ""
} |
q4099 | pinLeaders | train | func (w *upgradeSeriesWorker) pinLeaders() (err error) {
// if we encounter an error,
// attempt to ensure that no application leaders remain pinned.
defer func() {
if err != nil {
if unpinErr := w.unpinLeaders(); unpinErr != nil {
err = errors.Wrap(err, unpinErr)
}
}
}()
results, err := w.PinMachin... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.