_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q4100 | unpinLeaders | train | func (w *upgradeSeriesWorker) unpinLeaders() error {
results, err := w.UnpinMachineApplications()
if err != nil {
return errors.Trace(err)
}
var lastErr error
for app, err := range results {
if err == nil {
w.logger.Infof("unpinned leader for application %q", app)
continue
}
w.logger.Errorf("failed ... | go | {
"resource": ""
} |
q4101 | unitServices | train | func (w *upgradeSeriesWorker) unitServices() (map[string]string, error) {
services, err := w.service.ListServices()
if err != nil {
return nil, errors.Trace(err)
}
return service.FindUnitServiceNames(services), nil
} | go | {
"resource": ""
} |
q4102 | unitNames | train | func unitNames(units map[string]string) string {
unitIds := make([]string, len(units))
i := 0
for u := range units {
unitIds[i] = u
i++
}
return strings.Join(unitIds, ", ")
} | go | {
"resource": ""
} |
q4103 | NewEndpointPath | train | func NewEndpointPath(application, name string) string {
return fmt.Sprintf(HTTPEndpointPath, application, name)
} | go | {
"resource": ""
} |
q4104 | ExtractEndpointDetails | train | func ExtractEndpointDetails(url *url.URL) (application, name string) {
application = url.Query().Get(":application")
name = url.Query().Get(":resource")
return application, name
} | go | {
"resource": ""
} |
q4105 | SendHTTPStatusAndJSON | train | func SendHTTPStatusAndJSON(w http.ResponseWriter, statusCode int, response interface{}) {
body, err := json.Marshal(response)
if err != nil {
http.Error(w, errors.Annotatef(err, "cannot marshal JSON result %#v", response).Error(), 504)
return
}
if statusCode == http.StatusUnauthorized {
w.Header().Set("WWW-A... | go | {
"resource": ""
} |
q4106 | NewWorker | train | func NewWorker(config Config) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
// There are no upgrade steps for a CAAS model.
// We just set the status to available and unlock the gate.
return jujuworker.NewSimpleWorker(func(<-chan struct{}) error {
setStatus ... | go | {
"resource": ""
} |
q4107 | NewAPI | train | func NewAPI(
st *state.State,
resources facade.Resources,
authorizer facade.Authorizer,
) (*API, error) {
if !authorizer.AuthClient() {
return nil, common.ErrPerm
}
m, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
return &API{
access: getState(st, m),
authorizer: authorizer,
}... | go | {
"resource": ""
} |
q4108 | Get | train | func (api *API) Get(args params.Entities) params.AnnotationsGetResults {
if err := api.checkCanRead(); err != nil {
result := make([]params.AnnotationsGetResult, len(args.Entities))
for i := range result {
result[i].Error = params.ErrorResult{Error: common.ServerError(err)}
}
return params.AnnotationsGetRes... | go | {
"resource": ""
} |
q4109 | Set | train | func (api *API) Set(args params.AnnotationsSet) params.ErrorResults {
if err := api.checkCanWrite(); err != nil {
errorResults := make([]params.ErrorResult, len(args.Annotations))
for i := range errorResults {
errorResults[i].Error = common.ServerError(err)
}
return params.ErrorResults{Results: errorResults... | go | {
"resource": ""
} |
q4110 | UpgradeSeriesPrepare | train | func (c *upgradeSeriesCommand) UpgradeSeriesPrepare(ctx *cmd.Context) (err error) {
apiRoot, err := c.ensureAPIClient()
if err != nil {
return errors.Trace(err)
}
if apiRoot != nil {
defer apiRoot.Close()
}
units, err := c.upgradeMachineSeriesClient.UpgradeSeriesValidate(c.machineNumber, c.series)
if err !=... | go | {
"resource": ""
} |
q4111 | displayNotifications | train | func (c *upgradeSeriesCommand) displayNotifications(ctx *cmd.Context) func() error {
// We return and anonymous function here to satisfy the catacomb plan's
// need for a work function and to close over the commands context.
return func() error {
uw, wid, err := c.upgradeMachineSeriesClient.WatchUpgradeSeriesNotif... | go | {
"resource": ""
} |
q4112 | UpgradeSeriesComplete | train | func (c *upgradeSeriesCommand) UpgradeSeriesComplete(ctx *cmd.Context) error {
apiRoot, err := c.ensureAPIClient()
if err != nil {
return errors.Trace(err)
}
if apiRoot != nil {
defer apiRoot.Close()
}
if err := c.upgradeMachineSeriesClient.UpgradeSeriesComplete(c.machineNumber); err != nil {
return errors... | go | {
"resource": ""
} |
q4113 | Status | train | func (u *UnitAgent) Status() (status.StatusInfo, error) {
info, err := getStatus(u.st.db(), u.globalKey(), "agent")
if err != nil {
return status.StatusInfo{}, errors.Trace(err)
}
// The current health spec says when a hook error occurs, the workload should
// be in error state, but the state model more correctl... | go | {
"resource": ""
} |
q4114 | SetStatus | train | func (u *UnitAgent) SetStatus(unitAgentStatus status.StatusInfo) (err error) {
unit, err := u.st.Unit(u.name)
if errors.IsNotFound(err) {
return errors.Annotate(errors.NotFoundf("agent"), "cannot set status")
}
if err != nil {
return errors.Trace(err)
}
isAssigned := unit.doc.MachineId != ""
shouldBeAssigned... | go | {
"resource": ""
} |
q4115 | Path | train | func (ns *NetworkSpec) Path() string {
name := ns.Name
if name == "" {
name = networkDefaultName
}
return networkPathRoot + name
} | go | {
"resource": ""
} |
q4116 | newInterface | train | func (ns *NetworkSpec) newInterface(name string) *compute.NetworkInterface {
var access []*compute.AccessConfig
if name != "" {
// This interface has an internet connection.
access = append(access, &compute.AccessConfig{
Name: name,
Type: NetworkAccessOneToOneNAT,
// NatIP (only set if using a reserved p... | go | {
"resource": ""
} |
q4117 | firewallSpec | train | func firewallSpec(name, target string, sourceCIDRs []string, ports protocolPorts) *compute.Firewall {
if len(sourceCIDRs) == 0 {
sourceCIDRs = []string{"0.0.0.0/0"}
}
firewall := compute.Firewall{
// Allowed is set below.
// Description is not set.
Name: name,
// Network: (defaults to global)
// SourceTa... | go | {
"resource": ""
} |
q4118 | ModelStatus | train | func (c *ModelStatusAPI) ModelStatus(req params.Entities) (params.ModelStatusResults, error) {
models := req.Entities
status := make([]params.ModelStatus, len(models))
for i, model := range models {
modelStatus, err := c.modelStatus(model.Tag)
if err != nil {
status[i].Error = ServerError(err)
continue
}... | go | {
"resource": ""
} |
q4119 | ModelFilesystemInfo | train | func ModelFilesystemInfo(in []state.Filesystem) []params.ModelFilesystemInfo {
out := make([]params.ModelFilesystemInfo, len(in))
for i, in := range in {
var statusString string
status, err := in.Status()
if err != nil {
statusString = err.Error()
} else {
statusString = string(status.Status)
}
var ... | go | {
"resource": ""
} |
q4120 | ModelVolumeInfo | train | func ModelVolumeInfo(in []state.Volume) []params.ModelVolumeInfo {
out := make([]params.ModelVolumeInfo, len(in))
for i, in := range in {
var statusString string
status, err := in.Status()
if err != nil {
statusString = err.Error()
} else {
statusString = string(status.Status)
}
var providerId strin... | go | {
"resource": ""
} |
q4121 | NewRelationIdValue | train | func NewRelationIdValue(ctx Context, result *int) (*relationIdValue, error) {
v := &relationIdValue{result: result, ctx: ctx}
id := -1
if r, err := ctx.HookRelation(); err == nil {
id = r.Id()
v.value = r.FakeId()
} else if !errors.IsNotFound(err) {
return nil, errors.Trace(err)
}
*result = id
return v, ni... | go | {
"resource": ""
} |
q4122 | Set | train | func (v *relationIdValue) Set(value string) error {
trim := value
if idx := strings.LastIndex(trim, ":"); idx != -1 {
trim = trim[idx+1:]
}
id, err := strconv.Atoi(trim)
if err != nil {
return fmt.Errorf("invalid relation id")
}
if _, err := v.ctx.Relation(id); err != nil {
return errors.Trace(err)
}
*v.... | go | {
"resource": ""
} |
q4123 | FriendlyDuration | train | func FriendlyDuration(when *time.Time, now time.Time) string {
if when == nil {
return ""
}
return UserFriendlyDuration(*when, now)
} | go | {
"resource": ""
} |
q4124 | ModelInfoFromParams | train | func ModelInfoFromParams(info params.ModelInfo, now time.Time) (ModelInfo, error) {
ownerTag, err := names.ParseUserTag(info.OwnerTag)
if err != nil {
return ModelInfo{}, errors.Trace(err)
}
cloudTag, err := names.ParseCloudTag(info.CloudTag)
if err != nil {
return ModelInfo{}, errors.Trace(err)
}
modelInfo ... | go | {
"resource": ""
} |
q4125 | OwnerQualifiedModelName | train | func OwnerQualifiedModelName(modelName string, owner, user names.UserTag) string {
if owner.Id() == user.Id() {
return modelName
}
return jujuclient.JoinOwnerModelName(owner, modelName)
} | go | {
"resource": ""
} |
q4126 | NewCharmResourcesCommand | train | func NewCharmResourcesCommand(resourceLister ResourceLister) modelcmd.ModelCommand {
var c CharmResourcesCommand
c.setResourceLister(resourceLister)
return modelcmd.Wrap(&c)
} | go | {
"resource": ""
} |
q4127 | ListResources | train | func (c *baseCharmResourcesCommand) ListResources(ids []charmstore.CharmID) ([][]charmresource.Resource, error) {
bakeryClient, err := c.BakeryClient()
if err != nil {
return nil, errors.Trace(err)
}
conAPIRoot, err := c.NewControllerAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
csURL, err := get... | go | {
"resource": ""
} |
q4128 | Work | train | func (w *PrunerWorker) Work(getPrunerConfig func(*config.Config) (time.Duration, uint)) error {
modelConfigWatcher, err := w.config.Facade.WatchForModelConfigChanges()
if err != nil {
return errors.Trace(err)
}
err = w.catacomb.Add(modelConfigWatcher)
if err != nil {
return errors.Trace(err)
}
var (
maxAg... | go | {
"resource": ""
} |
q4129 | finalizeConfig | train | func finalizeConfig(
provider environs.EnvironProvider,
cloud environs.CloudSpec,
attrs map[string]interface{},
) (*config.Config, error) {
cfg, err := config.New(config.UseDefaults, attrs)
if err != nil {
return nil, errors.Annotate(err, "creating config from values failed")
}
cfg, err = provider.PrepareConfi... | go | {
"resource": ""
} |
q4130 | ProvisionMachine | train | func ProvisionMachine(args manual.ProvisionMachineArgs) (machineId string, err error) {
defer func() {
if machineId != "" && err != nil {
logger.Errorf("provisioning failed, removing machine %v: %v", machineId, err)
if cleanupErr := args.Client.ForceDestroyMachines(machineId); cleanupErr != nil {
logger.Er... | go | {
"resource": ""
} |
q4131 | NewCredentialInvalidatorFacade | train | func NewCredentialInvalidatorFacade(apiCaller base.APICaller) (CredentialAPI, error) {
return credentialvalidator.NewFacade(apiCaller), nil
} | go | {
"resource": ""
} |
q4132 | NewCloudCallContext | train | func NewCloudCallContext(c CredentialAPI, dying context.Dying) context.ProviderCallContext {
return &context.CloudCallContext{
DyingFunc: dying,
InvalidateCredentialFunc: c.InvalidateModelCredential,
}
} | go | {
"resource": ""
} |
q4133 | NewDisableCommand | train | func NewDisableCommand() cmd.Command {
return modelcmd.Wrap(&disableCommand{
apiFunc: func(c newAPIRoot) (blockClientAPI, error) {
return getBlockAPI(c)
},
})
} | go | {
"resource": ""
} |
q4134 | NewDeployerAPI | train | func NewDeployerAPI(
st *state.State,
resources facade.Resources,
authorizer facade.Authorizer,
) (*DeployerAPI, error) {
if !authorizer.AuthMachineAgent() {
return nil, common.ErrPerm
}
getAuthFunc := func() (common.AuthFunc, error) {
// Get all units of the machine and cache them.
thisMachineTag := author... | go | {
"resource": ""
} |
q4135 | SetStatus | train | func (d *DeployerAPI) SetStatus(args params.SetStatus) (params.ErrorResults, error) {
return d.StatusSetter.SetStatus(args)
} | go | {
"resource": ""
} |
q4136 | getAllUnits | train | func getAllUnits(st *state.State, tag names.Tag) ([]string, error) {
machine, err := st.Machine(tag.Id())
if err != nil {
return nil, err
}
// Start a watcher on machine's units, read the initial event and stop it.
watch := machine.WatchUnits()
defer watch.Stop()
if units, ok := <-watch.Changes(); ok {
retur... | go | {
"resource": ""
} |
q4137 | NewRestoreCommand | train | func NewRestoreCommand() cmd.Command {
c := &restoreCommand{}
c.getModelStatusAPI = func() (ModelStatusAPI, error) { return c.NewModelManagerAPIClient() }
return modelcmd.Wrap(c)
} | go | {
"resource": ""
} |
q4138 | SetFlags | train | func (c *restoreCommand) SetFlags(f *gnuflag.FlagSet) {
c.CommandBase.SetFlags(f)
f.StringVar(&c.Filename, "file", "", "Provide a file to be used as the backup")
f.StringVar(&c.BackupId, "id", "", "Provide the name of the backup to be restored")
} | go | {
"resource": ""
} |
q4139 | Init | train | func (c *restoreCommand) Init(args []string) error {
if c.Filename == "" && c.BackupId == "" {
return errors.Errorf("you must specify either a file or a backup id.")
}
if c.Filename != "" && c.BackupId != "" {
return errors.Errorf("you must specify either a file or a backup id but not both.")
}
if c.Filename ... | go | {
"resource": ""
} |
q4140 | Run | train | func (c *restoreCommand) Run(ctx *cmd.Context) error {
if err := c.validateIaasController(c.Info().Name); err != nil {
return errors.Trace(err)
}
if c.Log != nil {
if err := c.Log.Start(ctx); err != nil {
return err
}
}
// Don't allow restore in an HA environment
controllerModelUUID, modelStatus, err :=... | go | {
"resource": ""
} |
q4141 | NewWorker | train | func NewWorker(config WorkerConfig) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
started := make(chan struct{})
w := &agentConfigUpdater{
config: config,
mongoProfile: config.MongoProfile,
}
w.tomb.Go(func() error {
return w.loop(started)
})
s... | go | {
"resource": ""
} |
q4142 | SingularClaimer | train | func (st *State) SingularClaimer() lease.Claimer {
return lazyLeaseClaimer{func() (lease.Claimer, error) {
manager := st.workers.singularManager()
return manager.Claimer(singularControllerNamespace, st.modelUUID())
}}
} | go | {
"resource": ""
} |
q4143 | counterpartRole | train | func counterpartRole(r charm.RelationRole) charm.RelationRole {
switch r {
case charm.RoleProvider:
return charm.RoleRequirer
case charm.RoleRequirer:
return charm.RoleProvider
case charm.RolePeer:
return charm.RolePeer
}
panic(fmt.Errorf("unknown relation role %q", r))
} | go | {
"resource": ""
} |
q4144 | CanRelateTo | train | func (ep Endpoint) CanRelateTo(other Endpoint) bool {
return ep.ApplicationName != other.ApplicationName &&
ep.Interface == other.Interface &&
ep.Role != charm.RolePeer &&
counterpartRole(ep.Role) == other.Role
} | go | {
"resource": ""
} |
q4145 | NewStateFirewallerAPIV3 | train | func NewStateFirewallerAPIV3(context facade.Context) (*FirewallerAPIV3, error) {
st := context.State()
m, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
cloudSpecAPI := cloudspec.NewCloudSpec(
context.Resources(),
cloudspec.MakeCloudSpecGetterForModel(st),
cloudspec.MakeCloudSpecWatche... | go | {
"resource": ""
} |
q4146 | NewStateFirewallerAPIV4 | train | func NewStateFirewallerAPIV4(context facade.Context) (*FirewallerAPIV4, error) {
facadev3, err := NewStateFirewallerAPIV3(context)
if err != nil {
return nil, err
}
return &FirewallerAPIV4{
ControllerConfigAPI: common.NewStateControllerConfig(context.State()),
FirewallerAPIV3: facadev3,
}, nil
} | go | {
"resource": ""
} |
q4147 | NewStateFirewallerAPIV5 | train | func NewStateFirewallerAPIV5(context facade.Context) (*FirewallerAPIV5, error) {
facadev4, err := NewStateFirewallerAPIV4(context)
if err != nil {
return nil, err
}
return &FirewallerAPIV5{
FirewallerAPIV4: facadev4,
}, nil
} | go | {
"resource": ""
} |
q4148 | NewFirewallerAPI | train | func NewFirewallerAPI(
st State,
resources facade.Resources,
authorizer facade.Authorizer,
cloudSpecAPI cloudspec.CloudSpecAPI,
) (*FirewallerAPIV3, error) {
if !authorizer.AuthController() {
// Firewaller must run as a controller.
return nil, common.ErrPerm
}
// Set up the various authorization checkers.
a... | go | {
"resource": ""
} |
q4149 | WatchOpenedPorts | train | func (f *FirewallerAPIV3) WatchOpenedPorts(args params.Entities) (params.StringsWatchResults, error) {
result := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canWatch, err := f.accessModel()
if err != nil {
re... | go | {
"resource": ""
} |
q4150 | GetMachinePorts | train | func (f *FirewallerAPIV3) GetMachinePorts(args params.MachinePortsParams) (params.MachinePortsResults, error) {
result := params.MachinePortsResults{
Results: make([]params.MachinePortsResult, len(args.Params)),
}
canAccess, err := f.accessMachine()
if err != nil {
return params.MachinePortsResults{}, err
}
f... | go | {
"resource": ""
} |
q4151 | GetExposed | train | func (f *FirewallerAPIV3) GetExposed(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := f.accessApplication()
if err != nil {
return params.BoolResults{}, err
}
for i, entity := range args.Entities {
t... | go | {
"resource": ""
} |
q4152 | WatchIngressAddressesForRelations | train | func (f *FirewallerAPIV4) WatchIngressAddressesForRelations(relations params.Entities) (params.StringsWatchResults, error) {
results := params.StringsWatchResults{
make([]params.StringsWatchResult, len(relations.Entities)),
}
one := func(tag string) (id string, changes []string, _ error) {
logger.Debugf("Watchi... | go | {
"resource": ""
} |
q4153 | MacaroonForRelations | train | func (f *FirewallerAPIV4) MacaroonForRelations(args params.Entities) (params.MacaroonResults, error) {
var result params.MacaroonResults
result.Results = make([]params.MacaroonResult, len(args.Entities))
for i, entity := range args.Entities {
relationTag, err := names.ParseRelationTag(entity.Tag)
if err != nil {... | go | {
"resource": ""
} |
q4154 | SetRelationsStatus | train | func (f *FirewallerAPIV4) SetRelationsStatus(args params.SetStatus) (params.ErrorResults, error) {
var result params.ErrorResults
result.Results = make([]params.ErrorResult, len(args.Entities))
for i, entity := range args.Entities {
relationTag, err := names.ParseRelationTag(entity.Tag)
if err != nil {
result... | go | {
"resource": ""
} |
q4155 | FirewallRules | train | func (f *FirewallerAPIV4) FirewallRules(args params.KnownServiceArgs) (params.ListFirewallRulesResults, error) {
var result params.ListFirewallRulesResults
for _, knownService := range args.KnownServices {
rule, err := f.st.FirewallRule(state.WellKnownServiceType(knownService))
if err != nil && !errors.IsNotFound... | go | {
"resource": ""
} |
q4156 | NewDBInfo | train | func NewDBInfo(mgoInfo *mongo.MongoInfo, session DBSession, version mongo.Version) (*DBInfo, error) {
targets, err := getBackupTargetDatabases(session)
if err != nil {
return nil, errors.Trace(err)
}
info := DBInfo{
Address: mgoInfo.Addrs[0],
Password: mgoInfo.Password,
Targets: targets,
Mo... | go | {
"resource": ""
} |
q4157 | NewDBDumper | train | func NewDBDumper(info *DBInfo) (DBDumper, error) {
mongodumpPath, err := getMongodumpPath()
if err != nil {
return nil, errors.Annotate(err, "mongodump not available")
}
dumper := mongoDumper{
DBInfo: info,
binPath: mongodumpPath,
}
return &dumper, nil
} | go | {
"resource": ""
} |
q4158 | Dump | train | func (md *mongoDumper) Dump(baseDumpDir string) error {
if err := md.dump(baseDumpDir); err != nil {
return errors.Trace(err)
}
found, err := listDatabases(baseDumpDir)
if err != nil {
return errors.Trace(err)
}
// Strip the ignored database from the dump dir.
ignored := found.Difference(md.Targets)
// Ad... | go | {
"resource": ""
} |
q4159 | listDatabases | train | func listDatabases(dumpDir string) (set.Strings, error) {
list, err := ioutil.ReadDir(dumpDir)
if err != nil {
return set.Strings{}, errors.Trace(err)
}
databases := make(set.Strings)
for _, info := range list {
if !info.IsDir() {
// Notably, oplog.bson is thus excluded here.
continue
}
databases.Ad... | go | {
"resource": ""
} |
q4160 | NewDBRestorer | train | func NewDBRestorer(args RestorerArgs) (DBRestorer, error) {
mongorestorePath, err := getMongorestorePath()
if err != nil {
return nil, errors.Annotate(err, "mongorestore not available")
}
installedMongo := mongoInstalledVersion()
logger.Debugf("args: is %#v", args)
logger.Infof("installed mongo is %s", install... | go | {
"resource": ""
} |
q4161 | ensureOplogPermissions | train | func (md *mongoRestorer32) ensureOplogPermissions(dialInfo *mgo.DialInfo) error {
s, err := md.newMongoSession(dialInfo)
if err != nil {
return errors.Trace(err)
}
defer s.Close()
roles := bson.D{
{"createRole", "oploger"},
{"privileges", []bson.D{
{
{"resource", bson.M{"anyResource": true}},
{"a... | go | {
"resource": ""
} |
q4162 | NewUniter | train | func NewUniter(uniterParams *UniterParams) (*Uniter, error) {
startFunc := newUniter(uniterParams)
w, err := startFunc()
return w.(*Uniter), err
} | go | {
"resource": ""
} |
q4163 | StartUniter | train | func StartUniter(runner *worker.Runner, params *UniterParams) error {
startFunc := newUniter(params)
logger.Debugf("starting uniter for %q", params.UnitTag.Id())
err := runner.StartWorker(params.UnitTag.Id(), startFunc)
return errors.Annotate(err, "error starting uniter worker")
} | go | {
"resource": ""
} |
q4164 | stopUnitError | train | func (u *Uniter) stopUnitError() error {
logger.Debugf("u.modelType: %s", u.modelType)
if u.modelType == model.CAAS {
return ErrCAASUnitDead
}
return jworker.ErrTerminateAgent
} | go | {
"resource": ""
} |
q4165 | acquireExecutionLock | train | func (u *Uniter) acquireExecutionLock(action string) (func(), error) {
// We want to make sure we don't block forever when locking, but take the
// Uniter's catacomb into account.
spec := machinelock.Spec{
Cancel: u.catacomb.Dying(),
Worker: "uniter",
Comment: action,
}
releaser, err := u.hookLock.Acquire(... | go | {
"resource": ""
} |
q4166 | ReadLegacyCloudCredentials | train | func ReadLegacyCloudCredentials(readFile func(string) ([]byte, error)) (cloud.Credential, error) {
var (
jujuConfDir = jujupaths.MustSucceed(jujupaths.ConfDir(version.SupportedLTS()))
clientCertPath = path.Join(jujuConfDir, "lxd-client.crt")
clientKeyPath = path.Join(jujuConfDir, "lxd-client.key")
serverCe... | go | {
"resource": ""
} |
q4167 | ValidateExistingModelCredential | train | func ValidateExistingModelCredential(backend PersistentBackend, callCtx context.ProviderCallContext) (params.ErrorResults, error) {
model, err := backend.Model()
if err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
credentialTag, isSet := model.CloudCredential()
if !isSet {
return params.ErrorRes... | go | {
"resource": ""
} |
q4168 | ValidateNewModelCredential | train | func ValidateNewModelCredential(backend PersistentBackend, callCtx context.ProviderCallContext, credentialTag names.CloudCredentialTag, credential *cloud.Credential) (params.ErrorResults, error) {
openParams, err := buildOpenParams(backend, credentialTag, credential)
if err != nil {
return params.ErrorResults{}, er... | go | {
"resource": ""
} |
q4169 | checkMachineInstances | train | func checkMachineInstances(backend PersistentBackend, provider CloudProvider, callCtx context.ProviderCallContext) (params.ErrorResults, error) {
fail := func(original error) (params.ErrorResults, error) {
return params.ErrorResults{}, original
}
// Get machines from state
machines, err := backend.AllMachines()
... | go | {
"resource": ""
} |
q4170 | BootstrapEnv | train | func (dp DefaultProvider) BootstrapEnv(ctx environs.BootstrapContext, callCtx context.ProviderCallContext, args environs.BootstrapParams) (*environs.BootstrapResult, error) {
result, err := Bootstrap(ctx, dp.Env, callCtx, args)
if err != nil {
return nil, errors.Trace(err)
}
return result, nil
} | go | {
"resource": ""
} |
q4171 | DestroyEnv | train | func (dp DefaultProvider) DestroyEnv(ctx context.ProviderCallContext) error {
if err := Destroy(dp.Env, ctx); err != nil {
return errors.Trace(err)
}
return nil
} | go | {
"resource": ""
} |
q4172 | addPackageCommandsCommon | train | func addPackageCommandsCommon(
cfg CloudConfig,
packageProxySettings proxy.Settings,
packageMirror string,
addUpdateScripts bool,
addUpgradeScripts bool,
series string,
) {
// Set the package mirror.
cfg.SetPackageMirror(packageMirror)
// For LTS series which need support for the cloud-tools archive,
// we n... | go | {
"resource": ""
} |
q4173 | renderScriptCommon | train | func renderScriptCommon(cfg CloudConfig) (string, error) {
// TODO(axw): 2013-08-23 bug 1215777
// Carry out configuration for ssh-keys-per-user,
// machine-updates-authkeys, using cloud-init config.
//
// We should work with smoser to get a supported
// command in (or next to) cloud-init for manually
// invokin... | go | {
"resource": ""
} |
q4174 | restrictRoot | train | func restrictRoot(root rpc.Root, check func(string, string) error) *restrictedRoot {
return &restrictedRoot{
Root: root,
check: check,
}
} | go | {
"resource": ""
} |
q4175 | FindMethod | train | func (r *restrictedRoot) FindMethod(facadeName string, version int, methodName string) (rpcreflect.MethodCaller, error) {
if err := r.check(facadeName, methodName); err != nil {
return nil, err
}
return r.Root.FindMethod(facadeName, version, methodName)
} | go | {
"resource": ""
} |
q4176 | restrictAll | train | func restrictAll(root rpc.Root, err error) *restrictedRoot {
return restrictRoot(root, func(string, string) error {
return err
})
} | go | {
"resource": ""
} |
q4177 | osVal | train | func osVal(ser string, valname osVarType) (string, error) {
os, err := series.GetOSFromSeries(ser)
if err != nil {
return "", err
}
switch os {
case jujuos.Windows:
return winVals[valname], nil
default:
return nixVals[valname], nil
}
} | go | {
"resource": ""
} |
q4178 | makeWatcherAPICaller | train | func makeWatcherAPICaller(caller base.APICaller, facadeName, watcherId string) watcherAPICall {
bestVersion := caller.BestFacadeVersion(facadeName)
return func(request string, result interface{}) error {
return caller.APICall(facadeName, bestVersion,
watcherId, request, nil, &result)
}
} | go | {
"resource": ""
} |
q4179 | init | train | func (w *commonWatcher) init() {
w.in = make(chan interface{})
if w.newResult == nil {
panic("newResult must be set")
}
if w.call == nil {
panic("call must be set")
}
} | go | {
"resource": ""
} |
q4180 | commonLoop | train | func (w *commonWatcher) commonLoop() {
defer close(w.in)
var wg sync.WaitGroup
wg.Add(1)
go func() {
// When the watcher has been stopped, we send a Stop request
// to the server, which will remove the watcher and return a
// CodeStopped error to any currently outstanding call to
// Next. If a call to Next ... | go | {
"resource": ""
} |
q4181 | NewNotifyWatcher | train | func NewNotifyWatcher(caller base.APICaller, result params.NotifyWatchResult) watcher.NotifyWatcher {
w := ¬ifyWatcher{
caller: caller,
notifyWatcherId: result.NotifyWatcherId,
out: make(chan struct{}),
}
w.tomb.Go(w.loop)
return w
} | go | {
"resource": ""
} |
q4182 | NewRelationStatusWatcher | train | func NewRelationStatusWatcher(
caller base.APICaller, result params.RelationLifeSuspendedStatusWatchResult,
) watcher.RelationStatusWatcher {
w := &relationStatusWatcher{
caller: caller,
relationStatusWatcherId: result.RelationStatusWatcherId,
out: make(chan []watcher.Relati... | go | {
"resource": ""
} |
q4183 | NewOfferStatusWatcher | train | func NewOfferStatusWatcher(
caller base.APICaller, result params.OfferStatusWatchResult,
) watcher.OfferStatusWatcher {
w := &offerStatusWatcher{
caller: caller,
offerStatusWatcherId: result.OfferStatusWatcherId,
out: make(chan []watcher.OfferStatusChange),
}
w.tomb.Go(func() er... | go | {
"resource": ""
} |
q4184 | NewVolumeAttachmentsWatcher | train | func NewVolumeAttachmentsWatcher(caller base.APICaller, result params.MachineStorageIdsWatchResult) watcher.MachineStorageIdsWatcher {
return newMachineStorageIdsWatcher("VolumeAttachmentsWatcher", caller, result)
} | go | {
"resource": ""
} |
q4185 | NewMigrationStatusWatcher | train | func NewMigrationStatusWatcher(caller base.APICaller, watcherId string) watcher.MigrationStatusWatcher {
w := &migrationStatusWatcher{
caller: caller,
id: watcherId,
out: make(chan watcher.MigrationStatus),
}
w.tomb.Go(w.loop)
return w
} | go | {
"resource": ""
} |
q4186 | BridgeAndActivate | train | func BridgeAndActivate(params ActivationParams) (*ActivationResult, error) {
if len(params.Devices) == 0 {
return nil, errors.Errorf("no devices specified")
}
netplan, err := ReadDirectory(params.Directory)
if err != nil {
return nil, err
}
for _, device := range params.Devices {
var deviceId string
de... | go | {
"resource": ""
} |
q4187 | New | train | func New(in io.Reader, out, errOut io.Writer) *Pollster {
return &Pollster{
scanner: bufio.NewScanner(byteAtATimeReader{in}),
out: out,
errOut: errOut,
in: in,
}
} | go | {
"resource": ""
} |
q4188 | Select | train | func (p *Pollster) Select(l List) (string, error) {
return p.SelectVerify(l, VerifyOptions(l.Singular, l.Options, l.Default != ""))
} | go | {
"resource": ""
} |
q4189 | SelectVerify | train | func (p *Pollster) SelectVerify(l List, verify VerifyFunc) (string, error) {
if err := listTmpl.Execute(p.out, l); err != nil {
return "", err
}
question, err := sprint(selectTmpl, l)
if err != nil {
return "", errors.Trace(err)
}
val, err := QueryVerify(question, p.scanner, p.out, p.errOut, verify)
if err ... | go | {
"resource": ""
} |
q4190 | Enter | train | func (p *Pollster) Enter(valueName string) (string, error) {
return p.EnterVerify(valueName, func(s string) (ok bool, msg string, err error) {
return s != "", "", nil
})
} | go | {
"resource": ""
} |
q4191 | EnterPassword | train | func (p *Pollster) EnterPassword(valueName string) (string, error) {
if f, ok := p.in.(*os.File); ok && terminal.IsTerminal(int(f.Fd())) {
defer fmt.Fprint(p.out, "\n\n")
if _, err := fmt.Fprintf(p.out, "Enter "+valueName+": "); err != nil {
return "", errors.Trace(err)
}
value, err := terminal.ReadPassword... | go | {
"resource": ""
} |
q4192 | EnterDefault | train | func (p *Pollster) EnterDefault(valueName, defVal string) (string, error) {
return p.EnterVerifyDefault(valueName, nil, defVal)
} | go | {
"resource": ""
} |
q4193 | EnterOptional | train | func (p *Pollster) EnterOptional(valueName string) (string, error) {
return QueryVerify("Enter "+valueName+" (optional): ", p.scanner, p.out, p.errOut, nil)
} | go | {
"resource": ""
} |
q4194 | EnterVerifyDefault | train | func (p *Pollster) EnterVerifyDefault(valueName string, verify VerifyFunc, defVal string) (string, error) {
var verifyDefault VerifyFunc
if verify != nil {
verifyDefault = func(s string) (ok bool, errmsg string, err error) {
if s == "" {
return true, "", nil
}
return verify(s)
}
}
s, err := QueryVe... | go | {
"resource": ""
} |
q4195 | VerifyOptions | train | func VerifyOptions(singular string, options []string, hasDefault bool) VerifyFunc {
return func(s string) (ok bool, errmsg string, err error) {
if s == "" {
return hasDefault, "", nil
}
for _, opt := range options {
if strings.ToLower(opt) == strings.ToLower(s) {
return true, "", nil
}
}
return ... | go | {
"resource": ""
} |
q4196 | names | train | func names(m map[string]*jsonschema.Schema) []string {
ret := make([]string, 0, len(m))
for n := range m {
ret = append(ret, n)
}
sort.Strings(ret)
return ret
} | go | {
"resource": ""
} |
q4197 | convert | train | func convert(s string, t jsonschema.Type) (interface{}, error) {
switch t {
case jsonschema.IntegerType:
return strconv.Atoi(s)
case jsonschema.NumberType:
return strconv.ParseFloat(s, 64)
case jsonschema.StringType:
return s, nil
case jsonschema.BooleanType:
switch strings.ToLower(s) {
case "y", "yes", ... | go | {
"resource": ""
} |
q4198 | NewUnitAgent | train | func NewUnitAgent(ctx *cmd.Context, bufferedLogger *logsender.BufferedLogWriter) (*UnitAgent, error) {
prometheusRegistry, err := newPrometheusRegistry()
if err != nil {
return nil, errors.Trace(err)
}
return &UnitAgent{
AgentConf: NewAgentConf(""),
configChangedVal: voyeur.NewVal... | go | {
"resource": ""
} |
q4199 | Done | train | func (a *UnitAgent) Done(err error) {
a.errReason = err
close(a.dead)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.