_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q3900 | Destroy | train | func (k *kubernetesClient) Destroy(callbacks context.ProviderCallContext) error {
watcher, err := k.WatchNamespace()
if err != nil {
return errors.Trace(err)
}
defer watcher.Kill()
if err := k.deleteNamespace(); err != nil {
return errors.Annotate(err, "deleting model namespace")
}
// Delete any storage cl... | go | {
"resource": ""
} |
q3901 | APIVersion | train | func (k *kubernetesClient) APIVersion() (string, error) {
body, err := k.client().CoreV1().RESTClient().Get().AbsPath("/version").Do().Raw()
if err != nil {
return "", err
}
var info apimachineryversion.Info
err = json.Unmarshal(body, &info)
if err != nil {
return "", errors.Annotatef(err, "got '%s' querying ... | go | {
"resource": ""
} |
q3902 | ensureOCIImageSecret | train | func (k *kubernetesClient) ensureOCIImageSecret(
imageSecretName,
appName string,
imageDetails *caas.ImageDetails,
annotations k8sannotations.Annotation,
) error {
if imageDetails.Password == "" {
return errors.New("attempting to create a secret with no password")
}
secretData, err := createDockerConfigJSON(im... | go | {
"resource": ""
} |
q3903 | updateSecret | train | func (k *kubernetesClient) updateSecret(sec *core.Secret) error {
_, err := k.client().CoreV1().Secrets(k.namespace).Update(sec)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3904 | getSecret | train | func (k *kubernetesClient) getSecret(secretName string) (*core.Secret, error) {
secret, err := k.client().CoreV1().Secrets(k.namespace).Get(secretName, v1.GetOptions{IncludeUninitialized: true})
if err != nil {
if k8serrors.IsNotFound(err) {
return nil, errors.NotFoundf("secret %q", secretName)
}
return nil,... | go | {
"resource": ""
} |
q3905 | createSecret | train | func (k *kubernetesClient) createSecret(secret *core.Secret) error {
_, err := k.client().CoreV1().Secrets(k.namespace).Create(secret)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3906 | deleteSecret | train | func (k *kubernetesClient) deleteSecret(secretName string) error {
secrets := k.client().CoreV1().Secrets(k.namespace)
err := secrets.Delete(secretName, &v1.DeleteOptions{
PropagationPolicy: &defaultPropagationPolicy,
})
if k8serrors.IsNotFound(err) {
return nil
}
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3907 | OperatorExists | train | func (k *kubernetesClient) OperatorExists(appName string) (caas.OperatorState, error) {
var result caas.OperatorState
statefulsets := k.client().AppsV1().StatefulSets(k.namespace)
operator, err := statefulsets.Get(k.operatorName(appName), v1.GetOptions{IncludeUninitialized: true})
if k8serrors.IsNotFound(err) {
... | go | {
"resource": ""
} |
q3908 | ValidateStorageClass | train | func (k *kubernetesClient) ValidateStorageClass(config map[string]interface{}) error {
cfg, err := newStorageConfig(config)
if err != nil {
return errors.Trace(err)
}
sc, err := k.getStorageClass(cfg.storageClass)
if err != nil {
return errors.NewNotValid(err, fmt.Sprintf("storage class %q", cfg.storageClass))... | go | {
"resource": ""
} |
q3909 | maybeGetVolumeClaimSpec | train | func (k *kubernetesClient) maybeGetVolumeClaimSpec(params volumeParams) (*core.PersistentVolumeClaimSpec, error) {
storageClassName := params.storageConfig.storageClass
haveStorageClass := false
if storageClassName == "" {
return nil, errors.New("cannot create a volume claim spec without a storage class")
}
// S... | go | {
"resource": ""
} |
q3910 | getStorageClass | train | func (k *kubernetesClient) getStorageClass(name string) (*k8sstorage.StorageClass, error) {
storageClasses := k.client().StorageV1().StorageClasses()
qualifiedName := qualifiedStorageClassName(k.namespace, name)
sc, err := storageClasses.Get(qualifiedName, v1.GetOptions{})
if err == nil {
return sc, nil
}
if !k... | go | {
"resource": ""
} |
q3911 | EnsureStorageProvisioner | train | func (k *kubernetesClient) EnsureStorageProvisioner(cfg caas.StorageProvisioner) (*caas.StorageProvisioner, error) {
// First see if the named storage class exists.
sc, err := k.getStorageClass(cfg.Name)
if err == nil {
return &caas.StorageProvisioner{
Name: sc.Name,
Provisioner: sc.Provisioner,
Pa... | go | {
"resource": ""
} |
q3912 | DeleteOperator | train | func (k *kubernetesClient) DeleteOperator(appName string) (err error) {
logger.Debugf("deleting %s operator", appName)
operatorName := k.operatorName(appName)
legacy := isLegacyName(operatorName)
// First delete the config map(s).
configMaps := k.client().CoreV1().ConfigMaps(k.namespace)
configMapName := operat... | go | {
"resource": ""
} |
q3913 | GetService | train | func (k *kubernetesClient) GetService(appName string, includeClusterIP bool) (*caas.Service, error) {
services := k.client().CoreV1().Services(k.namespace)
servicesList, err := services.List(v1.ListOptions{
LabelSelector: applicationSelector(appName),
IncludeUninitialized: true,
})
if err != nil {
retu... | go | {
"resource": ""
} |
q3914 | DeleteService | train | func (k *kubernetesClient) DeleteService(appName string) (err error) {
logger.Debugf("deleting application %s", appName)
deploymentName := k.deploymentName(appName)
if err := k.deleteService(deploymentName); err != nil {
return errors.Trace(err)
}
if err := k.deleteStatefulSet(deploymentName); err != nil {
re... | go | {
"resource": ""
} |
q3915 | EnsureCustomResourceDefinition | train | func (k *kubernetesClient) EnsureCustomResourceDefinition(appName string, podSpec *caas.PodSpec) error {
for name, crd := range podSpec.CustomResourceDefinitions {
crd, err := k.ensureCustomResourceDefinitionTemplate(name, crd)
if err != nil {
return errors.Annotate(err, fmt.Sprintf("ensure custom resource defi... | go | {
"resource": ""
} |
q3916 | Upgrade | train | func (k *kubernetesClient) Upgrade(appName string, vers version.Number) error {
var resourceName string
if appName == JujuControllerStackName {
// upgrading controller.
resourceName = appName
} else {
// upgrading operator.
resourceName = k.operatorName(appName)
}
logger.Debugf("Upgrading %q", resourceName... | go | {
"resource": ""
} |
q3917 | createStatefulSet | train | func (k *kubernetesClient) createStatefulSet(spec *apps.StatefulSet) error {
_, err := k.client().AppsV1().StatefulSets(k.namespace).Create(spec)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3918 | deleteStatefulSet | train | func (k *kubernetesClient) deleteStatefulSet(name string) error {
deployments := k.client().AppsV1().StatefulSets(k.namespace)
err := deployments.Delete(name, &v1.DeleteOptions{
PropagationPolicy: &defaultPropagationPolicy,
})
if k8serrors.IsNotFound(err) {
return nil
}
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3919 | ensureK8sService | train | func (k *kubernetesClient) ensureK8sService(spec *core.Service) error {
services := k.client().CoreV1().Services(k.namespace)
// Set any immutable fields if the service already exists.
existing, err := services.Get(spec.Name, v1.GetOptions{IncludeUninitialized: true})
if err == nil {
spec.Spec.ClusterIP = existin... | go | {
"resource": ""
} |
q3920 | deleteService | train | func (k *kubernetesClient) deleteService(deploymentName string) error {
services := k.client().CoreV1().Services(k.namespace)
err := services.Delete(deploymentName, &v1.DeleteOptions{
PropagationPolicy: &defaultPropagationPolicy,
})
if k8serrors.IsNotFound(err) {
return nil
}
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3921 | ExposeService | train | func (k *kubernetesClient) ExposeService(appName string, resourceTags map[string]string, config application.ConfigAttributes) error {
logger.Debugf("creating/updating ingress resource for %s", appName)
host := config.GetString(caas.JujuExternalHostNameKey, "")
if host == "" {
return errors.Errorf("external hostna... | go | {
"resource": ""
} |
q3922 | UnexposeService | train | func (k *kubernetesClient) UnexposeService(appName string) error {
logger.Debugf("deleting ingress resource for %s", appName)
return k.deleteIngress(appName)
} | go | {
"resource": ""
} |
q3923 | WatchUnits | train | func (k *kubernetesClient) WatchUnits(appName string) (watcher.NotifyWatcher, error) {
selector := applicationSelector(appName)
logger.Debugf("selecting units %q to watch", selector)
w, err := k.client().CoreV1().Pods(k.namespace).Watch(v1.ListOptions{
LabelSelector: selector,
Watch: true,
... | go | {
"resource": ""
} |
q3924 | WatchService | train | func (k *kubernetesClient) WatchService(appName string) (watcher.NotifyWatcher, error) {
// Application may be a statefulset or deployment. It may not have
// been set up when the watcher is started so we don't know which it
// is ahead of time. So use a multi-watcher to cover both cases.
statefulsets := k.client()... | go | {
"resource": ""
} |
q3925 | WatchOperator | train | func (k *kubernetesClient) WatchOperator(appName string) (watcher.NotifyWatcher, error) {
pods := k.client().CoreV1().Pods(k.namespace)
w, err := pods.Watch(v1.ListOptions{
LabelSelector: operatorSelector(appName),
Watch: true,
})
if err != nil {
return nil, errors.Trace(err)
}
return k.newWatcher(w... | go | {
"resource": ""
} |
q3926 | Operator | train | func (k *kubernetesClient) Operator(appName string) (*caas.Operator, error) {
pods := k.client().CoreV1().Pods(k.namespace)
podsList, err := pods.List(v1.ListOptions{
LabelSelector: operatorSelector(appName),
})
if err != nil {
return nil, errors.Trace(err)
}
if len(podsList.Items) == 0 {
return nil, errors... | go | {
"resource": ""
} |
q3927 | ensureConfigMap | train | func (k *kubernetesClient) ensureConfigMap(configMap *core.ConfigMap) error {
configMaps := k.client().CoreV1().ConfigMaps(k.namespace)
_, err := configMaps.Update(configMap)
if k8serrors.IsNotFound(err) {
_, err = configMaps.Create(configMap)
}
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3928 | deleteConfigMap | train | func (k *kubernetesClient) deleteConfigMap(configMapName string) error {
err := k.client().CoreV1().ConfigMaps(k.namespace).Delete(configMapName, &v1.DeleteOptions{
PropagationPolicy: &defaultPropagationPolicy,
})
if k8serrors.IsNotFound(err) {
return nil
}
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3929 | createConfigMap | train | func (k *kubernetesClient) createConfigMap(configMap *core.ConfigMap) error {
_, err := k.client().CoreV1().ConfigMaps(k.namespace).Create(configMap)
return errors.Trace(err)
} | go | {
"resource": ""
} |
q3930 | getConfigMap | train | func (k *kubernetesClient) getConfigMap(cmName string) (*core.ConfigMap, error) {
cm, err := k.client().CoreV1().ConfigMaps(k.namespace).Get(cmName, v1.GetOptions{IncludeUninitialized: true})
if err != nil {
if k8serrors.IsNotFound(err) {
return nil, errors.NotFoundf("configmap %q", cmName)
}
return nil, err... | go | {
"resource": ""
} |
q3931 | legacyAppName | train | func (k *kubernetesClient) legacyAppName(appName string) bool {
statefulsets := k.client().AppsV1().StatefulSets(k.namespace)
legacyName := "juju-operator-" + appName
_, err := statefulsets.Get(legacyName, v1.GetOptions{IncludeUninitialized: true})
return err == nil
} | go | {
"resource": ""
} |
q3932 | Model | train | func (g StatePoolModelGetter) Model(modelUUID string) (Model, func(), error) {
model, ph, err := g.StatePool.GetModel(modelUUID)
if err != nil {
return nil, nil, errors.Trace(err)
}
return model, func() { ph.Release() }, nil
} | go | {
"resource": ""
} |
q3933 | NewRemoveCloudCommand | train | func NewRemoveCloudCommand() cmd.Command {
store := jujuclient.NewFileClientStore()
c := &removeCloudCommand{
OptionalControllerCommand: modelcmd.OptionalControllerCommand{Store: store},
store: store,
}
c.removeCloudAPIFunc = c.cloudAPI
return modelcmd.WrapBase(c)
} | go | {
"resource": ""
} |
q3934 | newOracleVolumeSource | train | func newOracleVolumeSource(env *OracleEnviron, name, uuid string, api StorageAPI, clock clock.Clock) (*oracleVolumeSource, error) {
if env == nil {
return nil, errors.NotFoundf("environ")
}
if api == nil {
return nil, errors.NotFoundf("storage client")
}
return &oracleVolumeSource{
env: env,
envNam... | go | {
"resource": ""
} |
q3935 | resourceName | train | func (s *oracleVolumeSource) resourceName(tag string) string {
return s.api.ComposeName(s.env.namespace.Value(s.envName + "-" + tag))
} | go | {
"resource": ""
} |
q3936 | CreateVolumes | train | func (s *oracleVolumeSource) CreateVolumes(ctx context.ProviderCallContext, params []storage.VolumeParams) ([]storage.CreateVolumesResult, error) {
if params == nil {
return []storage.CreateVolumesResult{}, nil
}
results := make([]storage.CreateVolumesResult, len(params))
for i, volume := range params {
vol, er... | go | {
"resource": ""
} |
q3937 | fetchVolumeStatus | train | func (s *oracleVolumeSource) fetchVolumeStatus(name, desiredStatus string) (complete bool, err error) {
details, err := s.api.StorageVolumeDetails(name)
if err != nil {
return false, errors.Trace(err)
}
if details.Status == ociCommon.VolumeError {
return false, errors.Errorf("volume entered error state: %q", d... | go | {
"resource": ""
} |
q3938 | fetchVolumeAttachmentStatus | train | func (s *oracleVolumeSource) fetchVolumeAttachmentStatus(name, desiredStatus string) (bool, error) {
details, err := s.api.StorageAttachmentDetails(name)
if err != nil {
return false, errors.Trace(err)
}
return string(details.State) == desiredStatus, nil
} | go | {
"resource": ""
} |
q3939 | getFreeIndexNumber | train | func (s *oracleVolumeSource) getFreeIndexNumber(existing []int, max int) (int, error) {
if len(existing) == 0 {
return 1, nil
}
sort.Ints(existing)
for i := 0; i <= len(existing)-1; i++ {
if i+1 >= max {
break
}
if i+1 == len(existing) {
return existing[i] + 1, nil
}
if existing[0] > 1 {
return... | go | {
"resource": ""
} |
q3940 | NewCloudSpec | train | func NewCloudSpec(
resources facade.Resources,
getCloudSpec func(names.ModelTag) (environs.CloudSpec, error),
watchCloudSpec func(tag names.ModelTag) (state.NotifyWatcher, error),
getAuthFunc common.GetAuthFunc,
) CloudSpecAPI {
return cloudSpecAPI{resources, getCloudSpec, watchCloudSpec, getAuthFunc}
} | go | {
"resource": ""
} |
q3941 | CloudSpec | train | func (s cloudSpecAPI) CloudSpec(args params.Entities) (params.CloudSpecResults, error) {
authFunc, err := s.getAuthFunc()
if err != nil {
return params.CloudSpecResults{}, err
}
results := params.CloudSpecResults{
Results: make([]params.CloudSpecResult, len(args.Entities)),
}
for i, arg := range args.Entities... | go | {
"resource": ""
} |
q3942 | GetCloudSpec | train | func (s cloudSpecAPI) GetCloudSpec(tag names.ModelTag) params.CloudSpecResult {
var result params.CloudSpecResult
spec, err := s.getCloudSpec(tag)
if err != nil {
result.Error = common.ServerError(err)
return result
}
var paramsCloudCredential *params.CloudCredential
if spec.Credential != nil && spec.Credenti... | go | {
"resource": ""
} |
q3943 | WatchCloudSpecsChanges | train | func (s cloudSpecAPI) WatchCloudSpecsChanges(args params.Entities) (params.NotifyWatchResults, error) {
authFunc, err := s.getAuthFunc()
if err != nil {
return params.NotifyWatchResults{}, err
}
results := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
for i, arg :... | go | {
"resource": ""
} |
q3944 | IsCmdNotFoundErr | train | func IsCmdNotFoundErr(err error) bool {
err = errors.Cause(err)
if os.IsNotExist(err) {
// Executable could not be found, go 1.3 and later
return true
}
if err == exec.ErrNotFound {
return true
}
if execErr, ok := err.(*exec.Error); ok {
// Executable could not be found, go 1.2
if os.IsNotExist(execErr.... | go | {
"resource": ""
} |
q3945 | AllAttrs | train | func (c ConfigValues) AllAttrs() map[string]interface{} {
result := make(map[string]interface{})
for attr, val := range c {
result[attr] = val
}
return result
} | go | {
"resource": ""
} |
q3946 | NewFacade | train | func NewFacade(apiCaller base.APICaller, claimant names.MachineTag, entity names.Tag) (Facade, error) {
facade, err := singular.NewAPI(apiCaller, claimant, entity)
if err != nil {
return nil, errors.Trace(err)
}
return facade, nil
} | go | {
"resource": ""
} |
q3947 | NewWorker | train | func NewWorker(config FlagConfig) (worker.Worker, error) {
worker, err := NewFlagWorker(config)
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
} | go | {
"resource": ""
} |
q3948 | NewSimpleWorker | train | func NewSimpleWorker(doWork func(stopCh <-chan struct{}) error) worker.Worker {
w := &simpleWorker{}
w.tomb.Go(func() error {
return doWork(w.tomb.Dying())
})
return w
} | go | {
"resource": ""
} |
q3949 | NewUnregisterCmd | train | func NewUnregisterCmd(ctx HookContext) (*UnregisterCmd, error) {
return &UnregisterCmd{hookContextFunc: componentHookContext(ctx)}, nil
} | go | {
"resource": ""
} |
q3950 | Run | train | func (c *UnregisterCmd) Run(ctx *cmd.Context) error {
//TODO(wwitzel3) make Unregister accept class and id and
// compose the ID in the API layer using BuildID
logger.Tracef(`Running unregister command with id "%s/%s"`, c.class, c.id)
hctx, err := c.hookContextFunc()
if err != nil {
return errors.Trace(err)
}... | go | {
"resource": ""
} |
q3951 | startIntrospection | train | func startIntrospection(cfg introspectionConfig) error {
if runtime.GOOS != "linux" {
logger.Debugf("introspection worker not supported on %q", runtime.GOOS)
return nil
}
socketName := cfg.NewSocketName(cfg.Agent.CurrentConfig().Tag())
w, err := cfg.WorkerFunc(introspection.Config{
SocketName: socket... | go | {
"resource": ""
} |
q3952 | newPrometheusRegistry | train | func newPrometheusRegistry() (*prometheus.Registry, error) {
r := prometheus.NewRegistry()
if err := r.Register(prometheus.NewGoCollector()); err != nil {
return nil, errors.Trace(err)
}
if err := r.Register(prometheus.NewProcessCollector(
prometheus.ProcessCollectorOpts{})); err != nil {
return nil, errors.T... | go | {
"resource": ""
} |
q3953 | NextSubnetIP | train | func NextSubnetIP(subnet *net.IPNet, ipsInUse []net.IP) (net.IP, error) {
ones, bits := subnet.Mask.Size()
subnetMaskUint32 := ipUint32(net.IP(subnet.Mask))
inUse := big.NewInt(0)
for _, ip := range ipsInUse {
if !subnet.Contains(ip) {
continue
}
index := ipIndex(ip, subnetMaskUint32)
inUse = inUse.SetB... | go | {
"resource": ""
} |
q3954 | NthSubnetIP | train | func NthSubnetIP(subnet *net.IPNet, n int) net.IP {
ones, bits := subnet.Mask.Size()
base := ipUint32(subnet.IP)
var valid int
for i := reservedAddressRangeEnd + 1; i < (1<<uint64(bits-ones) - 1); i++ {
ip := uint32IP(base + uint32(i))
if !ip.IsGlobalUnicast() {
continue
}
if n == valid {
return ip
... | go | {
"resource": ""
} |
q3955 | processNewConfig | train | func (lf *LogForwarder) processNewConfig(currentSender SendCloser) (SendCloser, error) {
lf.mu.Lock()
defer lf.mu.Unlock()
closeExisting := func() error {
lf.enabled = false
// If we are already sending, close the current sender.
if currentSender != nil {
return currentSender.Close()
}
return nil
}
... | go | {
"resource": ""
} |
q3956 | waitForEnabled | train | func (lf *LogForwarder) waitForEnabled() (bool, error) {
lf.mu.Lock()
enabled := lf.enabled
lf.mu.Unlock()
if enabled {
return true, nil
}
select {
case <-lf.catacomb.Dying():
return false, tomb.ErrDying
case enabled = <-lf.enabledCh:
}
lf.mu.Lock()
defer lf.mu.Unlock()
if !lf.enabled && enabled {
l... | go | {
"resource": ""
} |
q3957 | NewLogForwarder | train | func NewLogForwarder(args OpenLogForwarderArgs) (*LogForwarder, error) {
lf := &LogForwarder{
args: args,
enabledCh: make(chan bool, 1),
}
err := catacomb.Invoke(catacomb.Plan{
Site: &lf.catacomb,
Work: func() error {
return errors.Trace(lf.loop())
},
})
if err != nil {
return nil, errors.Trace... | go | {
"resource": ""
} |
q3958 | watchProfileChangesLoop | train | func (m MutaterMachine) watchProfileChangesLoop(removed <-chan struct{}, profileChangeWatcher watcher.NotifyWatcher) error {
m.logger.Tracef("watching change on MutaterMachine %s", m.id)
for {
select {
case <-m.context.dying():
return m.context.errDying()
case <-profileChangeWatcher.Changes():
info, err :... | go | {
"resource": ""
} |
q3959 | NewControllerAPIv7 | train | func NewControllerAPIv7(ctx facade.Context) (*ControllerAPI, error) {
st := ctx.State()
authorizer := ctx.Auth()
pool := ctx.StatePool()
resources := ctx.Resources()
presence := ctx.Presence()
hub := ctx.Hub()
return NewControllerAPI(
st,
pool,
authorizer,
resources,
presence,
hub,
)
} | go | {
"resource": ""
} |
q3960 | NewControllerAPIv6 | train | func NewControllerAPIv6(ctx facade.Context) (*ControllerAPIv6, error) {
v7, err := NewControllerAPIv7(ctx)
if err != nil {
return nil, errors.Trace(err)
}
return &ControllerAPIv6{v7}, nil
} | go | {
"resource": ""
} |
q3961 | NewControllerAPIv5 | train | func NewControllerAPIv5(ctx facade.Context) (*ControllerAPIv5, error) {
v6, err := NewControllerAPIv6(ctx)
if err != nil {
return nil, errors.Trace(err)
}
return &ControllerAPIv5{v6}, nil
} | go | {
"resource": ""
} |
q3962 | NewControllerAPIv4 | train | func NewControllerAPIv4(ctx facade.Context) (*ControllerAPIv4, error) {
v5, err := NewControllerAPIv5(ctx)
if err != nil {
return nil, errors.Trace(err)
}
return &ControllerAPIv4{v5}, nil
} | go | {
"resource": ""
} |
q3963 | NewControllerAPIv3 | train | func NewControllerAPIv3(ctx facade.Context) (*ControllerAPIv3, error) {
v4, err := NewControllerAPIv4(ctx)
if err != nil {
return nil, errors.Trace(err)
}
return &ControllerAPIv3{v4}, nil
} | go | {
"resource": ""
} |
q3964 | NewControllerAPI | train | func NewControllerAPI(
st *state.State,
pool *state.StatePool,
authorizer facade.Authorizer,
resources facade.Resources,
presence facade.Presence,
hub facade.Hub,
) (*ControllerAPI, error) {
if !authorizer.AuthClient() {
return nil, errors.Trace(common.ErrPerm)
}
// Since we know this is a user tag (because... | go | {
"resource": ""
} |
q3965 | MongoVersion | train | func (c *ControllerAPI) MongoVersion() (params.StringResult, error) {
result := params.StringResult{}
if err := c.checkHasAdmin(); err != nil {
return result, errors.Trace(err)
}
version, err := c.state.MongoVersion()
if err != nil {
return result, errors.Trace(err)
}
result.Result = version
return result, ... | go | {
"resource": ""
} |
q3966 | ListBlockedModels | train | func (c *ControllerAPI) ListBlockedModels() (params.ModelBlockInfoList, error) {
results := params.ModelBlockInfoList{}
if err := c.checkHasAdmin(); err != nil {
return results, errors.Trace(err)
}
blocks, err := c.state.AllBlocksForController()
if err != nil {
return results, errors.Trace(err)
}
modelBlock... | go | {
"resource": ""
} |
q3967 | ModelConfig | train | func (c *ControllerAPI) ModelConfig() (params.ModelConfigResults, error) {
result := params.ModelConfigResults{}
if err := c.checkHasAdmin(); err != nil {
return result, errors.Trace(err)
}
controllerState := c.statePool.SystemState()
controllerModel, err := controllerState.Model()
if err != nil {
return res... | go | {
"resource": ""
} |
q3968 | HostedModelConfigs | train | func (c *ControllerAPI) HostedModelConfigs() (params.HostedModelConfigsResults, error) {
result := params.HostedModelConfigsResults{}
if err := c.checkHasAdmin(); err != nil {
return result, errors.Trace(err)
}
modelUUIDs, err := c.state.AllModelUUIDs()
if err != nil {
return result, errors.Trace(err)
}
fo... | go | {
"resource": ""
} |
q3969 | WatchAllModels | train | func (c *ControllerAPI) WatchAllModels() (params.AllWatcherId, error) {
if err := c.checkHasAdmin(); err != nil {
return params.AllWatcherId{}, errors.Trace(err)
}
w := c.state.WatchAllModels(c.statePool)
return params.AllWatcherId{
AllWatcherId: c.resources.Register(w),
}, nil
} | go | {
"resource": ""
} |
q3970 | GetControllerAccess | train | func (c *ControllerAPI) GetControllerAccess(req params.Entities) (params.UserAccessResults, error) {
results := params.UserAccessResults{}
isAdmin, err := c.authorizer.HasPermission(permission.SuperuserAccess, c.state.ControllerTag())
if err != nil {
return results, errors.Trace(err)
}
users := req.Entities
re... | go | {
"resource": ""
} |
q3971 | InitiateMigration | train | func (c *ControllerAPI) InitiateMigration(reqArgs params.InitiateMigrationArgs) (
params.InitiateMigrationResults, error,
) {
out := params.InitiateMigrationResults{
Results: make([]params.InitiateMigrationResult, len(reqArgs.Specs)),
}
if err := c.checkHasAdmin(); err != nil {
return out, errors.Trace(err)
}
... | go | {
"resource": ""
} |
q3972 | ModifyControllerAccess | train | func (c *ControllerAPI) ModifyControllerAccess(args params.ModifyControllerAccessRequest) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Changes)),
}
if len(args.Changes) == 0 {
return result, nil
}
hasPermission, err := c.authorizer.HasPermission(pe... | go | {
"resource": ""
} |
q3973 | ConfigSet | train | func (c *ControllerAPI) ConfigSet(args params.ControllerConfigSet) error {
if err := c.checkHasAdmin(); err != nil {
return errors.Trace(err)
}
if err := c.state.UpdateControllerConfig(args.Config, nil); err != nil {
return errors.Trace(err)
}
// TODO(thumper): add a version to controller config to allow for
... | go | {
"resource": ""
} |
q3974 | grantControllerCloudAccess | train | func grantControllerCloudAccess(accessor *state.State, targetUserTag names.UserTag, access permission.Access) error {
controllerInfo, err := accessor.ControllerInfo()
if err != nil {
return errors.Trace(err)
}
cloud := controllerInfo.CloudName
err = accessor.CreateCloudAccess(cloud, targetUserTag, access)
if er... | go | {
"resource": ""
} |
q3975 | ChangeControllerAccess | train | func ChangeControllerAccess(accessor *state.State, apiUser, targetUserTag names.UserTag, action params.ControllerAction, access permission.Access) error {
switch action {
case params.GrantControllerAccess:
err := grantControllerAccess(accessor, targetUserTag, apiUser, access)
if err != nil {
return errors.Anno... | go | {
"resource": ""
} |
q3976 | Check | train | func (t token) Check(attempt int, trapdoorKey interface{}) error {
// This validation, which could be done at Token creation time, is deferred
// until this point for historical reasons. In particular, this code was
// extracted from a *leadership* implementation which has a LeadershipCheck
// method returning a t... | go | {
"resource": ""
} |
q3977 | invoke | train | func (c check) invoke(ch chan<- check) error {
for {
select {
case <-c.stop:
return errStopped
case ch <- c:
ch = nil
case err := <-c.response:
return errors.Trace(err)
}
}
} | go | {
"resource": ""
} |
q3978 | respond | train | func (c check) respond(err error) {
select {
case <-c.stop:
case c.response <- err:
}
} | go | {
"resource": ""
} |
q3979 | NewDataSource | train | func NewDataSource(baseURL string) simplestreams.DataSource {
requireSigned := true
return simplestreams.NewURLSignedDataSource(
sourceDescription,
baseURL,
keys.JujuPublicKey,
utils.VerifySSLHostnames,
simplestreams.DEFAULT_CLOUD_DATA,
requireSigned)
} | go | {
"resource": ""
} |
q3980 | FetchMetadata | train | func FetchMetadata(stream string, sources ...simplestreams.DataSource) ([]*Metadata, error) {
params := simplestreams.GetMetadataParams{
StreamsVersion: streamsVersion,
LookupConstraint: &constraint{
LookupParams: simplestreams.LookupParams{Stream: stream},
majorVersion: jujuversion.Current.Major,
},
Val... | go | {
"resource": ""
} |
q3981 | appendArchives | train | func appendArchives(
source simplestreams.DataSource,
matchingItems []interface{},
items map[string]interface{},
cons simplestreams.LookupConstraint,
) ([]interface{}, error) {
var majorVersion int
if guiConstraint, ok := cons.(*constraint); ok {
majorVersion = guiConstraint.majorVersion
}
for _, item := rang... | go | {
"resource": ""
} |
q3982 | NewState | train | func NewState(caller base.APICaller) (*State, error) {
facadeCaller := base.NewFacadeCaller(caller, storageProvisionerFacade)
return &State{facadeCaller}, nil
} | go | {
"resource": ""
} |
q3983 | WatchVolumes | train | func (st *State) WatchVolumes(scope names.Tag) (watcher.StringsWatcher, error) {
return st.watchStorageEntities("WatchVolumes", scope)
} | go | {
"resource": ""
} |
q3984 | WatchVolumeAttachments | train | func (st *State) WatchVolumeAttachments(scope names.Tag) (watcher.MachineStorageIdsWatcher, error) {
return st.watchAttachments("WatchVolumeAttachments", scope, apiwatcher.NewVolumeAttachmentsWatcher)
} | go | {
"resource": ""
} |
q3985 | WatchVolumeAttachmentPlans | train | func (st *State) WatchVolumeAttachmentPlans(scope names.Tag) (watcher.MachineStorageIdsWatcher, error) {
return st.watchAttachments("WatchVolumeAttachmentPlans", scope, apiwatcher.NewVolumeAttachmentPlansWatcher)
} | go | {
"resource": ""
} |
q3986 | WatchFilesystemAttachments | train | func (st *State) WatchFilesystemAttachments(scope names.Tag) (watcher.MachineStorageIdsWatcher, error) {
return st.watchAttachments("WatchFilesystemAttachments", scope, apiwatcher.NewFilesystemAttachmentsWatcher)
} | go | {
"resource": ""
} |
q3987 | VolumeBlockDevices | train | func (st *State) VolumeBlockDevices(ids []params.MachineStorageId) ([]params.BlockDeviceResult, error) {
args := params.MachineStorageIds{ids}
var results params.BlockDeviceResults
err := st.facade.FacadeCall("VolumeBlockDevices", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != len(... | go | {
"resource": ""
} |
q3988 | VolumeParams | train | func (st *State) VolumeParams(tags []names.VolumeTag) ([]params.VolumeParamsResult, error) {
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
var results params.VolumeParamsResults
err := st.facade.FacadeCall("VolumeParams"... | go | {
"resource": ""
} |
q3989 | VolumeAttachmentParams | train | func (st *State) VolumeAttachmentParams(ids []params.MachineStorageId) ([]params.VolumeAttachmentParamsResult, error) {
args := params.MachineStorageIds{ids}
var results params.VolumeAttachmentParamsResults
err := st.facade.FacadeCall("VolumeAttachmentParams", args, &results)
if err != nil {
return nil, err
}
i... | go | {
"resource": ""
} |
q3990 | FilesystemAttachmentParams | train | func (st *State) FilesystemAttachmentParams(ids []params.MachineStorageId) ([]params.FilesystemAttachmentParamsResult, error) {
args := params.MachineStorageIds{ids}
var results params.FilesystemAttachmentParamsResults
err := st.facade.FacadeCall("FilesystemAttachmentParams", args, &results)
if err != nil {
retur... | go | {
"resource": ""
} |
q3991 | Life | train | func (st *State) Life(tags []names.Tag) ([]params.LifeResult, error) {
var results params.LifeResults
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
if err := st.facade.FacadeCall("Life", args, &results); err != nil {
r... | go | {
"resource": ""
} |
q3992 | AttachmentLife | train | func (st *State) AttachmentLife(ids []params.MachineStorageId) ([]params.LifeResult, error) {
var results params.LifeResults
args := params.MachineStorageIds{ids}
if err := st.facade.FacadeCall("AttachmentLife", args, &results); err != nil {
return nil, err
}
if len(results.Results) != len(ids) {
return nil, e... | go | {
"resource": ""
} |
q3993 | EnsureDead | train | func (st *State) EnsureDead(tags []names.Tag) ([]params.ErrorResult, error) {
var results params.ErrorResults
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
if err := st.facade.FacadeCall("EnsureDead", args, &results); er... | go | {
"resource": ""
} |
q3994 | RemoveAttachments | train | func (st *State) RemoveAttachments(ids []params.MachineStorageId) ([]params.ErrorResult, error) {
var results params.ErrorResults
args := params.MachineStorageIds{ids}
if err := st.facade.FacadeCall("RemoveAttachment", args, &results); err != nil {
return nil, err
}
if len(results.Results) != len(ids) {
return... | go | {
"resource": ""
} |
q3995 | InstanceIds | train | func (st *State) InstanceIds(tags []names.MachineTag) ([]params.StringResult, error) {
var results params.StringResults
args := params.Entities{
Entities: make([]params.Entity, len(tags)),
}
for i, tag := range tags {
args.Entities[i].Tag = tag.String()
}
err := st.facade.FacadeCall("InstanceId", args, &resul... | go | {
"resource": ""
} |
q3996 | SetStatus | train | func (st *State) SetStatus(args []params.EntityStatusArgs) error {
var result params.ErrorResults
err := st.facade.FacadeCall("SetStatus", params.SetStatus{args}, &result)
if err != nil {
return err
}
return result.Combine()
} | go | {
"resource": ""
} |
q3997 | newSubordinateRelationsWatcher | train | func newSubordinateRelationsWatcher(backend *state.State, subordinateApp *state.Application, principalName string) (
state.StringsWatcher, error,
) {
w := &subRelationsWatcher{
backend: backend,
app: subordinateApp,
principalName: principalName,
relations: make(map[string]bool),
out: ... | go | {
"resource": ""
} |
q3998 | OneError | train | func (m *MetricResults) OneError() error {
for _, r := range m.Results {
if err := r.Error; err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q3999 | Validate | train | func (hi Info) Validate() error {
switch hi.Kind {
case hooks.RelationJoined, hooks.RelationChanged, hooks.RelationDeparted:
if hi.RemoteUnit == "" {
return fmt.Errorf("%q hook requires a remote unit", hi.Kind)
}
fallthrough
case hooks.Install, hooks.Start, hooks.ConfigChanged, hooks.UpgradeCharm, hooks.Sto... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.