private void LoadSettingsFromUnreliableTransportSettingsFile(string filePath) { if (File.Exists(filePath) == true) { try { using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (StreamReader file = new StreamReader(fileStream)) { string specificationString; while ((specificationString = file.ReadLine()) != null) { UnreliableTransportSpecification specification = new UnreliableTransportSpecification(); if (Constants.ErrorCode_Success == ParseSpecificationFromINI(specificationString, ref specification)) { Specification.Add(specification); } else { DeployerTrace.WriteWarning("Skipping malformed line in UnreliableTransportSettings File, value = [{0}]", specificationString); } } } } } catch (Exception e) { DeployerTrace.WriteError("Unable to read Unreliable Settings file because {0}", e); throw; } } }
internal static void RemoveFirewallRule() { DeployerTrace.WriteInfo("Removing firewall rule {0} if it exists...", FirewallRuleName); try { #if !DotNetCoreClrLinux INetFwPolicy2 fwPolicy2 = GetFirewallPolicy(); if (fwPolicy2 == null) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingFirewallPolicy2); return; } bool exists = DoesFirewallRuleExist(fwPolicy2); if (!exists) { DeployerTrace.WriteInfo("Firewall rule {0} doesn't exist. Nothing to remove", FirewallRuleName); return; } fwPolicy2.Rules.Remove(FirewallRuleName); #else INetFwRules rules = NetFwRules.GetAllRules(); rules.Remove(FirewallRuleName); #endif DeployerTrace.WriteInfo("Firewall rule {0} removed", FirewallRuleName); } catch (Exception ex) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorRemovingFirewallRule, FirewallRuleName, ex); } }
private static void NetCloseResource(string path) { const int MAX_PREFERRED_LENGTH = -1; int readEntries; int totalEntries; IntPtr buffer = IntPtr.Zero; // Enumerate all resouces in this path that are open remotly int enumerateStatus = NativeMethods.NetFileEnum(null, path, null, 3, ref buffer, MAX_PREFERRED_LENGTH, out readEntries, out totalEntries, IntPtr.Zero); if (enumerateStatus == NativeMethods.ERROR_SUCCESS) { NativeMethods.FILE_INFO_3 fileInfo = new NativeMethods.FILE_INFO_3(); for (int index = 0; index < readEntries; index++) { IntPtr bufferPtr = new IntPtr(buffer.ToInt64() + (index * Marshal.SizeOf(fileInfo))); fileInfo = (NativeMethods.FILE_INFO_3)Marshal.PtrToStructure(bufferPtr, typeof(NativeMethods.FILE_INFO_3)); int fileCloseStatus = NativeMethods.NetFileClose(null, fileInfo.fi3_id); if (fileCloseStatus != NativeMethods.ERROR_SUCCESS) { DeployerTrace.WriteWarning(string.Format("Could not close resource {0}. Error code: {1}", fileInfo.fi3_pathname, fileCloseStatus)); } } NativeMethods.NetApiBufferFree(buffer); } }
internal static IPAddress GetSubnetMask(NetworkInterface nic, IPAddress ipAddress, string networkAdapterName) { DeployerTrace.WriteInfo("Getting subnet mask for IP address {0} and network adapter {1}", ipAddress, networkAdapterName); IPInterfaceProperties ipProperties = nic.GetIPProperties(); if (ipProperties == null) { var message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingSubnetMask1, networkAdapterName); DeployerTrace.WriteWarning(message); throw new InvalidOperationException(message); } UnicastIPAddressInformationCollection ipInfos = ipProperties.UnicastAddresses; foreach (UnicastIPAddressInformation ipInfo in ipInfos) { // ToString() is the only valid way to get the IP address. There is no other explicit property if (string.Equals(ipInfo.Address.ToString(), ipAddress.ToString(), StringComparison.OrdinalIgnoreCase)) { DeployerTrace.WriteInfo("Successfully obtained subnet mask {0} for IP address {1} and network adapter {2}", ipInfo.IPv4Mask, ipAddress, networkAdapterName); return(ipInfo.IPv4Mask); } } var message2 = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingSubnetMask2, ipAddress, networkAdapterName); DeployerTrace.WriteWarning(message2); throw new InvalidOperationException(message2); }
public void Merge(UnreliableTransportSettings unreliableTransportSettings) { Dictionary <string, UnreliableTransportSpecification> specificationsDictionary = new Dictionary <string, UnreliableTransportSpecification>(); // populate dictionary with this settings foreach (var specification in Specification) { specificationsDictionary.Add(specification.Name, specification); } // now we merge the settings with precedence of specifications coming from this foreach (var specification in unreliableTransportSettings.Specification) { if (specificationsDictionary.ContainsKey(specification.Name) == false) { specificationsDictionary.Add(specification.Name, specification); } else { specificationsDictionary[specification.Name] = specification; DeployerTrace.WriteWarning("Conflicting Unreliable Transport Behavior when merging named {0}. Replacing with new behavior", specification.Name); } } // removing previous specifications to populate with ones in dictionary Specification.Clear(); Specification.AddRange(specificationsDictionary.Values); }
/// <summary> /// Gets a new IP address to be reassigned to <see cref="SFNetworkAdapterName"/>. /// The new IP address is 1 more than Docker's DNS IP address. /// </summary> internal static IPAddress GetNewIPAddressForSFNic(IPAddress dockerDnsIPAddress) { var bytes = dockerDnsIPAddress.GetAddressBytes(); try { checked { bytes[3] += 1; } var newIP = new IPAddress(bytes); var message = "New IP address for network adapter {0} is: {1}".ToFormat(SFNetworkAdapterName, newIP); DeployerTrace.WriteInfo(message); return(newIP); } catch (OverflowException ex) { var message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingNewIPAddress, SFNetworkAdapterName, dockerDnsIPAddress, ex); DeployerTrace.WriteWarning(message); throw; } }
internal static IPAddress GetFirstUnicastAddress(NetworkInterface nic, string networkAdapterName) { DeployerTrace.WriteInfo("Getting first unicast address for network adapter {0}", networkAdapterName); IPInterfaceProperties ipProperties = nic.GetIPProperties(); if (ipProperties == null) { var message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingSubnetMask1, networkAdapterName); DeployerTrace.WriteWarning(message); throw new InvalidOperationException(message); } UnicastIPAddressInformationCollection ipInfos = ipProperties.UnicastAddresses; foreach (UnicastIPAddressInformation ipInfo in ipInfos) { return(ipInfo.Address); } var message2 = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingSubnetMask2, networkAdapterName); DeployerTrace.WriteWarning(message2); throw new InvalidOperationException(message2); }
private static void RemoveNodeConfigurationXCopy(string machineName, bool deleteLog, string nodeName) { try { string fabricDataRoot = Utility.GetFabricDataRoot(machineName); if (string.IsNullOrEmpty(fabricDataRoot)) { DeployerTrace.WriteWarning("FabricDataRoot on machine {0} is empty or not present; no current installation likely exists", machineName); } else { DeployerTrace.WriteInfo("FabricDataRoot on machine {0} is {1}", machineName, fabricDataRoot); FabricDeployerServiceController.GetServiceInStoppedState(machineName, Constants.FabricInstallerServiceName); WriteTargetInformationFile(fabricDataRoot, machineName, deleteLog, nodeName); RunInstallerService(machineName); } FabricDeployerServiceController.DeleteFabricInstallerService(machineName); Utility.DeleteRegistryKeyTree(machineName); } catch (TimeoutException) { DeployerTrace.WriteError("FabricInstallerSvc timeout on machine {0}. Cleaning up to avoid environment corruption.", machineName); SuppressExceptions(() => { FabricDeployerServiceController.StopHostSvc(machineName); }); SuppressExceptions(() => { FabricDeployerServiceController.DeleteFabricHostService(machineName); }); SuppressExceptions(() => { FabricDeployerServiceController.StopInstallerSvc(machineName); }); SuppressExceptions(() => { FabricDeployerServiceController.DeleteFabricInstallerService(machineName); }); SuppressExceptions(() => { Utility.DeleteRegistryKeyTree(machineName); }); throw; } }
internal static T GetRegistryKeyValue <T>( RegistryKey baseRegistryKey, string keyName, string valueName, T defaultValue) { baseRegistryKey.Validate("baseRegistryKey"); keyName.Validate("keyName"); valueName.Validate("valueName"); DeployerTrace.WriteInfo("Getting key-value data for key name: {0}, value name: {1}", keyName, valueName); using (RegistryKey registryKey = baseRegistryKey.OpenSubKey(keyName)) { if (registryKey == null) { string message = "Error opening registry sub key: {0}, using default value: {1}".ToFormat(keyName, defaultValue); DeployerTrace.WriteWarning(message); return(defaultValue); } T value = (T)Registry.GetValue(registryKey.Name, valueName, defaultValue); DeployerTrace.WriteInfo( "Value successfully obtained. Key name: {0}, reg value name: {1}, reg value: {2}", keyName, valueName, value); return(value); } }
internal static FileStream GetExclusiveFilestream(string fileName, FileMode fileMode = FileMode.Create, uint retryCount = Constants.FileOpenDefaultRetryAttempts) { FileStream fileStream = null; for (var i = 0; ; i += 1) { try { fileStream = new FileStream(fileName, fileMode, FileAccess.ReadWrite, FileShare.None); break; } catch (IOException e) { if (i == retryCount) { throw; } DeployerTrace.WriteWarning("Transient error - {0}", e.Message); } Thread.Sleep(TimeSpan.FromMilliseconds(i * Constants.FileOpenDefaultRetryIntervalMilliSeconds)); } #if DotNetCoreClrLinux Helpers.UpdateFilePermission(fileName); #endif return(fileStream); }
private static async Task ExecuteAsync(Action func, string funcName) { for (int i = 0; i < MaxRetries; i++) { DeployerTrace.WriteInfo("Executing {0}, attempt {1} of {2}", funcName, i + 1, MaxRetries); try { // all operations are idempotent, so retry from beginning is okay func(); DeployerTrace.WriteInfo("Successfully completed {0}", funcName); break; } catch (Exception ex) { string message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_RetryMessage1, funcName, i + 1, MaxRetries, ex); if (i == MaxRetries - 1) { message += string.Format(CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_RetryExhausted, Environment.NewLine); DeployerTrace.WriteWarning(message); throw; } message += string.Format(CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_RetryContinue, Environment.NewLine); DeployerTrace.WriteWarning(message); } await Task.Delay(TimeSpan.FromSeconds(RetryDelayInSeconds)); } }
protected override void OnExecuteOperation(DeploymentParameters parameters, ClusterManifestType targetClusterManifest, Infrastructure infrastructure) { DeployerTrace.UpdateConsoleLevel(EventLevel.Verbose); try { string currentNodeIPAddressOrFQDN = string.Empty; if ((infrastructure != null) && (infrastructure.InfrastructureNodes != null)) { foreach (var infraNode in infrastructure.InfrastructureNodes) { if (NetworkApiHelper.IsAddressForThisMachine(infraNode.IPAddressOrFQDN)) { currentNodeIPAddressOrFQDN = infraNode.IPAddressOrFQDN; break; } } } new DockerDnsHelper(parameters, currentNodeIPAddressOrFQDN).SetupAsync().GetAwaiter().GetResult(); } catch (Exception ex) { DeployerTrace.WriteWarning( StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorContinuing2, ex); } }
private static void AclCert(CertId certId, string accountName) { X509Store store = null; try { store = new X509Store(certId.StoreName, StoreLocation.LocalMachine); store.Open(OpenFlags.ReadWrite | OpenFlags.OpenExistingOnly); X509Certificate2Collection certs = store.Certificates.Find(ConvertToX509FindType(certId.FindType), certId.FindValue, validOnly: false); if (certs == null || certs.Count == 0) { DeployerTrace.WriteInfo("AclCert is skipped for {0} because it's not installed", certId); return; } foreach (X509Certificate2 cert in certs) { if (cert.PrivateKey == null) { DeployerTrace.WriteWarning("AclCert is skipped for {0} because its private key is null", certId); continue; } RSACryptoServiceProvider privateKey = cert.PrivateKey as RSACryptoServiceProvider; if (privateKey == null) { DeployerTrace.WriteWarning("AclCert is skipped for {0} because its private key type {1} is not supported ", certId, cert.PrivateKey.GetType()); continue; } CspParameters csp = new CspParameters(privateKey.CspKeyContainerInfo.ProviderType, privateKey.CspKeyContainerInfo.ProviderName, privateKey.CspKeyContainerInfo.KeyContainerName); csp.Flags = CspProviderFlags.UseExistingKey | CspProviderFlags.UseMachineKeyStore; csp.KeyNumber = (int)privateKey.CspKeyContainerInfo.KeyNumber; #if !DotNetCoreClr csp.CryptoKeySecurity = privateKey.CspKeyContainerInfo.CryptoKeySecurity; CryptoKeyAccessRule accessRule = new CryptoKeyAccessRule(accountName, CryptoKeyRights.FullControl, AccessControlType.Allow); csp.CryptoKeySecurity.AddAccessRule(accessRule); #endif using (RSACryptoServiceProvider newCsp = new RSACryptoServiceProvider(csp)) { DeployerTrace.WriteInfo("AclCert success: {0}", certId); } } } catch (Exception ex) { DeployerTrace.WriteError("AclCert error with {0}: {1}", certId, ex); } finally { if (store != null) { store.Close(); } } }
internal static void AclClusterLevelCerts(ClusterManifestType clusterManifest) { DeployerTrace.WriteInfo("AclClusterLevelCerts: Enter"); ClusterManifestTypeNodeType[] nodeTypes = clusterManifest.NodeTypes; if (nodeTypes == null) { DeployerTrace.WriteWarning("AclClusterLevelCerts: No node type is defined on the cluster manifest."); return; } IEnumerable <FabricCertificateType> certs = nodeTypes.Where(nodeType => nodeType.Certificates != null).Select(nodeType => nodeType.Certificates) .SelectMany(certificates => new FabricCertificateType[] { certificates.ClientCertificate, certificates.ClusterCertificate, certificates.ServerCertificate }).Where(cert => cert != null); if (!certs.Any()) { DeployerTrace.WriteWarning("AclClusterLevelCerts: No load cert is defined."); return; } List <CertId> certIds = new List <CertId>(); foreach (FabricCertificateType cert in certs) { certIds.Add(new CertId(cert.X509FindType, cert.X509FindValue, cert.X509StoreName)); if (!string.IsNullOrWhiteSpace(cert.X509FindValueSecondary) && cert.X509FindValueSecondary != cert.X509FindValue) { certIds.Add(new CertId(cert.X509FindType, cert.X509FindValueSecondary, cert.X509StoreName)); } } string accountName = "NT AUTHORITY\\NETWORK SERVICE"; string runasAccount = TryGetRunAsAccountName(clusterManifest); if (runasAccount != null) { accountName = runasAccount; } List <CertId> acledCertIds = new List <CertId>(); foreach (CertId certId in certIds) { if (!acledCertIds.Any(p => p.Equals(certId))) { DeployerTrace.WriteInfo("AclClusterLevelCerts: processing {0}", certId); AclCert(certId, accountName); acledCertIds.Add(certId); DeployerTrace.WriteInfo("AclClusterLevelCerts: {0} processed", certId); } } }
internal static string GetTempPath(string machineName) { try { return(GetTempPathInner(machineName)); } catch (Exception exception) { DeployerTrace.WriteWarning(exception.ToString()); throw; } }
private static void SuppressExceptions(ExceptionExpectedMethod method) { try { method(); } catch (Exception ex) { // Suppress any exception DeployerTrace.WriteWarning(String.Format("RemoveNodeConfigOperation Suppressed exception: {0}", ex)); } }
private static void DeletePlaScheduledTask(string taskName) { var args = string.Format(@"/delete /tn \Microsoft\Windows\PLA\{0} /f", taskName); var errorCode = Utility.ExecuteCommand("schtasks", args); if (errorCode != SchtasksSuccessExitCode) { DeployerTrace.WriteWarning( "Unable to remove scheduled task for performance counters. The command \"schtasks {0}\" failed with error code {1}.", args, errorCode); } }
public async Task CleanupAsync() { DeployerTrace.WriteInfo("Starting DockerDnsHelper.CleanupAsync"); try { await ExecuteAsync(CleanupInternal, "DockerDnsHelper.CleanupAsync"); } catch (Exception ex) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_CleanupError, ex); } DeployerTrace.WriteInfo("Completed DockerDnsHelper.CleanupAsync"); }
private static void CollectEventLogs() { DeployerTrace.WriteInfo(StringResources.Info_CollectingErrorLogs); EventLogQuery adminQuery = new EventLogQuery(Constants.ServiceFabricAdminEventLogName, PathType.LogName, "*[System/Level=2]"); EventLogQuery operationalQuery = new EventLogQuery(Constants.ServiceFabricOperationalEventLogName, PathType.LogName, "*[System/Level=2]"); try { using (EventLogReader adminReader = new EventLogReader(adminQuery), operationalReader = new EventLogReader(operationalQuery)) { string path = Path.Combine(Utility.GetTempPath("localhost"), Constants.EventLogsFileName); if (File.Exists(path)) { File.Delete(path); } DeployerTrace.WriteInfo(StringResources.Info_CopyingEventLogs, path); using (StreamWriter tw = File.CreateText(path)) { EventRecord adminEventRecord; EventRecord operationalEventRecord; while ((adminEventRecord = adminReader.ReadEvent()) != null) { tw.WriteLine(String.Format("{0} - {1} - {2} - {3}", adminEventRecord.TimeCreated, Environment.MachineName, adminEventRecord.LevelDisplayName, adminEventRecord.FormatDescription())); } while ((operationalEventRecord = operationalReader.ReadEvent()) != null) { tw.WriteLine(String.Format("{0} - {1} - {2} - {3}", operationalEventRecord.TimeCreated, Environment.MachineName, operationalEventRecord.LevelDisplayName, operationalEventRecord.FormatDescription())); } } } } catch (EventLogException e) { DeployerTrace.WriteWarning(StringResources.Error_IssueOccursWhenGetEventLogs, e); } }
internal static IPAddress GetIPAddress(int interfaceIndex, bool throwOnError = true) { DeployerTrace.WriteInfo("Getting IP address for InterfaceIndex: {0}", interfaceIndex); string script = "(Get-NetIPConfiguration -InterfaceIndex {0}).IPv4Address.IPAddress".ToFormat(interfaceIndex); var psObjects = Utility.ExecutePowerShellScript(script, true); if (psObjects == null || psObjects.Count != 1 || psObjects[0] == null) { string message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingIPAddressForInterfaceIndex, interfaceIndex); DeployerTrace.WriteWarning(message); if (throwOnError) { throw new InvalidOperationException(message); } return(null); } string ipAddress = psObjects[0].ToString(); DeployerTrace.WriteInfo("Successfully obtained IP address: {0}", ipAddress); IPAddress ip; bool status = IPAddress.TryParse(ipAddress, out ip); if (!status) { string message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorParsingIPAddressForInterfaceIndex, ipAddress, interfaceIndex); DeployerTrace.WriteWarning(message); if (throwOnError) { throw new InvalidOperationException(message); } return(null); } return(ip); }
internal bool ValidateContainersFeature() { if (IsContainersFeaturePresent()) { DeployerTrace.WriteInfo("{0} feature present", ContainersFeatureName); return(true); } // on a system where the above checks fail for some reason, then we can at least move forward if (deploymentParameters.ContinueIfContainersFeatureNotInstalled) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_FeatureNotPresentContinuing, ContainersFeatureName); return(true); } DeployerTrace.WriteInfo("{0} feature not present. Not continuing further", ContainersFeatureName); return(false); }
private void CleanupInternal() { #if !DotNetCoreClr // Disable compiling on windows for now. Need to correct when porting FabricDeployer for windows. bool proceed = ValidateContainersFeature(); if (!proceed) { return; } #endif CleanupPersistedNetworkDetail(new List <string> { DnsServerIPAddressRegValue }); RemoveFirewallRule(); #if !DotNetCoreClr // Disable compiling on windows for now. Need to correct when porting FabricDeployer for windows. NetworkInterface nic = GetNetworkAdapter(SFNetworkAdapterName); if (nic != null) { int interfaceIndex = GetInterfaceIndex(nic, SFNetworkAdapterName, false); if (interfaceIndex == -1) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingInterfaceIndex, SFNetworkAdapterName); return; } IPAddress ipAddress = GetIPAddress(interfaceIndex, false); if (ipAddress == null) { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingIPAddress, SFNetworkAdapterName); return; } RemoveIPAddress(ipAddress, interfaceIndex); RemoveNetworkAdapter(SFNetworkAdapterName); } else { DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingNetworkAdapter3, SFNetworkAdapterName); } #endif }
public static bool IsContainersFeaturePresent() { try { DismPackageFeatureState featureState = DismHelper.GetFeatureState(ContainersFeatureName); switch (featureState) { case DismPackageFeatureState.DismStateInstallPending: case DismPackageFeatureState.DismStateInstalled: case DismPackageFeatureState.DismStateSuperseded: return(true); } } catch (COMException ex) { // Dism COM errors aren't well understood yet across different OSes. TODO Handle specific error codes and throw the rest DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingFeatureState1, ContainersFeatureName, ex); } catch (DllNotFoundException ex) { // This happens on platforms that don't have dismapi.dll // https://technet.microsoft.com/en-us/library/hh825186.aspx DeployerTrace.WriteWarning( StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingFeatureState2, ContainersFeatureName, ex); } catch (Exception ex) { // Swallowing all! // Setup for Docker isn't a mainline scenario currently. Hence try and continue. // If an exception is thrown on an OS that has Docker, and setup doesn't continue, we have mitigation // steps on the VM by setting ContinueIfContainersFeatureNotInstalled. // E.g. FabricDeployer.exe /operation:DockerDnsSetup /continueIfContainersFeatureNotInstalled:true DeployerTrace.WriteWarning( StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorGettingFeatureState3, ContainersFeatureName, ex); } return(false); }
internal static void RemoveRegistryKeyValues(RegistryKey baseRegistryKey, string keyName, IList <string> valueNames) { baseRegistryKey.Validate("baseRegistryKey"); keyName.Validate("keyName"); valueNames.Validate("valueNames"); DeployerTrace.WriteInfo("Removing key-value data for key name {0}", keyName); using (RegistryKey registryKey = baseRegistryKey.OpenSubKey(keyName, true)) { if (registryKey == null) { string message = "Error opening registry sub key. Continuing. Registry values have to be cleaned up manually. Reg key: {0}".ToFormat(keyName); DeployerTrace.WriteWarning(message); return; } foreach (var v in valueNames) { try { registryKey.DeleteValue(v, false); DeployerTrace.WriteInfo( "Successfully created reg value. Reg key: {0}, reg value name: {1}", keyName, v); } catch (Exception ex) { string message = "Error creating reg value. Continuing. This needs to be cleaned up manually. Reg key: {0}, reg value name: {1}, exception: {2}".ToFormat( keyName, v, ex); DeployerTrace.WriteWarning(message); } } } DeployerTrace.WriteInfo("Key-value(s) successfully deleted for key name {0}", keyName); }
internal static int GetInterfaceIndex(NetworkInterface nic, string networkAdapterName, bool throwOnError = true) { DeployerTrace.WriteInfo("Calling GetIPProperties() for network adapter {0}", networkAdapterName); IPInterfaceProperties ipProperties = nic.GetIPProperties(); if (ipProperties == null) { var message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_GetIPPropertiesError, networkAdapterName); DeployerTrace.WriteWarning(message); if (throwOnError) { throw new InvalidOperationException(message); } return(-1); } DeployerTrace.WriteInfo("Calling GetIPv4Properties() for network adapter {0}", networkAdapterName); IPv4InterfaceProperties ipv4Properties = ipProperties.GetIPv4Properties(); if (ipv4Properties == null) { var message = string.Format( CultureInfo.CurrentUICulture, StringResources.Warning_FabricDeployer_DockerDnsSetup_GetIPv4PropertiesError, networkAdapterName); DeployerTrace.WriteWarning(message); if (throwOnError) { throw new InvalidOperationException(message); } return(-1); } DeployerTrace.WriteInfo("Returning InterfaceIndex: {0} for network adapter {1}", ipv4Properties.Index, networkAdapterName); return(ipv4Properties.Index); }
internal static void DeleteRegistryKeyTree(string machineName) { try { DeployerTrace.WriteInfo("Deleting Fabric registry key tree for machine {0}", machineName); RegistryKey baseKey = string.IsNullOrEmpty(machineName) ? Registry.LocalMachine : RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, machineName); if (baseKey.OpenSubKey(FabricConstants.FabricRegistryKeyPath) != null) { baseKey.DeleteSubKeyTree(FabricConstants.FabricRegistryKeyPath); } } catch (ArgumentException e) { DeployerTrace.WriteWarning("Trying to delete registry key tree threw ArgumentException: {0}", e.ToString()); } }
internal static string GetCurrentCodeVersion(string packageLocation) { #if DotNetCoreClrLinux string currentAssembly = typeof(Utility).GetTypeInfo().Assembly.Location; string versionFile = Path.Combine(Path.GetDirectoryName(currentAssembly), "ClusterVersion"); string codeVersion = File.ReadAllText(versionFile); return(codeVersion); #else if (string.IsNullOrEmpty(packageLocation)) { string currentAssembly = typeof(Utility).GetTypeInfo().Assembly.Location; string fabricPath = Path.Combine(Path.GetDirectoryName(currentAssembly), Constants.FabricExe); if (!File.Exists(fabricPath)) { DeployerTrace.WriteWarning("{0} Fabric Path doesn't exist", fabricPath); string codePath = GetFabricCodePath(); if (!string.IsNullOrEmpty(codePath)) { fabricPath = Path.Combine(codePath, Constants.FabricExe); if (!File.Exists(fabricPath)) { DeployerTrace.WriteWarning("{0} Code Path doesn't exist", fabricPath); codePath = null; } } if (string.IsNullOrEmpty(codePath)) { string errorMessage = string.Format("Fabric.exe not found in current execution assembly directory. CurrentAssembly : {0}, Fabric Path : {1}", currentAssembly, fabricPath); throw new InvalidOperationException(errorMessage); } } var versionInfo = System.Diagnostics.FileVersionInfo.GetVersionInfo(fabricPath); return(string.Format(CultureInfo.InvariantCulture, Constants.FabricVersions.CodeVersionPattern, versionInfo.ProductMajorPart, versionInfo.ProductMinorPart, versionInfo.ProductBuildPart, versionInfo.ProductPrivatePart)); } else { return(CabFileOperations.GetCabVersion(packageLocation)); } #endif }
private static void DeleteTargetInformationFile(string targetInformationFile) { if (FabricFile.Exists(targetInformationFile)) { try { DeployerTrace.WriteInfo("Attempting to delete TargetInformationFile."); FabricFile.Delete(targetInformationFile, true); } catch (Exception ex) { DeployerTrace.WriteError("Failed to delete: {0}. Exception: {1}.", targetInformationFile, ex); throw; } } else { DeployerTrace.WriteWarning("TargetInformationFile does not exist."); } }
internal static bool IsContainersFeaturePresent() { try { DismPackageFeatureState featureState = DismHelper.GetFeatureState(Constants.ContainersFeatureName); switch (featureState) { case DismPackageFeatureState.DismStateInstallPending: case DismPackageFeatureState.DismStateInstalled: case DismPackageFeatureState.DismStateSuperseded: return(true); } } catch (COMException ex) { // Dism COM errors aren't well understood yet across different OSes. TODO Handle specific error codes and throw the rest DeployerTrace.WriteWarning("Error getting feature state for feature {0}. Treating feature as not present and continuing. Exception: {1}", Constants.ContainersFeatureName, ex); } catch (DllNotFoundException ex) { // This happens on platforms that don't have dismapi.dll // https://technet.microsoft.com/en-us/library/hh825186.aspx DeployerTrace.WriteWarning( "Error getting feature state for feature {0}. This usually means that the platform doesn't support DISM APIs. " + "Treating feature as not present and continuing. Exception: {1}", Constants.ContainersFeatureName, ex); } catch (Exception ex) { // Swallowing all! DeployerTrace.WriteWarning( "Unexpected error getting feature state for feature {0}. " + "Treating feature as not present and continuing. Exception: {1}", Constants.ContainersFeatureName, ex); } return(false); }
internal static void CleanupPersistedNetworkDetail(IList <string> valueNames) { try { #if !DotNetCoreClrLinux Utility.RemoveRegistryKeyValues(Registry.LocalMachine, FabricConstants.FabricRegistryKeyPath, valueNames); #else foreach (var name in valueNames) { string path = Path.Combine(FabricEtcConfigPath, name); File.Delete(path); } #endif DeployerTrace.WriteInfo("Persisted network details cleaned up"); } catch (Exception ex) { // best effort DeployerTrace.WriteWarning(StringResources.Warning_FabricDeployer_DockerDnsSetup_ErrorCleaningNetworkDetails, ex); } }