_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q4200 | Run | train | func (a *UnitAgent) Run(ctx *cmd.Context) (err error) {
defer a.Done(err)
if err := a.ReadConfig(a.Tag().String()); err != nil {
return err
}
setupAgentLogging(a.CurrentConfig())
a.runner.StartWorker("api", a.APIWorkers)
err = cmdutil.AgentDone(logger, a.runner.Wait())
return err
} | go | {
"resource": ""
} |
q4201 | APIWorkers | train | func (a *UnitAgent) APIWorkers() (worker.Worker, error) {
updateAgentConfLogging := func(loggingConfig string) error {
return a.AgentConf.ChangeConfig(func(setter agent.ConfigSetter) error {
setter.SetLoggingConfig(loggingConfig)
return nil
})
}
agentConfig := a.AgentConf.CurrentConfig()
a.upgradeComplet... | go | {
"resource": ""
} |
q4202 | NewStateCrossControllerAPI | train | func NewStateCrossControllerAPI(ctx facade.Context) (*CrossControllerAPI, error) {
st := ctx.State()
return NewCrossControllerAPI(
ctx.Resources(),
func() ([]string, string, error) { return common.StateControllerInfo(st) },
st.WatchAPIHostPortsForClients,
)
} | go | {
"resource": ""
} |
q4203 | NewCrossControllerAPI | train | func NewCrossControllerAPI(
resources facade.Resources,
localControllerInfo localControllerInfoFunc,
watchLocalControllerInfo watchLocalControllerInfoFunc,
) (*CrossControllerAPI, error) {
return &CrossControllerAPI{
resources: resources,
localControllerInfo: localControllerInfo,
watchLoca... | go | {
"resource": ""
} |
q4204 | WatchControllerInfo | train | func (api *CrossControllerAPI) WatchControllerInfo() (params.NotifyWatchResults, error) {
results := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, 1),
}
w := api.watchLocalControllerInfo()
if _, ok := <-w.Changes(); !ok {
results.Results[0].Error = common.ServerError(watcher.EnsureErr(w))... | go | {
"resource": ""
} |
q4205 | ControllerInfo | train | func (api *CrossControllerAPI) ControllerInfo() (params.ControllerAPIInfoResults, error) {
results := params.ControllerAPIInfoResults{
Results: make([]params.ControllerAPIInfoResult, 1),
}
addrs, caCert, err := api.localControllerInfo()
if err != nil {
results.Results[0].Error = common.ServerError(err)
return... | go | {
"resource": ""
} |
q4206 | NewContextAPI | train | func NewContextAPI(apiClient APIClient, dataDir string) *Context {
return &Context{
apiClient: apiClient,
dataDir: dataDir,
}
} | go | {
"resource": ""
} |
q4207 | Download | train | func (c *Context) Download(name string) (string, error) {
deps := &contextDeps{
APIClient: c.apiClient,
name: name,
dataDir: c.dataDir,
}
path, err := internal.ContextDownload(deps)
if err != nil {
return "", errors.Trace(err)
}
return path, nil
} | go | {
"resource": ""
} |
q4208 | attachmentLife | train | func attachmentLife(ctx *context, ids []params.MachineStorageId) (
alive, dying, dead []params.MachineStorageId, _ error,
) {
lifeResults, err := ctx.config.Life.AttachmentLife(ids)
if err != nil {
return nil, nil, nil, errors.Annotate(err, "getting machine attachment life")
}
for i, result := range lifeResults ... | go | {
"resource": ""
} |
q4209 | removeEntities | train | func removeEntities(ctx *context, tags []names.Tag) error {
if len(tags) == 0 {
return nil
}
logger.Debugf("removing entities: %v", tags)
errorResults, err := ctx.config.Life.Remove(tags)
if err != nil {
return errors.Annotate(err, "removing storage entities")
}
for i, result := range errorResults {
if res... | go | {
"resource": ""
} |
q4210 | removeAttachments | train | func removeAttachments(ctx *context, ids []params.MachineStorageId) error {
if len(ids) == 0 {
return nil
}
errorResults, err := ctx.config.Life.RemoveAttachments(ids)
if err != nil {
return errors.Annotate(err, "removing attachments")
}
for i, result := range errorResults {
if result.Error != nil && !param... | go | {
"resource": ""
} |
q4211 | setStatus | train | func setStatus(ctx *context, statuses []params.EntityStatusArgs) {
if len(statuses) > 0 {
if err := ctx.config.Status.SetStatus(statuses); err != nil {
logger.Errorf("failed to set status: %v", err)
}
}
} | go | {
"resource": ""
} |
q4212 | NewNonCanonicalArchivePaths | train | func NewNonCanonicalArchivePaths(rootDir string) ArchivePaths {
return ArchivePaths{
ContentDir: filepath.Join(rootDir, contentDir),
FilesBundle: filepath.Join(rootDir, contentDir, filesBundle),
DBDumpDir: filepath.Join(rootDir, contentDir, dbDumpDir),
MetadataFile: filepath.Join(rootDir, contentDir, met... | go | {
"resource": ""
} |
q4213 | NewArchiveWorkspaceReader | train | func NewArchiveWorkspaceReader(archive io.Reader) (*ArchiveWorkspace, error) {
ws, err := newArchiveWorkspace()
if err != nil {
return nil, errors.Trace(err)
}
err = unpackCompressedReader(ws.RootDir, archive)
return ws, errors.Trace(err)
} | go | {
"resource": ""
} |
q4214 | Close | train | func (ws *ArchiveWorkspace) Close() error {
err := os.RemoveAll(ws.RootDir)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q4215 | UnpackFilesBundle | train | func (ws *ArchiveWorkspace) UnpackFilesBundle(targetRoot string) error {
tarFile, err := os.Open(ws.FilesBundle)
if err != nil {
return errors.Trace(err)
}
defer tarFile.Close()
err = tar.UntarFiles(tarFile, targetRoot)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q4216 | OpenBundledFile | train | func (ws *ArchiveWorkspace) OpenBundledFile(filename string) (io.Reader, error) {
if filepath.IsAbs(filename) {
return nil, errors.Errorf("filename must be relative, got %q", filename)
}
tarFile, err := os.Open(ws.FilesBundle)
if err != nil {
return nil, errors.Trace(err)
}
_, file, err := tar.FindFile(tarF... | go | {
"resource": ""
} |
q4217 | Metadata | train | func (ws *ArchiveWorkspace) Metadata() (*Metadata, error) {
metaFile, err := os.Open(ws.MetadataFile)
if err != nil {
return nil, errors.Trace(err)
}
defer metaFile.Close()
meta, err := NewMetadataJSONReader(metaFile)
return meta, errors.Trace(err)
} | go | {
"resource": ""
} |
q4218 | NewArchiveDataReader | train | func NewArchiveDataReader(r io.Reader) (*ArchiveData, error) {
gzr, err := gzip.NewReader(r)
if err != nil {
return nil, errors.Trace(err)
}
defer gzr.Close()
data, err := ioutil.ReadAll(gzr)
if err != nil {
return nil, errors.Trace(err)
}
return NewArchiveData(data), nil
} | go | {
"resource": ""
} |
q4219 | Metadata | train | func (ad *ArchiveData) Metadata() (*Metadata, error) {
buf := ad.NewBuffer()
_, metaFile, err := tar.FindFile(buf, ad.MetadataFile)
if err != nil {
return nil, errors.Trace(err)
}
meta, err := NewMetadataJSONReader(metaFile)
return meta, errors.Trace(err)
} | go | {
"resource": ""
} |
q4220 | Version | train | func (ad *ArchiveData) Version() (*version.Number, error) {
meta, err := ad.Metadata()
if errors.IsNotFound(err) {
return &legacyVersion, nil
}
if err != nil {
return nil, errors.Trace(err)
}
return &meta.Origin.Version, nil
} | go | {
"resource": ""
} |
q4221 | searchHook | train | func searchHook(charmDir, hook string) (string, error) {
hookFile := filepath.Join(charmDir, hook)
if jujuos.HostOS() != jujuos.Windows {
// we are not running on windows,
// there is no need to look for suffixed hooks
return lookPath(hookFile)
}
for _, suffix := range windowsSuffixOrder {
file := fmt.Sprin... | go | {
"resource": ""
} |
q4222 | ProvisioningInfo | train | func (p *ProvisionerAPI) ProvisioningInfo(args params.Entities) (params.ProvisioningInfoResults, error) {
result := params.ProvisioningInfoResults{
Results: make([]params.ProvisioningInfoResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, errors.Trace(err)
}
env, er... | go | {
"resource": ""
} |
q4223 | machineTags | train | func (p *ProvisionerAPI) machineTags(m *state.Machine, jobs []multiwatcher.MachineJob) (map[string]string, error) {
// Names of all units deployed to the machine.
//
// TODO(axw) 2015-06-02 #1461358
// We need a worker that periodically updates
// instance tags with current deployment info.
units, err := m.Units(... | go | {
"resource": ""
} |
q4224 | machineSubnetsAndZones | train | func (p *ProvisionerAPI) machineSubnetsAndZones(m *state.Machine) (map[string][]string, error) {
mcons, err := m.Constraints()
if err != nil {
return nil, errors.Annotate(err, "cannot get machine constraints")
}
includeSpaces := mcons.IncludeSpaces()
if len(includeSpaces) < 1 {
// Nothing to do.
return nil, ... | go | {
"resource": ""
} |
q4225 | machineLXDProfileNames | train | func (p *ProvisionerAPI) machineLXDProfileNames(m *state.Machine, env environs.Environ) ([]string, error) {
profileEnv, ok := env.(environs.LXDProfiler)
if !ok {
logger.Tracef("LXDProfiler not implemented by environ")
return nil, nil
}
units, err := m.Units()
if err != nil {
return nil, errors.Trace(err)
}
... | go | {
"resource": ""
} |
q4226 | availableImageMetadata | train | func (p *ProvisionerAPI) availableImageMetadata(m *state.Machine, env environs.Environ) ([]params.CloudImageMetadata, error) {
imageConstraint, err := p.constructImageConstraint(m, env)
if err != nil {
return nil, errors.Annotate(err, "could not construct image constraint")
}
// Look for image metadata in state.... | go | {
"resource": ""
} |
q4227 | constructImageConstraint | train | func (p *ProvisionerAPI) constructImageConstraint(m *state.Machine, env environs.Environ) (*imagemetadata.ImageConstraint, error) {
lookup := simplestreams.LookupParams{
Series: []string{m.Series()},
Stream: env.Config().ImageStream(),
}
mcons, err := m.Constraints()
if err != nil {
return nil, errors.Annota... | go | {
"resource": ""
} |
q4228 | findImageMetadata | train | func (p *ProvisionerAPI) findImageMetadata(imageConstraint *imagemetadata.ImageConstraint, env environs.Environ) ([]params.CloudImageMetadata, error) {
// Look for image metadata in state.
stateMetadata, err := p.imageMetadataFromState(imageConstraint)
if err != nil && !errors.IsNotFound(err) {
// look into simple... | go | {
"resource": ""
} |
q4229 | imageMetadataFromState | train | func (p *ProvisionerAPI) imageMetadataFromState(constraint *imagemetadata.ImageConstraint) ([]params.CloudImageMetadata, error) {
filter := cloudimagemetadata.MetadataFilter{
Series: constraint.Series,
Arches: constraint.Arches,
Region: constraint.Region,
Stream: constraint.Stream,
}
stored, err := p.st.Clou... | go | {
"resource": ""
} |
q4230 | imageMetadataFromDataSources | train | func (p *ProvisionerAPI) imageMetadataFromDataSources(env environs.Environ, constraint *imagemetadata.ImageConstraint) ([]params.CloudImageMetadata, error) {
sources, err := environs.ImageMetadataSources(env)
if err != nil {
return nil, errors.Trace(err)
}
cfg := env.Config()
toModel := func(m *imagemetadata.Im... | go | {
"resource": ""
} |
q4231 | Less | train | func (m metadataList) Less(i, j int) bool {
return m[i].Priority < m[j].Priority
} | go | {
"resource": ""
} |
q4232 | NewHTTPBlobOpener | train | func NewHTTPBlobOpener(hostnameVerification utils.SSLHostnameVerification) func(*url.URL) (io.ReadCloser, error) {
return func(url *url.URL) (io.ReadCloser, error) {
// TODO(rog) make the download operation interruptible.
client := utils.GetHTTPClient(hostnameVerification)
resp, err := client.Get(url.String())
... | go | {
"resource": ""
} |
q4233 | NewSha256Verifier | train | func NewSha256Verifier(expected string) func(*os.File) error {
return func(file *os.File) error {
actual, _, err := utils.ReadSHA256(file)
if err != nil {
return errors.Trace(err)
}
if actual != expected {
err := errors.Errorf("expected sha256 %q, got %q", expected, actual)
return errors.NewNotValid(e... | go | {
"resource": ""
} |
q4234 | Refresh | train | func (s *Application) Refresh() error {
life, err := s.st.life(s.tag)
if err != nil {
return err
}
s.life = life
return nil
} | go | {
"resource": ""
} |
q4235 | CharmModifiedVersion | train | func (s *Application) CharmModifiedVersion() (int, error) {
var results params.IntResults
args := params.Entities{
Entities: []params.Entity{{Tag: s.tag.String()}},
}
err := s.st.facade.FacadeCall("CharmModifiedVersion", args, &results)
if err != nil {
return -1, err
}
if len(results.Results) != 1 {
retur... | go | {
"resource": ""
} |
q4236 | SetStatus | train | func (s *Application) SetStatus(unitName string, appStatus status.Status, info string, data map[string]interface{}) error {
tag := names.NewUnitTag(unitName)
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{
{
Tag: tag.String(),
Status: appStatus.String(),
... | go | {
"resource": ""
} |
q4237 | Status | train | func (s *Application) Status(unitName string) (params.ApplicationStatusResult, error) {
tag := names.NewUnitTag(unitName)
var results params.ApplicationStatusResults
args := params.Entities{
Entities: []params.Entity{
{
Tag: tag.String(),
},
},
}
err := s.st.facade.FacadeCall("ApplicationStatus", arg... | go | {
"resource": ""
} |
q4238 | WatchLeadershipSettings | train | func (s *Application) WatchLeadershipSettings() (watcher.NotifyWatcher, error) {
return s.st.LeadershipSettings.WatchLeadershipSettings(s.tag.Id())
} | go | {
"resource": ""
} |
q4239 | ParseIngressRules | train | func ParseIngressRules(r io.Reader) ([]network.IngressRule, error) {
var rules []network.IngressRule
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
rule, ok, err := parseIngressRule(strings.TrimSpace(line))
if err != nil {
logger.Warningf("failed to parse iptables line %q: %v", l... | go | {
"resource": ""
} |
q4240 | popField | train | func popField(s string) (field, remainder string, ok bool) {
i := strings.IndexRune(s, ' ')
if i == -1 {
return s, "", s != ""
}
field, remainder = s[:i], strings.TrimLeft(s[i+1:], " ")
return field, remainder, true
} | go | {
"resource": ""
} |
q4241 | OAuthConfig | train | func OAuthConfig(
sdkCtx context.Context,
client subscriptions.Client,
resourceManagerEndpoint string,
subscriptionId string,
) (*adal.OAuthConfig, string, error) {
authURI, err := DiscoverAuthorizationURI(sdkCtx, client, subscriptionId)
if err != nil {
return nil, "", errors.Annotate(err, "detecting auth URI")... | go | {
"resource": ""
} |
q4242 | newEnviron | train | func newEnviron(cloud environs.CloudSpec, cfg *config.Config) (*joyentEnviron, error) {
env := &joyentEnviron{
name: cfg.Name(),
cloud: cloud,
}
if err := env.SetConfig(cfg); err != nil {
return nil, err
}
var err error
env.compute, err = newCompute(cloud)
if err != nil {
return nil, err
}
return env,... | go | {
"resource": ""
} |
q4243 | GetLastSent | train | func (c LastSentClient) GetLastSent(ids []LastSentID) ([]LastSentResult, error) {
var args params.LogForwardingGetLastSentParams
args.IDs = make([]params.LogForwardingID, len(ids))
for i, id := range ids {
args.IDs[i] = params.LogForwardingID{
ModelTag: id.Model.String(),
Sink: id.Sink,
}
}
var apiR... | go | {
"resource": ""
} |
q4244 | SetLastSent | train | func (c LastSentClient) SetLastSent(reqs []LastSentInfo) ([]LastSentResult, error) {
var args params.LogForwardingSetLastSentParams
args.Params = make([]params.LogForwardingSetLastSentParam, len(reqs))
for i, req := range reqs {
args.Params[i] = params.LogForwardingSetLastSentParam{
LogForwardingID: params.LogF... | go | {
"resource": ""
} |
q4245 | NewReader | train | func NewReader(config ReaderConfig) (*Reader, error) {
if err := config.validate(); err != nil {
return nil, errors.Trace(err)
}
r := &Reader{config: config}
return r, nil
} | go | {
"resource": ""
} |
q4246 | Now | train | func (r *Reader) Now() (time.Time, error) {
coll, closer := r.config.Mongo.GetCollection(r.config.Collection)
defer closer()
t, err := readClock(coll)
if errors.Cause(err) == mgo.ErrNotFound {
// No time written yet. When it is written
// for the first time, it'll be globalEpoch.
t = globalEpoch
} else if e... | go | {
"resource": ""
} |
q4247 | ModelStatus | train | func (c *ModelStatusAPI) ModelStatus(tags ...names.ModelTag) ([]base.ModelStatus, error) {
result := params.ModelStatusResults{}
models := make([]params.Entity, len(tags))
for i, tag := range tags {
models[i] = params.Entity{Tag: tag.String()}
}
req := params.Entities{
Entities: models,
}
if err := c.facade.... | go | {
"resource": ""
} |
q4248 | OnlyConnect | train | func OnlyConnect(a agent.Agent, apiOpen api.OpenFunc) (api.Connection, error) {
agentConfig := a.CurrentConfig()
info, ok := agentConfig.APIInfo()
if !ok {
return nil, errors.New("API info not available")
}
conn, _, err := connectFallback(apiOpen, info, agentConfig.OldPassword())
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q4249 | NewExternalControllerConnection | train | func NewExternalControllerConnection(apiInfo *api.Info) (api.Connection, error) {
return api.Open(apiInfo, api.DialOpts{
Timeout: 2 * time.Second,
RetryDelay: 500 * time.Millisecond,
})
} | go | {
"resource": ""
} |
q4250 | StoreCharmArchive | train | func StoreCharmArchive(st State, archive CharmArchive) error {
storage := newStateStorage(st.ModelUUID(), st.MongoSession())
storagePath, err := charmArchiveStoragePath(archive.ID)
if err != nil {
return errors.Annotate(err, "cannot generate charm archive name")
}
if err := storage.Put(storagePath, archive.Data,... | go | {
"resource": ""
} |
q4251 | charmArchiveStoragePath | train | func charmArchiveStoragePath(curl *charm.URL) (string, error) {
uuid, err := utils.NewUUID()
if err != nil {
return "", err
}
return fmt.Sprintf("charms/%s-%s", curl.String(), uuid), nil
} | go | {
"resource": ""
} |
q4252 | NewAPI | train | func NewAPI(caller base.APICallCloser) *API {
if caller == nil {
panic("caller is nil")
}
clientFacade, facadeCaller := base.NewClientFacade(caller, subnetsFacade)
return &API{
ClientFacade: clientFacade,
facade: facadeCaller,
}
} | go | {
"resource": ""
} |
q4253 | AddSubnet | train | func (api *API) AddSubnet(subnet names.SubnetTag, providerId network.Id, space names.SpaceTag, zones []string) error {
var response params.ErrorResults
// Prefer ProviderId when set over CIDR.
subnetTag := subnet.String()
if providerId != "" {
subnetTag = ""
}
params := params.AddSubnetsParams{
Subnets: []pa... | go | {
"resource": ""
} |
q4254 | CreateSubnet | train | func (api *API) CreateSubnet(subnet names.SubnetTag, space names.SpaceTag, zones []string, isPublic bool) error {
var response params.ErrorResults
params := params.CreateSubnetsParams{
Subnets: []params.CreateSubnetParams{{
SubnetTag: subnet.String(),
SpaceTag: space.String(),
Zones: zones,
IsPubli... | go | {
"resource": ""
} |
q4255 | ListSubnets | train | func (api *API) ListSubnets(spaceTag *names.SpaceTag, zone string) ([]params.Subnet, error) {
var response params.ListSubnetsResults
var space string
if spaceTag != nil {
space = spaceTag.String()
}
args := params.SubnetsFilters{
SpaceTag: space,
Zone: zone,
}
err := api.facade.FacadeCall("ListSubnets"... | go | {
"resource": ""
} |
q4256 | MongoIndexes | train | func MongoIndexes() []mgo.Index {
return []mgo.Index{{
Key: []string{"expire-at"},
ExpireAfter: expiryTime,
Sparse: true,
}}
} | go | {
"resource": ""
} |
q4257 | SaveMetadataNoExpiry | train | func (s *storage) SaveMetadataNoExpiry(metadata []Metadata) error {
return s.saveMetadata(metadata, false)
} | go | {
"resource": ""
} |
q4258 | SaveMetadata | train | func (s *storage) SaveMetadata(metadata []Metadata) error {
return s.saveMetadata(metadata, true)
} | go | {
"resource": ""
} |
q4259 | DeleteMetadata | train | func (s *storage) DeleteMetadata(imageId string) error {
deleteOperation := func(docId string) txn.Op {
logger.Debugf("deleting metadata (ID=%v) for image (ID=%v)", docId, imageId)
return txn.Op{
C: s.collection,
Id: docId,
Assert: txn.DocExists,
Remove: true,
}
}
noOp := func() ([]txn.Op... | go | {
"resource": ""
} |
q4260 | AllCloudImageMetadata | train | func (s *storage) AllCloudImageMetadata() ([]Metadata, error) {
coll, closer := s.store.GetCollection(s.collection)
defer closer()
results := []Metadata{}
docs := []imagesMetadataDoc{}
err := coll.Find(nil).All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "cannot get all image metadata")
}
for _,... | go | {
"resource": ""
} |
q4261 | FindMetadata | train | func (s *storage) FindMetadata(criteria MetadataFilter) (map[string][]Metadata, error) {
coll, closer := s.store.GetCollection(s.collection)
defer closer()
logger.Debugf("searching for image metadata %#v", criteria)
searchCriteria := buildSearchClauses(criteria)
var docs []imagesMetadataDoc
if err := coll.Find(s... | go | {
"resource": ""
} |
q4262 | SupportedArchitectures | train | func (s *storage) SupportedArchitectures(criteria MetadataFilter) ([]string, error) {
coll, closer := s.store.GetCollection(s.collection)
defer closer()
var arches []string
if err := coll.Find(buildSearchClauses(criteria)).Distinct("arch", &arches); err != nil {
return nil, errors.Trace(err)
}
return arches, n... | go | {
"resource": ""
} |
q4263 | putState | train | func putState(stor storage.StorageWriter, data []byte) error {
logger.Debugf("putting %q to bootstrap storage %T", StateFile, stor)
return stor.Put(StateFile, bytes.NewBuffer(data), int64(len(data)))
} | go | {
"resource": ""
} |
q4264 | CreateStateFile | train | func CreateStateFile(stor storage.Storage) (string, error) {
err := putState(stor, []byte{})
if err != nil {
return "", fmt.Errorf("cannot create initial state file: %v", err)
}
return stor.URL(StateFile)
} | go | {
"resource": ""
} |
q4265 | SaveState | train | func SaveState(storage storage.StorageWriter, state *BootstrapState) error {
data, err := goyaml.Marshal(state)
if err != nil {
return err
}
return putState(storage, data)
} | go | {
"resource": ""
} |
q4266 | LoadState | train | func LoadState(stor storage.StorageReader) (*BootstrapState, error) {
r, err := storage.Get(stor, StateFile)
if err != nil {
if errors.IsNotFound(err) {
return nil, environs.ErrNotBootstrapped
}
return nil, err
}
return loadState(r)
} | go | {
"resource": ""
} |
q4267 | AddStateInstance | train | func AddStateInstance(stor storage.Storage, id instance.Id) error {
state, err := LoadState(stor)
if err == environs.ErrNotBootstrapped {
state = &BootstrapState{}
} else if err != nil {
return errors.Annotate(err, "cannot record state instance-id")
}
state.StateInstances = append(state.StateInstances, id)
re... | go | {
"resource": ""
} |
q4268 | RemoveStateInstances | train | func RemoveStateInstances(stor storage.Storage, ids ...instance.Id) error {
state, err := LoadState(stor)
if err == environs.ErrNotBootstrapped {
return nil
} else if err != nil {
return errors.Annotate(err, "cannot remove recorded state instance-id")
}
var anyFound bool
for i := 0; i < len(state.StateInstanc... | go | {
"resource": ""
} |
q4269 | ProviderStateInstances | train | func ProviderStateInstances(stor storage.StorageReader) ([]instance.Id, error) {
st, err := LoadState(stor)
if err != nil {
return nil, err
}
return st.StateInstances, nil
} | go | {
"resource": ""
} |
q4270 | NewFacade | train | func NewFacade(
resources facade.Resources,
authorizer facade.Authorizer,
st CAASFirewallerState,
) (*Facade, error) {
if !authorizer.AuthController() {
return nil, common.ErrPerm
}
accessApplication := common.AuthFuncForTagKind(names.ApplicationTagKind)
return &Facade{
LifeGetter: common.NewLifeGetter(
s... | go | {
"resource": ""
} |
q4271 | IsExposed | train | func (f *Facade) IsExposed(args params.Entities) (params.BoolResults, error) {
results := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
for i, arg := range args.Entities {
exposed, err := f.isExposed(f.state, arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerEr... | go | {
"resource": ""
} |
q4272 | Run | train | func (c *importKeysCommand) Run(context *cmd.Context) error {
client, err := c.NewKeyManagerClient()
if err != nil {
return err
}
defer client.Close()
// TODO(alexisb) - currently keys are global which is not ideal.
// keymanager needs to be updated to allow keys per user
c.user = "admin"
results, err := cli... | go | {
"resource": ""
} |
q4273 | ValidateToolsMetadata | train | func ValidateToolsMetadata(params *ToolsMetadataLookupParams) ([]string, *simplestreams.ResolveInfo, error) {
if len(params.Sources) == 0 {
return nil, nil, fmt.Errorf("required parameter sources not specified")
}
if params.Version == "" && params.Major == 0 {
params.Version = jujuversion.Current.String()
}
va... | go | {
"resource": ""
} |
q4274 | Save | train | func (fw *firewallRulesState) Save(rule FirewallRule) error {
if err := rule.WellKnownService.validate(); err != nil {
return errors.Trace(err)
}
for _, cidr := range rule.WhitelistCIDRs {
if _, _, err := net.ParseCIDR(cidr); err != nil {
return errors.NotValidf("CIDR %q", cidr)
}
}
serviceStr := string(r... | go | {
"resource": ""
} |
q4275 | Rule | train | func (fw *firewallRulesState) Rule(service WellKnownServiceType) (*FirewallRule, error) {
coll, closer := fw.st.db().GetCollection(firewallRulesC)
defer closer()
var doc firewallRulesDoc
err := coll.FindId(string(service)).One(&doc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("firewall rules for se... | go | {
"resource": ""
} |
q4276 | AllRules | train | func (fw *firewallRulesState) AllRules() ([]*FirewallRule, error) {
coll, closer := fw.st.db().GetCollection(firewallRulesC)
defer closer()
var docs []firewallRulesDoc
err := coll.Find(nil).All(&docs)
if err != nil {
return nil, errors.Trace(err)
}
result := make([]*FirewallRule, len(docs))
for i, doc := ran... | go | {
"resource": ""
} |
q4277 | acquireExecutionLock | train | func (w *hookRunner) acquireExecutionLock(action string, interrupt <-chan struct{}) (func(), error) {
spec := machinelock.Spec{
Cancel: interrupt,
Worker: "meterstatus",
Comment: action,
}
releaser, err := w.machineLock.Acquire(spec)
if err != nil {
return nil, errors.Trace(err)
}
return releaser, nil
} | go | {
"resource": ""
} |
q4278 | CreateCloudAccess | train | func (st *State) CreateCloudAccess(cloud string, user names.UserTag, access permission.Access) error {
if err := permission.ValidateCloudAccess(access); err != nil {
return errors.Trace(err)
}
// Local users must exist.
if user.IsLocal() {
_, err := st.User(user)
if err != nil {
if errors.IsNotFound(err) ... | go | {
"resource": ""
} |
q4279 | GetCloudAccess | train | func (st *State) GetCloudAccess(cloud string, user names.UserTag) (permission.Access, error) {
perm, err := st.userPermission(cloudGlobalKey(cloud), userGlobalKey(userAccessID(user)))
if err != nil {
return "", errors.Trace(err)
}
return perm.access(), nil
} | go | {
"resource": ""
} |
q4280 | GetCloudUsers | train | func (st *State) GetCloudUsers(cloud string) (map[string]permission.Access, error) {
perms, err := st.usersPermissions(cloudGlobalKey(cloud))
if err != nil {
return nil, errors.Trace(err)
}
result := make(map[string]permission.Access)
for _, p := range perms {
result[userIDFromGlobalKey(p.doc.SubjectGlobalKey)... | go | {
"resource": ""
} |
q4281 | UpdateCloudAccess | train | func (st *State) UpdateCloudAccess(cloud string, user names.UserTag, access permission.Access) error {
if err := permission.ValidateCloudAccess(access); err != nil {
return errors.Trace(err)
}
buildTxn := func(int) ([]txn.Op, error) {
_, err := st.GetCloudAccess(cloud, user)
if err != nil {
return nil, err... | go | {
"resource": ""
} |
q4282 | RemoveCloudAccess | train | func (st *State) RemoveCloudAccess(cloud string, user names.UserTag) error {
buildTxn := func(int) ([]txn.Op, error) {
_, err := st.GetCloudAccess(cloud, user)
if err != nil {
return nil, err
}
ops := []txn.Op{removePermissionOp(cloudGlobalKey(cloud), userGlobalKey(userAccessID(user)))}
return ops, nil
}... | go | {
"resource": ""
} |
q4283 | CloudsForUser | train | func (st *State) CloudsForUser(user names.UserTag, all bool) ([]CloudInfo, error) {
// We only treat the user as a superuser if they pass --all
isControllerSuperuser := false
if all {
var err error
isControllerSuperuser, err = st.isUserSuperuser(user)
if err != nil {
return nil, errors.Trace(err)
}
}
c... | go | {
"resource": ""
} |
q4284 | cloudNamesForUser | train | func (st *State) cloudNamesForUser(user names.UserTag) ([]string, error) {
// Start by looking up cloud names that the user has access to, and then load only the records that are
// included in that set
permissions, permCloser := st.db().GetRawCollection(permissionsC)
defer permCloser()
findExpr := fmt.Sprintf("^... | go | {
"resource": ""
} |
q4285 | NewMachineInitReader | train | func NewMachineInitReader(series string) (InitReader, error) {
cloudInitConfigDir, err := paths.CloudInitCfgDir(series)
if err != nil {
return nil, errors.Annotate(err, "determining CloudInitCfgDir for the machine")
}
cloudInitInstanceConfigDir, err := paths.MachineCloudInitDir(series)
if err != nil {
return n... | go | {
"resource": ""
} |
q4286 | GetInitConfig | train | func (r *MachineInitReader) GetInitConfig() (map[string]interface{}, error) {
series := r.config.Series
containerOS, err := utilsseries.GetOSFromSeries(series)
if err != nil {
return nil, errors.Trace(err)
}
switch containerOS {
case utilsos.Ubuntu, utilsos.CentOS, utilsos.OpenSUSE:
if series != utilsseries.... | go | {
"resource": ""
} |
q4287 | getMachineCloudCfgDirData | train | func (r *MachineInitReader) getMachineCloudCfgDirData() (map[string]interface{}, error) {
dir := r.config.CloudInitConfigDir
files, err := ioutil.ReadDir(dir)
if err != nil {
return nil, errors.Annotate(err, "determining files in CloudInitCfgDir for the machine")
}
sortedFiles := sortableFileInfos(files)
sort.... | go | {
"resource": ""
} |
q4288 | unmarshallConfigFile | train | func (r *MachineInitReader) unmarshallConfigFile(file string) (map[string]interface{}, error) {
raw, config, err := fileAsConfigMap(file)
if err == nil {
return config, nil
}
if !errors.IsNotValid(err) {
return nil, errors.Trace(err)
}
// The data maybe be gzipped, base64 encoded, both, or neither.
// If bo... | go | {
"resource": ""
} |
q4289 | fileAsConfigMap | train | func fileAsConfigMap(file string) ([]byte, map[string]interface{}, error) {
raw, err := ioutil.ReadFile(file)
if err != nil {
return nil, nil, errors.Annotatef(err, "reading config from %q", file)
}
if len(raw) == 0 {
return nil, nil, nil
}
cfg, err := bytesAsConfigMap(raw)
if err != nil {
return raw, cfg... | go | {
"resource": ""
} |
q4290 | extractPropertiesFromConfig | train | func extractPropertiesFromConfig(props []string, cfg map[string]interface{}, log loggo.Logger) map[string]interface{} {
foundDataMap := make(map[string]interface{})
for _, k := range props {
key := strings.TrimSpace(k)
switch key {
case "apt-security", "apt-primary", "apt-sources", "apt-sources_list":
if val... | go | {
"resource": ""
} |
q4291 | extractPropertiesFromConfigLegacy | train | func extractPropertiesFromConfigLegacy(
props []string, cfg map[string]interface{}, log loggo.Logger,
) map[string]interface{} {
foundDataMap := make(map[string]interface{})
aptProcessed := false
for _, k := range props {
key := strings.TrimSpace(k)
switch key {
case "apt-primary", "apt-sources":
if aptPr... | go | {
"resource": ""
} |
q4292 | authorizeCharmStoreEntity | train | func authorizeCharmStoreEntity(csClient charmstoreForDeploy, curl *charm.URL) (*macaroon.Macaroon, error) {
endpoint := "/delegatable-macaroon?id=" + url.QueryEscape(curl.String())
var m *macaroon.Macaroon
if err := csClient.Get(endpoint, &m); err != nil {
return nil, errors.Trace(err)
}
return m, nil
} | go | {
"resource": ""
} |
q4293 | WatchApplication | train | func (c *Client) WatchApplication(appName string) (watcher.NotifyWatcher, error) {
appTag, err := applicationTag(appName)
if err != nil {
return nil, errors.Trace(err)
}
return common.Watch(c.facade, "Watch", appTag)
} | go | {
"resource": ""
} |
q4294 | Life | train | func (c *Client) Life(appName string) (life.Value, error) {
appTag, err := applicationTag(appName)
if err != nil {
return "", errors.Trace(err)
}
args := entities(appTag)
var results params.LifeResults
if err := c.facade.FacadeCall("Life", args, &results); err != nil {
return "", err
}
if n := len(results.... | go | {
"resource": ""
} |
q4295 | IsExposed | train | func (c *Client) IsExposed(appName string) (bool, error) {
appTag, err := applicationTag(appName)
if err != nil {
return false, errors.Trace(err)
}
args := entities(appTag)
var results params.BoolResults
if err := c.facade.FacadeCall("IsExposed", args, &results); err != nil {
return false, err
}
if n := le... | go | {
"resource": ""
} |
q4296 | Arch | train | func (p CreateMachineParams) Arch() string {
if p.arch != "" {
return p.arch
}
return arch.HostArch()
} | go | {
"resource": ""
} |
q4297 | ValidateDomainParams | train | func (p CreateMachineParams) ValidateDomainParams() error {
if p.Hostname == "" {
return errors.Errorf("missing required hostname")
}
if len(p.disks) < 2 {
// We need at least the drive and the data source disk.
return errors.Errorf("got %d disks, need at least 2", len(p.disks))
}
var ds, fs bool
for _, d :... | go | {
"resource": ""
} |
q4298 | CreateMachine | train | func CreateMachine(params CreateMachineParams) error {
if params.Hostname == "" {
return fmt.Errorf("hostname is required")
}
setDefaults(¶ms)
templateDir := filepath.Dir(params.UserDataFile)
err := writeMetadata(templateDir)
if err != nil {
return errors.Annotate(err, "failed to write instance metadat... | go | {
"resource": ""
} |
q4299 | setDefaults | train | func setDefaults(p *CreateMachineParams) {
if p.findPath == nil {
p.findPath = paths.DataDir
}
if p.runCmd == nil {
p.runCmd = runAsLibvirt
}
if p.runCmdAsRoot == nil {
p.runCmdAsRoot = run
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.