public GradleProjectGenerator(String SolutionName, Project Project, List <ProjectReference> ProjectReferences, PathString InputDirectory, PathString OutputDirectory, PathString SolutionOutputDirectory, String BuildGradleTemplateText, OperatingSystemType HostOperatingSystem, ArchitectureType HostArchitecture, OperatingSystemType TargetOperatingSystem, ArchitectureType?TargetArchitecture, ToolchainType Toolchain, CompilerType Compiler, CLibraryType CLibrary, CLibraryForm CLibraryForm, CppLibraryType CppLibrary, CppLibraryForm CppLibraryForm, ConfigurationType?ConfigurationType, PathString AndroidNdk)
{
this.SolutionName = SolutionName;
this.ProjectName = Project.Name.Split(':').First();
this.Project = Project;
this.ProjectReferences = ProjectReferences;
this.InputDirectory = InputDirectory.FullPath;
this.OutputDirectory = OutputDirectory.FullPath;
this.SolutionOutputDirectory = SolutionOutputDirectory.FullPath;
this.BuildGradleTemplateText = BuildGradleTemplateText;
this.HostOperatingSystem = HostOperatingSystem;
this.HostArchitecture = HostArchitecture;
this.TargetOperatingSystem = TargetOperatingSystem;
this.TargetArchitecture = TargetArchitecture;
if (!TargetArchitecture.HasValue)
{
throw new NotSupportedException("ArchitectureTypeIsNull");
}
this.Toolchain = Toolchain;
this.Compiler = Compiler;
this.CLibrary = CLibrary;
this.CLibraryForm = CLibraryForm;
this.CppLibrary = CppLibrary;
this.CppLibraryForm = CppLibraryForm;
this.ConfigurationType = ConfigurationType;
this.AndroidNdk = AndroidNdk;
}
public static int PortToInt(string portString)
{
string prefix = String.Empty;
OperatingSystemType plat = Common.OperatingSystem.GetOperatingSystemType();
if (plat == OperatingSystemType.Windows)
{
prefix = WinComPrefix;
}
else if (plat == OperatingSystemType.Linux)
{
prefix = LinuxSysComPrefix;
LinuxCom linuxCom = GlobalConfigTool.GlobalConfig.LinuxComList.FirstOrDefault(l => portString.Contains(l.LinuxPort.ToString()));
if (linuxCom != null)
{
if (linuxCom.LinuxComType == LinuxComType.Usb)
{
prefix = LinuxUsbComPrefix;
}
else if (linuxCom.LinuxComType == LinuxComType.System)
{
prefix = LinuxSysComPrefix;
}
}
}
if (prefix.Length > 0)
{
return(int.Parse(portString.Substring(prefix.Length)));
}
else
{
throw new IndexOutOfRangeException("串口字符串无法转换");
}
}
private static List <string> GetConditions(OperatingSystemType OperatingSystem, List <ConfigurationType> MatchingConfigurationTypes, List <ArchitectureType> MatchingTargetArchitectures)
{
List <string> Conditions;
if ((MatchingConfigurationTypes != null) || (MatchingTargetArchitectures != null))
{
var Keys = "";
var Values = new List <String> {
""
};
if (MatchingConfigurationTypes != null)
{
Keys = (Keys != "" ? Keys + "|" : "") + "$(Configuration)";
Values = MatchingConfigurationTypes.SelectMany(t => Values.Select(v => (v != "" ? v + "|" : "") + t.ToString())).ToList();
}
if (MatchingTargetArchitectures != null)
{
Keys = (Keys != "" ? Keys + "|" : "") + "$(Platform)";
Values = MatchingTargetArchitectures.SelectMany(a => Values.Select(v => (v != "" ? v + "|" : "") + GetArchitectureString(OperatingSystem, a))).ToList();
}
Conditions = Values.Select(v => "'" + Keys + "' == '" + v + "'").ToList();
}
else
{
Conditions = new List <String> {
null
};
}
return(Conditions);
}
public OSInfo(string displayName, string templateName, int priority, OperatingSystemType ostype)
{
DisplayName = displayName;
TemplateName = templateName;
Priority = priority;
OSType = ostype;
}
public void returns_expected_command_shell_when_shell_is_not_defined(OperatingSystemType operatingSystemType, string expected)
{
var sut = new RealCommandFactory(new StubOperatingSystemTypeProvider(operatingSystemType));
var result = sut.Create("?");
Assert.Equal(expected, result.Shell);
}
public void returns_expected_default_shell(OperatingSystemType operatingSystemType, string expected)
{
var sut = new RealCommandFactory(new StubOperatingSystemTypeProvider(operatingSystemType));
var result = sut.GetDefaultOSShell();
Assert.Equal(expected, result);
}
public static String GetArchitectureString(OperatingSystemType OperatingSystem, ArchitectureType Architecture)
{
if (Architecture == ArchitectureType.x86)
{
if (OperatingSystem == OperatingSystemType.Windows)
{
return("Win32");
}
else
{
return("x86");
}
}
else if (Architecture == ArchitectureType.x64)
{
return("x64");
}
else if (Architecture == ArchitectureType.armv7a)
{
return("ARM");
}
else if (Architecture == ArchitectureType.arm64)
{
return("ARM64");
}
else
{
throw new NotSupportedException("NotSupportedArchitecture: " + Architecture.ToString());
}
}
public static string PortToString(int port)
{
string prefix = String.Empty;
OperatingSystemType plat = Common.OperatingSystem.GetOperatingSystemType();
if (plat == OperatingSystemType.Windows)
{
prefix = WinComPrefix;
}
else if (plat == OperatingSystemType.Linux)
{
prefix = LinuxSysComPrefix;
LinuxCom linuxCom = GlobalConfigTool.GlobalConfig.LinuxComList.FirstOrDefault(l => l.LinuxPort == port);
if (linuxCom != null)
{
if (linuxCom.LinuxComType == LinuxComType.Usb)
{
prefix = LinuxUsbComPrefix;
}
else if (linuxCom.LinuxComType == LinuxComType.System)
{
prefix = LinuxSysComPrefix;
}
}
}
return(String.Format("{0}{1}", prefix, port.ToString()));
}
public ExportRenderingSubsystemAttribute(OperatingSystemType requiredOS, int priority, string name, Type initializationType, string initializationMethod)
{
Name = name;
InitializationType = initializationType;
InitializationMethod = initializationMethod;
RequiredOS = requiredOS;
Priority = priority;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExportRenderingSubsystemAttribute"/> class.
/// </summary>
/// <param name="requiredOS"></param>
/// <param name="priority"></param>
/// <param name="name"></param>
/// <param name="initializationType"></param>
/// <param name="initializationMethod"></param>
public ExportRenderingSubsystemAttribute(OperatingSystemType requiredOS, int priority, string name, Type initializationType, string initializationMethod)
{
Name = name;
InitializationType = initializationType;
InitializationMethod = initializationMethod;
RequiredOS = requiredOS;
Priority = priority;
}
public override string ToString()
{
return($"PC Info:\n\t>>> Processor: {Processor} - {ProcessorInGHz} GHz - {ProcessorCount} cores.\n\t" +
$">>> RAM: {RAMType.ToString()} {RAMSizeInGb} Gb.\n\t" +
$">>> Graphics card: {GraphicsCard.ToString()} {GraphicsCardMemoryInMb} Mb.\n\t" +
$">>> Hard Disk: {HardDiskType.ToString()} {HardDiskSizeInGb} Gb.\n\t" +
$">>> OS: {OperatingSystemType.ToString()} {OperatingSystemVersion}.");
}
/// <summary>
/// Initializes a new instance of the <see cref="ExportWindowingSubsystemAttribute"/> class.
/// </summary>
/// <param name="requiredRuntimePlatform"></param>
/// <param name="priority"></param>
/// <param name="name"></param>
/// <param name="initializationType"></param>
/// <param name="initializationMethod"></param>
public ExportWindowingSubsystemAttribute(OperatingSystemType requiredRuntimePlatform, int priority, string name, Type initializationType, string initializationMethod)
{
Name = name;
InitializationType = initializationType;
InitializationMethod = initializationMethod;
RequiredOS = requiredRuntimePlatform;
Priority = priority;
}
public ExportWindowingSubsystemAttribute(OperatingSystemType requiredRuntimePlatform, int priority, string name, Type initializationType, string initializationMethod)
{
Name = name;
InitializationType = initializationType;
InitializationMethod = initializationMethod;
RequiredOS = requiredRuntimePlatform;
Priority = priority;
}
public Phone(string model, string brand, double price, OperatingSystemType type, bool isAvailable, Shop shop)
{
Model = model;
Brand = brand;
Price = price;
Type = type;
IsAvailable = isAvailable;
ShopPlace = shop;
}
//AddDataDisk
//DeleteDataDisk
//GetDataDisk
//UpdateDataDisk
public Task<string> CreateDiskAsync(string name, string label, Uri linkToBlob, OperatingSystemType osType = OperatingSystemType.None,
CancellationToken token = default(CancellationToken))
{
VirtualHardDisk info = new VirtualHardDisk(name, label, linkToBlob, osType);
HttpRequestMessage message = CreateBaseMessage(HttpMethod.Post, CreateTargetUri(UriFormatStrings.Disks), info);
return StartSendTask(message, token);
}
public PbxprojGenerator(Project Project, List <ProjectReference> ProjectReferences, String InputDirectory, String OutputDirectory, String PbxprojTemplateText, OperatingSystemType BuildingOperatingSystem, OperatingSystemType TargetOperatingSystem)
{
this.Project = Project;
this.ProjectReferences = ProjectReferences;
this.InputDirectory = InputDirectory;
this.OutputDirectory = OutputDirectory;
this.PbxprojTemplateText = PbxprojTemplateText;
this.BuildingOperatingSystem = BuildingOperatingSystem;
this.TargetOperatingSystem = TargetOperatingSystem;
}
public Make(ToolchainType Toolchain, CompilerType Compiler, OperatingSystemType TargetOperationSystem, String SourceDirectory, String BuildDirectory, bool EnableRebuild)
{
this.Toolchain = Toolchain;
this.Compiler = Compiler;
this.TargetOperationSystem = TargetOperationSystem;
this.SourceDirectory = SourceDirectory;
this.BuildDirectory = BuildDirectory;
this.EnableRebuild = EnableRebuild;
this.BuildingOperatingSystem = OperatingSystemType.Windows;
}
public static OSVirtualHardDisk OSDiskFromVirtualDisk(string diskName, OperatingSystemType osType, string label = null, HostCaching caching = HostCaching.ReadWrite)
{
return new OSVirtualHardDisk
{
HostCaching = caching,
DiskLabel = label,
DiskName = diskName,
OSType = osType
};
}
public static OSVirtualHardDisk OSDiskFromLink(Uri mediaLink, OperatingSystemType osType, string label = null, HostCaching caching = HostCaching.ReadWrite)
{
return new OSVirtualHardDisk
{
HostCaching = caching,
DiskLabel = label,
MediaLink = mediaLink,
OSType = osType
};
}
public ExportRenderingSubsystemAttribute(OperatingSystemType requiredOS, int priority, string name, Type initializationType, string initializationMethod,
Type?environmentChecker = null)
{
Name = name;
InitializationType = initializationType;
InitializationMethod = initializationMethod;
EnvironmentChecker = environmentChecker;
RequiredOS = requiredOS;
Priority = priority;
}
public SlnGenerator(String SolutionName, String SolutionId, List <ProjectReference> ProjectReferences, PathString OutputDirectory, String SlnTemplateText, OperatingSystemType TargetOperatingSystem, ArchitectureType TargetArchitecture)
{
this.SolutionName = SolutionName;
this.SolutionId = SolutionId;
this.ProjectReferences = ProjectReferences;
this.OutputDirectory = OutputDirectory.FullPath;
this.TargetOperatingSystem = TargetOperatingSystem;
this.TargetArchitecture = TargetArchitecture;
this.SlnTemplateText = SlnTemplateText;
}
/// <summary>
/// Initializes a new instance of the UpdateConfiguration class.
/// </summary>
/// <param name="operatingSystem">operating system of target machines.
/// Possible values include: 'Windows', 'Linux'</param>
/// <param name="windows">Windows specific update
/// configuration.</param>
/// <param name="linux">Linux specific update configuration.</param>
/// <param name="duration">Maximum time allowed for the software update
/// configuration run. Duration needs to be specified using the format
/// PT[n]H[n]M[n]S as per ISO8601</param>
/// <param name="azureVirtualMachines">List of azure resource Ids for
/// azure virtual machines targeted by the software update
/// configuration.</param>
/// <param name="nonAzureComputerNames">List of names of non-azure
/// machines targeted by the software update configuration.</param>
/// <param name="targets">Group targets for the software update
/// configuration.</param>
public UpdateConfiguration(OperatingSystemType operatingSystem, WindowsProperties windows = default(WindowsProperties), LinuxProperties linux = default(LinuxProperties), System.TimeSpan?duration = default(System.TimeSpan?), IList <string> azureVirtualMachines = default(IList <string>), IList <string> nonAzureComputerNames = default(IList <string>), TargetProperties targets = default(TargetProperties))
{
OperatingSystem = operatingSystem;
Windows = windows;
Linux = linux;
Duration = duration;
AzureVirtualMachines = azureVirtualMachines;
NonAzureComputerNames = nonAzureComputerNames;
Targets = targets;
CustomInit();
}
public static OSVirtualHardDisk OSDiskFromImage(string imageName, OperatingSystemType osType, Uri targetBlob, string label = null, HostCaching caching = HostCaching.ReadWrite)
{
return new OSVirtualHardDisk
{
HostCaching = caching,
DiskLabel = label,
SourceImageName = imageName,
OSType = osType,
MediaLink = targetBlob
};
}
public CMakeProjectGenerator(Project Project, List <ProjectReference> ProjectReferences, String InputDirectory, String OutputDirectory, ToolchainType Toolchain, CompilerType Compiler, OperatingSystemType BuildingOperatingSystem, OperatingSystemType TargetOperatingSystem)
{
this.Project = Project;
this.ProjectReferences = ProjectReferences;
this.InputDirectory = InputDirectory;
this.OutputDirectory = OutputDirectory;
this.Toolchain = Toolchain;
this.Compiler = Compiler;
this.BuildingOperatingSystem = BuildingOperatingSystem;
this.TargetOperatingSystem = TargetOperatingSystem;
}
public override int GetHashCode()
{
int hash = 1;
if (Primary != false)
{
hash ^= Primary.GetHashCode();
}
if (Username.Length != 0)
{
hash ^= Username.GetHashCode();
}
if (Uid != 0L)
{
hash ^= Uid.GetHashCode();
}
if (Gid != 0L)
{
hash ^= Gid.GetHashCode();
}
if (HomeDirectory.Length != 0)
{
hash ^= HomeDirectory.GetHashCode();
}
if (Shell.Length != 0)
{
hash ^= Shell.GetHashCode();
}
if (Gecos.Length != 0)
{
hash ^= Gecos.GetHashCode();
}
if (SystemId.Length != 0)
{
hash ^= SystemId.GetHashCode();
}
if (AccountId.Length != 0)
{
hash ^= AccountId.GetHashCode();
}
if (OperatingSystemType != global::Google.Cloud.OsLogin.Common.OperatingSystemType.Unspecified)
{
hash ^= OperatingSystemType.GetHashCode();
}
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public NinjaSolutionGenerator(String SolutionName, List <ProjectReference> ProjectReferences, PathString ProjectOutputDirectory, OperatingSystemType TargetOperatingSystem, String CC, String CXX, String AR, String STRIP)
{
this.SolutionName = SolutionName;
this.ProjectReferences = ProjectReferences;
this.ProjectOutputDirectory = ProjectOutputDirectory.FullPath;
this.TargetOperatingSystem = TargetOperatingSystem;
this.CC = CC;
this.CXX = CXX;
this.AR = AR;
this.STRIP = STRIP;
}
public static void GetLogs(
OperatingSystemType clusterOperatingSystemType, CloudTable cloudTable,
DateTimeOffset dateTimeMin, DateTimeOffset dateTimeMax,
string roleName = null, string roleInstance = null, string componentName = null,
string endpointSuffix = "core.windows.net")
{
//string partitionKeyMin = string.Format("0000000000000000000___{0}", new DateTime(dateTimeMin.Ticks, DateTimeKind.Unspecified).ToBinary().ToString("D19"));
//string partitionKeyMax = string.Format("0000000000000000100___{0}", new DateTime(dateTimeMax.Ticks, DateTimeKind.Unspecified).ToBinary().ToString("D19"));
//Logger.InfoFormat(partitionKeyMin);
//Logger.InfoFormat(partitionKeyMax);
var filters = new List <FilterClause>()
{
//new FilterClause("PartitionKey", "gt", partitionKeyMin),
//new FilterClause("PartitionKey", "lt", partitionKeyMax),
new FilterClause("Timestamp", QueryComparisons.GreaterThan, dateTimeMin), //2012-12-23T21:11:32.8339201Z
new FilterClause("Timestamp", QueryComparisons.LessThan, dateTimeMax)
//new FilterClause("TraceLevel", QueryComparisons.Equal, "Error"),
//new FilterClause("Role", QueryComparisons.Equal, "workernode")
};
if (!String.IsNullOrEmpty(roleName))
{
filters.Add(new FilterClause("Role", "eq", roleName));
}
if (!String.IsNullOrEmpty(roleInstance))
{
if (clusterOperatingSystemType == OperatingSystemType.Linux)
{
filters.Add(new FilterClause("Host", "eq", roleInstance));
}
else
{
filters.Add(new FilterClause("RoleInstance", "eq", roleInstance));
}
}
if (!String.IsNullOrEmpty(componentName))
{
filters.Add(new FilterClause("ComponentName", "eq", componentName));
}
var query = BuildQuery <HadoopServiceLogEntity>(filters);
Logger.InfoFormat("Query = {0}", query.FilterString);
var logList = RunQuery(clusterOperatingSystemType, cloudTable, query);
HDInsightClusterLogsWriter.Write(clusterOperatingSystemType, cloudTable.Name + ".xlsx", logList);
Logger.InfoFormat("Done - {0}. Rows: {1}", cloudTable.Name, logList.Count);
}
internal static string ToSerializedValue(this OperatingSystemType value)
{
switch (value)
{
case OperatingSystemType.Windows:
return("Windows");
case OperatingSystemType.Linux:
return("Linux");
}
return(null);
}
/// <summary>
/// Tries to fetch the default package directory for NuGet packages.
/// Taken from:
/// https://github.com/dotnet/core-setup/blob/master/src/Microsoft.Extensions.DependencyModel/Resolution/PackageCompilationAssemblyResolver.cs#L41-L64
/// </summary>
/// <param name="osPlatform">OS Platform to fetch default package
/// directory for.</param>
/// <returns>The path to the default package directory; null if none
/// could be set.</returns>
private static string GetDefaultPackageDirectory(OperatingSystemType osPlatform)
{
var packageDirectory = Environment.GetEnvironmentVariable("NUGET_PACKAGES");
if (!string.IsNullOrEmpty(packageDirectory))
{
return(packageDirectory);
}
var basePath = Environment.GetEnvironmentVariable(osPlatform == OperatingSystemType.Windows ? "USERPROFILE" : "HOME");
return(string.IsNullOrEmpty(basePath) ? null : Path.Combine(basePath, ".nuget", "packages"));
}
public int CalculatePhonesByType(OperatingSystemType type)
{
int amount = 0;
foreach (var phone in Phones)
{
if (phone.Type == type && phone.IsAvailable == true)
{
amount++;
}
}
return(amount);
}
public DataService(OperatingSystemType OperatingSystemType, string url)
{
this.OperatingSystemType = OperatingSystemType;
string dir = GetDir();
if (string.IsNullOrWhiteSpace(dir))
{
this.Url = $"{url}/api";
}
else
{
this.Url = $"{url}/api/{dir}";
}
}
public DataService(OperatingSystemType OperatingSystemType)
{
this.OperatingSystemType = OperatingSystemType;
string dir = GetDir();
if (string.IsNullOrWhiteSpace(dir))
{
this.Url = $"{Config.GetApiLocation()}/api";
}
else
{
this.Url = $"{Config.GetApiLocation()}/api/{dir}";
}
}
public object Convert(object input)
{
var inputString = (string)input;
if (inputString.Contains("Windows"))
{
OperatingSystemType os = OperatingSystemType.Windows;
#region Detect Specific Windows Version
if (inputString.Contains("Windows XP"))
{
os = OperatingSystemType.WindowsXP;
}
else if (inputString.Contains("Vista"))
{
os = OperatingSystemType.WindowsVista;
}
else if (inputString.Contains("Windows 7"))
{
os = OperatingSystemType.Windows7;
}
else if (inputString.Contains("Windows 8"))
{
os = OperatingSystemType.Windows8;
}
else if (inputString.Contains("Windows 10"))
{
os = OperatingSystemType.Windows10;
}
#endregion
return(os);
}
if (inputString.Contains("Linux"))
{
return(OperatingSystemType.Linux);
}
if (inputString.Contains("OSX"))
{
return(OperatingSystemType.OSX);
}
throw new FormatException(String.Format(CultureInfo.InvariantCulture,
"Failed to parse OS value from '{0}'.", inputString));
}
public static ILibraryLoader Get(OperatingSystemType os)
{
switch (os)
{
case OperatingSystemType.Windows:
return(new WindowsLoader());
case OperatingSystemType.Darwin:
return(new DarwinLoader());
case OperatingSystemType.Linux:
return(new LinuxLoader());
default:
throw new PlatformNotSupportedException($"This operating system ({os}) is not supported");
}
}
public static OperatingSystemType GetOperatingSystemType()
{
OperatingSystemType type = OperatingSystemType.Windows;
string osType = Environment.OSVersion.Platform.ToString();
switch (osType)
{
case "Win32NT":
type = OperatingSystemType.Windows;
break;
case "Unix":
type = OperatingSystemType.Linux;
break;
}
return(type);
}
public NinjaProjectGenerator(Project Project, List <ProjectReference> ProjectReferences, PathString InputDirectory, PathString OutputDirectory, OperatingSystemType HostOperatingSystem, ArchitectureType HostArchitecture, OperatingSystemType TargetOperatingSystem, ArchitectureType TargetArchitecture, WindowsRuntimeType?WindowsRuntime, ToolchainType Toolchain, CompilerType Compiler, CLibraryType CLibrary, CLibraryForm CLibraryForm, CppLibraryType CppLibrary, CppLibraryForm CppLibraryForm, ConfigurationType ConfigurationType)
{
this.Project = Project;
this.ProjectReferences = ProjectReferences;
this.InputDirectory = InputDirectory.FullPath;
this.OutputDirectory = OutputDirectory.FullPath;
this.HostOperatingSystem = HostOperatingSystem;
this.HostArchitecture = HostArchitecture;
this.TargetOperatingSystem = TargetOperatingSystem;
this.TargetArchitecture = TargetArchitecture;
this.WindowsRuntime = WindowsRuntime;
this.Toolchain = Toolchain;
this.Compiler = Compiler;
this.CLibrary = CLibrary;
this.CLibraryForm = CLibraryForm;
this.CppLibrary = CppLibrary;
this.CppLibraryForm = CppLibraryForm;
this.ConfigurationType = ConfigurationType;
}
static void Create(string subscriptionId, string resourceGroupName, string clusterDnsName, string clusterLocation,
List<AzureStorageConfig> asvAccounts, int clusterSize, string clusterUsername, string clusterPassword,
string hdInsightVersion, List<SqlAzureConfig> sqlAzureMetaStores,
ClusterType clusterType, OperatingSystemType osType)
{
Logger.InfoFormat("ResourceGroup: {0}, Cluster: {1} - Submitting a new cluster deployment request", resourceGroupName, clusterDnsName);
var clusterCreateParameters = new ClusterCreateParameters()
{
ClusterSizeInNodes = clusterSize,
ClusterType = (HDInsightClusterType)Enum.Parse(typeof(HDInsightClusterType), clusterType.ToString()),
DefaultStorageAccountKey = asvAccounts[0].Key,
DefaultStorageAccountName = asvAccounts[0].Name,
DefaultStorageContainer = asvAccounts[0].Container,
Location = clusterLocation,
Password = clusterPassword,
UserName = clusterUsername,
Version = hdInsightVersion,
OSType = (OSType)Enum.Parse(typeof(OSType), osType.ToString()),
};
if (clusterCreateParameters.OSType == OSType.Linux)
{
clusterCreateParameters.SshUserName = config.SshUsername;
if (String.IsNullOrWhiteSpace(config.SshPassword))
{
var publicKey = File.ReadAllText(config.SshPublicKeyFilePath);
Logger.Debug("SSH RSA Public Key: " + Environment.NewLine + publicKey + Environment.NewLine);
clusterCreateParameters.SshPublicKey = publicKey;
}
else
{
clusterCreateParameters.SshPassword = config.SshPassword;
}
}
else
{
if (config.AutoEnableRdp)
{
clusterCreateParameters.RdpUsername = config.RdpUsername;
clusterCreateParameters.RdpPassword = config.RdpPassword;
clusterCreateParameters.RdpAccessExpiry = DateTime.Now.AddDays(int.Parse(config.RdpExpirationInDays));
}
}
if (sqlAzureMetaStores != null && sqlAzureMetaStores.Count > 0)
{
var hiveMetastore = sqlAzureMetaStores.FirstOrDefault(s => s.Type.Equals("HiveMetastore"));
if (hiveMetastore != null)
{
clusterCreateParameters.HiveMetastore =
new Metastore(hiveMetastore.Server, hiveMetastore.Database, hiveMetastore.User, hiveMetastore.Password);
}
var oozieMetastore = sqlAzureMetaStores.FirstOrDefault(s => s.Type.Equals("OozieMetastore"));
if (oozieMetastore != null)
{
clusterCreateParameters.OozieMetastore =
new Metastore(oozieMetastore.Server, oozieMetastore.Database, oozieMetastore.User, oozieMetastore.Password);
}
}
var localStopWatch = Stopwatch.StartNew();
var createTask = hdInsightManagementClient.Clusters.CreateAsync(resourceGroupName, clusterDnsName, clusterCreateParameters);
Logger.InfoFormat("Cluster: {0} - Create cluster request submitted with task id: {1}, task status: {2}",
clusterDnsName, createTask.Id, createTask.Status);
Thread.Sleep(pollInterval);
var error = MonitorCreate(resourceGroupName, clusterDnsName, createTask);
if (error)
{
if (config.CleanupOnError)
{
Logger.InfoFormat("{0} - {1}. Submitting a delete request for the failed cluster creation.", Config.ConfigName.CleanupOnError.ToString(), config.CleanupOnError.ToString());
Delete(resourceGroupName, clusterDnsName);
}
else
{
throw new ApplicationException(String.Format("Cluster: {0} - Creation unsuccessful", clusterDnsName));
}
}
else
{
if (config.AutoEnableRdp && clusterCreateParameters.OSType == OSType.Windows)
{
HDInsightManagementCLIHelpers.CreateRdpFile(clusterDnsName, config.RdpUsername, config.RdpPassword);
}
}
}
public static void Write(OperatingSystemType clusterOperatingSystemType, string filePath, List<Object> logEntities)
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
var excelPackageLogs = new ExcelPackage(new FileInfo(filePath));
List<MemberInfo> columnInfoBuilds;
var excelWorksheetHadoopServiceLogs = CreateExcelWorksheetForDataList(excelPackageLogs, "HadoopServiceLog", logEntities, out columnInfoBuilds);
if (columnInfoBuilds != null && columnInfoBuilds.Count > 0)
{
CreateExcelPivotForWorksheet(excelPackageLogs, excelWorksheetHadoopServiceLogs, "ComponentLogTypePivot",
new List<PivotField>() { new PivotField("Role") },
new List<PivotField>() { new PivotField("ComponentName") },
new List<PivotField>() { new PivotField("TraceLevel") },
new List<PivotDataField>() { new PivotDataField("Message", "Count", DataFieldFunctions.Count) },
logEntities.Count, columnInfoBuilds.Count
);
}
excelPackageLogs.Save();
}
