private void GenerateWorkFolders()
{
string workFolder = this.nodeSettings.DeploymentFoldersInfo.WorkFolder;
DeployerTrace.WriteNoise("Deploying work folder {0}", workFolder);
#if DotNetCoreClrLinux
FabricDirectory.CreateDirectory(workFolder);
#else
Directory.CreateDirectory(workFolder);
#endif
}
internal static async Task <bool> IsUriReachableAsync(Uri uri, string requestMethod, int operationTimeoutInMs, int requestTimeoutInMs, int retryIntervalInMs)
{
ReleaseAssert.AssertIf(uri == null, "uri cannot be null for IsUriReachableAsync.");
if (uri.IsFile && !uri.IsUnc)
{
FileInfo fi = new FileInfo(uri.LocalPath);
return(fi.Exists);
}
else
{
if (string.IsNullOrWhiteSpace(uri.Host))
{
return(false);
}
var timeout = new System.Fabric.Common.TimeoutHelper(TimeSpan.FromMilliseconds(operationTimeoutInMs));
while (!System.Fabric.Common.TimeoutHelper.HasExpired(timeout))
{
WebRequest request = WebRequest.Create(uri);
#if !DotNetCoreClrLinux && !DotNetCoreClrIOT
request.Timeout = requestTimeoutInMs;
#endif
request.Method = requestMethod;
try
{
using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
{
if (response is HttpWebResponse)
{
if (((HttpWebResponse)response).StatusCode == HttpStatusCode.OK)
{
return(true);
}
return(false);
}
else
{
return(response.ContentLength > 0);
}
}
}
catch (WebException ex)
{
DeployerTrace.WriteNoise("Unable to reach uri {0} becaue {1}.", uri, ex.Message);
}
System.Threading.Thread.Sleep(retryIntervalInMs);
}
}
return(false);
}
private void DeployConfig(SettingsType settings)
{
string configDeploymentPath = this.nodeSettings.DeploymentFoldersInfo.ConfigDeploymentDirectory;
#if DotNetCoreClrLinux
FabricDirectory.CreateDirectory(configDeploymentPath);
#else
Directory.CreateDirectory(configDeploymentPath);
#endif
string configFilePath = Path.Combine(configDeploymentPath, Constants.FileNames.Settings);
DeployerTrace.WriteNoise("Generating the settings file at {0}", configFilePath);
XmlHelper.WriteXmlExclusive <SettingsType>(configFilePath, settings);
}
private void GenerateDataDeployment()
{
string dataDeploymentPath = this.nodeSettings.DeploymentFoldersInfo.DataDeploymentDirectory;
#if DotNetCoreClrLinux
FabricDirectory.CreateDirectory(dataDeploymentPath);
#else
Directory.CreateDirectory(dataDeploymentPath);
#endif
InfrastructureInformationType infrastructureManifest = this.infrastructure.GetInfrastructureManifest();
string filePath = this.nodeSettings.DeploymentFoldersInfo.InfrastructureManfiestFile;
DeployerTrace.WriteNoise("Writing infrastructure manifest file at {0}", filePath);
WriteManifestFile <InfrastructureInformationType>(filePath, infrastructureManifest);
CopyClusterSettingsToFabricData();
}
private static void WriteTargetInformationFile(string fabricDataRoot, string machineName, bool deleteLog, string nodeName)
{
string targetInformationFileName = Path.Combine(fabricDataRoot, Constants.FileNames.TargetInformation);
DeployerTrace.WriteNoise("targetInformationFileName is {0}", targetInformationFileName);
if (!string.IsNullOrEmpty(machineName) && !machineName.Equals(Helpers.GetMachine()))
{
targetInformationFileName = Helpers.GetRemotePath(targetInformationFileName, machineName);
}
DeployerTrace.WriteInfo("Creating target information file {0} to be written on machine {1}", targetInformationFileName, machineName);
TargetInformationType targetInformation = new TargetInformationType();
targetInformation.CurrentInstallation = new WindowsFabricDeploymentInformation();
targetInformation.CurrentInstallation.UndoUpgradeEntryPointExe = "FabricSetup.exe";
targetInformation.CurrentInstallation.UndoUpgradeEntryPointExeParameters = string.Format("/operation:Uninstall {0}", deleteLog ? "/deleteLog:true" : "");
targetInformation.CurrentInstallation.NodeName = nodeName;
DeployerTrace.WriteInfo("Writing Target information file {0} on machine {1}", targetInformationFileName, machineName);
XmlHelper.WriteXmlExclusive <TargetInformationType>(targetInformationFileName, targetInformation);
}
private int GenerateAndDeployUnreliableTransportSettings()
{
string filePath = System.IO.Path.Combine(this.nodeSettings.DeploymentFoldersInfo.WorkFolder, UnreliableTransportSettings.SettingsFileName);
DeployerTrace.WriteNoise("Writing Unreliable Transport Settings file at {0}", filePath);
UnreliableTransportSettings unreliableTransportSettings = new UnreliableTransportSettings(this.clusterSettings);
// acquiring lock to read and write to unreliable transport settings file.
FileLock fileLock = new FileLock(filePath, false /* writing lock */);
if (!fileLock.Acquire(new TimeSpan(0, 0, 5)))
{
DeployerTrace.WriteWarning("Failed to acquire lock to load Unreliable Transport Settings File. Aborting loading at file: {0}", filePath);
return(Constants.ErrorCode_Failure);
}
// checks if it necessary to merge
if (!File.Exists(filePath))
{
// writes the result to Unreliable Transport Settings File
unreliableTransportSettings.WriteUnreliableTransportSettingsFile(filePath);
}
else
{
// creates a new UnreliableTransportSettings from existing UnreliableTransportSettings file
UnreliableTransportSettings unreliableTransportSettingsExisting = new UnreliableTransportSettings(filePath);
// merge files giving precedence to settings coming from cluster manifest
unreliableTransportSettingsExisting.Merge(unreliableTransportSettings);
// writes the result to Unreliable Transport Settings File
unreliableTransportSettingsExisting.WriteUnreliableTransportSettingsFile(filePath);
}
#if DotNetCoreClrLinux
Helpers.UpdateFilePermission(filePath);
#endif
// releasing lock.
fileLock.Release();
return(Constants.ErrorCode_Success);
}
public void UpgradeDeployment()
{
string currentPackagePath = this.nodeSettings.DeploymentFoldersInfo.CurrentFabricPackageFile;
if (!File.Exists(currentPackagePath))
{
DeployerTrace.WriteError("Current package file {0} not found. Upgrade can't proceed", currentPackagePath);
throw new InvalidDeploymentParameterException(StringResources.Error_FabricDeployer_CurrentPackageFileNotFound_Formatted);
}
this.GenerateCodeDeployment();
this.GenerateConfigDeployment();
this.GenerateDataDeployment();
ServicePackageType currentServicePackage = XmlHelper.ReadXml <ServicePackageType>(currentPackagePath);
RolloutVersion updatedRolloutVersion = RolloutVersion.CreateRolloutVersion(currentServicePackage.RolloutVersion).NextMinorRolloutVersion();
DeployerTrace.WriteNoise("Creating Service Package RolloutVersion = {0}", updatedRolloutVersion);
this.DeployClusterManifest();
this.DeploySeedInfoFile();
this.GenerateAndDeployUnreliableTransportSettings();
this.GenerateAndDeployFabricPackage(updatedRolloutVersion.ToString());
}
private void GenerateAndDeployFabricPackage(string rolloutVersion)
{
ServicePackageType package = new ServicePackageType();
package.ManifestVersion = this.nodeSettings.DeploymentFoldersInfo.versions.ClusterManifestVersion;
package.Name = "Fabric";
package.RolloutVersion = rolloutVersion;
package.DigestedConfigPackage = new ServicePackageTypeDigestedConfigPackage[1];
package.DigestedDataPackage = new ServicePackageTypeDigestedDataPackage[1];
package.DigestedCodePackage = new ServicePackageTypeDigestedCodePackage[this.servicesToBeDeployed.Length];
package.DigestedServiceTypes = new ServicePackageTypeDigestedServiceTypes();
package.DigestedServiceTypes.RolloutVersion = rolloutVersion;
package.DigestedServiceTypes.ServiceTypes = new ServiceTypeType[this.servicesToBeDeployed.Length];
package.DigestedResources = new ServicePackageTypeDigestedResources();
package.DigestedResources.RolloutVersion = rolloutVersion;
package.DigestedConfigPackage[0] = new ServicePackageTypeDigestedConfigPackage();
package.DigestedConfigPackage[0].RolloutVersion = rolloutVersion;
package.DigestedConfigPackage[0].ConfigPackage = new ConfigPackageType();
package.DigestedConfigPackage[0].ConfigPackage.Name = Constants.ConfigName;
package.DigestedConfigPackage[0].ConfigPackage.Version = this.nodeSettings.DeploymentFoldersInfo.versions.ConfigVersion;
package.DigestedDataPackage[0] = new ServicePackageTypeDigestedDataPackage();
package.DigestedDataPackage[0].RolloutVersion = rolloutVersion;
package.DigestedDataPackage[0].DataPackage = new DataPackageType();
package.DigestedDataPackage[0].DataPackage.Name = Constants.DataName;
package.DigestedDataPackage[0].DataPackage.Version = string.Empty;
int packageIndex = 0;
foreach (string service in this.servicesToBeDeployed)
{
package.DigestedCodePackage[packageIndex] = new ServicePackageTypeDigestedCodePackage();
package.DigestedCodePackage[packageIndex].RolloutVersion = rolloutVersion;
package.DigestedCodePackage[packageIndex].CodePackage = new CodePackageType();
package.DigestedCodePackage[packageIndex].CodePackage.Name = service;
package.DigestedCodePackage[packageIndex].CodePackage.Version = string.Empty;
package.DigestedCodePackage[packageIndex].CodePackage.EntryPoint =
new EntryPointDescriptionType
{
Item = new EntryPointDescriptionTypeExeHost
{
Program = Constants.ServiceExes[service],
Arguments = null,
WorkingFolder = ExeHostEntryPointTypeWorkingFolder.Work
}
};
package.DigestedServiceTypes.ServiceTypes[packageIndex] = new StatefulServiceTypeType();
package.DigestedServiceTypes.ServiceTypes[packageIndex].ServiceTypeName = service;
packageIndex++;
}
string packageFilePath = this.nodeSettings.DeploymentFoldersInfo.GetVersionedFabricPackageFile(rolloutVersion);
DeployerTrace.WriteNoise("Generating the fabric package file at {0}", packageFilePath);
XmlHelper.WriteXmlExclusive <ServicePackageType>(packageFilePath, package);
string currentPackageFilePath = this.nodeSettings.DeploymentFoldersInfo.CurrentFabricPackageFile;
DeployerTrace.WriteInfo("Generating the fabric package file at {0}", currentPackageFilePath);
XmlHelper.WriteXmlExclusive <ServicePackageType>(currentPackageFilePath, package);
}
public void AddToHostedServiceSections(string service)
{
ReleaseAssert.AssertIfNot(Constants.RequiredServices.Contains(service, StringComparer.Ordinal), string.Format(CultureInfo.InvariantCulture, "Unknown service {0}", service));
string serviceExePath = Path.Combine(this.nodeSettings.DeploymentFoldersInfo.GetCodeDeploymentDirectory(service), Constants.ServiceExes[service]);
string ctrlCHelperPath = Path.Combine(this.nodeSettings.DeploymentFoldersInfo.GetCodeDeploymentDirectory(Constants.FabricService), Constants.CtrlCSenderExe);
List <SettingsTypeSectionParameter> parameters = new List <SettingsTypeSectionParameter>();
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.ExePath, Value = serviceExePath, MustOverride = false
});
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.CtrlCSenderPath, Value = ctrlCHelperPath, MustOverride = false
});
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.EnvironmentMap,
Value = string.Format(CultureInfo.InvariantCulture, "FabricPackageFileName={0}", this.nodeSettings.DeploymentFoldersInfo.CurrentFabricPackageFile),
MustOverride = false
});
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.ServiceNodeName, Value = this.nodeSettings.NodeName, MustOverride = false
});
// Generate SF system service resource governance policy
var sfssRgPolicy = nodeSettings.Settings.FirstOrDefault(
param =>
param.Name.Equals(Constants.SectionNames.NodeSfssRgPolicies, StringComparison.OrdinalIgnoreCase));
if (sfssRgPolicy != null)
{
GenerateSfssRGPolicy(sfssRgPolicy, parameters, service);
}
#if DotNetCoreClrLinux
var serviceRunAsSectionName = GetServiceSpecificRunAsSectionName(service);
// First check if the service specific run as section exists
var runAsSection = this.clusterSettings.Settings.SingleOrDefault(section => section.Name.Equals(serviceRunAsSectionName, StringComparison.OrdinalIgnoreCase));
if (runAsSection == null)
{
// If the service specific run as section does not exist read the generic one for all services
runAsSection =
this.clusterSettings.Settings.SingleOrDefault(
section =>
section.Name.Equals(Constants.SectionNames.RunAs, StringComparison.OrdinalIgnoreCase));
}
#else
var runAsSection = this.clusterSettings.Settings.SingleOrDefault(section => section.Name.Equals(Constants.SectionNames.RunAs, StringComparison.OrdinalIgnoreCase));
#endif
if (runAsSection != null)
{
var accountNameParameter = runAsSection.Parameter.SingleOrDefault(parameter => parameter.Name.Equals(Constants.ParameterNames.RunAsAccountName, StringComparison.OrdinalIgnoreCase));
if (accountNameParameter != null)
{
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.RunAsAccountName, Value = accountNameParameter.Value, MustOverride = accountNameParameter.MustOverride
});
}
var accountTypeParameter = runAsSection.Parameter.SingleOrDefault(parameter => parameter.Name.Equals(Constants.ParameterNames.RunAsAccountType, StringComparison.OrdinalIgnoreCase));
if (accountTypeParameter != null)
{
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.RunAsAccountType, Value = accountTypeParameter.Value, MustOverride = accountTypeParameter.MustOverride
});
}
var passwordParameter = runAsSection.Parameter.SingleOrDefault(parameter => parameter.Name.Equals(Constants.ParameterNames.RunAsPassword, StringComparison.OrdinalIgnoreCase));
if (passwordParameter != null)
{
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.RunAsPassword, Value = passwordParameter.Value, MustOverride = passwordParameter.MustOverride, IsEncrypted = passwordParameter.IsEncrypted
});
}
}
else if (this.infrastructure.IsDefaultSystem &&
!this.infrastructure.IsScaleMin)
{
parameters.Add(new SettingsTypeSectionParameter()
{
Name = Constants.ParameterNames.RunAsAccountType, Value = "LocalSystem"
});
}
string sectionName = string.Format(CultureInfo.InvariantCulture, Constants.SectionNames.HostSettingsSectionPattern, this.nodeSettings.NodeName, service);
this.fabricHostSections.Add(new SettingsTypeSection()
{
Name = sectionName, Parameter = parameters.ToArray()
});
DeployerTrace.WriteNoise("Created the {0} section for node {1}.", sectionName, this.nodeSettings.NodeName);
}
