Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "DestroyController", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "DestroyController", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "InstanceTypes", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "constraints", ".", "Value", ")", "(", "instances", ".", "InstanceTypesWithCostMetadata", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "instances", ".", "InstanceTypesWithCostMetadata", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "InstanceTypes", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "Instances", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "[", "]", "instance", ".", "Id", ")", "(", "[", "]", "instances", ".", "Instance", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "instances", ".", "Instance", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "Instances", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "MaintainInstance", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "environs", ".", "StartInstanceParams", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "MaintainInstance", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "PrecheckInstance", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "environs", ".", "PrecheckInstanceParams", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "PrecheckInstance", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "PrepareForBootstrap", "(", "arg0", "environs", ".", "BootstrapContext", ",", "arg1", "string", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ",", "arg1", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "PrepareForBootstrap", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "Provider", "(", ")", "environs", ".", "EnvironProvider", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "environs", ".", "EnvironProvider", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Provider", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "SetConfig", "(", "arg0", "*", "config", ".", "Config", ")", "error", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SetConfig", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "StopInstances", "(", "arg0", "context", ".", "ProviderCallContext", ",", "arg1", "...", "instance", ".", "Id", ")", "error", "{", "varargs", ":=", "[", "]", "interface", "{", "}", "{", "arg0", "}", "\n", "for", "_", ",", "a", ":=", "range", "arg1", "{", "varargs", "=", "append", "(", "varargs", ",", "a", ")", "\n", "}", "\n", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "varargs", "...", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "error", ")", "\n", "return", "ret0", "\n", "}" ]

[ "StopInstances", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "StorageProvider", "(", "arg0", "storage", ".", "ProviderType", ")", "(", "storage", ".", "Provider", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "storage", ".", "Provider", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "StorageProvider", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockZonedEnvironMockRecorder", ")", "StorageProvider", "(", "arg0", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockZonedEnviron", ")", "(", "nil", ")", ".", "StorageProvider", ")", ",", "arg0", ")", "\n", "}" ]

[ "StorageProvider", "indicates", "an", "expected", "call", "of", "StorageProvider" ]

[ "func", "(", "m", "*", "MockZonedEnviron", ")", "StorageProviderTypes", "(", ")", "(", "[", "]", "storage", ".", "ProviderType", ",", "error", ")", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "[", "]", "storage", ".", "ProviderType", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "StorageProviderTypes", "mocks", "base", "method" ]

[ "func", "NewStorageAddCommand", "(", "ctx", "Context", ")", "(", "cmd", ".", "Command", ",", "error", ")", "{", "return", "&", "StorageAddCommand", "{", "ctx", ":", "ctx", "}", ",", "nil", "\n", "}" ]

[ "NewStorageAddCommand", "makes", "a", "jujuc", "storage", "-", "add", "command", "." ]

[ "func", "IAASManifolds", "(", "config", "ManifoldsConfig", ")", "dependency", ".", "Manifolds", "{", "var", "externalUpdateProxyFunc", "func", "(", "proxy", ".", "Settings", ")", "error", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "externalUpdateProxyFunc", "=", "lxd", ".", "ConfigureLXDProxies", "\n", "}", "\n", "manifolds", ":=", "dependency", ".", "Manifolds", "{", "toolsVersionCheckerName", ":", "ifNotMigrating", "(", "toolsversionchecker", ".", "Manifold", "(", "toolsversionchecker", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "}", ")", ")", ",", "authenticationWorkerName", ":", "ifNotMigrating", "(", "authenticationworker", ".", "Manifold", "(", "authenticationworker", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "}", ")", ")", ",", "// The proxy config updater is a leaf worker that sets http/https/apt/etc", "// proxy settings.", "proxyConfigUpdater", ":", "ifNotMigrating", "(", "proxyupdater", ".", "Manifold", "(", "proxyupdater", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "Logger", ":", "loggo", ".", "GetLogger", "(", "\"", "\"", ")", ",", "WorkerFunc", ":", "proxyupdater", ".", "NewWorker", ",", "ExternalUpdate", ":", "externalUpdateProxyFunc", ",", "InProcessUpdate", ":", "proxyconfig", ".", "DefaultConfig", ".", "Set", ",", "RunFunc", ":", "proxyupdater", ".", "RunWithStdIn", ",", "}", ")", ")", ",", "hostKeyReporterName", ":", "ifNotMigrating", "(", "hostkeyreporter", ".", "Manifold", "(", "hostkeyreporter", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "RootDir", ":", "config", ".", "RootDir", ",", "NewFacade", ":", "hostkeyreporter", ".", "NewFacade", ",", "NewWorker", ":", "hostkeyreporter", ".", "NewWorker", ",", "}", ")", ")", ",", "// The upgrader is a leaf worker that returns a specific error", "// type recognised by the machine agent, causing other workers", "// to be stopped and the agent to be restarted running the new", "// tools. We should only need one of these in a consolidated", "// agent, but we'll need to be careful about behavioural", "// differences, and interactions with the upgrade-steps", "// worker.", "upgraderName", ":", "upgrader", ".", "Manifold", "(", "upgrader", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "UpgradeStepsGateName", ":", "upgradeStepsGateName", ",", "UpgradeCheckGateName", ":", "upgradeCheckGateName", ",", "PreviousAgentVersion", ":", "config", ".", "PreviousAgentVersion", ",", "}", ")", ",", "upgradeSeriesWorkerName", ":", "ifNotMigrating", "(", "upgradeseries", ".", "Manifold", "(", "upgradeseries", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "Logger", ":", "loggo", ".", "GetLogger", "(", "\"", "\"", ")", ",", "NewFacade", ":", "upgradeseries", ".", "NewFacade", ",", "NewWorker", ":", "upgradeseries", ".", "NewWorker", ",", "}", ")", ")", ",", "// The deployer worker is primary for deploying and recalling unit", "// agents, according to changes in a set of state units; and for the", "// final removal of its agents' units from state when they are no", "// longer needed.", "deployerName", ":", "ifNotMigrating", "(", "deployer", ".", "Manifold", "(", "deployer", ".", "ManifoldConfig", "{", "NewDeployContext", ":", "config", ".", "NewDeployContext", ",", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "}", ")", ")", ",", "// The reboot manifold manages a worker which will reboot the", "// machine when requested. It needs an API connection and", "// waits for upgrades to be complete.", "rebootName", ":", "ifNotMigrating", "(", "reboot", ".", "Manifold", "(", "reboot", ".", "ManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "MachineLock", ":", "config", ".", "MachineLock", ",", "Clock", ":", "config", ".", "Clock", ",", "}", ")", ")", ",", "// The storageProvisioner worker manages provisioning", "// (deprovisioning), and attachment (detachment) of first-class", "// volumes and filesystems.", "storageProvisionerName", ":", "ifNotMigrating", "(", "ifCredentialValid", "(", "storageprovisioner", ".", "MachineManifold", "(", "storageprovisioner", ".", "MachineManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "Clock", ":", "config", ".", "Clock", ",", "NewCredentialValidatorFacade", ":", "common", ".", "NewCredentialInvalidatorFacade", ",", "}", ")", ")", ")", ",", "brokerTrackerName", ":", "ifNotMigrating", "(", "lxdbroker", ".", "Manifold", "(", "lxdbroker", ".", "ManifoldConfig", "{", "APICallerName", ":", "apiCallerName", ",", "AgentName", ":", "agentName", ",", "MachineLock", ":", "config", ".", "MachineLock", ",", "NewBrokerFunc", ":", "config", ".", "NewBrokerFunc", ",", "NewTracker", ":", "lxdbroker", ".", "NewWorkerTracker", ",", "}", ")", ")", ",", "instanceMutaterName", ":", "ifNotMigrating", "(", "instancemutater", ".", "MachineManifold", "(", "instancemutater", ".", "MachineManifoldConfig", "{", "AgentName", ":", "agentName", ",", "APICallerName", ":", "apiCallerName", ",", "BrokerName", ":", "brokerTrackerName", ",", "Logger", ":", "loggo", ".", "GetLogger", "(", "\"", "\"", ")", ",", "NewClient", ":", "instancemutater", ".", "NewClient", ",", "NewWorker", ":", "instancemutater", ".", "NewContainerWorker", ",", "}", ")", ")", ",", "}", "\n\n", "return", "mergeManifolds", "(", "config", ",", "manifolds", ")", "\n", "}" ]

[ "IAASManifolds", "returns", "a", "set", "of", "co", "-", "configured", "manifolds", "covering", "the", "various", "responsibilities", "of", "a", "IAAS", "machine", "agent", "." ]

[ "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", ":", "apiCallerName", ",", "UpgradeStepsGateName", ":", "upgradeStepsGateName", ",", "UpgradeCheckGateName", ":", "upgradeCheckGateName", ",", "PreviousAgentVersion", ":", "config", ".", "PreviousAgentVersion", ",", "}", ")", ",", "}", ")", "\n", "}" ]

[ "CAASManifolds", "returns", "a", "set", "of", "co", "-", "configured", "manifolds", "covering", "the", "various", "responsibilities", "of", "a", "CAAS", "machine", "agent", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "OpenPorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "return", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}" ]

[ "OpenPorts", "is", "not", "supported", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "IngressRules", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "NotSupportedf", "(", "\"", "\"", ")", "\n", "}" ]

[ "IngressRules", "returns", "the", "port", "ranges", "opened", "for", "the", "whole", "environment", ".", "Must", "only", "be", "used", "if", "the", "environment", "was", "setup", "with", "the", "FwGlobal", "firewall", "mode", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "DeleteGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "names", "...", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "DeleteGroups", "implements", "OpenstackFirewaller", "interface", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "DeleteAllControllerGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "controllerUUID", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "DeleteAllControllerGroups", "implements", "OpenstackFirewaller", "interface", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "GetSecurityGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "ids", "...", "instance", ".", "Id", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "nil", ",", "nil", "\n", "}" ]

[ "GetSecurityGroups", "implements", "OpenstackFirewaller", "interface", "." ]

[ "func", "(", "c", "*", "rackspaceFirewaller", ")", "SetUpGroups", "(", "ctx", "context", ".", "ProviderCallContext", ",", "controllerUUID", ",", "machineId", "string", ",", "apiPort", "int", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "nil", ",", "nil", "\n", "}" ]

[ "SetUpGroups", "implements", "OpenstackFirewaller", "interface", "." ]

[ "func", "filesystemsChanged", "(", "ctx", "*", "context", ",", "changes", "[", "]", "string", ")", "error", "{", "tags", ":=", "make", "(", "[", "]", "names", ".", "Tag", ",", "len", "(", "changes", ")", ")", "\n", "for", "i", ",", "change", ":=", "range", "changes", "{", "tags", "[", "i", "]", "=", "names", ".", "NewFilesystemTag", "(", "change", ")", "\n", "}", "\n", "alive", ",", "dying", ",", "dead", ",", "err", ":=", "storageEntityLife", "(", "ctx", ",", "tags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "alive", ",", "dying", ",", "dead", ")", "\n", "if", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", "+", "len", "(", "dead", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Get filesystem information for filesystems, so we can provision,", "// deprovision, attach and detach.", "filesystemTags", ":=", "make", "(", "[", "]", "names", ".", "FilesystemTag", ",", "0", ",", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", "+", "len", "(", "dead", ")", ")", "\n", "for", "_", ",", "tag", ":=", "range", "alive", "{", "filesystemTags", "=", "append", "(", "filesystemTags", ",", "tag", ".", "(", "names", ".", "FilesystemTag", ")", ")", "\n", "}", "\n", "for", "_", ",", "tag", ":=", "range", "dying", "{", "filesystemTags", "=", "append", "(", "filesystemTags", ",", "tag", ".", "(", "names", ".", "FilesystemTag", ")", ")", "\n", "}", "\n", "for", "_", ",", "tag", ":=", "range", "dead", "{", "filesystemTags", "=", "append", "(", "filesystemTags", ",", "tag", ".", "(", "names", ".", "FilesystemTag", ")", ")", "\n", "}", "\n", "filesystemResults", ",", "err", ":=", "ctx", ".", "config", ".", "Filesystems", ".", "Filesystems", "(", "filesystemTags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "aliveFilesystemTags", ":=", "filesystemTags", "[", ":", "len", "(", "alive", ")", "]", "\n", "dyingFilesystemTags", ":=", "filesystemTags", "[", "len", "(", "alive", ")", ":", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", "]", "\n", "deadFilesystemTags", ":=", "filesystemTags", "[", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", ":", "]", "\n", "aliveFilesystemResults", ":=", "filesystemResults", "[", ":", "len", "(", "alive", ")", "]", "\n", "dyingFilesystemResults", ":=", "filesystemResults", "[", "len", "(", "alive", ")", ":", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", "]", "\n", "deadFilesystemResults", ":=", "filesystemResults", "[", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", ":", "]", "\n\n", "if", "err", ":=", "processDeadFilesystems", "(", "ctx", ",", "deadFilesystemTags", ",", "deadFilesystemResults", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "processDyingFilesystems", "(", "ctx", ",", "dyingFilesystemTags", ",", "dyingFilesystemResults", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "processAliveFilesystems", "(", "ctx", ",", "aliveFilesystemTags", ",", "aliveFilesystemResults", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "filesystemsChanged", "is", "called", "when", "the", "lifecycle", "states", "of", "the", "filesystems", "with", "the", "provided", "IDs", "have", "been", "seen", "to", "have", "changed", "." ]

[ "func", "filesystemAttachmentsChanged", "(", "ctx", "*", "context", ",", "watcherIds", "[", "]", "watcher", ".", "MachineStorageId", ")", "error", "{", "ids", ":=", "copyMachineStorageIds", "(", "watcherIds", ")", "\n", "alive", ",", "dying", ",", "dead", ",", "err", ":=", "attachmentLife", "(", "ctx", ",", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "alive", ",", "dying", ",", "dead", ")", "\n", "if", "len", "(", "dead", ")", "!=", "0", "{", "// We should not see dead filesystem attachments;", "// attachments go directly from Dying to removed.", "logger", ".", "Warningf", "(", "\"", "\"", ",", "dead", ")", "\n", "}", "\n", "if", "len", "(", "alive", ")", "+", "len", "(", "dying", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// Get filesystem information for alive and dying filesystem attachments, so", "// we can attach/detach.", "ids", "=", "append", "(", "alive", ",", "dying", "...", ")", "\n", "filesystemAttachmentResults", ",", "err", ":=", "ctx", ".", "config", ".", "Filesystems", ".", "FilesystemAttachments", "(", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Deprovision Dying filesystem attachments.", "dyingFilesystemAttachmentResults", ":=", "filesystemAttachmentResults", "[", "len", "(", "alive", ")", ":", "]", "\n", "if", "err", ":=", "processDyingFilesystemAttachments", "(", "ctx", ",", "dying", ",", "dyingFilesystemAttachmentResults", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Provision Alive filesystem attachments.", "aliveFilesystemAttachmentResults", ":=", "filesystemAttachmentResults", "[", ":", "len", "(", "alive", ")", "]", "\n", "if", "err", ":=", "processAliveFilesystemAttachments", "(", "ctx", ",", "alive", ",", "aliveFilesystemAttachmentResults", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "filesystemAttachmentsChanged", "is", "called", "when", "the", "lifecycle", "states", "of", "the", "filesystem", "attachments", "with", "the", "provided", "IDs", "have", "been", "seen", "to", "have", "changed", "." ]

[ "func", "processDyingFilesystems", "(", "ctx", "*", "context", ",", "tags", "[", "]", "names", ".", "FilesystemTag", ",", "filesystemResults", "[", "]", "params", ".", "FilesystemResult", ")", "error", "{", "for", "_", ",", "tag", ":=", "range", "tags", "{", "removePendingFilesystem", "(", "ctx", ",", "tag", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processDyingFilesystems", "processes", "the", "FilesystemResults", "for", "Dying", "filesystems", "removing", "them", "from", "provisioning", "-", "pending", "as", "necessary", "." ]

[ "func", "updatePendingFilesystemAttachment", "(", "ctx", "*", "context", ",", "id", "params", ".", "MachineStorageId", ",", "params", "storage", ".", "FilesystemAttachmentParams", ",", ")", "{", "var", "incomplete", "bool", "\n", "filesystem", ",", "ok", ":=", "ctx", ".", "filesystems", "[", "params", ".", "Filesystem", "]", "\n", "if", "!", "ok", "{", "incomplete", "=", "true", "\n", "}", "else", "{", "params", ".", "FilesystemId", "=", "filesystem", ".", "FilesystemId", "\n", "if", "filesystem", ".", "Volume", "!=", "(", "names", ".", "VolumeTag", "{", "}", ")", "{", "// The filesystem is volume-backed: if the filesystem", "// was created in another session, then the block device", "// may not have been seen yet. We must wait for the block", "// device watcher to trigger.", "if", "_", ",", "ok", ":=", "ctx", ".", "volumeBlockDevices", "[", "filesystem", ".", "Volume", "]", ";", "!", "ok", "{", "incomplete", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "params", ".", "InstanceId", "==", "\"", "\"", "{", "watchMachine", "(", "ctx", ",", "params", ".", "Machine", ".", "(", "names", ".", "MachineTag", ")", ")", "\n", "incomplete", "=", "true", "\n", "}", "\n", "if", "params", ".", "FilesystemId", "==", "\"", "\"", "{", "incomplete", "=", "true", "\n", "}", "\n", "if", "incomplete", "{", "ctx", ".", "incompleteFilesystemAttachmentParams", "[", "id", "]", "=", "params", "\n", "return", "\n", "}", "\n", "delete", "(", "ctx", ".", "incompleteFilesystemAttachmentParams", ",", "id", ")", "\n", "scheduleOperations", "(", "ctx", ",", "&", "attachFilesystemOp", "{", "args", ":", "params", "}", ")", "\n", "}" ]

[ "updatePendingFilesystemAttachment", "adds", "the", "given", "filesystem", "attachment", "params", "to", "either", "the", "incomplete", "set", "or", "the", "schedule", ".", "If", "the", "params", "are", "incomplete", "due", "to", "a", "missing", "instance", "ID", "updatePendingFilesystemAttachment", "will", "request", "that", "the", "machine", "be", "watched", "so", "its", "instance", "ID", "can", "be", "learned", "." ]

[ "func", "processDeadFilesystems", "(", "ctx", "*", "context", ",", "tags", "[", "]", "names", ".", "FilesystemTag", ",", "filesystemResults", "[", "]", "params", ".", "FilesystemResult", ")", "error", "{", "for", "_", ",", "tag", ":=", "range", "tags", "{", "removePendingFilesystem", "(", "ctx", ",", "tag", ")", "\n", "}", "\n", "var", "destroy", "[", "]", "names", ".", "FilesystemTag", "\n", "var", "remove", "[", "]", "names", ".", "Tag", "\n", "for", "i", ",", "result", ":=", "range", "filesystemResults", "{", "tag", ":=", "tags", "[", "i", "]", "\n", "if", "result", ".", "Error", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "filesystem", ",", "err", ":=", "filesystemFromParams", "(", "result", ".", "Result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "updateFilesystem", "(", "ctx", ",", "filesystem", ")", "\n", "destroy", "=", "append", "(", "destroy", ",", "tag", ")", "\n", "continue", "\n", "}", "\n", "if", "params", ".", "IsCodeNotProvisioned", "(", "result", ".", "Error", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "remove", "=", "append", "(", "remove", ",", "tag", ")", "\n", "continue", "\n", "}", "\n", "return", "errors", ".", "Annotatef", "(", "result", ".", "Error", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "if", "len", "(", "destroy", ")", ">", "0", "{", "ops", ":=", "make", "(", "[", "]", "scheduleOp", ",", "len", "(", "destroy", ")", ")", "\n", "for", "i", ",", "tag", ":=", "range", "destroy", "{", "ops", "[", "i", "]", "=", "&", "removeFilesystemOp", "{", "tag", ":", "tag", "}", "\n", "}", "\n", "scheduleOperations", "(", "ctx", ",", "ops", "...", ")", "\n", "}", "\n", "if", "err", ":=", "removeEntities", "(", "ctx", ",", "remove", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processDeadFilesystems", "processes", "the", "FilesystemResults", "for", "Dead", "filesystems", "deprovisioning", "filesystems", "and", "removing", "from", "state", "as", "necessary", "." ]

[ "func", "processDyingFilesystemAttachments", "(", "ctx", "*", "context", ",", "ids", "[", "]", "params", ".", "MachineStorageId", ",", "filesystemAttachmentResults", "[", "]", "params", ".", "FilesystemAttachmentResult", ",", ")", "error", "{", "for", "_", ",", "id", ":=", "range", "ids", "{", "removePendingFilesystemAttachment", "(", "ctx", ",", "id", ")", "\n", "}", "\n", "detach", ":=", "make", "(", "[", "]", "params", ".", "MachineStorageId", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "remove", ":=", "make", "(", "[", "]", "params", ".", "MachineStorageId", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "filesystemAttachmentResults", "{", "id", ":=", "ids", "[", "i", "]", "\n", "if", "result", ".", "Error", "==", "nil", "{", "detach", "=", "append", "(", "detach", ",", "id", ")", "\n", "continue", "\n", "}", "\n", "if", "params", ".", "IsCodeNotProvisioned", "(", "result", ".", "Error", ")", "{", "remove", "=", "append", "(", "remove", ",", "id", ")", "\n", "continue", "\n", "}", "\n", "return", "errors", ".", "Annotatef", "(", "result", ".", "Error", ",", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "if", "len", "(", "detach", ")", ">", "0", "{", "attachmentParams", ",", "err", ":=", "filesystemAttachmentParams", "(", "ctx", ",", "detach", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ops", ":=", "make", "(", "[", "]", "scheduleOp", ",", "len", "(", "attachmentParams", ")", ")", "\n", "for", "i", ",", "p", ":=", "range", "attachmentParams", "{", "ops", "[", "i", "]", "=", "&", "detachFilesystemOp", "{", "args", ":", "p", "}", "\n", "}", "\n", "scheduleOperations", "(", "ctx", ",", "ops", "...", ")", "\n", "}", "\n", "if", "err", ":=", "removeAttachments", "(", "ctx", ",", "remove", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processDyingFilesystemAttachments", "processes", "the", "FilesystemAttachmentResults", "for", "Dying", "filesystem", "attachments", "detaching", "filesystems", "and", "updating", "state", "as", "necessary", "." ]

[ "func", "processAliveFilesystems", "(", "ctx", "*", "context", ",", "tags", "[", "]", "names", ".", "FilesystemTag", ",", "filesystemResults", "[", "]", "params", ".", "FilesystemResult", ")", "error", "{", "// Filter out the already-provisioned filesystems.", "pending", ":=", "make", "(", "[", "]", "names", ".", "FilesystemTag", ",", "0", ",", "len", "(", "tags", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "filesystemResults", "{", "tag", ":=", "tags", "[", "i", "]", "\n", "if", "result", ".", "Error", "==", "nil", "{", "// Filesystem is already provisioned: skip.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ")", "\n", "filesystem", ",", "err", ":=", "filesystemFromParams", "(", "result", ".", "Result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "updateFilesystem", "(", "ctx", ",", "filesystem", ")", "\n", "if", "!", "ctx", ".", "isApplicationKind", "(", ")", "{", "if", "filesystem", ".", "Volume", "!=", "(", "names", ".", "VolumeTag", "{", "}", ")", "{", "// Ensure that volume-backed filesystems' block", "// devices are present even after creating the", "// filesystem, so that attachments can be made.", "maybeAddPendingVolumeBlockDevice", "(", "ctx", ",", "filesystem", ".", "Volume", ")", "\n", "}", "\n", "}", "\n", "continue", "\n", "}", "\n", "if", "!", "params", ".", "IsCodeNotProvisioned", "(", "result", ".", "Error", ")", "{", "return", "errors", ".", "Annotatef", "(", "result", ".", "Error", ",", "\"", "\"", ",", "tag", ".", "Id", "(", ")", ",", ")", "\n", "}", "\n", "// The filesystem has not yet been provisioned, so record its tag", "// to enquire about parameters below.", "pending", "=", "append", "(", "pending", ",", "tag", ")", "\n", "}", "\n", "if", "len", "(", "pending", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "params", ",", "err", ":=", "filesystemParams", "(", "ctx", ",", "pending", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "params", ":=", "range", "params", "{", "if", "ctx", ".", "isApplicationKind", "(", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "ctx", ".", "config", ".", "Scope", ".", "Id", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "updatePendingFilesystem", "(", "ctx", ",", "params", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processAliveFilesystems", "processes", "the", "FilesystemResults", "for", "Alive", "filesystems", "provisioning", "filesystems", "and", "setting", "the", "info", "in", "state", "as", "necessary", "." ]

[ "func", "processAliveFilesystemAttachments", "(", "ctx", "*", "context", ",", "ids", "[", "]", "params", ".", "MachineStorageId", ",", "filesystemAttachmentResults", "[", "]", "params", ".", "FilesystemAttachmentResult", ",", ")", "error", "{", "// Filter out the already-attached.", "pending", ":=", "make", "(", "[", "]", "params", ".", "MachineStorageId", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "filesystemAttachmentResults", "{", "if", "result", ".", "Error", "==", "nil", "{", "// Filesystem attachment is already provisioned: if we", "// didn't (re)attach in this session, then we must do", "// so now.", "action", ":=", "\"", "\"", "\n", "if", "_", ",", "ok", ":=", "ctx", ".", "filesystemAttachments", "[", "ids", "[", "i", "]", "]", ";", "!", "ok", "{", "// Not yet (re)attached in this session.", "pending", "=", "append", "(", "pending", ",", "ids", "[", "i", "]", ")", "\n", "action", "=", "\"", "\"", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "ids", "[", "i", "]", ".", "AttachmentTag", ",", "ids", "[", "i", "]", ".", "MachineTag", ",", "action", ",", ")", "\n", "removePendingFilesystemAttachment", "(", "ctx", ",", "ids", "[", "i", "]", ")", "\n", "continue", "\n", "}", "\n", "if", "!", "params", ".", "IsCodeNotProvisioned", "(", "result", ".", "Error", ")", "{", "return", "errors", ".", "Annotatef", "(", "result", ".", "Error", ",", "\"", "\"", ",", "ids", "[", "i", "]", ",", ")", "\n", "}", "\n", "// The filesystem has not yet been attached, so", "// record its tag to enquire about parameters below.", "pending", "=", "append", "(", "pending", ",", "ids", "[", "i", "]", ")", "\n", "}", "\n", "if", "len", "(", "pending", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "params", ",", "err", ":=", "filesystemAttachmentParams", "(", "ctx", ",", "pending", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "i", ",", "params", ":=", "range", "params", "{", "if", "params", ".", "Machine", "!=", "nil", "&&", "params", ".", "Machine", ".", "Kind", "(", ")", "!=", "names", ".", "MachineTagKind", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "params", ".", "Machine", ")", "\n", "continue", "\n", "}", "\n", "updatePendingFilesystemAttachment", "(", "ctx", ",", "pending", "[", "i", "]", ",", "params", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processAliveFilesystemAttachments", "processes", "the", "FilesystemAttachmentResults", "for", "Alive", "filesystem", "attachments", "attaching", "filesystems", "and", "setting", "the", "info", "in", "state", "as", "necessary", "." ]

[ "func", "filesystemAttachmentParams", "(", "ctx", "*", "context", ",", "ids", "[", "]", "params", ".", "MachineStorageId", ",", ")", "(", "[", "]", "storage", ".", "FilesystemAttachmentParams", ",", "error", ")", "{", "paramsResults", ",", "err", ":=", "ctx", ".", "config", ".", "Filesystems", ".", "FilesystemAttachmentParams", "(", "ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "attachmentParams", ":=", "make", "(", "[", "]", "storage", ".", "FilesystemAttachmentParams", ",", "len", "(", "ids", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "paramsResults", "{", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "result", ".", "Error", ",", "\"", "\"", ")", "\n", "}", "\n", "params", ",", "err", ":=", "filesystemAttachmentParamsFromParams", "(", "result", ".", "Result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "attachmentParams", "[", "i", "]", "=", "params", "\n", "}", "\n", "return", "attachmentParams", ",", "nil", "\n", "}" ]

[ "filesystemAttachmentParams", "obtains", "the", "specified", "attachments", "parameters", "." ]

[ "func", "filesystemParams", "(", "ctx", "*", "context", ",", "tags", "[", "]", "names", ".", "FilesystemTag", ")", "(", "[", "]", "storage", ".", "FilesystemParams", ",", "error", ")", "{", "paramsResults", ",", "err", ":=", "ctx", ".", "config", ".", "Filesystems", ".", "FilesystemParams", "(", "tags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "allParams", ":=", "make", "(", "[", "]", "storage", ".", "FilesystemParams", ",", "len", "(", "tags", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "paramsResults", "{", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "result", ".", "Error", ",", "\"", "\"", ")", "\n", "}", "\n", "params", ",", "err", ":=", "filesystemParamsFromParams", "(", "result", ".", "Result", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "allParams", "[", "i", "]", "=", "params", "\n", "}", "\n", "return", "allParams", ",", "nil", "\n", "}" ]

[ "filesystemParams", "obtains", "the", "specified", "filesystems", "parameters", "." ]

[ "func", "removeFilesystemParams", "(", "ctx", "*", "context", ",", "tags", "[", "]", "names", ".", "FilesystemTag", ")", "(", "[", "]", "params", ".", "RemoveFilesystemParams", ",", "error", ")", "{", "paramsResults", ",", "err", ":=", "ctx", ".", "config", ".", "Filesystems", ".", "RemoveFilesystemParams", "(", "tags", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "allParams", ":=", "make", "(", "[", "]", "params", ".", "RemoveFilesystemParams", ",", "len", "(", "tags", ")", ")", "\n", "for", "i", ",", "result", ":=", "range", "paramsResults", "{", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotate", "(", "result", ".", "Error", ",", "\"", "\"", ")", "\n", "}", "\n", "allParams", "[", "i", "]", "=", "result", ".", "Result", "\n", "}", "\n", "return", "allParams", ",", "nil", "\n", "}" ]

[ "removeFilesystemParams", "obtains", "the", "specified", "filesystems", "destruction", "parameters", "." ]

[ "func", "(", "metadata", "*", "CloudMetadata", ")", "extractCatalogsForProducts", "(", "productIds", "[", "]", "string", ")", "[", "]", "MetadataCatalog", "{", "result", ":=", "[", "]", "MetadataCatalog", "{", "}", "\n", "for", "_", ",", "id", ":=", "range", "productIds", "{", "if", "catalog", ",", "ok", ":=", "metadata", ".", "Products", "[", "id", "]", ";", "ok", "{", "result", "=", "append", "(", "result", ",", "catalog", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "extractCatalogsForProducts", "gives", "you", "just", "those", "catalogs", "from", "a", "cloudImageMetadata", "that", "are", "for", "the", "given", "product", "IDs", ".", "They", "are", "kept", "in", "the", "order", "of", "the", "parameter", "." ]

[ "func", "(", "ind", "*", "Indices", ")", "extractIndexes", "(", "indexIds", "[", "]", "string", ")", "IndexMetadataSlice", "{", "result", ":=", "make", "(", "IndexMetadataSlice", ",", "0", ",", "len", "(", "ind", ".", "Indexes", ")", ")", "\n", "if", "len", "(", "indexIds", ")", "==", "0", "{", "// No ids specified so return everything.", "for", "_", ",", "metadata", ":=", "range", "ind", ".", "Indexes", "{", "result", "=", "append", "(", "result", ",", "metadata", ")", "\n", "}", "\n", "}", "else", "{", "// Return metadata for just the specified ids.", "for", "_", ",", "id", ":=", "range", "indexIds", "{", "if", "metadata", ",", "ok", ":=", "ind", ".", "Indexes", "[", "id", "]", ";", "ok", "{", "result", "=", "append", "(", "result", ",", "metadata", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "extractIndexes", "returns", "just", "the", "array", "of", "indexes", "in", "arbitrary", "order", "." ]

[ "func", "(", "metadata", "*", "IndexMetadata", ")", "hasCloud", "(", "cloud", "CloudSpec", ")", "bool", "{", "for", "_", ",", "metadataCloud", ":=", "range", "metadata", ".", "Clouds", "{", "if", "metadataCloud", ".", "equals", "(", "&", "cloud", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "len", "(", "metadata", ".", "Clouds", ")", "==", "0", "\n", "}" ]

[ "hasCloud", "tells", "you", "whether", "an", "IndexMetadata", "has", "the", "given", "cloud", "in", "its", "Clouds", "list", ".", "If", "IndexMetadata", "has", "no", "clouds", "defined", "then", "hasCloud", "returns", "true", "regardless", "so", "that", "the", "corresponding", "product", "records", "are", "searched", "." ]

[ "func", "(", "metadata", "*", "IndexMetadata", ")", "hasProduct", "(", "prodIds", "[", "]", "string", ")", "bool", "{", "for", "_", ",", "pid", ":=", "range", "metadata", ".", "ProductIds", "{", "if", "containsString", "(", "prodIds", ",", "pid", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "hasProduct", "tells", "you", "whether", "an", "IndexMetadata", "provides", "any", "of", "the", "given", "product", "IDs", "." ]

[ "func", "(", "entries", "IndexMetadataSlice", ")", "filter", "(", "match", "func", "(", "*", "IndexMetadata", ")", "bool", ")", "IndexMetadataSlice", "{", "result", ":=", "IndexMetadataSlice", "{", "}", "\n", "for", "_", ",", "metadata", ":=", "range", "entries", "{", "if", "match", "(", "metadata", ")", "{", "result", "=", "append", "(", "result", ",", "metadata", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "filter", "returns", "those", "entries", "from", "an", "IndexMetadata", "array", "for", "which", "the", "given", "match", "function", "returns", "true", ".", "It", "preserves", "order", "." ]

[ "func", "UnsignedIndex", "(", "streamsVersion", "string", ",", "indexFileVersion", "int", ")", "string", "{", "indexFileSuffix", ":=", "\"", "\"", "\n", "if", "indexFileVersion", ">", "1", "{", "indexFileSuffix", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "indexFileVersion", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "unsignedIndex", ",", "streamsVersion", ",", "indexFileSuffix", ")", "\n", "}" ]

[ "UnsignedIndex", "returns", "an", "unsigned", "index", "file", "name", "for", "streamsVersion", "." ]

[ "func", "getMaybeSignedMetadata", "(", "source", "DataSource", ",", "params", "GetMetadataParams", ",", "signed", "bool", ")", "(", "[", "]", "interface", "{", "}", ",", "*", "ResolveInfo", ",", "error", ")", "{", "makeIndexPath", ":=", "func", "(", "basePath", "string", ")", "string", "{", "pathNoSuffix", ":=", "fmt", ".", "Sprintf", "(", "basePath", ",", "params", ".", "StreamsVersion", ")", "\n", "indexPath", ":=", "pathNoSuffix", "+", "UnsignedSuffix", "\n", "if", "signed", "{", "indexPath", "=", "pathNoSuffix", "+", "SignedSuffix", "\n", "}", "\n", "return", "indexPath", "\n", "}", "\n\n", "resolveInfo", ":=", "&", "ResolveInfo", "{", "}", "\n", "resolveInfo", ".", "Source", "=", "source", ".", "Description", "(", ")", "\n", "resolveInfo", ".", "Signed", "=", "signed", "\n", "indexPath", ":=", "makeIndexPath", "(", "defaultIndexPath", ")", "\n\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexPath", ")", "\n", "mirrorsPath", ":=", "fmt", ".", "Sprintf", "(", "defaultMirrorsPath", ",", "params", ".", "StreamsVersion", ")", "\n", "cons", ":=", "params", ".", "LookupConstraint", "\n\n", "indexRef", ",", "indexURL", ",", "err", ":=", "fetchIndex", "(", "source", ",", "indexPath", ",", "mirrorsPath", ",", "cons", ".", "Params", "(", ")", ".", "CloudSpec", ",", "signed", ",", "params", ".", "ValueParams", ",", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexURL", ")", "\n", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "legacyIndexPath", ":=", "makeIndexPath", "(", "defaultLegacyIndexPath", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexPath", ",", "err", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexPath", ",", "legacyIndexPath", ")", "\n", "indexPath", "=", "legacyIndexPath", "\n", "indexRef", ",", "indexURL", ",", "err", "=", "fetchIndex", "(", "source", ",", "indexPath", ",", "mirrorsPath", ",", "cons", ".", "Params", "(", ")", ".", "CloudSpec", ",", "signed", ",", "params", ".", "ValueParams", ",", ")", "\n", "}", "\n", "resolveInfo", ".", "IndexURL", "=", "indexURL", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexURL", ",", "err", ")", "\n", "}", "\n", "return", "nil", ",", "resolveInfo", ",", "err", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "indexURL", ")", "\n", "items", ",", "err", ":=", "indexRef", ".", "getLatestMetadataWithFormat", "(", "cons", ",", "ProductFormat", ",", "signed", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "indexURL", ",", "err", ")", "\n", "return", "nil", ",", "resolveInfo", ",", "err", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "noMatchingProductsError", ")", ";", "!", "ok", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "indexRef", ".", "Source", ".", "Description", "(", ")", "==", "\"", "\"", "{", "resolveInfo", ".", "MirrorURL", "=", "indexRef", ".", "Source", ".", "(", "*", "urlDataSource", ")", ".", "baseURL", "\n", "}", "\n", "return", "items", ",", "resolveInfo", ",", "err", "\n", "}" ]

[ "getMaybeSignedMetadata", "returns", "metadata", "records", "matching", "the", "specified", "constraint", "in", "params", "." ]

[ "func", "fetchIndex", "(", "source", "DataSource", ",", "indexPath", "string", ",", "mirrorsPath", "string", ",", "cloudSpec", "CloudSpec", ",", "signed", "bool", ",", "params", "ValueParams", ")", "(", "indexRef", "*", "IndexReference", ",", "indexURL", "string", ",", "_", "error", ")", "{", "indexURL", ",", "err", ":=", "source", ".", "URL", "(", "indexPath", ")", "\n", "if", "err", "!=", "nil", "{", "// Some providers return an error if asked for the URL of a non-existent file.", "// So the best we can do is use the relative path for the URL when logging messages.", "indexURL", "=", "indexPath", "\n", "}", "\n", "indexRef", ",", "err", "=", "GetIndexWithFormat", "(", "source", ",", "indexPath", ",", "IndexFormat", ",", "mirrorsPath", ",", "signed", ",", "cloudSpec", ",", "params", ",", ")", "\n", "return", "indexRef", ",", "indexURL", ",", "err", "\n", "}" ]

[ "fetchIndex", "attempts", "to", "load", "the", "index", "file", "at", "indexPath", "in", "source", "." ]

[ "func", "fetchData", "(", "source", "DataSource", ",", "path", "string", ",", "requireSigned", "bool", ")", "(", "data", "[", "]", "byte", ",", "dataURL", "string", ",", "err", "error", ")", "{", "rc", ",", "dataURL", ",", "err", ":=", "source", ".", "Fetch", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "dataURL", ",", "err", ")", "\n", "return", "nil", ",", "dataURL", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "dataURL", ")", "\n", "}", "\n", "defer", "rc", ".", "Close", "(", ")", "\n", "if", "requireSigned", "{", "data", ",", "err", "=", "DecodeCheckSignature", "(", "rc", ",", "source", ".", "PublicSigningKey", "(", ")", ")", "\n", "}", "else", "{", "data", ",", "err", "=", "ioutil", ".", "ReadAll", "(", "rc", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "dataURL", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "source", ".", "Description", "(", ")", ",", "dataURL", ")", "\n", "}", "\n", "return", "data", ",", "dataURL", ",", "nil", "\n", "}" ]

[ "fetchData", "gets", "all", "the", "data", "from", "the", "given", "source", "located", "at", "the", "specified", "path", ".", "It", "returns", "the", "data", "found", "and", "the", "full", "URL", "used", "." ]

[ "func", "GetIndexWithFormat", "(", "source", "DataSource", ",", "indexPath", ",", "indexFormat", ",", "mirrorsPath", "string", ",", "requireSigned", "bool", ",", "cloudSpec", "CloudSpec", ",", "params", "ValueParams", ")", "(", "*", "IndexReference", ",", "error", ")", "{", "data", ",", "url", ",", "err", ":=", "fetchData", "(", "source", ",", "indexPath", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "var", "indices", "Indices", "\n", "err", "=", "json", ".", "Unmarshal", "(", "data", ",", "&", "indices", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "string", "(", "data", ")", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n", "if", "indices", ".", "Format", "!=", "indexFormat", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "indices", ".", "Format", ",", "indexFormat", ",", "url", ")", "\n", "}", "\n\n", "mirrors", ",", "url", ",", "err", ":=", "getMirrorRefs", "(", "source", ",", "mirrorsPath", ",", "requireSigned", ",", "params", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "errors", ".", "IsNotFound", "(", "err", ")", "&&", "!", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n\n", "indexRef", ":=", "&", "IndexReference", "{", "Source", ":", "source", ",", "Indices", ":", "indices", ",", "valueParams", ":", "params", ",", "}", "\n\n", "// Apply any mirror information to the source.", "if", "params", ".", "MirrorContentId", "!=", "\"", "\"", "{", "mirrorInfo", ",", "err", ":=", "getMirror", "(", "source", ",", "mirrors", ",", "params", ".", "DataType", ",", "params", ".", "MirrorContentId", ",", "cloudSpec", ",", "requireSigned", ")", "\n", "if", "err", "==", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "path", ".", "Join", "(", "mirrorInfo", ".", "MirrorURL", ",", "mirrorInfo", ".", "Path", ")", ")", "\n", "indexRef", ".", "Source", "=", "NewURLSignedDataSource", "(", "\"", "\"", ",", "mirrorInfo", ".", "MirrorURL", ",", "source", ".", "PublicSigningKey", "(", ")", ",", "utils", ".", "VerifySSLHostnames", ",", "source", ".", "Priority", "(", ")", ",", "requireSigned", ")", "\n", "indexRef", ".", "MirroredProductsPath", "=", "mirrorInfo", ".", "Path", "\n", "}", "else", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "cloudSpec", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "indexRef", ",", "nil", "\n", "}" ]

[ "GetIndexWithFormat", "returns", "a", "simplestreams", "index", "of", "the", "specified", "format", ".", "Exported", "for", "testing", "." ]

[ "func", "getMirrorRefs", "(", "source", "DataSource", ",", "baseMirrorsPath", "string", ",", "requireSigned", "bool", ",", "params", "ValueParams", ")", "(", "MirrorRefs", ",", "string", ",", "error", ")", "{", "mirrorsPath", ":=", "baseMirrorsPath", "+", "UnsignedSuffix", "\n", "if", "requireSigned", "{", "mirrorsPath", "=", "baseMirrorsPath", "+", "SignedSuffix", "\n", "}", "\n", "var", "mirrors", "MirrorRefs", "\n", "data", ",", "url", ",", "err", ":=", "fetchData", "(", "source", ",", "mirrorsPath", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "return", "mirrors", ",", "url", ",", "err", "\n", "}", "\n", "return", "mirrors", ",", "url", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "data", ",", "&", "mirrors", ")", "\n", "if", "err", "!=", "nil", "{", "return", "mirrors", ",", "url", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n", "return", "mirrors", ",", "url", ",", "err", "\n", "}" ]

[ "getMirrorRefs", "parses", "and", "returns", "a", "simplestreams", "mirror", "reference", "." ]

[ "func", "getMirror", "(", "source", "DataSource", ",", "mirrors", "MirrorRefs", ",", "datatype", ",", "contentId", "string", ",", "cloudSpec", "CloudSpec", ",", "requireSigned", "bool", ")", "(", "*", "MirrorInfo", ",", "error", ")", "{", "mirrorRef", ",", "err", ":=", "mirrors", ".", "getMirrorReference", "(", "datatype", ",", "contentId", ",", "cloudSpec", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mirrorInfo", ",", "err", ":=", "mirrorRef", ".", "getMirrorInfo", "(", "source", ",", "contentId", ",", "cloudSpec", ",", "MirrorFormat", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "mirrorInfo", "==", "nil", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "contentId", ",", "cloudSpec", ")", "\n", "}", "\n", "return", "mirrorInfo", ",", "nil", "\n", "}" ]

[ "getMirror", "returns", "a", "mirror", "info", "struct", "matching", "the", "specified", "content", "and", "cloud", "." ]

[ "func", "(", "indexRef", "*", "IndexReference", ")", "GetProductsPath", "(", "cons", "LookupConstraint", ")", "(", "string", ",", "error", ")", "{", "if", "indexRef", ".", "MirroredProductsPath", "!=", "\"", "\"", "{", "return", "indexRef", ".", "MirroredProductsPath", ",", "nil", "\n", "}", "\n", "prodIds", ",", "err", ":=", "cons", ".", "ProductIds", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "candidates", ":=", "indexRef", ".", "extractIndexes", "(", "cons", ".", "IndexIds", "(", ")", ")", "\n", "// Restrict to the relevant data type entries.", "dataTypeMatches", ":=", "func", "(", "metadata", "*", "IndexMetadata", ")", "bool", "{", "return", "metadata", ".", "DataType", "==", "indexRef", ".", "valueParams", ".", "DataType", "\n", "}", "\n", "candidates", "=", "candidates", ".", "filter", "(", "dataTypeMatches", ")", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "// TODO: jam 2015-04-01 This isn't a great error to use,", "// because it is generally reserved for file-not-found", "// semantics.", "// This was formatted as: index file missing \"content-download\" data not found", "// It now formats as: \"content-download\" data not found", "// which at least reads better.", "// Shouldn't we be using noMatchingProductsError instead?", "return", "\"", "\"", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "indexRef", ".", "valueParams", ".", "DataType", ")", "\n", "}", "\n", "// Restrict by cloud spec, if required.", "if", "cons", ".", "Params", "(", ")", ".", "CloudSpec", "!=", "EmptyCloudSpec", "{", "hasRightCloud", ":=", "func", "(", "metadata", "*", "IndexMetadata", ")", "bool", "{", "return", "metadata", ".", "hasCloud", "(", "cons", ".", "Params", "(", ")", ".", "CloudSpec", ")", "\n", "}", "\n", "candidates", "=", "candidates", ".", "filter", "(", "hasRightCloud", ")", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "cons", ".", "Params", "(", ")", ".", "CloudSpec", ")", "\n", "}", "\n", "}", "\n", "// Restrict by product IDs.", "hasProduct", ":=", "func", "(", "metadata", "*", "IndexMetadata", ")", "bool", "{", "return", "metadata", ".", "hasProduct", "(", "prodIds", ")", "\n", "}", "\n", "candidates", "=", "candidates", ".", "filter", "(", "hasProduct", ")", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "return", "\"", "\"", ",", "newNoMatchingProductsError", "(", "\"", "\"", ",", "prodIds", ")", "\n", "}", "\n\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "prodIds", ",", "candidates", ")", "\n\n", "// Pick arbitrary match.", "return", "candidates", "[", "0", "]", ".", "ProductsFilePath", ",", "nil", "\n", "}" ]

[ "GetProductsPath", "returns", "the", "path", "to", "the", "metadata", "file", "containing", "products", "for", "the", "specified", "constraint", ".", "Exported", "for", "testing", "." ]

[ "func", "(", "mirrorRefs", "*", "MirrorRefs", ")", "extractMirrorRefs", "(", "contentId", "string", ")", "MirrorRefSlice", "{", "for", "id", ",", "refs", ":=", "range", "mirrorRefs", ".", "Mirrors", "{", "if", "id", "==", "contentId", "{", "return", "refs", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "extractMirrorRefs", "returns", "just", "the", "array", "of", "MirrorRef", "structs", "for", "the", "contentId", "in", "arbitrary", "order", "." ]

[ "func", "(", "mirrorRef", "*", "MirrorReference", ")", "hasCloud", "(", "cloud", "CloudSpec", ")", "bool", "{", "for", "_", ",", "refCloud", ":=", "range", "mirrorRef", ".", "Clouds", "{", "if", "refCloud", ".", "equals", "(", "&", "cloud", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "hasCloud", "tells", "you", "whether", "a", "MirrorReference", "has", "the", "given", "cloud", "in", "its", "Clouds", "list", "." ]

[ "func", "(", "mirrorRefs", "*", "MirrorRefs", ")", "getMirrorReference", "(", "datatype", ",", "contentId", "string", ",", "cloud", "CloudSpec", ")", "(", "*", "MirrorReference", ",", "error", ")", "{", "candidates", ":=", "mirrorRefs", ".", "extractMirrorRefs", "(", "contentId", ")", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "contentId", ")", "\n", "}", "\n", "// Restrict by cloud spec and datatype.", "hasRightCloud", ":=", "func", "(", "mirrorRef", "*", "MirrorReference", ")", "bool", "{", "return", "mirrorRef", ".", "hasCloud", "(", "cloud", ")", "&&", "mirrorRef", ".", "DataType", "==", "datatype", "\n", "}", "\n", "matchingCandidates", ":=", "candidates", ".", "filter", "(", "hasRightCloud", ")", "\n", "if", "len", "(", "matchingCandidates", ")", "==", "0", "{", "// No cloud specific mirrors found so look for a non cloud specific mirror.", "for", "_", ",", "candidate", ":=", "range", "candidates", "{", "if", "len", "(", "candidate", ".", "Clouds", ")", "==", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "contentId", ",", "candidate", ")", "\n", "return", "&", "candidate", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "cloud", ")", "\n", "}", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "contentId", ",", "candidates", ")", "\n\n", "// Pick arbitrary match.", "return", "&", "matchingCandidates", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getMirrorReference", "returns", "the", "reference", "to", "the", "metadata", "file", "containing", "mirrors", "for", "the", "specified", "content", "and", "cloud", "." ]

[ "func", "(", "mirrorRef", "*", "MirrorReference", ")", "getMirrorInfo", "(", "source", "DataSource", ",", "contentId", "string", ",", "cloud", "CloudSpec", ",", "format", "string", ",", "requireSigned", "bool", ")", "(", "*", "MirrorInfo", ",", "error", ")", "{", "metadata", ",", "err", ":=", "GetMirrorMetadataWithFormat", "(", "source", ",", "mirrorRef", ".", "Path", ",", "format", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mirrorInfo", ",", "err", ":=", "metadata", ".", "getMirrorInfo", "(", "contentId", ",", "cloud", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "mirrorInfo", ",", "nil", "\n", "}" ]

[ "getMirrorInfo", "returns", "mirror", "information", "from", "the", "mirror", "file", "at", "the", "given", "path", "for", "the", "specified", "content", "and", "cloud", "." ]

[ "func", "GetMirrorMetadataWithFormat", "(", "source", "DataSource", ",", "mirrorPath", ",", "format", "string", ",", "requireSigned", "bool", ")", "(", "*", "MirrorMetadata", ",", "error", ")", "{", "data", ",", "url", ",", "err", ":=", "fetchData", "(", "source", ",", "mirrorPath", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "||", "errors", ".", "IsUnauthorized", "(", "err", ")", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "var", "mirrors", "MirrorMetadata", "\n", "err", "=", "json", ".", "Unmarshal", "(", "data", ",", "&", "mirrors", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n", "if", "mirrors", ".", "Format", "!=", "format", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "mirrors", ".", "Format", ",", "format", ",", "url", ")", "\n", "}", "\n", "return", "&", "mirrors", ",", "nil", "\n", "}" ]

[ "GetMirrorMetadataWithFormat", "returns", "simplestreams", "mirror", "data", "of", "the", "specified", "format", ".", "Exported", "for", "testing", "." ]

[ "func", "(", "mirrorInfo", "*", "MirrorInfo", ")", "hasCloud", "(", "cloud", "CloudSpec", ")", "bool", "{", "for", "_", ",", "metadataCloud", ":=", "range", "mirrorInfo", ".", "Clouds", "{", "if", "metadataCloud", ".", "equals", "(", "&", "cloud", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "hasCloud", "tells", "you", "whether", "an", "MirrorInfo", "has", "the", "given", "cloud", "in", "its", "Clouds", "list", "." ]

[ "func", "(", "mirrorMetadata", "*", "MirrorMetadata", ")", "getMirrorInfo", "(", "contentId", "string", ",", "cloud", "CloudSpec", ")", "(", "*", "MirrorInfo", ",", "error", ")", "{", "var", "candidates", "MirrorInfoSlice", "\n", "for", "id", ",", "m", ":=", "range", "mirrorMetadata", ".", "Mirrors", "{", "if", "id", "==", "contentId", "{", "candidates", "=", "m", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "contentId", ")", "\n", "}", "\n\n", "// Restrict by cloud spec.", "hasRightCloud", ":=", "func", "(", "mirrorInfo", "*", "MirrorInfo", ")", "bool", "{", "return", "mirrorInfo", ".", "hasCloud", "(", "cloud", ")", "\n", "}", "\n", "candidates", "=", "candidates", ".", "filter", "(", "hasRightCloud", ")", "\n", "if", "len", "(", "candidates", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "NotFoundf", "(", "\"", "\"", ",", "cloud", ")", "\n", "}", "\n\n", "// Pick arbitrary match.", "return", "&", "candidates", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getMirrorInfo", "returns", "the", "mirror", "metadata", "for", "the", "specified", "content", "and", "cloud", "." ]

[ "func", "containsString", "(", "values", "[", "]", "string", ",", "element", "string", ")", "bool", "{", "for", "_", ",", "value", ":=", "range", "values", "{", "if", "value", "==", "element", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "utility", "function", "to", "see", "if", "element", "exists", "in", "values", "slice", "." ]

[ "func", "(", "metadata", "*", "CloudMetadata", ")", "processAliases", "(", "item", "interface", "{", "}", ")", "{", "for", "tag", ":=", "range", "tags", "(", "item", ")", "{", "aliases", ",", "ok", ":=", "metadata", ".", "Aliases", "[", "tag", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "// 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.", "fields", ",", "ok", ":=", "aliases", "[", "fieldByTag", "(", "item", ",", "tag", ")", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "// The alias matches - set all the aliased fields in the struct.", "for", "attr", ",", "val", ":=", "range", "fields", "{", "setFieldByTag", "(", "item", ",", "attr", ",", "val", ",", "true", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "processAliases", "looks", "through", "the", "struct", "fields", "to", "see", "if", "any", "aliases", "apply", "and", "sets", "attributes", "appropriately", "if", "so", "." ]

[ "func", "(", "metadata", "*", "CloudMetadata", ")", "applyAliases", "(", ")", "{", "for", "_", ",", "metadataCatalog", ":=", "range", "metadata", ".", "Products", "{", "for", "_", ",", "ItemCollection", ":=", "range", "metadataCatalog", ".", "Items", "{", "for", "_", ",", "item", ":=", "range", "ItemCollection", ".", "Items", "{", "metadata", ".", "processAliases", "(", "item", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Apply", "any", "attribute", "aliases", "to", "the", "metadata", "records", "." ]

[ "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", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "construct", "iterates", "over", "the", "metadata", "records", "and", "replaces", "the", "generic", "maps", "of", "values", "with", "structs", "of", "the", "required", "type", "." ]

[ "func", "(", "indexRef", "*", "IndexReference", ")", "GetCloudMetadataWithFormat", "(", "cons", "LookupConstraint", ",", "format", "string", ",", "requireSigned", "bool", ")", "(", "*", "CloudMetadata", ",", "error", ")", "{", "productFilesPath", ",", "err", ":=", "indexRef", ".", "GetProductsPath", "(", "cons", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "productFilesPath", ")", "\n", "data", ",", "url", ",", "err", ":=", "fetchData", "(", "indexRef", ".", "Source", ",", "productFilesPath", ",", "requireSigned", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Tracef", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "ParseCloudMetadata", "(", "data", ",", "format", ",", "url", ",", "indexRef", ".", "valueParams", ".", "ValueTemplate", ")", "\n", "}" ]

[ "GetCloudMetadataWithFormat", "loads", "the", "entire", "cloud", "metadata", "encoded", "using", "the", "specified", "format", ".", "Exported", "for", "testing", "." ]

[ "func", "ParseCloudMetadata", "(", "data", "[", "]", "byte", ",", "format", ",", "url", "string", ",", "valueTemplate", "interface", "{", "}", ")", "(", "*", "CloudMetadata", ",", "error", ")", "{", "var", "metadata", "CloudMetadata", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n", "if", "metadata", ".", "Format", "!=", "format", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "metadata", ".", "Format", ",", "format", ",", "url", ")", "\n", "}", "\n", "if", "valueTemplate", "!=", "nil", "{", "err", "=", "metadata", ".", "construct", "(", "reflect", ".", "TypeOf", "(", "valueTemplate", ")", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "string", "(", "data", ")", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "}", "\n", "metadata", ".", "applyAliases", "(", ")", "\n", "metadata", ".", "denormaliseMetadata", "(", ")", "\n", "return", "&", "metadata", ",", "nil", "\n", "}" ]

[ "ParseCloudMetadata", "parses", "the", "given", "bytes", "into", "simplestreams", "metadata", "." ]

[ "func", "paramsFromProviderSpaceInfo", "(", "info", "*", "environs", ".", "ProviderSpaceInfo", ")", "params", ".", "RemoteSpace", "{", "result", ":=", "params", ".", "RemoteSpace", "{", "CloudType", ":", "info", ".", "CloudType", ",", "Name", ":", "info", ".", "Name", ",", "ProviderId", ":", "string", "(", "info", ".", "ProviderId", ")", ",", "ProviderAttributes", ":", "info", ".", "ProviderAttributes", ",", "}", "\n", "for", "_", ",", "subnet", ":=", "range", "info", ".", "Subnets", "{", "resultSubnet", ":=", "params", ".", "Subnet", "{", "CIDR", ":", "subnet", ".", "CIDR", ",", "ProviderId", ":", "string", "(", "subnet", ".", "ProviderId", ")", ",", "ProviderNetworkId", ":", "string", "(", "subnet", ".", "ProviderNetworkId", ")", ",", "ProviderSpaceId", ":", "string", "(", "subnet", ".", "SpaceProviderId", ")", ",", "VLANTag", ":", "subnet", ".", "VLANTag", ",", "Zones", ":", "subnet", ".", "AvailabilityZones", ",", "}", "\n", "result", ".", "Subnets", "=", "append", "(", "result", ".", "Subnets", ",", "resultSubnet", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "paramsFromProviderSpaceInfo", "converts", "a", "ProviderSpaceInfo", "into", "the", "equivalent", "params", ".", "RemoteSpace", "." ]

[ "func", "spaceInfoFromState", "(", "space", "Space", ")", "(", "*", "network", ".", "SpaceInfo", ",", "error", ")", "{", "result", ":=", "&", "network", ".", "SpaceInfo", "{", "Name", ":", "space", ".", "Name", "(", ")", ",", "ProviderId", ":", "space", ".", "ProviderId", "(", ")", ",", "}", "\n", "subnets", ",", "err", ":=", "space", ".", "Subnets", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "subnet", ":=", "range", "subnets", "{", "resultSubnet", ":=", "network", ".", "SubnetInfo", "{", "CIDR", ":", "subnet", ".", "CIDR", "(", ")", ",", "ProviderId", ":", "subnet", ".", "ProviderId", "(", ")", ",", "ProviderNetworkId", ":", "subnet", ".", "ProviderNetworkId", "(", ")", ",", "VLANTag", ":", "subnet", ".", "VLANTag", "(", ")", ",", "AvailabilityZones", ":", "subnet", ".", "AvailabilityZones", "(", ")", ",", "}", "\n", "result", ".", "Subnets", "=", "append", "(", "result", ".", "Subnets", ",", "resultSubnet", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "spaceInfoFromState", "converts", "a", "state", ".", "Space", "into", "the", "equivalent", "network", ".", "SpaceInfo", "." ]

[ "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", "(", ")", "\n", "flavors", ",", "err", ":=", "nova", ".", "ListFlavorsDetail", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Not all needed information is available in flavors,", "// for e.g. architectures or virtualisation types.", "// For these properties, we assume that all instance types support", "// all values.", "allInstanceTypes", ":=", "[", "]", "instances", ".", "InstanceType", "{", "}", "\n", "for", "_", ",", "flavor", ":=", "range", "flavors", "{", "if", "!", "e", ".", "flavorFilter", ".", "AcceptFlavor", "(", "flavor", ")", "{", "continue", "\n", "}", "\n", "instanceType", ":=", "instances", ".", "InstanceType", "{", "Id", ":", "flavor", ".", "Id", ",", "Name", ":", "flavor", ".", "Name", ",", "Arches", ":", "ic", ".", "Arches", ",", "Mem", ":", "uint64", "(", "flavor", ".", "RAM", ")", ",", "CpuCores", ":", "uint64", "(", "flavor", ".", "VCPUs", ")", ",", "RootDisk", ":", "uint64", "(", "flavor", ".", "Disk", "*", "1024", ")", ",", "// tags not currently supported on openstack", "}", "\n", "if", "ic", ".", "Constraints", ".", "HasVirtType", "(", ")", "{", "// Instance Type virtual type depends on the virtual type of the selected image, i.e.", "// picking an image with a virt type gives a machine with this virt type.", "instanceType", ".", "VirtType", "=", "ic", ".", "Constraints", ".", "VirtType", "\n", "}", "\n", "allInstanceTypes", "=", "append", "(", "allInstanceTypes", ",", "instanceType", ")", "\n", "}", "\n\n", "images", ":=", "instances", ".", "ImageMetadataToImages", "(", "imageMetadata", ")", "\n", "spec", ",", "err", ":=", "instances", ".", "FindInstanceSpec", "(", "images", ",", "ic", ",", "allInstanceTypes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// If instance constraints did not have a virtualisation type,", "// but image metadata did, we will have an instance type", "// with virtualisation type of an image.", "if", "!", "ic", ".", "Constraints", ".", "HasVirtType", "(", ")", "&&", "spec", ".", "Image", ".", "VirtType", "!=", "\"", "\"", "{", "spec", ".", "InstanceType", ".", "VirtType", "=", "&", "spec", ".", "Image", ".", "VirtType", "\n", "}", "\n", "return", "spec", ",", "nil", "\n", "}" ]

[ "findInstanceSpec", "returns", "an", "image", "and", "instance", "type", "satisfying", "the", "constraint", ".", "The", "instance", "type", "comes", "from", "querying", "the", "flavors", "supported", "by", "the", "deployment", "." ]

[ "func", "NewClient", "(", "caller", "base", ".", "APICaller", ",", "newWatcher", "NewWatcherFunc", ")", "(", "*", "Client", ",", "error", ")", "{", "modelTag", ",", "ok", ":=", "caller", ".", "ModelTag", "(", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "Client", "{", "modelTag", ":", "modelTag", ",", "caller", ":", "base", ".", "NewFacadeCaller", "(", "caller", ",", "\"", "\"", ")", ",", "newWatcher", ":", "newWatcher", ",", "}", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "client", "for", "accessing", "the", "undertaker", "API", "." ]

[ "func", "(", "c", "*", "Client", ")", "WatchModelResources", "(", ")", "(", "watcher", ".", "NotifyWatcher", ",", "error", ")", "{", "var", "results", "params", ".", "NotifyWatchResults", "\n", "err", ":=", "c", ".", "entityFacadeCall", "(", "\"", "\"", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "results", ".", "Results", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "results", ".", "Results", ")", ")", "\n", "}", "\n", "result", ":=", "results", ".", "Results", "[", "0", "]", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "result", ".", "Error", "\n", "}", "\n", "w", ":=", "c", ".", "newWatcher", "(", "c", ".", "caller", ".", "RawAPICaller", "(", ")", ",", "result", ")", "\n", "return", "w", ",", "nil", "\n", "}" ]

[ "WatchModelResources", "starts", "a", "watcher", "for", "changes", "to", "the", "model", "s", "machines", "and", "applications", "." ]

[ "func", "NewFirewall", "(", "cfg", "environs", ".", "ConfigGetter", ",", "client", "FirewallerAPI", ",", "c", "clock", ".", "Clock", ")", "*", "Firewall", "{", "return", "&", "Firewall", "{", "environ", ":", "cfg", ",", "client", ":", "client", ",", "clock", ":", "c", ",", "}", "\n", "}" ]

[ "NewFirewall", "returns", "a", "new", "Firewall" ]

[ "func", "(", "f", "Firewall", ")", "OpenPorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "mode", ":=", "f", ".", "environ", ".", "Config", "(", ")", ".", "FirewallMode", "(", ")", "\n", "if", "mode", "!=", "config", ".", "FwGlobal", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "mode", ",", ")", "\n", "}", "\n\n", "globalGroupName", ":=", "f", ".", "globalGroupName", "(", ")", "\n", "seclist", ",", "err", ":=", "f", ".", "ensureSecList", "(", "f", ".", "client", ".", "ComposeName", "(", "globalGroupName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "f", ".", "ensureSecRules", "(", "seclist", ",", "rules", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "OpenPorts", "is", "specified", "on", "the", "environ", ".", "Firewaller", "interface", "." ]

[ "func", "(", "f", "Firewall", ")", "ClosePorts", "(", "ctx", "context", ".", "ProviderCallContext", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "groupName", ":=", "f", ".", "globalGroupName", "(", ")", "\n", "return", "f", ".", "closePortsOnList", "(", "ctx", ",", "f", ".", "client", ".", "ComposeName", "(", "groupName", ")", ",", "rules", ")", "\n", "}" ]

[ "ClosePorts", "is", "specified", "on", "the", "environ", ".", "Firewaller", "interface", "." ]

[ "func", "(", "f", "Firewall", ")", "IngressRules", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "return", "f", ".", "GlobalIngressRules", "(", "ctx", ")", "\n", "}" ]

[ "IngressRules", "is", "specified", "on", "the", "environ", ".", "Firewaller", "interface", "." ]

[ "func", "(", "f", "Firewall", ")", "MachineIngressRules", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineId", "string", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "seclist", ":=", "f", ".", "machineGroupName", "(", "machineId", ")", "\n", "return", "f", ".", "getIngressRules", "(", "ctx", ",", "f", ".", "client", ".", "ComposeName", "(", "seclist", ")", ")", "\n", "}" ]

[ "MachineIngressRules", "returns", "all", "ingress", "rules", "from", "the", "machine", "specific", "sec", "list" ]

[ "func", "(", "f", "Firewall", ")", "OpenPortsOnInstance", "(", "ctx", "context", ".", "ProviderCallContext", ",", "machineId", "string", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "error", "{", "machineGroup", ":=", "f", ".", "machineGroupName", "(", "machineId", ")", "\n", "seclist", ",", "err", ":=", "f", ".", "ensureSecList", "(", "f", ".", "client", ".", "ComposeName", "(", "machineGroup", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "f", ".", "ensureSecRules", "(", "seclist", ",", "rules", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "OpenPortsOnInstance", "will", "open", "ports", "corresponding", "to", "the", "supplied", "rules", "on", "the", "given", "instance" ]

[ "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", ")", "\n", "return", "f", ".", "closePortsOnList", "(", "ctx", ",", "f", ".", "client", ".", "ComposeName", "(", "groupName", ")", ",", "rules", ")", "\n", "}" ]

[ "ClosePortsOnInstnace", "will", "close", "ports", "corresponding", "to", "the", "supplied", "rules", "for", "a", "given", "instance", "." ]

[ "func", "(", "f", "Firewall", ")", "CreateMachineSecLists", "(", "machineId", "string", ",", "apiPort", "int", ")", "(", "[", "]", "string", ",", "error", ")", "{", "defaultSecList", ",", "err", ":=", "f", ".", "createDefaultGroupAndRules", "(", "apiPort", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "name", ":=", "f", ".", "machineGroupName", "(", "machineId", ")", "\n", "resourceName", ":=", "f", ".", "client", ".", "ComposeName", "(", "name", ")", "\n", "secList", ",", "err", ":=", "f", ".", "ensureSecList", "(", "resourceName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "[", "]", "string", "{", "defaultSecList", ".", "Name", ",", "secList", ".", "Name", ",", "}", ",", "nil", "\n", "}" ]

[ "CreateMachineSecLists", "creates", "a", "security", "list", "for", "the", "given", "instance", ".", "It", "s", "worth", "noting", "that", "this", "function", "also", "ensures", "that", "the", "default", "environment", "sec", "list", "is", "also", "present", "and", "has", "the", "appropriate", "default", "rules", ".", "The", "port", "parameter", "is", "the", "API", "port", "for", "the", "state", "machine", "for", "which", "we", "need", "to", "create", "rules", "." ]

[ "func", "(", "f", "Firewall", ")", "DeleteMachineSecList", "(", "machineId", "string", ")", "error", "{", "listName", ":=", "f", ".", "machineGroupName", "(", "machineId", ")", "\n", "globalListName", ":=", "f", ".", "globalGroupName", "(", ")", "\n", "err", ":=", "f", ".", "maybeDeleteList", "(", "f", ".", "client", ".", "ComposeName", "(", "listName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// check if we can delete the global list as well", "err", "=", "f", ".", "maybeDeleteList", "(", "f", ".", "client", ".", "ComposeName", "(", "globalListName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteMachineSecList", "will", "delete", "the", "security", "list", "on", "the", "given", "machine" ]

[ "func", "(", "f", "Firewall", ")", "RemoveACLAndRules", "(", "machineId", "string", ")", "error", "{", "groupName", ":=", "f", ".", "machineGroupName", "(", "machineId", ")", "\n", "resourceName", ":=", "f", ".", "client", ".", "ComposeName", "(", "groupName", ")", "\n", "secRules", ",", "err", ":=", "f", ".", "getAllSecurityRules", "(", "resourceName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "secRules", "{", "err", ":=", "f", ".", "client", ".", "DeleteSecurityRule", "(", "val", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "api", ".", "IsNotFound", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "err", "=", "f", ".", "client", ".", "DeleteAcl", "(", "resourceName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "api", ".", "IsNotFound", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RemoveACLAndRules", "will", "remove", "the", "ACL", "and", "any", "associated", "rules", "." ]

[ "func", "(", "f", "Firewall", ")", "GlobalIngressRules", "(", "ctx", "context", ".", "ProviderCallContext", ")", "(", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "seclist", ":=", "f", ".", "globalGroupName", "(", ")", "\n", "return", "f", ".", "getIngressRules", "(", "ctx", ",", "f", ".", "client", ".", "ComposeName", "(", "seclist", ")", ")", "\n", "}" ]

[ "GlobalIngressRules", "returns", "the", "ingress", "rules", "applied", "to", "the", "whole", "environment", "." ]

[ "func", "(", "f", "Firewall", ")", "getDefaultIngressRules", "(", "apiPort", "int", ")", "[", "]", "network", ".", "IngressRule", "{", "return", "[", "]", "network", ".", "IngressRule", "{", "{", "PortRange", ":", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "22", ",", "ToPort", ":", "22", ",", "Protocol", ":", "\"", "\"", ",", "}", ",", "SourceCIDRs", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", ",", "{", "PortRange", ":", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "3389", ",", "ToPort", ":", "3389", ",", "Protocol", ":", "\"", "\"", ",", "}", ",", "SourceCIDRs", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", ",", "{", "PortRange", ":", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "apiPort", ",", "ToPort", ":", "apiPort", ",", "Protocol", ":", "\"", "\"", ",", "}", ",", "SourceCIDRs", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", ",", "{", "PortRange", ":", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "controller", ".", "DefaultStatePort", ",", "ToPort", ":", "controller", ".", "DefaultStatePort", ",", "Protocol", ":", "\"", "\"", ",", "}", ",", "SourceCIDRs", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "getDefaultIngressRules", "will", "create", "the", "default", "ingressRules", "given", "an", "api", "port" ]

[ "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", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// converts all security rules into a map of ingress rules", "mapping", ",", "err", ":=", "f", ".", "secRuleToIngresRule", "(", "secrules", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "//TODO (gsamfira): optimize this", "for", "name", ",", "rule", ":=", "range", "mapping", "{", "sort", ".", "Strings", "(", "rule", ".", "SourceCIDRs", ")", "\n", "for", "_", ",", "ingressRule", ":=", "range", "rules", "{", "sort", ".", "Strings", "(", "ingressRule", ".", "SourceCIDRs", ")", "\n", "if", "reflect", ".", "DeepEqual", "(", "rule", ",", "ingressRule", ")", "{", "err", ":=", "f", ".", "client", ".", "DeleteSecRule", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "closePortsOnList", "on", "list", "will", "close", "all", "ports", "corresponding", "to", "the", "supplied", "ingress", "rules", "on", "a", "particular", "list" ]

[ "func", "(", "f", "Firewall", ")", "deleteAllSecRulesOnList", "(", "list", "string", ")", "error", "{", "// get all security rules associated with this list", "secrules", ",", "err", ":=", "f", ".", "getSecRules", "(", "list", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// delete everything", "for", "_", ",", "rule", ":=", "range", "secrules", "{", "err", ":=", "f", ".", "client", ".", "DeleteSecRule", "(", "rule", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "if", "api", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "deleteAllSecRulesOnList", "will", "delete", "all", "security", "rules", "from", "a", "give", "security", "list" ]

[ "func", "(", "f", "*", "Firewall", ")", "maybeDeleteList", "(", "list", "string", ")", "error", "{", "filter", ":=", "[", "]", "api", ".", "Filter", "{", "{", "Arg", ":", "\"", "\"", ",", "Value", ":", "list", ",", "}", ",", "}", "\n", "iter", ":=", "0", "\n", "found", ":=", "true", "\n", "var", "assoc", "response", ".", "AllSecAssociations", "\n", "for", "{", "if", "iter", ">=", "10", "{", "break", "\n", "}", "\n", "assoc", ",", "err", ":=", "f", ".", "client", ".", "AllSecAssociations", "(", "filter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "assoc", ".", "Result", ")", ">", "0", "{", "<-", "f", ".", "clock", ".", "After", "(", "1", "*", "time", ".", "Second", ")", "\n", "iter", "++", "\n", "continue", "\n", "}", "\n", "found", "=", "false", "\n", "break", "\n", "}", "\n", "if", "found", "{", "logger", ".", "Warningf", "(", "\"", "\"", ",", "list", ",", "assoc", ".", "Result", ",", ")", "\n", "return", "nil", "\n", "}", "\n", "err", ":=", "f", ".", "deleteAllSecRulesOnList", "(", "list", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "list", ")", "\n", "err", "=", "f", ".", "client", ".", "DeleteSecList", "(", "list", ")", "\n", "if", "err", "!=", "nil", "{", "if", "api", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "maybeDeleteList", "tries", "to", "delete", "a", "security", "list", ".", "Lists", "that", "are", "still", "in", "use", "may", "not", "be", "deleted", ".", "When", "deleting", "an", "environment", "we", "want", "to", "also", "cleanup", "the", "environment", "level", "sec", "list", ".", "This", "function", "attempts", "to", "delete", "a", "sec", "list", ".", "If", "the", "sec", "list", "still", "has", "some", "associations", "to", "any", "instance", "we", "simply", "return", "and", "assume", "the", "last", "VM", "to", "get", "killed", "as", "part", "of", "the", "tear", "-", "down", "will", "also", "remove", "the", "global", "list", "as", "well" ]

[ "func", "(", "f", "Firewall", ")", "getAllApplications", "(", ")", "(", "[", "]", "response", ".", "SecApplication", ",", "error", ")", "{", "// get all user defined sec applications", "applications", ",", "err", ":=", "f", ".", "client", ".", "AllSecApplications", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// get also default ones defined in the provider", "defaultApps", ",", "err", ":=", "f", ".", "client", ".", "DefaultSecApplications", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "allApps", ":=", "[", "]", "response", ".", "SecApplication", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "applications", ".", "Result", "{", "if", "val", ".", "PortProtocolPair", "(", ")", "==", "\"", "\"", "{", "// (gsamfira):this should not really happen,", "// but I get paranoid when I run out of coffee", "continue", "\n", "}", "\n", "allApps", "=", "append", "(", "allApps", ",", "val", ")", "\n", "}", "\n", "for", "_", ",", "val", ":=", "range", "defaultApps", ".", "Result", "{", "if", "val", ".", "PortProtocolPair", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "allApps", "=", "append", "(", "allApps", ",", "val", ")", "\n", "}", "\n", "return", "allApps", ",", "nil", "\n", "}" ]

[ "getAllApplications", "returns", "all", "security", "applications", "known", "to", "the", "oracle", "compute", "cloud", ".", "These", "are", "used", "as", "part", "of", "security", "rules" ]

[ "func", "(", "f", "Firewall", ")", "getAllApplicationsAsMap", "(", ")", "(", "map", "[", "string", "]", "response", ".", "SecApplication", ",", "error", ")", "{", "// get all defined protocols", "// from the current identity and default ones", "apps", ",", "err", ":=", "f", ".", "getAllApplications", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// copy all of them into this map", "allApps", ":=", "map", "[", "string", "]", "response", ".", "SecApplication", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "apps", "{", "if", "val", ".", "String", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "allApps", "[", "val", ".", "String", "(", ")", "]", ";", "!", "ok", "{", "allApps", "[", "val", ".", "String", "(", ")", "]", "=", "val", "\n", "}", "\n", "}", "\n", "return", "allApps", ",", "nil", "\n", "}" ]

[ "getAllApplicationsAsMap", "returns", "all", "sec", "applications", "as", "a", "map" ]

[ "func", "(", "f", "Firewall", ")", "convertToSecRules", "(", "seclist", "response", ".", "SecList", ",", "rules", "[", "]", "network", ".", "IngressRule", ")", "(", "[", "]", "api", ".", "SecRuleParams", ",", "error", ")", "{", "applications", ",", "err", ":=", "f", ".", "getAllApplications", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "iplists", ",", "err", ":=", "f", ".", "getAllIPLists", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "ret", ":=", "make", "(", "[", "]", "api", ".", "SecRuleParams", ",", "0", ",", "len", "(", "rules", ")", ")", "\n", "// for every rule we need to ensure that the there is a relationship", "// between security applications and security IP lists", "// and from every one of them create a slice of security rule parameters", "for", "_", ",", "val", ":=", "range", "rules", "{", "app", ",", "err", ":=", "f", ".", "ensureApplication", "(", "val", ".", "PortRange", ",", "&", "applications", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "ipList", ",", "err", ":=", "f", ".", "ensureSecIpList", "(", "val", ".", "SourceCIDRs", ",", "&", "iplists", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "uuid", ",", "err", ":=", "utils", ".", "NewUUID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "name", ":=", "f", ".", "newResourceName", "(", "uuid", ".", "String", "(", ")", ")", "\n", "resourceName", ":=", "f", ".", "client", ".", "ComposeName", "(", "name", ")", "\n", "dstList", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "seclist", ".", "Name", ")", "\n", "srcList", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ipList", ")", "\n", "// create the new security rule parameters", "rule", ":=", "api", ".", "SecRuleParams", "{", "Action", ":", "common", ".", "SecRulePermit", ",", "Application", ":", "app", ",", "Description", ":", "\"", "\"", ",", "Disabled", ":", "false", ",", "Dst_list", ":", "dstList", ",", "Name", ":", "resourceName", ",", "Src_list", ":", "srcList", ",", "}", "\n", "// append the new parameters rule", "ret", "=", "append", "(", "ret", ",", "rule", ")", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "convertToSecRules", "converts", "network", ".", "IngressRules", "to", "api", ".", "SecRuleParams" ]

[ "func", "(", "f", "Firewall", ")", "convertApplicationToPortRange", "(", "app", "response", ".", "SecApplication", ")", "corenetwork", ".", "PortRange", "{", "appCopy", ":=", "app", "\n", "if", "appCopy", ".", "Value2", "==", "-", "1", "{", "appCopy", ".", "Value2", "=", "appCopy", ".", "Value1", "\n", "}", "\n", "return", "corenetwork", ".", "PortRange", "{", "FromPort", ":", "appCopy", ".", "Value1", ",", "ToPort", ":", "appCopy", ".", "Value2", ",", "Protocol", ":", "string", "(", "appCopy", ".", "Protocol", ")", ",", "}", "\n", "}" ]

[ "convertApplicationToPortRange", "takes", "a", "SecApplication", "and", "converts", "it", "to", "a", "network", ".", "PortRange", "type" ]

[ "func", "(", "f", "Firewall", ")", "convertFromSecRules", "(", "rules", "...", "response", ".", "SecRule", ")", "(", "map", "[", "string", "]", "[", "]", "network", ".", "IngressRule", ",", "error", ")", "{", "applications", ",", "err", ":=", "f", ".", "getAllApplicationsAsMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "iplists", ",", "err", ":=", "f", ".", "getAllIPListsAsMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "ret", ":=", "map", "[", "string", "]", "[", "]", "network", ".", "IngressRule", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "rules", "{", "app", ":=", "val", ".", "Application", "\n", "srcList", ":=", "strings", ".", "TrimPrefix", "(", "val", ".", "Src_list", ",", "\"", "\"", ")", "\n", "dstList", ":=", "strings", ".", "TrimPrefix", "(", "val", ".", "Dst_list", ",", "\"", "\"", ")", "\n", "portRange", ":=", "f", ".", "convertApplicationToPortRange", "(", "applications", "[", "app", "]", ")", "\n", "if", "_", ",", "ok", ":=", "ret", "[", "dstList", "]", ";", "!", "ok", "{", "ret", "[", "dstList", "]", "=", "[", "]", "network", ".", "IngressRule", "{", "{", "PortRange", ":", "portRange", ",", "SourceCIDRs", ":", "iplists", "[", "srcList", "]", ".", "Secipentries", ",", "}", ",", "}", "\n", "}", "else", "{", "toAdd", ":=", "network", ".", "IngressRule", "{", "PortRange", ":", "portRange", ",", "SourceCIDRs", ":", "iplists", "[", "srcList", "]", ".", "Secipentries", ",", "}", "\n", "ret", "[", "dstList", "]", "=", "append", "(", "ret", "[", "dstList", "]", ",", "toAdd", ")", "\n", "}", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "convertFromSecRules", "takes", "a", "slice", "of", "security", "rules", "and", "creates", "a", "map", "of", "them" ]

[ "func", "(", "f", "Firewall", ")", "globalGroupName", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ".", "environ", ".", "Config", "(", ")", ".", "UUID", "(", ")", ")", "\n", "}" ]

[ "globalGroupName", "returns", "the", "global", "group", "name", "derived", "from", "the", "model", "UUID" ]

[ "func", "(", "f", "Firewall", ")", "machineGroupName", "(", "machineId", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ".", "environ", ".", "Config", "(", ")", ".", "UUID", "(", ")", ",", "machineId", ")", "\n", "}" ]

[ "machineGroupName", "returns", "the", "machine", "group", "name", "derived", "from", "the", "model", "UUID", "and", "the", "machine", "ID" ]

[ "func", "(", "f", "Firewall", ")", "newResourceName", "(", "appName", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ".", "environ", ".", "Config", "(", ")", ".", "UUID", "(", ")", ",", "appName", ")", "\n", "}" ]

[ "resourceName", "returns", "the", "resource", "name", "derived", "from", "the", "model", "UUID", "and", "the", "name", "of", "the", "resource" ]

[ "func", "(", "f", "Firewall", ")", "getAllSecurityRules", "(", "aclName", "string", ")", "(", "[", "]", "response", ".", "SecurityRule", ",", "error", ")", "{", "rules", ",", "err", ":=", "f", ".", "client", ".", "AllSecurityRules", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "aclName", "==", "\"", "\"", "{", "return", "rules", ".", "Result", ",", "nil", "\n", "}", "\n", "var", "ret", "[", "]", "response", ".", "SecurityRule", "\n", "for", "_", ",", "val", ":=", "range", "rules", ".", "Result", "{", "if", "val", ".", "Acl", "==", "aclName", "{", "ret", "=", "append", "(", "ret", ",", "val", ")", "\n", "}", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "get", "all", "security", "rules", "associated", "with", "an", "ACL" ]

[ "func", "(", "f", "Firewall", ")", "getSecRules", "(", "seclist", "string", ")", "(", "[", "]", "response", ".", "SecRule", ",", "error", ")", "{", "// we only care about ingress rules", "name", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "seclist", ")", "\n", "rulesFilter", ":=", "[", "]", "api", ".", "Filter", "{", "{", "Arg", ":", "\"", "\"", ",", "Value", ":", "name", ",", "}", ",", "}", "\n", "rules", ",", "err", ":=", "f", ".", "client", ".", "AllSecRules", "(", "rulesFilter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "// gsamfira: the oracle compute API does not allow filtering by action", "ret", ":=", "[", "]", "response", ".", "SecRule", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "rules", ".", "Result", "{", "// gsamfira: We set a default policy of DENY. No use in worrying about", "// DENY rules (if by any chance someone add one manually for some reason)", "if", "val", ".", "Action", "!=", "common", ".", "SecRulePermit", "{", "continue", "\n", "}", "\n", "// We only care about rules that have a destination set", "// to a security list. Those lists get attached to VMs", "// NOTE: someone decided, when writing the oracle API", "// that some fields should be bool, some should be string.", "// never mind they both are boolean values...but hey.", "// I swear...some people like to watch the world burn", "if", "val", ".", "Dst_is_ip", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "// We only care about rules that have an IP list as source", "if", "val", ".", "Src_is_ip", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "ret", "=", "append", "(", "ret", ",", "val", ")", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "getSecRules", "retrieves", "the", "security", "rules", "associated", "with", "a", "particular", "security", "list" ]

[ "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", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "seclist", ".", "Name", ",", "secRules", ")", "\n\n", "converted", ",", "err", ":=", "f", ".", "convertFromSecRules", "(", "secRules", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "converted", ")", "\n", "asIngressRules", ":=", "converted", "[", "seclist", ".", "Name", "]", "\n", "missing", ":=", "[", "]", "network", ".", "IngressRule", "{", "}", "\n\n", "// search through all rules and find the missing ones", "for", "_", ",", "toAdd", ":=", "range", "rules", "{", "found", ":=", "false", "\n", "for", "_", ",", "exists", ":=", "range", "asIngressRules", "{", "sort", ".", "Strings", "(", "toAdd", ".", "SourceCIDRs", ")", "\n", "sort", ".", "Strings", "(", "exists", ".", "SourceCIDRs", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "toAdd", ".", "SourceCIDRs", ",", "exists", ".", "SourceCIDRs", ")", "\n", "if", "reflect", ".", "DeepEqual", "(", "toAdd", ",", "exists", ")", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "found", "{", "continue", "\n", "}", "\n", "missing", "=", "append", "(", "missing", ",", "toAdd", ")", "\n", "}", "\n", "if", "len", "(", "missing", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "missing", ")", "\n", "// convert the missing rules back to sec rules", "asSecRule", ",", "err", ":=", "f", ".", "convertToSecRules", "(", "seclist", ",", "missing", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "val", ":=", "range", "asSecRule", "{", "_", ",", "err", "=", "f", ".", "client", ".", "CreateSecRule", "(", "val", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ensureSecRules", "ensures", "that", "the", "list", "passed", "has", "all", "the", "rules", "that", "it", "needs", "if", "one", "is", "missing", "it", "will", "create", "it", "inside", "the", "oracle", "cloud", "environment", "and", "it", "will", "return", "nil", "if", "none", "rule", "is", "missing", "then", "it", "will", "return", "nil" ]

[ "func", "(", "f", "Firewall", ")", "ensureSecList", "(", "name", "string", ")", "(", "response", ".", "SecList", ",", "error", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ")", "\n", "// check if the security list is already there", "details", ",", "err", ":=", "f", ".", "client", ".", "SecListDetails", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "if", "api", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Infof", "(", "\"", "\"", ",", "name", ")", "\n", "details", ",", "err", ":=", "f", ".", "client", ".", "CreateSecList", "(", "\"", "\"", ",", "name", ",", "common", ".", "SecRulePermit", ",", "common", ".", "SecRuleDeny", ")", "\n", "if", "err", "!=", "nil", "{", "return", "response", ".", "SecList", "{", "}", ",", "err", "\n", "}", "\n", "return", "details", ",", "nil", "\n", "}", "\n", "return", "response", ".", "SecList", "{", "}", ",", "err", "\n", "}", "\n", "return", "details", ",", "nil", "\n", "}" ]

[ "ensureSecList", "creates", "a", "new", "seclist", "if", "one", "does", "not", "already", "exist", ".", "this", "function", "is", "idempotent" ]

[ "func", "(", "f", "Firewall", ")", "getAllIPListsAsMap", "(", ")", "(", "map", "[", "string", "]", "response", ".", "SecIpList", ",", "error", ")", "{", "allIps", ",", "err", ":=", "f", ".", "getAllIPLists", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "allIpLists", ":=", "map", "[", "string", "]", "response", ".", "SecIpList", "{", "}", "\n", "for", "_", ",", "val", ":=", "range", "allIps", "{", "allIpLists", "[", "val", ".", "Name", "]", "=", "val", "\n", "}", "\n", "return", "allIpLists", ",", "nil", "\n", "}" ]

[ "getAllIPListsAsMap", "returns", "all", "IP", "lists", "as", "a", "map", "with", "the", "key", "being", "the", "resource", "name" ]

[ "func", "(", "f", "Firewall", ")", "ensureSecIpList", "(", "cidr", "[", "]", "string", ",", "cache", "*", "[", "]", "response", ".", "SecIpList", ")", "(", "string", ",", "error", ")", "{", "sort", ".", "Strings", "(", "cidr", ")", "\n", "for", "_", ",", "val", ":=", "range", "*", "cache", "{", "sort", ".", "Strings", "(", "val", ".", "Secipentries", ")", "\n", "if", "reflect", ".", "DeepEqual", "(", "val", ".", "Secipentries", ",", "cidr", ")", "{", "return", "val", ".", "Name", ",", "nil", "\n", "}", "\n", "}", "\n", "uuid", ",", "err", ":=", "utils", ".", "NewUUID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "name", ":=", "f", ".", "newResourceName", "(", "uuid", ".", "String", "(", ")", ")", "\n", "resource", ":=", "f", ".", "client", ".", "ComposeName", "(", "name", ")", "\n", "secList", ",", "err", ":=", "f", ".", "client", ".", "CreateSecIpList", "(", "\"", "\"", ",", "resource", ",", "cidr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "*", "cache", "=", "append", "(", "*", "cache", ",", "secList", ")", "\n", "return", "secList", ".", "Name", ",", "nil", "\n", "}" ]

[ "ensureSecIpList", "ensures", "that", "a", "sec", "ip", "list", "with", "the", "provided", "cidr", "list", "exists", ".", "If", "one", "does", "not", "it", "gets", "created", ".", "This", "function", "is", "idempotent", "." ]

[ "func", "(", "h", "*", "backupHandler", ")", "sendError", "(", "w", "http", ".", "ResponseWriter", ",", "err", "error", ")", "{", "err", ",", "status", ":=", "common", ".", "ServerErrorAndStatus", "(", "err", ")", "\n", "if", "err", ":=", "sendStatusAndJSON", "(", "w", ",", "status", ",", "err", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "sendError", "sends", "a", "JSON", "-", "encoded", "error", "response", ".", "Note", "the", "difference", "from", "the", "error", "response", "sent", "by", "the", "sendError", "function", "-", "the", "error", "is", "encoded", "directly", "rather", "than", "in", "the", "Error", "field", "." ]

[ "func", "(", "rs", "*", "Resources", ")", "Get", "(", "id", "string", ")", "facade", ".", "Resource", "{", "rs", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rs", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "rs", ".", "resources", "[", "id", "]", "\n", "}" ]

[ "Get", "returns", "the", "resource", "for", "the", "given", "id", "or", "nil", "if", "there", "is", "no", "such", "resource", "." ]

[ "func", "(", "rs", "*", "Resources", ")", "Register", "(", "r", "facade", ".", "Resource", ")", "string", "{", "rs", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rs", ".", "mu", ".", "Unlock", "(", ")", "\n", "rs", ".", "maxId", "++", "\n", "id", ":=", "strconv", ".", "FormatUint", "(", "rs", ".", "maxId", ",", "10", ")", "\n", "rs", ".", "resources", "[", "id", "]", "=", "r", "\n", "rs", ".", "stack", "=", "append", "(", "rs", ".", "stack", ",", "id", ")", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "id", ")", "\n", "return", "id", "\n", "}" ]

[ "Register", "registers", "the", "given", "resource", ".", "It", "returns", "a", "unique", "identifier", "for", "the", "resource", "which", "can", "then", "be", "used", "in", "subsequent", "API", "requests", "to", "refer", "to", "the", "resource", "." ]

[ "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", "// well with the way we invariably implement Stop.", "logger", ".", "Tracef", "(", "\"", "\"", ",", "id", ")", "\n", "r", ":=", "rs", ".", "Get", "(", "id", ")", "\n", "if", "r", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "err", ":=", "r", ".", "Stop", "(", ")", "\n", "rs", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rs", ".", "mu", ".", "Unlock", "(", ")", "\n", "delete", "(", "rs", ".", "resources", ",", "id", ")", "\n", "for", "pos", ":=", "0", ";", "pos", "<", "len", "(", "rs", ".", "stack", ")", ";", "pos", "++", "{", "if", "rs", ".", "stack", "[", "pos", "]", "==", "id", "{", "rs", ".", "stack", "=", "append", "(", "rs", ".", "stack", "[", "0", ":", "pos", "]", ",", "rs", ".", "stack", "[", "pos", "+", "1", ":", "]", "...", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Stop", "stops", "the", "resource", "with", "the", "given", "id", "and", "unregisters", "it", ".", "It", "returns", "any", "error", "from", "the", "underlying", "Stop", "call", ".", "It", "does", "not", "return", "an", "error", "if", "the", "resource", "has", "already", "been", "unregistered", "." ]

[ "func", "(", "rs", "*", "Resources", ")", "StopAll", "(", ")", "{", "rs", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rs", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "i", ":=", "len", "(", "rs", ".", "stack", ")", ";", "i", ">", "0", ";", "i", "--", "{", "id", ":=", "rs", ".", "stack", "[", "i", "-", "1", "]", "\n", "r", ":=", "rs", ".", "resources", "[", "id", "]", "\n", "logger", ".", "Tracef", "(", "\"", "\"", ",", "id", ")", "\n", "if", "err", ":=", "r", ".", "Stop", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "r", ",", "err", ")", "\n", "}", "\n", "}", "\n", "rs", ".", "resources", "=", "make", "(", "map", "[", "string", "]", "facade", ".", "Resource", ")", "\n", "rs", ".", "stack", "=", "nil", "\n", "}" ]

[ "StopAll", "stops", "all", "the", "resources", "." ]

[ "func", "(", "rs", "*", "Resources", ")", "Count", "(", ")", "int", "{", "rs", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "rs", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "len", "(", "rs", ".", "resources", ")", "\n", "}" ]

[ "Count", "returns", "the", "number", "of", "resources", "currently", "held", "." ]

[ "func", "(", "s", "*", "Space", ")", "ProviderId", "(", ")", "network", ".", "Id", "{", "return", "network", ".", "Id", "(", "s", ".", "doc", ".", "ProviderId", ")", "\n", "}" ]

[ "ProviderId", "returns", "the", "provider", "id", "of", "the", "space", ".", "This", "will", "be", "the", "empty", "string", "except", "on", "substrates", "that", "directly", "support", "spaces", "." ]

[ "func", "(", "s", "*", "Space", ")", "Subnets", "(", ")", "(", "results", "[", "]", "*", "Subnet", ",", "err", "error", ")", "{", "defer", "errors", ".", "DeferredAnnotatef", "(", "&", "err", ",", "\"", "\"", ")", "\n", "name", ":=", "s", ".", "Name", "(", ")", "\n\n", "subnetsCollection", ",", "closer", ":=", "s", ".", "st", ".", "db", "(", ")", ".", "GetCollection", "(", "subnetsC", ")", "\n", "defer", "closer", "(", ")", "\n\n", "var", "doc", "subnetDoc", "\n", "// We ignore space-name field for FAN subnets...", "iter", ":=", "subnetsCollection", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "name", "}", ",", "bson", ".", "DocElem", "{", "\"", "\"", ",", "bson", ".", "D", "{", "{", "\"", "\"", ",", "false", "}", "}", "}", "}", ")", ".", "Iter", "(", ")", "\n", "defer", "iter", ".", "Close", "(", ")", "\n", "for", "iter", ".", "Next", "(", "&", "doc", ")", "{", "subnet", ":=", "&", "Subnet", "{", "s", ".", "st", ",", "doc", ",", "name", "}", "\n", "results", "=", "append", "(", "results", ",", "subnet", ")", "\n", "// ...and then add them explicitly as descendants of underlay network.", "childIter", ":=", "subnetsCollection", ".", "Find", "(", "bson", ".", "D", "{", "{", "\"", "\"", ",", "doc", ".", "CIDR", "}", "}", ")", ".", "Iter", "(", ")", "\n", "for", "childIter", ".", "Next", "(", "&", "doc", ")", "{", "subnet", ":=", "&", "Subnet", "{", "s", ".", "st", ",", "doc", ",", "name", "}", "\n", "results", "=", "append", "(", "results", ",", "subnet", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "iter", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "Subnets", "returns", "all", "the", "subnets", "associated", "with", "the", "Space", "." ]