private static void RemoveNodeConfigurationInner(bool deleteLog, FabricPackageType fabricPackageType, string machineName) { var parameters = new Dictionary <string, dynamic> { { DeploymentParameters.MachineNameString, machineName } }; // Create DeploymentParameters object with conditional retrieval of FabricBinRoot (to work around infinite recursion due to invalid reflection) bool setBinRoot = fabricPackageType != FabricPackageType.XCopyPackage; var deploymentParameters = new DeploymentParameters(setBinRoot); deploymentParameters.DeleteLog = deleteLog; deploymentParameters.DeploymentPackageType = fabricPackageType; deploymentParameters.SetParameters(parameters, DeploymentOperations.RemoveNodeConfig); try { DeploymentOperation.ExecuteOperation(deploymentParameters); } catch (Exception e) { DeployerTrace.WriteError("{0}", e.ToString()); throw; } }
internal static void RemoveNodeConfiguration(bool deleteLog, FabricPackageType fabricPackageType, string machineName) { try { RemoveNodeConfigurationInner(deleteLog, fabricPackageType, machineName); } catch (Exception exception) { DeployerTrace.WriteError(exception.ToString()); throw; } }
internal static void NewNodeConfiguration( string clusterManifestPath, string infrastructureManifestPath, string jsonClusterConfigPath, /* Value is null if it's not Standalone deployment */ string fabricDataRoot, string fabricLogRoot, string fabricHostCredentialUser, SecureString fabricHostCredentialPassword, bool runFabricHostServiceAsManual, bool removeExistingConfiguration, FabricPackageType fabricPackageType, string fabricPackageRoot, string machineName, string bootstrapPackagePath) { try { NewNodeConfigurationInner( clusterManifestPath, infrastructureManifestPath, jsonClusterConfigPath, fabricDataRoot, fabricLogRoot, fabricHostCredentialUser, fabricHostCredentialPassword, runFabricHostServiceAsManual, removeExistingConfiguration, fabricPackageType, fabricPackageRoot, machineName, bootstrapPackagePath); } catch (Exception exception) { DeployerTrace.WriteError(exception.ToString()); throw; } }
private void CopyBaselinePackageIfPathExists(string bootstrapPackagePath, string fabricDataRoot, FabricPackageType fabricPackageType, string machineName) { string targetPath = Helpers.GetRemotePath(fabricDataRoot, machineName); DeployerTrace.WriteInfo("Copying {0} from {1} to {2}", fabricPackageType == FabricPackageType.MSI ? "BootstrapMSI" : "Standalone CAB", bootstrapPackagePath, fabricDataRoot); if (fabricPackageType == FabricPackageType.XCopyPackage) { targetPath = Path.Combine(targetPath, Constants.FileNames.BaselineCab); } else { targetPath = Path.Combine(targetPath, Path.GetFileName(bootstrapPackagePath)); } using (FileStream sourceStream = File.Open(bootstrapPackagePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (FileStream destStream = File.Create(targetPath)) { sourceStream.CopyTo(destStream); } } if (!File.Exists(targetPath)) { string message = string.Format(StringResources.Error_SFErrorCreatingCab, targetPath, machineName); DeployerTrace.WriteError(message); throw new FileNotFoundException(message); } string adminConfigPath = Environment.GetEnvironmentVariable(Constants.FabricTestAdminConfigPath); if (!string.IsNullOrEmpty(adminConfigPath)) { CopyNewAdminConfigToFabricDataRoot(fabricDataRoot, adminConfigPath, machineName); } }
internal void WriteTargetInformationFile(string clusterManifestLocation, string infrastructureManifestLocation, string fabricDataRoot, string machineName, string packageLocation, FabricPackageType fabricPackageType, string sourcePackageLocation) { ReleaseAssert.AssertIfNull(fabricDataRoot, "DataRoot Should not be null after configuration"); TargetInformationType targetInformation = new TargetInformationType { TargetInstallation = new WindowsFabricDeploymentInformation { TargetVersion = Utility.GetCurrentCodeVersion(sourcePackageLocation), ClusterManifestLocation = clusterManifestLocation, UpgradeEntryPointExe = "FabricSetup.exe", UpgradeEntryPointExeParameters = "/operation:Install" } }; if (fabricPackageType == FabricPackageType.XCopyPackage) { targetInformation.TargetInstallation.MSILocation = packageLocation; } if (!string.IsNullOrEmpty(infrastructureManifestLocation)) { targetInformation.TargetInstallation.InfrastructureManifestLocation = infrastructureManifestLocation; } string targetInformationFileName = Path.Combine(fabricDataRoot, Constants.FileNames.TargetInformation); DeployerTrace.WriteInfo("TargetInformationFileName is {0}", targetInformationFileName); if (!string.IsNullOrEmpty(machineName) && !machineName.Equals(Helpers.GetMachine())) { targetInformation.TargetInstallation.ClusterManifestLocation = Path.Combine(fabricDataRoot, "clusterManifest.xml"); targetInformationFileName = Helpers.GetRemotePath(targetInformationFileName, machineName); } XmlHelper.WriteXmlExclusive <TargetInformationType>(targetInformationFileName, targetInformation); DeployerTrace.WriteInfo("Target information file {0} written on machine: {1}", targetInformationFileName, machineName); }
internal static AnalysisSummary AnalyzeClusterSetup( string configPath, string oldConfigPath, string cabPath, bool usingClusterManifest = false, FabricPackageType fabricPackageType = FabricPackageType.XCopyPackage, bool isForcedRun = false, int maxPercentFailedNodes = 0) { SFDeployerTrace.WriteInfo(StringResources.Info_BPAStart); var summary = new AnalysisSummary(); // Check user has local admin privilege summary.LocalAdminPrivilege = CheckLocalAdminPrivilege(); // Validate JSON config StandAloneInstallerJsonModelBase standAloneModel = null; StandAloneInstallerJsonModelBase oldStandAloneModel = null; if (!usingClusterManifest) { standAloneModel = StandAloneInstallerJsonModelBase.GetJsonConfigFromFile(configPath); if (!string.IsNullOrEmpty(oldConfigPath)) { oldStandAloneModel = StandAloneInstallerJsonModelBase.GetJsonConfigFromFile(oldConfigPath); } summary.IsJsonValid = IsJsonConfigModelValid(standAloneModel, oldStandAloneModel, validateDownNodes: true, throwIfError: false) && ValidateCodeVersionExists(standAloneModel); } // Deliberately not checking empty. Some invocations aren't intended to test cabPath. if (cabPath != null) { summary.IsCabValid = CheckIsCabFile(cabPath); } // Below depends on JSON being valid if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } // Get machine names from JSON config IEnumerable <string> healthyMachineNames = usingClusterManifest ? StandaloneUtility.GetMachineNamesFromClusterManifest(configPath) : standAloneModel.GetClusterTopology().Machines; MachineHealthContainer machineHealthContainer = new MachineHealthContainer(healthyMachineNames, maxPercentFailedNodes); // Validate machine FQDNs, Check SMB ports opened summary.RequiredPortsOpen = StandaloneUtility.CheckRequiredPorts(machineHealthContainer); // Below depends on machines being reachable if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } // Validate Remote Registry Service is not disabled on all machines summary.RemoteRegistryAvailable = CheckRemoteRegistryEnabled(machineHealthContainer); // Below depends on remote registry service if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } summary.FirewallAvailable = CheckFirewallEnabled(machineHealthContainer); // Below depends on firewall service if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } // Run RPC check to validate end-to-end registry access to all machines summary.RpcCheckPassed = CheckRPCAccess(machineHealthContainer); // Below depend on remote registry access if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } summary.NoDomainController = CheckNoMachineIsDomainController(machineHealthContainer); // Below depends on machines not being domain controller if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } if (fabricPackageType == FabricPackageType.XCopyPackage) { // Validate that Fabric runtime MSI is not installed since this will be conflicting with Standalone summary.NoConflictingInstallations = !StandaloneUtility.IsMsiInstalled(machineHealthContainer); } string fabricDataRoot = null; string fabricLogRoot = null; if (!usingClusterManifest) { if (string.IsNullOrEmpty(oldConfigPath)) { summary.FabricInstallable = CheckForCleanInstall(standAloneModel, machineHealthContainer, isForcedRun); // Fabric is not installed on target machines } var importantSettings = standAloneModel.GetFabricSystemSettings(); fabricDataRoot = importantSettings.ContainsKey(DMConstants.FabricDataRootString) ? importantSettings[DMConstants.FabricDataRootString] : null; fabricLogRoot = importantSettings.ContainsKey(DMConstants.FabricLogRootString) ? importantSettings[DMConstants.FabricLogRootString] : null; summary.DataDrivesAvailable = CheckDataSystemDrives(machineHealthContainer, fabricDataRoot, fabricLogRoot); // System drives for path-based settings, exist on target machines // Below depend on data system drives if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } } summary.DrivesEnoughAvailableSpace = CheckDrivesAvailableSpace(machineHealthContainer, fabricDataRoot, fabricLogRoot); // Below depend on root drives having enough space available if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } summary.IsAllOrNoneIOTDevice = CheckAllIOTDevices(machineHealthContainer); // Below depend on all or none machines being IOT Devices if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } // Check dotnet.exe exists in %Path% // Currently we only need to check for IOTCore environment. summary.DotNetExeInPath = IsDotNetExeInPath(machineHealthContainer); // Below depend on IOT Devices having dotnet.exe in path if (!summary.Passed) { SFDeployerTrace.WriteError(StringResources.Error_BPABailing); return(summary); } summary.MachineHealthContainer = machineHealthContainer; LogResult(summary); return(summary); }
internal static bool ValidateClusterSetupXmlManifest(string xmlManifestPath, FabricPackageType fabricPackageType) { AnalysisSummary result = AnalyzeClusterSetup(xmlManifestPath, oldConfigPath: null, cabPath: null, usingClusterManifest: true, fabricPackageType: fabricPackageType); return(result.Passed); }
private static void NewNodeConfigurationInner( string clusterManifestPath, string infrastructureManifestPath, string jsonClusterConfigPath, string fabricDataRoot, string fabricLogRoot, string fabricHostCredentialUser, SecureString fabricHostCredentialPassword, bool runFabricHostServiceAsManual, bool removeExistingConfiguration, FabricPackageType fabricPackageType, string fabricPackageRoot, string machineName, string bootstrapPackagePath) { if (!string.IsNullOrEmpty(machineName)) { if (!string.IsNullOrEmpty(fabricHostCredentialUser) || fabricHostCredentialPassword != null) { throw new InvalidOperationException(StringResources.Error_RemoteNodeConfigNotSupportedWithCredential); } } // Delete the registry value used for RemoveNodeConfiguration if it is present if (fabricPackageType == FabricPackageType.MSI) { RemoveNodeConfigOperation.DeleteRemoveNodeConfigurationRegistryValue(machineName); } if (removeExistingConfiguration) { RemoveNodeConfigurationInner(true, fabricPackageType, machineName); } var parameters = new Dictionary <string, dynamic> { { DeploymentParameters.ClusterManifestString, clusterManifestPath }, { DeploymentParameters.InfrastructureManifestString, infrastructureManifestPath }, { DeploymentParameters.FabricDataRootString, fabricDataRoot }, { DeploymentParameters.FabricLogRootString, fabricLogRoot } }; if (fabricHostCredentialUser != null) { parameters.Add(DeploymentParameters.RunAsUserNameString, fabricHostCredentialUser); } if (jsonClusterConfigPath != null) { parameters.Add(DeploymentParameters.JsonClusterConfigLocationString, jsonClusterConfigPath); } if (fabricHostCredentialPassword != null) { parameters.Add(DeploymentParameters.RunAsPaswordString, fabricHostCredentialPassword); } if (machineName != null) { parameters.Add(DeploymentParameters.MachineNameString, machineName); } if (fabricPackageRoot != null) { parameters.Add(DeploymentParameters.FabricPackageRootString, fabricPackageRoot); } if (runFabricHostServiceAsManual) { parameters.Add(DeploymentParameters.ServiceStartupTypeString, FabricDeployerServiceController.ServiceStartupType.Manual.ToString()); } if (bootstrapPackagePath != null) { parameters.Add(DeploymentParameters.BootstrapMSIPathString, bootstrapPackagePath); } // Create DeploymentParameters object with conditional retrieval of FabricBinRoot (to work around infinite recursion due to invalid reflection) bool setBinRoot = fabricPackageType != FabricPackageType.XCopyPackage; var deploymentParameters = new DeploymentParameters(setBinRoot); deploymentParameters.DeploymentPackageType = fabricPackageType; try { deploymentParameters.SetParameters(parameters, DeploymentOperations.Configure); DeploymentOperation.ExecuteOperation(deploymentParameters); } catch (Exception e) { DeployerTrace.WriteError("{0}", e.ToString()); throw; } }