_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q3500 | DestroyController | train | func (m *MockZonedEnviron) DestroyController(arg0 context.ProviderCallContext, arg1 string) error {
ret := m.ctrl.Call(m, "DestroyController", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3501 | InstanceTypes | train | func (m *MockZonedEnviron) InstanceTypes(arg0 context.ProviderCallContext, arg1 constraints.Value) (instances.InstanceTypesWithCostMetadata, error) {
ret := m.ctrl.Call(m, "InstanceTypes", arg0, arg1)
ret0, _ := ret[0].(instances.InstanceTypesWithCostMetadata)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3502 | Instances | train | func (m *MockZonedEnviron) Instances(arg0 context.ProviderCallContext, arg1 []instance.Id) ([]instances.Instance, error) {
ret := m.ctrl.Call(m, "Instances", arg0, arg1)
ret0, _ := ret[0].([]instances.Instance)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3503 | MaintainInstance | train | func (m *MockZonedEnviron) MaintainInstance(arg0 context.ProviderCallContext, arg1 environs.StartInstanceParams) error {
ret := m.ctrl.Call(m, "MaintainInstance", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3504 | PrecheckInstance | train | func (m *MockZonedEnviron) PrecheckInstance(arg0 context.ProviderCallContext, arg1 environs.PrecheckInstanceParams) error {
ret := m.ctrl.Call(m, "PrecheckInstance", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3505 | PrepareForBootstrap | train | func (m *MockZonedEnviron) PrepareForBootstrap(arg0 environs.BootstrapContext, arg1 string) error {
ret := m.ctrl.Call(m, "PrepareForBootstrap", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3506 | Provider | train | func (m *MockZonedEnviron) Provider() environs.EnvironProvider {
ret := m.ctrl.Call(m, "Provider")
ret0, _ := ret[0].(environs.EnvironProvider)
return ret0
} | go | {
"resource": ""
} |
q3507 | SetConfig | train | func (m *MockZonedEnviron) SetConfig(arg0 *config.Config) error {
ret := m.ctrl.Call(m, "SetConfig", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3508 | StopInstances | train | func (m *MockZonedEnviron) StopInstances(arg0 context.ProviderCallContext, arg1 ...instance.Id) error {
varargs := []interface{}{arg0}
for _, a := range arg1 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "StopInstances", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q3509 | StorageProvider | train | func (m *MockZonedEnviron) StorageProvider(arg0 storage.ProviderType) (storage.Provider, error) {
ret := m.ctrl.Call(m, "StorageProvider", arg0)
ret0, _ := ret[0].(storage.Provider)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3510 | StorageProvider | train | func (mr *MockZonedEnvironMockRecorder) StorageProvider(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageProvider", reflect.TypeOf((*MockZonedEnviron)(nil).StorageProvider), arg0)
} | go | {
"resource": ""
} |
q3511 | StorageProviderTypes | train | func (m *MockZonedEnviron) StorageProviderTypes() ([]storage.ProviderType, error) {
ret := m.ctrl.Call(m, "StorageProviderTypes")
ret0, _ := ret[0].([]storage.ProviderType)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q3512 | NewStorageAddCommand | train | func NewStorageAddCommand(ctx Context) (cmd.Command, error) {
return &StorageAddCommand{ctx: ctx}, nil
} | go | {
"resource": ""
} |
q3513 | IAASManifolds | train | func IAASManifolds(config ManifoldsConfig) dependency.Manifolds {
var externalUpdateProxyFunc func(proxy.Settings) error
if runtime.GOOS == "linux" {
externalUpdateProxyFunc = lxd.ConfigureLXDProxies
}
manifolds := dependency.Manifolds{
toolsVersionCheckerName: ifNotMigrating(toolsversionchecker.Manifold(toolsv... | go | {
"resource": ""
} |
q3514 | CAASManifolds | train | func CAASManifolds(config ManifoldsConfig) dependency.Manifolds {
return mergeManifolds(config, dependency.Manifolds{
// TODO(caas) - when we support HA, only want this on primary
upgraderName: caasupgrader.Manifold(caasupgrader.ManifoldConfig{
AgentName: agentName,
APICallerName: apiCaller... | go | {
"resource": ""
} |
q3515 | OpenPorts | train | func (c *rackspaceFirewaller) OpenPorts(ctx context.ProviderCallContext, rules []network.IngressRule) error {
return errors.NotSupportedf("OpenPorts")
} | go | {
"resource": ""
} |
q3516 | IngressRules | train | func (c *rackspaceFirewaller) IngressRules(ctx context.ProviderCallContext) ([]network.IngressRule, error) {
return nil, errors.NotSupportedf("Ports")
} | go | {
"resource": ""
} |
q3517 | DeleteGroups | train | func (c *rackspaceFirewaller) DeleteGroups(ctx context.ProviderCallContext, names ...string) error {
return nil
} | go | {
"resource": ""
} |
q3518 | DeleteAllControllerGroups | train | func (c *rackspaceFirewaller) DeleteAllControllerGroups(ctx context.ProviderCallContext, controllerUUID string) error {
return nil
} | go | {
"resource": ""
} |
q3519 | GetSecurityGroups | train | func (c *rackspaceFirewaller) GetSecurityGroups(ctx context.ProviderCallContext, ids ...instance.Id) ([]string, error) {
return nil, nil
} | go | {
"resource": ""
} |
q3520 | SetUpGroups | train | func (c *rackspaceFirewaller) SetUpGroups(ctx context.ProviderCallContext, controllerUUID, machineId string, apiPort int) ([]string, error) {
return nil, nil
} | go | {
"resource": ""
} |
q3521 | filesystemsChanged | train | func filesystemsChanged(ctx *context, changes []string) error {
tags := make([]names.Tag, len(changes))
for i, change := range changes {
tags[i] = names.NewFilesystemTag(change)
}
alive, dying, dead, err := storageEntityLife(ctx, tags)
if err != nil {
return errors.Trace(err)
}
logger.Debugf("filesystems ali... | go | {
"resource": ""
} |
q3522 | filesystemAttachmentsChanged | train | func filesystemAttachmentsChanged(ctx *context, watcherIds []watcher.MachineStorageId) error {
ids := copyMachineStorageIds(watcherIds)
alive, dying, dead, err := attachmentLife(ctx, ids)
if err != nil {
return errors.Trace(err)
}
logger.Debugf("filesystem attachment alive: %v, dying: %v, dead: %v", alive, dying... | go | {
"resource": ""
} |
q3523 | processDyingFilesystems | train | func processDyingFilesystems(ctx *context, tags []names.FilesystemTag, filesystemResults []params.FilesystemResult) error {
for _, tag := range tags {
removePendingFilesystem(ctx, tag)
}
return nil
} | go | {
"resource": ""
} |
q3524 | updatePendingFilesystemAttachment | train | func updatePendingFilesystemAttachment(
ctx *context,
id params.MachineStorageId,
params storage.FilesystemAttachmentParams,
) {
var incomplete bool
filesystem, ok := ctx.filesystems[params.Filesystem]
if !ok {
incomplete = true
} else {
params.FilesystemId = filesystem.FilesystemId
if filesystem.Volume !=... | go | {
"resource": ""
} |
q3525 | processDeadFilesystems | train | func processDeadFilesystems(ctx *context, tags []names.FilesystemTag, filesystemResults []params.FilesystemResult) error {
for _, tag := range tags {
removePendingFilesystem(ctx, tag)
}
var destroy []names.FilesystemTag
var remove []names.Tag
for i, result := range filesystemResults {
tag := tags[i]
if resul... | go | {
"resource": ""
} |
q3526 | processDyingFilesystemAttachments | train | func processDyingFilesystemAttachments(
ctx *context,
ids []params.MachineStorageId,
filesystemAttachmentResults []params.FilesystemAttachmentResult,
) error {
for _, id := range ids {
removePendingFilesystemAttachment(ctx, id)
}
detach := make([]params.MachineStorageId, 0, len(ids))
remove := make([]params.Ma... | go | {
"resource": ""
} |
q3527 | processAliveFilesystems | train | func processAliveFilesystems(ctx *context, tags []names.FilesystemTag, filesystemResults []params.FilesystemResult) error {
// Filter out the already-provisioned filesystems.
pending := make([]names.FilesystemTag, 0, len(tags))
for i, result := range filesystemResults {
tag := tags[i]
if result.Error == nil {
... | go | {
"resource": ""
} |
q3528 | processAliveFilesystemAttachments | train | func processAliveFilesystemAttachments(
ctx *context,
ids []params.MachineStorageId,
filesystemAttachmentResults []params.FilesystemAttachmentResult,
) error {
// Filter out the already-attached.
pending := make([]params.MachineStorageId, 0, len(ids))
for i, result := range filesystemAttachmentResults {
if resu... | go | {
"resource": ""
} |
q3529 | filesystemAttachmentParams | train | func filesystemAttachmentParams(
ctx *context, ids []params.MachineStorageId,
) ([]storage.FilesystemAttachmentParams, error) {
paramsResults, err := ctx.config.Filesystems.FilesystemAttachmentParams(ids)
if err != nil {
return nil, errors.Annotate(err, "getting filesystem attachment params")
}
attachmentParams ... | go | {
"resource": ""
} |
q3530 | filesystemParams | train | func filesystemParams(ctx *context, tags []names.FilesystemTag) ([]storage.FilesystemParams, error) {
paramsResults, err := ctx.config.Filesystems.FilesystemParams(tags)
if err != nil {
return nil, errors.Annotate(err, "getting filesystem params")
}
allParams := make([]storage.FilesystemParams, len(tags))
for i,... | go | {
"resource": ""
} |
q3531 | removeFilesystemParams | train | func removeFilesystemParams(ctx *context, tags []names.FilesystemTag) ([]params.RemoveFilesystemParams, error) {
paramsResults, err := ctx.config.Filesystems.RemoveFilesystemParams(tags)
if err != nil {
return nil, errors.Annotate(err, "getting filesystem params")
}
allParams := make([]params.RemoveFilesystemPara... | go | {
"resource": ""
} |
q3532 | extractCatalogsForProducts | train | func (metadata *CloudMetadata) extractCatalogsForProducts(productIds []string) []MetadataCatalog {
result := []MetadataCatalog{}
for _, id := range productIds {
if catalog, ok := metadata.Products[id]; ok {
result = append(result, catalog)
}
}
return result
} | go | {
"resource": ""
} |
q3533 | extractIndexes | train | func (ind *Indices) extractIndexes(indexIds []string) IndexMetadataSlice {
result := make(IndexMetadataSlice, 0, len(ind.Indexes))
if len(indexIds) == 0 {
// No ids specified so return everything.
for _, metadata := range ind.Indexes {
result = append(result, metadata)
}
} else {
// Return metadata for ju... | go | {
"resource": ""
} |
q3534 | hasCloud | train | func (metadata *IndexMetadata) hasCloud(cloud CloudSpec) bool {
for _, metadataCloud := range metadata.Clouds {
if metadataCloud.equals(&cloud) {
return true
}
}
return len(metadata.Clouds) == 0
} | go | {
"resource": ""
} |
q3535 | hasProduct | train | func (metadata *IndexMetadata) hasProduct(prodIds []string) bool {
for _, pid := range metadata.ProductIds {
if containsString(prodIds, pid) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q3536 | filter | train | func (entries IndexMetadataSlice) filter(match func(*IndexMetadata) bool) IndexMetadataSlice {
result := IndexMetadataSlice{}
for _, metadata := range entries {
if match(metadata) {
result = append(result, metadata)
}
}
return result
} | go | {
"resource": ""
} |
q3537 | UnsignedIndex | train | func UnsignedIndex(streamsVersion string, indexFileVersion int) string {
indexFileSuffix := ""
if indexFileVersion > 1 {
indexFileSuffix = fmt.Sprintf("%d", indexFileVersion)
}
return fmt.Sprintf(unsignedIndex, streamsVersion, indexFileSuffix)
} | go | {
"resource": ""
} |
q3538 | getMaybeSignedMetadata | train | func getMaybeSignedMetadata(source DataSource, params GetMetadataParams, signed bool) ([]interface{}, *ResolveInfo, error) {
makeIndexPath := func(basePath string) string {
pathNoSuffix := fmt.Sprintf(basePath, params.StreamsVersion)
indexPath := pathNoSuffix + UnsignedSuffix
if signed {
indexPath = pathNoSu... | go | {
"resource": ""
} |
q3539 | fetchIndex | train | func fetchIndex(source DataSource, indexPath string, mirrorsPath string, cloudSpec CloudSpec,
signed bool, params ValueParams) (indexRef *IndexReference, indexURL string, _ error) {
indexURL, err := source.URL(indexPath)
if err != nil {
// Some providers return an error if asked for the URL of a non-existent file.... | go | {
"resource": ""
} |
q3540 | fetchData | train | func fetchData(source DataSource, path string, requireSigned bool) (data []byte, dataURL string, err error) {
rc, dataURL, err := source.Fetch(path)
if err != nil {
logger.Tracef("fetchData failed for %q: %v", dataURL, err)
return nil, dataURL, errors.NotFoundf("invalid URL %q", dataURL)
}
defer rc.Close()
if ... | go | {
"resource": ""
} |
q3541 | GetIndexWithFormat | train | func GetIndexWithFormat(source DataSource, indexPath, indexFormat, mirrorsPath string, requireSigned bool,
cloudSpec CloudSpec, params ValueParams) (*IndexReference, error) {
data, url, err := fetchData(source, indexPath, requireSigned)
if err != nil {
if errors.IsNotFound(err) || errors.IsUnauthorized(err) {
... | go | {
"resource": ""
} |
q3542 | getMirrorRefs | train | func getMirrorRefs(source DataSource, baseMirrorsPath string, requireSigned bool,
params ValueParams) (MirrorRefs, string, error) {
mirrorsPath := baseMirrorsPath + UnsignedSuffix
if requireSigned {
mirrorsPath = baseMirrorsPath + SignedSuffix
}
var mirrors MirrorRefs
data, url, err := fetchData(source, mirror... | go | {
"resource": ""
} |
q3543 | getMirror | train | func getMirror(source DataSource, mirrors MirrorRefs, datatype, contentId string, cloudSpec CloudSpec,
requireSigned bool) (*MirrorInfo, error) {
mirrorRef, err := mirrors.getMirrorReference(datatype, contentId, cloudSpec)
if err != nil {
return nil, err
}
mirrorInfo, err := mirrorRef.getMirrorInfo(source, cont... | go | {
"resource": ""
} |
q3544 | GetProductsPath | train | func (indexRef *IndexReference) GetProductsPath(cons LookupConstraint) (string, error) {
if indexRef.MirroredProductsPath != "" {
return indexRef.MirroredProductsPath, nil
}
prodIds, err := cons.ProductIds()
if err != nil {
return "", err
}
candidates := indexRef.extractIndexes(cons.IndexIds())
// Restrict t... | go | {
"resource": ""
} |
q3545 | extractMirrorRefs | train | func (mirrorRefs *MirrorRefs) extractMirrorRefs(contentId string) MirrorRefSlice {
for id, refs := range mirrorRefs.Mirrors {
if id == contentId {
return refs
}
}
return nil
} | go | {
"resource": ""
} |
q3546 | hasCloud | train | func (mirrorRef *MirrorReference) hasCloud(cloud CloudSpec) bool {
for _, refCloud := range mirrorRef.Clouds {
if refCloud.equals(&cloud) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q3547 | getMirrorReference | train | func (mirrorRefs *MirrorRefs) getMirrorReference(datatype, contentId string, cloud CloudSpec) (*MirrorReference, error) {
candidates := mirrorRefs.extractMirrorRefs(contentId)
if len(candidates) == 0 {
return nil, errors.NotFoundf("mirror data for %q", contentId)
}
// Restrict by cloud spec and datatype.
hasRigh... | go | {
"resource": ""
} |
q3548 | getMirrorInfo | train | func (mirrorRef *MirrorReference) getMirrorInfo(source DataSource, contentId string, cloud CloudSpec, format string,
requireSigned bool) (*MirrorInfo, error) {
metadata, err := GetMirrorMetadataWithFormat(source, mirrorRef.Path, format, requireSigned)
if err != nil {
return nil, err
}
mirrorInfo, err := metadat... | go | {
"resource": ""
} |
q3549 | GetMirrorMetadataWithFormat | train | func GetMirrorMetadataWithFormat(source DataSource, mirrorPath, format string,
requireSigned bool) (*MirrorMetadata, error) {
data, url, err := fetchData(source, mirrorPath, requireSigned)
if err != nil {
if errors.IsNotFound(err) || errors.IsUnauthorized(err) {
return nil, err
}
return nil, fmt.Errorf("ca... | go | {
"resource": ""
} |
q3550 | hasCloud | train | func (mirrorInfo *MirrorInfo) hasCloud(cloud CloudSpec) bool {
for _, metadataCloud := range mirrorInfo.Clouds {
if metadataCloud.equals(&cloud) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q3551 | getMirrorInfo | train | func (mirrorMetadata *MirrorMetadata) getMirrorInfo(contentId string, cloud CloudSpec) (*MirrorInfo, error) {
var candidates MirrorInfoSlice
for id, m := range mirrorMetadata.Mirrors {
if id == contentId {
candidates = m
break
}
}
if len(candidates) == 0 {
return nil, errors.NotFoundf("mirror info for %... | go | {
"resource": ""
} |
q3552 | containsString | train | func containsString(values []string, element string) bool {
for _, value := range values {
if value == element {
return true
}
}
return false
} | go | {
"resource": ""
} |
q3553 | processAliases | train | func (metadata *CloudMetadata) processAliases(item interface{}) {
for tag := range tags(item) {
aliases, ok := metadata.Aliases[tag]
if !ok {
continue
}
// We have found a set of aliases for one of the fields in the metadata struct.
// Now check to see if the field matches one of the defined aliases.
fi... | go | {
"resource": ""
} |
q3554 | applyAliases | train | func (metadata *CloudMetadata) applyAliases() {
for _, metadataCatalog := range metadata.Products {
for _, ItemCollection := range metadataCatalog.Items {
for _, item := range ItemCollection.Items {
metadata.processAliases(item)
}
}
}
} | go | {
"resource": ""
} |
q3555 | construct | train | func (metadata *CloudMetadata) construct(valueType reflect.Type) error {
for _, metadataCatalog := range metadata.Products {
for _, ItemCollection := range metadataCatalog.Items {
if err := ItemCollection.construct(valueType); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q3556 | GetCloudMetadataWithFormat | train | func (indexRef *IndexReference) GetCloudMetadataWithFormat(cons LookupConstraint, format string, requireSigned bool) (*CloudMetadata, error) {
productFilesPath, err := indexRef.GetProductsPath(cons)
if err != nil {
return nil, err
}
logger.Tracef("finding products at path %q", productFilesPath)
data, url, err :=... | go | {
"resource": ""
} |
q3557 | ParseCloudMetadata | train | func ParseCloudMetadata(data []byte, format, url string, valueTemplate interface{}) (*CloudMetadata, error) {
var metadata CloudMetadata
err := json.Unmarshal(data, &metadata)
if err != nil {
return nil, fmt.Errorf("cannot unmarshal JSON metadata at URL %q: %v", url, err)
}
if metadata.Format != format {
retur... | go | {
"resource": ""
} |
q3558 | paramsFromProviderSpaceInfo | train | func paramsFromProviderSpaceInfo(info *environs.ProviderSpaceInfo) params.RemoteSpace {
result := params.RemoteSpace{
CloudType: info.CloudType,
Name: info.Name,
ProviderId: string(info.ProviderId),
ProviderAttributes: info.ProviderAttributes,
}
for _, subnet := range info.Subn... | go | {
"resource": ""
} |
q3559 | spaceInfoFromState | train | func spaceInfoFromState(space Space) (*network.SpaceInfo, error) {
result := &network.SpaceInfo{
Name: space.Name(),
ProviderId: space.ProviderId(),
}
subnets, err := space.Subnets()
if err != nil {
return nil, errors.Trace(err)
}
for _, subnet := range subnets {
resultSubnet := network.SubnetInfo{
... | go | {
"resource": ""
} |
q3560 | findInstanceSpec | train | func findInstanceSpec(
e *Environ,
ic *instances.InstanceConstraint,
imageMetadata []*imagemetadata.ImageMetadata,
) (*instances.InstanceSpec, error) {
// First construct all available instance types from the supported flavors.
nova := e.nova()
flavors, err := nova.ListFlavorsDetail()
if err != nil {
return ni... | go | {
"resource": ""
} |
q3561 | NewClient | train | func NewClient(caller base.APICaller, newWatcher NewWatcherFunc) (*Client, error) {
modelTag, ok := caller.ModelTag()
if !ok {
return nil, errors.New("undertaker client is not appropriate for controller-only API")
}
return &Client{
modelTag: modelTag,
caller: base.NewFacadeCaller(caller, "Undertaker"),
... | go | {
"resource": ""
} |
q3562 | WatchModelResources | train | func (c *Client) WatchModelResources() (watcher.NotifyWatcher, error) {
var results params.NotifyWatchResults
err := c.entityFacadeCall("WatchModelResources", &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))... | go | {
"resource": ""
} |
q3563 | NewFirewall | train | func NewFirewall(cfg environs.ConfigGetter, client FirewallerAPI, c clock.Clock) *Firewall {
return &Firewall{
environ: cfg,
client: client,
clock: c,
}
} | go | {
"resource": ""
} |
q3564 | OpenPorts | train | func (f Firewall) OpenPorts(ctx context.ProviderCallContext, rules []network.IngressRule) error {
mode := f.environ.Config().FirewallMode()
if mode != config.FwGlobal {
return fmt.Errorf(
"invalid firewall mode %q for opening ports on model",
mode,
)
}
globalGroupName := f.globalGroupName()
seclist, err... | go | {
"resource": ""
} |
q3565 | ClosePorts | train | func (f Firewall) ClosePorts(ctx context.ProviderCallContext, rules []network.IngressRule) error {
groupName := f.globalGroupName()
return f.closePortsOnList(ctx, f.client.ComposeName(groupName), rules)
} | go | {
"resource": ""
} |
q3566 | IngressRules | train | func (f Firewall) IngressRules(ctx context.ProviderCallContext) ([]network.IngressRule, error) {
return f.GlobalIngressRules(ctx)
} | go | {
"resource": ""
} |
q3567 | MachineIngressRules | train | func (f Firewall) MachineIngressRules(ctx context.ProviderCallContext, machineId string) ([]network.IngressRule, error) {
seclist := f.machineGroupName(machineId)
return f.getIngressRules(ctx, f.client.ComposeName(seclist))
} | go | {
"resource": ""
} |
q3568 | OpenPortsOnInstance | train | func (f Firewall) OpenPortsOnInstance(ctx context.ProviderCallContext, machineId string, rules []network.IngressRule) error {
machineGroup := f.machineGroupName(machineId)
seclist, err := f.ensureSecList(f.client.ComposeName(machineGroup))
if err != nil {
return errors.Trace(err)
}
err = f.ensureSecRules(seclist... | go | {
"resource": ""
} |
q3569 | ClosePortsOnInstance | train | func (f Firewall) ClosePortsOnInstance(ctx context.ProviderCallContext, machineId string, rules []network.IngressRule) error {
// fetch the group name based on the machine id provided
groupName := f.machineGroupName(machineId)
return f.closePortsOnList(ctx, f.client.ComposeName(groupName), rules)
} | go | {
"resource": ""
} |
q3570 | CreateMachineSecLists | train | func (f Firewall) CreateMachineSecLists(machineId string, apiPort int) ([]string, error) {
defaultSecList, err := f.createDefaultGroupAndRules(apiPort)
if err != nil {
return nil, errors.Trace(err)
}
name := f.machineGroupName(machineId)
resourceName := f.client.ComposeName(name)
secList, err := f.ensureSecList... | go | {
"resource": ""
} |
q3571 | DeleteMachineSecList | train | func (f Firewall) DeleteMachineSecList(machineId string) error {
listName := f.machineGroupName(machineId)
globalListName := f.globalGroupName()
err := f.maybeDeleteList(f.client.ComposeName(listName))
if err != nil {
return errors.Trace(err)
}
// check if we can delete the global list as well
err = f.maybeDel... | go | {
"resource": ""
} |
q3572 | RemoveACLAndRules | train | func (f Firewall) RemoveACLAndRules(machineId string) error {
groupName := f.machineGroupName(machineId)
resourceName := f.client.ComposeName(groupName)
secRules, err := f.getAllSecurityRules(resourceName)
if err != nil {
return err
}
for _, val := range secRules {
err := f.client.DeleteSecurityRule(val.Name)... | go | {
"resource": ""
} |
q3573 | GlobalIngressRules | train | func (f Firewall) GlobalIngressRules(ctx context.ProviderCallContext) ([]network.IngressRule, error) {
seclist := f.globalGroupName()
return f.getIngressRules(ctx, f.client.ComposeName(seclist))
} | go | {
"resource": ""
} |
q3574 | getDefaultIngressRules | train | func (f Firewall) getDefaultIngressRules(apiPort int) []network.IngressRule {
return []network.IngressRule{
{
PortRange: corenetwork.PortRange{
FromPort: 22,
ToPort: 22,
Protocol: "tcp",
},
SourceCIDRs: []string{
"0.0.0.0/0",
},
},
{
PortRange: corenetwork.PortRange{
FromPort... | go | {
"resource": ""
} |
q3575 | closePortsOnList | train | func (f Firewall) closePortsOnList(ctx context.ProviderCallContext, list string, rules []network.IngressRule) error {
// get all security rules based on the dst_list=list
secrules, err := f.getSecRules(list)
if err != nil {
return errors.Trace(err)
}
// converts all security rules into a map of ingress rules
ma... | go | {
"resource": ""
} |
q3576 | deleteAllSecRulesOnList | train | func (f Firewall) deleteAllSecRulesOnList(list string) error {
// get all security rules associated with this list
secrules, err := f.getSecRules(list)
if err != nil {
return errors.Trace(err)
}
// delete everything
for _, rule := range secrules {
err := f.client.DeleteSecRule(rule.Name)
if err != nil {
... | go | {
"resource": ""
} |
q3577 | maybeDeleteList | train | func (f *Firewall) maybeDeleteList(list string) error {
filter := []api.Filter{
{
Arg: "seclist",
Value: list,
},
}
iter := 0
found := true
var assoc response.AllSecAssociations
for {
if iter >= 10 {
break
}
assoc, err := f.client.AllSecAssociations(filter)
if err != nil {
return errors.... | go | {
"resource": ""
} |
q3578 | getAllApplications | train | func (f Firewall) getAllApplications() ([]response.SecApplication, error) {
// get all user defined sec applications
applications, err := f.client.AllSecApplications(nil)
if err != nil {
return nil, errors.Trace(err)
}
// get also default ones defined in the provider
defaultApps, err := f.client.DefaultSecAppli... | go | {
"resource": ""
} |
q3579 | getAllApplicationsAsMap | train | func (f Firewall) getAllApplicationsAsMap() (map[string]response.SecApplication, error) {
// get all defined protocols
// from the current identity and default ones
apps, err := f.getAllApplications()
if err != nil {
return nil, errors.Trace(err)
}
// copy all of them into this map
allApps := map[string]respon... | go | {
"resource": ""
} |
q3580 | convertToSecRules | train | func (f Firewall) convertToSecRules(seclist response.SecList, rules []network.IngressRule) ([]api.SecRuleParams, error) {
applications, err := f.getAllApplications()
if err != nil {
return nil, errors.Trace(err)
}
iplists, err := f.getAllIPLists()
if err != nil {
return nil, errors.Trace(err)
}
ret := make(... | go | {
"resource": ""
} |
q3581 | convertApplicationToPortRange | train | func (f Firewall) convertApplicationToPortRange(app response.SecApplication) corenetwork.PortRange {
appCopy := app
if appCopy.Value2 == -1 {
appCopy.Value2 = appCopy.Value1
}
return corenetwork.PortRange{
FromPort: appCopy.Value1,
ToPort: appCopy.Value2,
Protocol: string(appCopy.Protocol),
}
} | go | {
"resource": ""
} |
q3582 | convertFromSecRules | train | func (f Firewall) convertFromSecRules(rules ...response.SecRule) (map[string][]network.IngressRule, error) {
applications, err := f.getAllApplicationsAsMap()
if err != nil {
return nil, errors.Trace(err)
}
iplists, err := f.getAllIPListsAsMap()
if err != nil {
return nil, errors.Trace(err)
}
ret := map[str... | go | {
"resource": ""
} |
q3583 | globalGroupName | train | func (f Firewall) globalGroupName() string {
return fmt.Sprintf("juju-%s-global", f.environ.Config().UUID())
} | go | {
"resource": ""
} |
q3584 | machineGroupName | train | func (f Firewall) machineGroupName(machineId string) string {
return fmt.Sprintf("juju-%s-%s", f.environ.Config().UUID(), machineId)
} | go | {
"resource": ""
} |
q3585 | newResourceName | train | func (f Firewall) newResourceName(appName string) string {
return fmt.Sprintf("juju-%s-%s", f.environ.Config().UUID(), appName)
} | go | {
"resource": ""
} |
q3586 | getAllSecurityRules | train | func (f Firewall) getAllSecurityRules(aclName string) ([]response.SecurityRule, error) {
rules, err := f.client.AllSecurityRules(nil)
if err != nil {
return nil, err
}
if aclName == "" {
return rules.Result, nil
}
var ret []response.SecurityRule
for _, val := range rules.Result {
if val.Acl == aclName {
... | go | {
"resource": ""
} |
q3587 | getSecRules | train | func (f Firewall) getSecRules(seclist string) ([]response.SecRule, error) {
// we only care about ingress rules
name := fmt.Sprintf("seclist:%s", seclist)
rulesFilter := []api.Filter{
{
Arg: "dst_list",
Value: name,
},
}
rules, err := f.client.AllSecRules(rulesFilter)
if err != nil {
return nil, err... | go | {
"resource": ""
} |
q3588 | ensureSecRules | train | func (f Firewall) ensureSecRules(seclist response.SecList, rules []network.IngressRule) error {
// get all security rules associated with the seclist
secRules, err := f.getSecRules(seclist.Name)
if err != nil {
return errors.Trace(err)
}
logger.Tracef("list %v has sec rules: %v", seclist.Name, secRules)
conver... | go | {
"resource": ""
} |
q3589 | ensureSecList | train | func (f Firewall) ensureSecList(name string) (response.SecList, error) {
logger.Infof("Fetching details for list: %s", name)
// check if the security list is already there
details, err := f.client.SecListDetails(name)
if err != nil {
logger.Infof("Got error fetching details for %s: %v", name, err)
if api.IsNotF... | go | {
"resource": ""
} |
q3590 | getAllIPListsAsMap | train | func (f Firewall) getAllIPListsAsMap() (map[string]response.SecIpList, error) {
allIps, err := f.getAllIPLists()
if err != nil {
return nil, errors.Trace(err)
}
allIpLists := map[string]response.SecIpList{}
for _, val := range allIps {
allIpLists[val.Name] = val
}
return allIpLists, nil
} | go | {
"resource": ""
} |
q3591 | ensureSecIpList | train | func (f Firewall) ensureSecIpList(cidr []string, cache *[]response.SecIpList) (string, error) {
sort.Strings(cidr)
for _, val := range *cache {
sort.Strings(val.Secipentries)
if reflect.DeepEqual(val.Secipentries, cidr) {
return val.Name, nil
}
}
uuid, err := utils.NewUUID()
if err != nil {
return "", e... | go | {
"resource": ""
} |
q3592 | sendError | train | func (h *backupHandler) sendError(w http.ResponseWriter, err error) {
err, status := common.ServerErrorAndStatus(err)
if err := sendStatusAndJSON(w, status, err); err != nil {
logger.Errorf("%v", err)
}
} | go | {
"resource": ""
} |
q3593 | Get | train | func (rs *Resources) Get(id string) facade.Resource {
rs.mu.Lock()
defer rs.mu.Unlock()
return rs.resources[id]
} | go | {
"resource": ""
} |
q3594 | Register | train | func (rs *Resources) Register(r facade.Resource) string {
rs.mu.Lock()
defer rs.mu.Unlock()
rs.maxId++
id := strconv.FormatUint(rs.maxId, 10)
rs.resources[id] = r
rs.stack = append(rs.stack, id)
logger.Tracef("registered unnamed resource: %s", id)
return id
} | go | {
"resource": ""
} |
q3595 | Stop | train | func (rs *Resources) Stop(id string) error {
// We don't hold the mutex while calling Stop, because
// that might take a while and we don't want to
// stop all other resource manipulation while we do so.
// If resources.Stop is called concurrently, we'll get
// two concurrent calls to Stop, but that should fit
//... | go | {
"resource": ""
} |
q3596 | StopAll | train | func (rs *Resources) StopAll() {
rs.mu.Lock()
defer rs.mu.Unlock()
for i := len(rs.stack); i > 0; i-- {
id := rs.stack[i-1]
r := rs.resources[id]
logger.Tracef("stopping resource: %s", id)
if err := r.Stop(); err != nil {
logger.Errorf("error stopping %T resource: %v", r, err)
}
}
rs.resources = make(... | go | {
"resource": ""
} |
q3597 | Count | train | func (rs *Resources) Count() int {
rs.mu.Lock()
defer rs.mu.Unlock()
return len(rs.resources)
} | go | {
"resource": ""
} |
q3598 | ProviderId | train | func (s *Space) ProviderId() network.Id {
return network.Id(s.doc.ProviderId)
} | go | {
"resource": ""
} |
q3599 | Subnets | train | func (s *Space) Subnets() (results []*Subnet, err error) {
defer errors.DeferredAnnotatef(&err, "cannot fetch subnets")
name := s.Name()
subnetsCollection, closer := s.st.db().GetCollection(subnetsC)
defer closer()
var doc subnetDoc
// We ignore space-name field for FAN subnets...
iter := subnetsCollection.Fin... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.