/// <summary> /// Constructor. /// </summary> /// <param name="hive">The hive being managed.</param> /// <param name="logFolder"> /// The folder where log files are to be written, otherwise or <c>null</c> or /// empty if logging is disabled. /// </param> public XenServerHostingManager(HiveProxy hive, string logFolder = null) { this.hive = hive; this.hive.HostingManager = this; this.logFolder = logFolder; this.maxVmNameWidth = hive.Definition.Nodes.Max(n => n.Name.Length) + hive.Definition.Hosting.GetVmNamePrefix(hive.Definition).Length; }
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> internal HiveMQManager(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); this.hive = hive; this.Internal = new InternalManager(this); }
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> internal DockerManager(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); this.hive = hive; this.Config = new DockerConfigManager(hive); this.Secret = new DockerSecretManager(hive); }
/// <inheritdoc/> public override void Run(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); var node = hive.GetNode(nodeName); node.SudoCommand("docker-volume-rm", volumeName); }
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> /// <param name="name">The traffic manager name (<b>public</b> or <b>private</b>).</param> /// <param name="useBootstrap"> /// Optionally specifies that the instance should use the HiveMQ client /// to directly reference to the HiveMQ cluster nodes for broadcasting /// proxy update messages rather than routing traffic through the <b>private</b> /// traffic manager. This is used internally to resolve chicken-and-the-egg /// dilemmas for the traffic manager and proxy implementations that rely on /// HiveMQ messaging. /// </param> internal TrafficManager(HiveProxy hive, string name, bool useBootstrap = false) { Covenant.Requires <ArgumentNullException>(hive != null); Covenant.Requires <ArgumentException>(name == "public" || name == "private"); this.hive = hive; this.Name = name; this.useBootstrap = useBootstrap; }
/// <summary> /// Returns the <see cref="HostingManager"/> for a specific environment. /// </summary> /// <param name="hive">The hive being managed.</param> /// <param name="logFolder"> /// The folder where log files are to be written, otherwise or <c>null</c> or /// empty if logging is disabled. /// </param> /// <returns> /// The <see cref="HostingManager"/> or <c>null</c> if no hosting manager /// could be located for the specified hive environment. /// </returns> public HostingManager GetManager(HiveProxy hive, string logFolder = null) { Covenant.Requires <ArgumentNullException>(hive != null); Covenant.Assert(environmentToHostingManager != null, $"[{nameof(HostingLoader)}] is not initialized. You must call [{nameof(HostingLoader)}.{nameof(HostingLoader.Initialize)}()] first."); if (!environmentToHostingManager.TryGetValue(hive.Definition.Hosting.Environment, out var managerType)) { return(null); } return((HostingManager)Activator.CreateInstance(managerType, hive, logFolder)); }
/// <inheritdoc/> public override void Run(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); var node = hive.GetNode(nodeName); if (operationName != null) { node.InvokeIdempotentAction(operationName, () => action(node)); } else { action(node); } }
/// <inheritdoc/> public override void Run(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); foreach (var node in hive.Nodes) { node.Status = $"pause {delay}"; } Thread.Sleep(delay); foreach (var node in hive.Nodes) { node.Status = string.Empty; } }
/// <inheritdoc/> public void Validate(HiveDefinition hiveDefinition) { CheckInitialized(); Covenant.Requires <ArgumentNullException>(hiveDefinition != null); var hive = new HiveProxy(hiveDefinition); var manager = GetManager(hive); if (manager == null) { throw new HiveException($"Cannot locate a [{nameof(IHostingManager)}] implementation for the [{hiveDefinition.Hosting.Environment}] hosting environment."); } manager.Validate(hiveDefinition); }
/// <inheritdoc/> public override void Run(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); var node = hive.GetNode(nodeName); var status = this.ToString(); node.UploadText(path, text, tabStop, outputEncoding); if (!string.IsNullOrEmpty(permissions)) { node.SudoCommand("chmod", permissions, path); } StatusPause(); node.Status = string.Empty; }
//--------------------------------------------------------------------- // Static members /// <summary> /// Returns the summary from a hive proxy. /// </summary> /// <param name="hive">The target hive proxy.</param> /// <param name="definition">Optionally overrides the hive definition passed within <paramref name="hive"/>.</param> /// <returns>The <see cref="HiveSummary"/>.</returns> public static HiveSummary FromHive(HiveProxy hive, HiveDefinition definition = null) { Covenant.Requires <ArgumentNullException>(hive != null); var summary = new HiveSummary(); // Load the hive globals. var globals = hive.Consul.Client.KV.DictionaryOrEmpty(HiveConst.GlobalKey).Result; var internals = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase) { // We don't include these internal globals in the summary. HiveGlobals.DefinitionDeflate, HiveGlobals.DefinitionHash, HiveGlobals.PetsDefinition }; foreach (var item in globals.Where(i => !internals.Contains(i.Key))) { summary.Globals.Add(item.Key, Encoding.UTF8.GetString(item.Value)); } // Summarize information from the hive definition. summary.NodeCount = definition.Nodes.Count(); summary.ManagerCount = definition.Managers.Count(); summary.WorkerCount = definition.Workers.Count(); summary.PetCount = definition.Pets.Count(); summary.OperatingSystem = definition.HiveNode.OperatingSystem; summary.HostingEnvironment = definition.Hosting.Environment; summary.HiveFSEnabled = definition.HiveFS.Enabled; summary.LogEnabled = definition.Log.Enabled; summary.VpnEnabled = definition.Vpn.Enabled; return(summary); }
/// <summary> /// Called internally by <see cref="HiveHelper.OpenHiveRemote(DebugSecrets, DebugConfigs, string, bool)"/> /// to create any requested Vault and Consul credentials and add them to the dictionary. /// </summary> /// <param name="hive">The attached hive.</param> /// <param name="hiveLogin">The hive login.</param> internal void Realize(HiveProxy hive, HiveLogin hiveLogin) { this.hiveLogin = hiveLogin; HiveCredentials credentials; foreach (var request in credentialRequests) { switch (request.Type) { case CredentialType.VaultToken: // Serialize the credentials as JSON and persist. credentials = HiveCredentials.FromVaultToken(request.Token); Add(request.SecretName, NeonHelper.JsonSerialize(credentials, Formatting.Indented)); break; case CredentialType.VaultAppRole: // Serialize the credentials as JSON and persist. credentials = VaultClient.GetAppRoleCredentialsAsync(request.RoleName).Result; Add(request.SecretName, NeonHelper.JsonSerialize(credentials, Formatting.Indented)); break; case CredentialType.ConsulToken: // $todo(jeff.lill): Implement this. break; } } }
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> internal RegistryManager(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); this.hive = hive; }
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> internal DockerConfigManager(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); this.hive = hive; }
/// <summary> /// Implements the configuration step. /// </summary> /// <param name="hive">The hive proxy instance.</param> public abstract void Run(HiveProxy hive);
/// <summary> /// Internal constructor. /// </summary> /// <param name="hive">The parent <see cref="HiveProxy"/>.</param> internal CertificateManager(HiveProxy hive) { Covenant.Requires <ArgumentNullException>(hive != null); this.hive = hive; }
/// <summary> /// Constructor. /// </summary> /// <param name="hive">The hive being managed.</param> /// <param name="logFolder"> /// The folder where log files are to be written, otherwise or <c>null</c> or /// empty if logging is disabled. /// </param> public HyperVDevHostingManager(HiveProxy hive, string logFolder = null) { hive.HostingManager = this; this.hive = hive; }
/// <summary> /// Called internally by <see cref="HiveHelper.OpenHiveRemote(DebugSecrets, DebugConfigs, string, bool)"/> /// to create any requested configs and add them to the dictionary. /// </summary> /// <param name="hive">The attached hive.</param> /// <param name="hiveLogin">The hive login.</param> internal void Realize(HiveProxy hive, HiveLogin hiveLogin) { // This is a NOP because we already added all of the configs // to the base dictionary in the [Add()] methods. }
/// <inheritdoc/> public HostingManager GetManager(HiveProxy hive, string logFolder = null) { CheckInitialized(); return(Loader.GetManager(hive, logFolder)); }
/// <summary> /// Constructor. /// </summary> /// <param name="hive">The hive being managed.</param> /// <param name="logFolder"> /// The folder where log files are to be written, otherwise or <c>null</c> or /// empty if logging is disabled. /// </param> public GoogleHostingManager(HiveProxy hive, string logFolder = null) { hive.HostingManager = this; this.hive = hive; }