public OS(OSType type, Version versionNumber, string versionString, bool is64Bit)
{
Type = type;
VersionNumber = versionNumber;
VersionString = versionString;
Is64BitOS = is64Bit;
}
public OSInfo(OSType type)
{
Type = type;
VersionNumber = Environment.OSVersion.Version;
VersionString = Environment.OSVersion.VersionString;
Is64Bit = Environment.Is64BitOperatingSystem;
}
public SettingsMenuWrapper(ConfigManager configManager, ConfigGUI configGUI)
{
this.configManager = configManager;
this.configGUI = configGUI;
usePS3 = configManager.UsingPS3 ();
osType = OsSpec.getOS ();
settingsSkin = (GUISkin)Resources.Load ("_GUISkins/Settings");
regularUI = (GUISkin)Resources.Load ("_GUISkins/RegularUI");
}
private bool IsExtensionInstalled(OSType currentOSType)
{
if (OSType.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
}
else if (OSType.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
}
AzureOperationResponse <VirtualMachineExtension> extensionResult = this.VirtualMachineExtensionClient.GetWithInstanceView(this.ResourceGroupName, this.VMName, this.Name);
if (extensionResult == null)
{
return(false);
}
PSVirtualMachineExtension returnedExtension = extensionResult.ToPSVirtualMachineExtension(
this.ResourceGroupName, this.VMName);
if ((returnedExtension == null) ||
(string.IsNullOrWhiteSpace(returnedExtension.Publisher)) ||
(string.IsNullOrWhiteSpace(returnedExtension.ExtensionType)))
{
return(false);
}
bool publisherMatch = false;
if (OSType.Linux.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(this.ExtensionPublisherName ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(this.ExtensionType ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultType,
StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
else if (OSType.Windows.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(this.ExtensionPublisherName ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(this.ExtensionType ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultType, StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
if (publisherMatch)
{
return(true);
}
return(false);
}
internal static string ToSerializedValue(this OSType value)
{
switch( value )
{
case OSType.Linux:
return "Linux";
case OSType.Windows:
return "Windows";
}
return null;
}
private IEnumerator Start()
{
while (true)
{
var joystickNames = Input.GetJoystickNames();
for (int i = 0; i < joystickNames.Length; i++)
{
//Debug.LogFormat("{0} {1}", i, joystickNames);
var joystickName = joystickNames[i];
if (joystickName == "")
{
continue;
}
else if (joystickName.Contains("Xbox") || joystickName.Contains("XBOX") || joystickName.Contains("xinput"))
{
controllerType = ControllerType.Xbox;
break;
}
else if (joystickName.Contains("Wireless Controller"))
{
controllerType = ControllerType.PS4;
break;
}
else
{
controllerType = ControllerType.Other;
break;
}
}
if (SystemInfo.operatingSystem.Contains("Windows"))
{
osType = OSType.Win;
}
else if (SystemInfo.operatingSystem.Contains("Mac"))
{
osType = OSType.Mac;
}
else
{
osType = OSType.Other;
}
ClearInputEvent();
SetKeyboard();
SetGamepad();
SetFreelookCamera();
yield return(new WaitForSeconds(1f));
}
}
public override string ToString()
{
if (IsSuccessed)
{
return(string.Format("匹配成功 {0} {1} {2} Ver{3}", OSType.GetEnumFlagDescription(), Manufacture, AppName, AppVersion));
}
else
{
return("匹配失败");
}
}
private EncryptionStatus AreDataVolumesEncrypted(VirtualMachine vmParameters)
{
// return true if any (non-OS) data volume attached to the VM reports an encrypted state
VirtualMachineInstanceView iv = this.ComputeClient.ComputeManagementClient.VirtualMachines.InstanceView(this.ResourceGroupName, this.VMName);
foreach (DiskInstanceView div in iv.Disks)
{
if (!((div.Name.Equals("osDisk") || div.Name.Contains("_OsDisk_"))) &&
GetLastEncryptionStatus(div).Equals("EncryptionState/encrypted"))
{
return(EncryptionStatus.Encrypted);
}
}
// no encrypted status found in disk instance data, check vm model
if (vmParameters == null || vmParameters.Resources == null)
{
return(EncryptionStatus.Unknown);
}
OSType osType = this.GetOSType(vmParameters);
foreach (VirtualMachineExtension vmExtension in vmParameters.Resources)
{
switch (osType)
{
case OSType.Windows:
case OSType.Linux:
if (IsAzureDiskEncryptionExtension(osType, vmExtension))
{
AzureDiskEncryptionExtensionContext adeExtension = new AzureDiskEncryptionExtensionContext(vmExtension.ToPSVirtualMachineExtension(this.ResourceGroupName, this.VMName));
if (DataVolumeInExtensionConfig(adeExtension))
{
if (adeExtension.EncryptionOperation.Equals(AzureDiskEncryptionExtensionConstants.enableEncryptionOperation, StringComparison.InvariantCultureIgnoreCase))
{
if (ExtensionProvisioningSucceeded(adeExtension))
{
return(EncryptionStatus.Encrypted);
}
}
}
}
break;
case OSType.Unknown:
return(EncryptionStatus.Unknown);
default:
return(EncryptionStatus.Unknown);
}
}
return(EncryptionStatus.NotEncrypted);
}
public static string GetMachineCode(bool platformIndependent = false, int v = 1 /*bool includeProcessId = false*/)
{
int p = 0;
OSType os = OSType.Windows;
if (!WindowsOnly)
{
p = (int)Environment.OSVersion.Platform;
os = GetPlatform();
}
#if !SYSTEM_MANAGEMENT
platformIndependent = true;
#endif
if (os == OSType.Unix)
{
//unix
if (os == OSType.Mac)
{
return(SKGL.SKM.getSHA256(ExecCommand("/bin/bash", "system_profiler SPHardwareDataType | awk '/UUID/ { print $3; }'")));
}
else if (os == OSType.Linux)
{
// requires sudo
return(SKGL.SKM.getSHA256(ExecCommand("/bin/bash", "dmidecode -s system-uuid")));
}
try
{
// always assume it's MAC if it's unix
return(SKGL.SKM.getSHA256(ExecCommand("/bin/bash", "system_profiler SPHardwareDataType | awk '/UUID/ { print $3; }'")));
}
catch (Exception ex)
{
// but if we get an error, it must be Linux:
return(SKGL.SKM.getSHA256(ExecCommand("/bin/bash", "dmidecode -s system-uuid")));
}
}
else
{
// not unix --> windows
if (platformIndependent)
{
return(SKGL.SKM.getSHA256(ExecCommand("cmd.exe", "/C wmic csproduct get uuid", v), v));
}
else
{
return(SKGL.SKM.getMachineCode(SKGL.SKM.getSHA256));
}
}
}
// Token: 0x0600112C RID: 4396 RVA: 0x000F913D File Offset: 0x000F753D
public void changeOS(OSType newOS)
{
if (newOS == this.os)
{
return;
}
this.energyProgress = 0f;
this.magicProgress = 0f;
this.energyLevel = 0L;
this.magicLevel = 0L;
this.os = newOS;
}
private void ConfigureAppenders()
{
PatternLayout layout = new PatternLayout();
layout.ConversionPattern = "%date [%thread] %-5level %logger - %message%n";
layout.ActivateOptions();
ValionLogAppender logAppender = new ValionLogAppender();
logAppender.MaximumEntries = 600;
logAppender.Threshold = Level.Debug;
logAppender.Layout = layout;
logAppender.ActivateOptions();
OSType osType = GetOperatingSystem();
if (osType == OSType.WebPlayer)
{
UnityEngine.Debug.Log("Detected Web-Player, only using appended logger");
BasicConfigurator.Configure(logAppender);
return;
}
ConsoleAppender consoleAppener = new ConsoleAppender();
consoleAppener.Layout = layout;
consoleAppener.Threshold = Level.Debug;
consoleAppener.Target = ConsoleAppender.ConsoleOut;
consoleAppener.ActivateOptions();
#if UNITY_WEBPLAYER
BasicConfigurator.Configure(logAppender, consoleAppener);
#else
PatternLayout fileLayout = new PatternLayout();
fileLayout.ConversionPattern = "%date [%thread] %-5level %logger - %message%n";
fileLayout.ActivateOptions();
RollingFileAppender fileAppender = new RollingFileAppender();
fileAppender.AppendToFile = true;
fileAppender.MaxFileSize = 2048 * 1024;
fileAppender.MaxSizeRollBackups = 10;
fileAppender.RollingStyle = RollingFileAppender.RollingMode.Composite;
fileAppender.Threshold = Level.Debug;
fileAppender.File = GetLogDirectory(osType) + "/log.txt";
fileAppender.Layout = fileLayout;
fileAppender.PreserveLogFileNameExtension = true;
fileAppender.ImmediateFlush = true;
fileAppender.ActivateOptions();
UnityEngine.Debug.Log("Detected " + osType + ", using file Logging: " + fileAppender.File);
BasicConfigurator.Configure(fileAppender, logAppender, consoleAppener);
#endif
}
internal static string ToSerializedValue(this OSType value)
{
switch (value)
{
case OSType.Linux:
return("linux");
case OSType.Windows:
return("windows");
}
return(null);
}
public AddAzureVMImageCmdletInfo(string imageName, string mediaLocation, OSType os, string label)
{
cmdletName = Utilities.AddAzureVMImageCmdletName;
cmdletParams.Add(new CmdletParam("ImageName", imageName));
cmdletParams.Add(new CmdletParam("MediaLocation", mediaLocation));
cmdletParams.Add(new CmdletParam("OS", os.ToString()));
if (System.String.IsNullOrWhiteSpace(label))
{
cmdletParams.Add(new CmdletParam("Label", label));
}
}
public WidgetFactory GetWidgetFactory(OSType os)
{
if (os == OSType.Windows10)
{
return(new Windows10WidgetFactory());
}
else if (os == OSType.OSX)
{
return(new OSXWidgetFactory());
}
else
{
throw new Exception($"Unsupported GUI ({os.ToString()})");
}
}
public List <DeviceInfo> GetDevicesInformationList(string domainName)
{
int DevicesCount = 0;
DirectorySearcher mySearcher;
var deviceInfoList = new List <DeviceInfo>();
try
{
var entry = new DirectoryEntry("LDAP://" + domainName);
// For Windows Servers
mySearcher = new DirectorySearcher(entry)
{
Filter = ("(objectClass=computer)")
};
foreach (SearchResult resEnt in mySearcher.FindAll())
{
string cmpName = resEnt.GetDirectoryEntry().Name.Substring(3);
string sFilter = "(&(objectCategory=computer)(name=" + cmpName + "))";
var directorySearch = new DirectorySearcher(entry, sFilter);
var directorySearchResult = directorySearch.FindOne();
var deComp = directorySearchResult.GetDirectoryEntry();
var cmpOs = deComp.Properties["operatingSystem"].Value.ToString();
string devType = OSType.GetDeviceType(cmpOs);
string devCategory = OSType.GetCMPCategory(cmpOs);
string cmpType = OSType.GetCMPType(cmpOs);
var deviceInfo = new DeviceInfo
{
DevType = devType,
DevCategory = devCategory,
ComType = cmpType,
ComName = cmpName,
ComOS = cmpOs
};
deviceInfoList.Add(deviceInfo);
DevicesCount++;
WriteTextFile.WriteErrorLog(DevicesCount + ") Machine Type: " + devType + " | " + "cat: " + devCategory + " | " + "CMP Type: " + cmpType + " | " + "CmpName: " + cmpName + " | Cmp OS:" + cmpOs);
}
}
catch (Exception ex)
{
WriteTextFile.WriteErrorLog("Device Info List ERROR");
WriteTextFile.WriteErrorLog("==========================================");
WriteTextFile.WriteErrorLog(ex);
deviceInfoList = null;
}
return(deviceInfoList);
}
public static ASoftware GetSoftware(OSType type)
{
if (type == OSType.LINUX)
{
return(new SoftwareLinux());
}
else if (type == OSType.MAC)
{
return(new SoftwareMac());
}
else if (type == OSType.WINDOWS)
{
return(new SoftwareWindows());
}
return(new SoftwareWindows());
}
/// <inheritdoc />
public async Task <Collection <string> > ListAvailableLocationsAsync(OSType osType)
{
var client = ServiceLocator.Instance.Locate <ILocationFinderClientFactory>().Create(this.credentials, this.Context, this.IgnoreSslErrors);
switch (osType)
{
case OSType.Windows:
return(await client.ListAvailableLocations());
case OSType.Linux:
return(await client.ListAvailableIaasLocations());
default:
throw new InvalidProgramException(String.Format("Encountered unhandled value for OSType: {0}", osType));
}
}
private static bool IsOsDarwin(OSType osType)
{
osType.ValidateDefined(nameof(osType));
switch (osType)
{
case OSType.Darwin:
case OSType.MacOSX:
case OSType.IOS:
case OSType.TvOS:
case OSType.WatchOS:
return(true);
default:
return(false);
}
}
internal ImageInformation(string nodeAgentSKUId, ImageReference imageReference, OSType osType, VerificationType verificationType)
{
if (nodeAgentSKUId == null)
{
throw new ArgumentNullException(nameof(nodeAgentSKUId));
}
if (imageReference == null)
{
throw new ArgumentNullException(nameof(imageReference));
}
NodeAgentSKUId = nodeAgentSKUId;
ImageReference = imageReference;
OsType = osType;
VerificationType = verificationType;
}
public Datastore()
{
if (!File.Exists(datastoreLocation))
{
ApplicationDataStorage.Instance.FirstRun = true;
}
OSType osType = OsInformation.OperatingSystem;
switch (osType)
{
case OSType.Windows:
dbSQLite = new SQLiteWin32.SQLiteConnection(datastoreLocation);
break;
case OSType.Mac:
dbSQLite = new SQLiteUnix.SQLiteConnection(datastoreLocation);
break;
case OSType.X11:
dbSQLite = new SQLiteUnix.SQLiteConnection(datastoreLocation);
break;
case OSType.Android:
dbSQLite = new SQLiteAndroid.SQLiteConnection(datastoreLocation);
break;
default:
throw new NotImplementedException();
}
if (TEST_FLAG)
{
//In test mode - attempt to drop all tables (in case db was locked when we tried to delete it)
foreach (Type table in dataStoreTables)
{
try
{
this.dbSQLite.DropTable(table);
}
catch
{
GuiWidget.BreakInDebugger();
}
}
}
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters, OSType currentOSType)
{
Hashtable publicSettings = new Hashtable();
Hashtable protectedSettings = new Hashtable();
publicSettings.Add(AzureDiskEncryptionExtensionConstants.encryptionOperationKey, AzureDiskEncryptionExtensionConstants.queryEncryptionStatusOperation);
publicSettings.Add(AzureDiskEncryptionExtensionConstants.sequenceVersionKey, Guid.NewGuid().ToString());
if (vmParameters == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "Get-AzureDiskEncryptionExtension can enable encryption only on a VM that was already created ")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
VirtualMachineExtension vmExtensionParameters = null;
if (OSType.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
else if (OSType.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
return vmExtensionParameters;
}
public Phone(string name, float price, CategoryType category, PhoneType type,
string brandName, DateTime releaseDate, float displaySize, OSType OS, int simCardQuantity,
float RAM, float ROM, float camera, int batteryCapacity, Communication comm) :
base(name, price, category)
{
Type = type;
BrandName = brandName;
ReleaseDate = releaseDate;
DisplaySize = displaySize;
this.OS = OS;
SimCardQuantity = simCardQuantity;
this.RAM = RAM;
this.ROM = ROM;
Camera = camera;
BatteryCapacity = batteryCapacity;
Comm = comm;
}
public ScpForm()
{
InitializeComponent();
Configuration();
StringBuilder sb = new StringBuilder();
sb.AppendFormat("SCP Driver Installer {0} [{1}]", Application.ProductVersion, DateTime.Now);
sb.AppendLine();
sb.AppendLine();
Installer = Difx.Factory();
Installer.onLogEvent += Logger;
String Info = OSInfo();
Valid = OSParse(Info);
sb.Append("Detected - ");
sb.Append(Info);
sb.AppendLine();
tbOutput.AppendText(sb.ToString());
sb.Clear();
if (Valid == OSType.INVALID)
{
btnInstall.Enabled = false;
btnUninstall.Enabled = false;
sb.AppendLine("Could not find a valid configuration.");
}
else
{
btnInstall.Enabled = true;
btnUninstall.Enabled = true;
sb.AppendFormat("Selected {0} configuration.", Valid);
}
sb.AppendLine();
sb.AppendLine();
tbOutput.AppendText(sb.ToString());
}
public Computer(ProcessorType processor, ComputerManufacturer manufacturer, OSType operationSystem, int coreClock, int RAM)
{
ProcessorType = processor;
ComputerManufacturer = manufacturer;
OperationSystemType = operationSystem;
ProcessorCoreClock = coreClock;
RAMVolume = RAM;
InstalledPrograms = new List <string>()
{
"Office 365",
"Microsft Edge",
"Skype"
};
UserList = new List <string>()
{
"admin"
};
}
void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName("osType");
writer.WriteStringValue(OSType.ToSerialString());
writer.WritePropertyName("osState");
writer.WriteStringValue(OSState.ToSerialString());
if (Optional.IsDefined(Snapshot))
{
writer.WritePropertyName("snapshot");
JsonSerializer.Serialize(writer, Snapshot);
}
if (Optional.IsDefined(ManagedDisk))
{
writer.WritePropertyName("managedDisk");
JsonSerializer.Serialize(writer, ManagedDisk);
}
if (Optional.IsDefined(BlobUri))
{
writer.WritePropertyName("blobUri");
writer.WriteStringValue(BlobUri.AbsoluteUri);
}
if (Optional.IsDefined(Caching))
{
writer.WritePropertyName("caching");
writer.WriteStringValue(Caching.Value.ToSerialString());
}
if (Optional.IsDefined(DiskSizeGB))
{
writer.WritePropertyName("diskSizeGB");
writer.WriteNumberValue(DiskSizeGB.Value);
}
if (Optional.IsDefined(StorageAccountType))
{
writer.WritePropertyName("storageAccountType");
writer.WriteStringValue(StorageAccountType.Value.ToString());
}
if (Optional.IsDefined(DiskEncryptionSet))
{
writer.WritePropertyName("diskEncryptionSet");
JsonSerializer.Serialize(writer, DiskEncryptionSet);
}
writer.WriteEndObject();
}
/// <summary>
/// Check if the current OS is compatible with the given type
/// </summary>
/// <param name="type">The type of OS to check for compatibility with</param>
/// <returns>True if compatible</returns>
public static bool IsCompatible(OSType type)
{
if (type == OSType.All)
{
return(true);
}
if (type == OS)
{
return(true);
}
if (type == OSType.Linux || type == OSType.Mac && OS == OSType.Nix)
{
return(true);
}
return(false);
}
public void Post([FromBody] PxeClient data)
{
string content;
string mac = data.mac;
OSType os = data.os;
content = string.Format(template, os, OSMap[os]);
Console.Write("Writing content as {0}\n\n", mac);
Console.Write(content);
try
{
System.IO.File.WriteAllText(mac, content);
}
catch
{
throw new Exception();
}
}
private EncryptionStatus AreDataVolumesEncrypted(VirtualMachine vmParameters)
{
if (vmParameters == null || vmParameters.Resources == null)
{
return(EncryptionStatus.Unknown);
}
OSType osType = this.GetOSType(vmParameters);
foreach (VirtualMachineExtension vmExtension in vmParameters.Resources)
{
switch (osType)
{
case OSType.Windows:
case OSType.Linux:
if (IsAzureDiskEncryptionExtension(osType, vmExtension))
{
AzureDiskEncryptionExtensionContext adeExtension = new AzureDiskEncryptionExtensionContext(vmExtension.ToPSVirtualMachineExtension(this.ResourceGroupName, this.VMName));
if (DataVolumeInExtensionConfig(adeExtension))
{
if (adeExtension.EncryptionOperation.Equals(AzureDiskEncryptionExtensionConstants.enableEncryptionOperation, StringComparison.InvariantCultureIgnoreCase))
{
if (ExtensionProvisioningSucceeded(adeExtension))
{
return(EncryptionStatus.Encrypted);
}
}
}
}
break;
case OSType.Unknown:
return(EncryptionStatus.Unknown);
default:
return(EncryptionStatus.Unknown);
}
}
return(EncryptionStatus.NotEncrypted);
}
public static Image Image(OSType OSImage)
{
Image img = Properties.Resources.Windows;
switch (OSImage)
{
case OSType.Linux:
img = Properties.Resources.Linux;
break;
case OSType.MacOSX:
img = Properties.Resources.MacOSX;
break;
}
if (OS.Type != OSImage)
{
img = img.GetOpacityImage();
}
return(img);
}
private string GetLogDirectory(OSType type)
{
string homeDirectory = Environment.GetEnvironmentVariable("HOME");
if (String.IsNullOrEmpty(homeDirectory))
{
homeDirectory = Environment.GetEnvironmentVariable("TMP");
if (String.IsNullOrEmpty(homeDirectory))
{
homeDirectory = ".";
}
}
if (String.IsNullOrEmpty(ApplicationName))
{
ApplicationName = "Unity3D-Project";
}
switch (type)
{
case OSType.MacOS:
{
return(homeDirectory + "/Library/Logs/" + ApplicationName);
}
case OSType.WindowsXP:
{
return(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + ApplicationName + "/Logs");
}
case OSType.WindowsVista7:
{
return(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "/" + ApplicationName + "/Logs");
}
}
// Unix and all others ...
return(homeDirectory + "/." + ApplicationName);
}
public static Computer Generate()
{
ComputerManufacturer manufacturer = (ComputerManufacturer)random.Next(7);
ProcessorType processor = (ProcessorType)random.Next(2);
OSType operationSystem = (OSType)random.Next(3);
int coreClock = (int)(1000.0 * (random.Next(1, 5) + random.NextDouble()));
int RAM = 1024 * random.Next(1, 65);
List <string> users = new List <string>();
for (int i = random.Next(0, userNames.Count); i < random.Next(1, userNames.Count); i++)
{
users.Add(userNames[i]);
}
List <string> programs = new List <string>();
for (int i = random.Next(0, programList.Count); i < random.Next(1, programList.Count); i++)
{
programs.Add(programList[i]);
}
return(new Computer(processor, manufacturer, operationSystem, coreClock, RAM, programs, users));
}
private VirtualMachineExtension GetVmExtensionParameters(VirtualMachine vmParameters, OSType currentOSType)
{
Hashtable publicSettings = new Hashtable();
Hashtable protectedSettings = new Hashtable();
publicSettings.Add(AzureDiskEncryptionExtensionConstants.encryptionOperationKey, AzureDiskEncryptionExtensionConstants.queryEncryptionStatusOperation);
publicSettings.Add(AzureDiskEncryptionExtensionConstants.sequenceVersionKey, Guid.NewGuid().ToString());
if (vmParameters == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "Get-AzureDiskEncryptionExtension can enable encryption only on a VM that was already created ")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
VirtualMachineExtension vmExtensionParameters = null;
if (OSType.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.ExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.ExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
else if (OSType.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
vmExtensionParameters = new VirtualMachineExtension
{
Location = vmParameters.Location,
Publisher = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher,
VirtualMachineExtensionType = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName,
TypeHandlerVersion = AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultVersion,
Settings = publicSettings,
ProtectedSettings = protectedSettings
};
}
return(vmExtensionParameters);
}
public static extern OSStatus AECreateDescFromExternalPtr (OSType descriptorType, IntPtr dataPtr, Size dataLength, AEDisposeExternalUPP disposeCallback, uint disposeRefcon, out AEDesc result);
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
VirtualMachine vmParameters = (this.ComputeClient.ComputeManagementClient.VirtualMachines.Get(this.ResourceGroupName, this.VMName));
EncryptionStatus osVolumeEncrypted = IsOsVolumeEncrypted(vmParameters);
DiskEncryptionSettings osVolumeEncryptionSettings = GetOsVolumeEncryptionSettings(vmParameters);
EncryptionStatus dataVolumesEncrypted = AreDataVolumesEncrypted(vmParameters);
AzureDiskEncryptionStatusContext encryptionStatus = null;
string progressMessage = null;
OSType osType = GetOSType(vmParameters);
switch (osType)
{
case OSType.Windows:
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = osVolumeEncrypted,
DataVolumesEncrypted = dataVolumesEncrypted,
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = string.Format(CultureInfo.CurrentUICulture, "OsVolume: {0}, DataVolumes: {1}", osVolumeEncrypted, dataVolumesEncrypted)
};
WriteObject(encryptionStatus);
break;
case OSType.Linux:
if (!IsExtensionInstalled(osType))
{
VirtualMachine virtualMachineResponse = this.ComputeClient.ComputeManagementClient.VirtualMachines.GetWithInstanceView(
this.ResourceGroupName, VMName).Body;
VirtualMachineExtension parameters = GetVmExtensionParameters(virtualMachineResponse, osType);
this.VirtualMachineExtensionClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.VMName,
this.Name,
parameters).GetAwaiter().GetResult();
}
Dictionary <string, string> encryptionStatusParsed = null;
try
{
string encryptionStatusJson = GetExtensionStatusMessage(osType, returnSubstatusMessage: true);
encryptionStatusParsed = JsonConvert.DeserializeObject <Dictionary <string, string> >(encryptionStatusJson);
}
catch (KeyNotFoundException)
{
encryptionStatusParsed = new Dictionary <string, string>()
{
{ AzureDiskEncryptionExtensionConstants.encryptionResultOsKey, EncryptionStatus.Unknown.ToString() },
{ AzureDiskEncryptionExtensionConstants.encryptionResultDataKey, EncryptionStatus.Unknown.ToString() }
};
}
try
{
progressMessage = GetExtensionStatusMessage(osType);
}
catch (KeyNotFoundException)
{
progressMessage = string.Format(CultureInfo.CurrentUICulture, "Extension status not available on the VM");
}
encryptionStatus = new AzureDiskEncryptionStatusContext
{
OsVolumeEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultOsKey]),
DataVolumesEncrypted = (EncryptionStatus)Enum.Parse(typeof(EncryptionStatus), encryptionStatusParsed[AzureDiskEncryptionExtensionConstants.encryptionResultDataKey]),
OsVolumeEncryptionSettings = osVolumeEncryptionSettings,
ProgressMessage = progressMessage
};
WriteObject(encryptionStatus);
break;
case OSType.Unknown:
ThrowTerminatingError(new ErrorRecord(new ApplicationException(string.Format(CultureInfo.CurrentUICulture, "OS type unknown.")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
break;
}
});
}
private static Dictionary<string, Dictionary<string, string>> GetMetastoreConfig(Metastore metastore, OSType osType, string metastoreType)
{
if (osType == OSType.Windows)
{
return GetMetastoreConfigPaas(metastore, metastoreType);
}
else
{
return GetMetastoreConfigIaas(metastore, metastoreType);
}
}
public Task<Collection<string>> ListAvailableLocationsAsync(OSType osType)
{
return TaskEx2.FromResult(new Collection<string> { "East US", "East US 2", "West US", "North Europe" });
}
private string GetExtensionStatusMessage(OSType currentOSType, bool returnSubstatusMessage=false)
{
AzureOperationResponse<VirtualMachineExtension> extensionResult = this.VirtualMachineExtensionClient.GetWithInstanceView(this.ResourceGroupName, this.VMName, this.Name);
if (extensionResult == null)
{
ThrowTerminatingError(new ErrorRecord(new ApplicationFailedException(string.Format(CultureInfo.CurrentUICulture, "Failed to retrieve extension status")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
PSVirtualMachineExtension returnedExtension = extensionResult.ToPSVirtualMachineExtension(
this.ResourceGroupName, this.VMName);
if ((returnedExtension == null) ||
(string.IsNullOrWhiteSpace(returnedExtension.Publisher)) ||
(string.IsNullOrWhiteSpace(returnedExtension.ExtensionType)))
{
ThrowTerminatingError(new ErrorRecord(new ApplicationFailedException(string.Format(CultureInfo.CurrentUICulture, "Missing extension publisher and type info")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
bool publisherMatch = false;
if (OSType.Linux.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
else if (OSType.Windows.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
if (publisherMatch)
{
AzureDiskEncryptionExtensionContext context = new AzureDiskEncryptionExtensionContext(returnedExtension);
if ((context == null) ||
(context.Statuses == null) ||
(context.Statuses.Count < 1) ||
(string.IsNullOrWhiteSpace(context.Statuses[0].Message)))
{
throw new KeyNotFoundException(string.Format(CultureInfo.CurrentUICulture, "Invalid extension status"));
}
if (returnSubstatusMessage)
{
if((context == null) ||
(context.SubStatuses == null) ||
(context.SubStatuses.Count < 1))
{
throw new KeyNotFoundException(string.Format(CultureInfo.CurrentUICulture, "Invalid extension substatus"));
}
else
{
return context.SubStatuses[0].Message;
}
}
return context.Statuses[0].Message;
}
else
{
ThrowTerminatingError(new ErrorRecord(new ApplicationFailedException(string.Format(CultureInfo.CurrentUICulture, "Extension publisher and type mismatched")),
"InvalidResult",
ErrorCategory.InvalidResult,
null));
}
return null;
}
public ControllerKeyBindings()
{
osType = OsSpec.getOS ();
}
/// <inheritdoc />
public async Task<Collection<string>> ListAvailableLocationsAsync(OSType osType)
{
var client = ServiceLocator.Instance.Locate<ILocationFinderClientFactory>().Create(this.credentials, this.Context, this.IgnoreSslErrors);
switch (osType)
{
case OSType.Windows:
return await client.ListAvailableLocations();
case OSType.Linux:
return await client.ListAvailableIaasLocations();
default:
throw new InvalidProgramException(String.Format("Encountered unhandled value for OSType: {0}", osType));
}
}
public Collection<string> ListAvailableLocations(OSType osType)
{
Task<Collection<string>> listTask = this.ListAvailableLocationsAsync(osType);
listTask.Wait();
return listTask.Result;
}
public static extern ComponentInstance OpenDefaultComponent(OSType componentType, OSType componentSubType);
public static RemoteWebDriver GetSauceDriver <TDriver>(this IWebDriver iWebDriver, string testName, OSType os = OSType.LINUX, string url = null) where TDriver : IWebDriver, new()
{
dynamic options = null;
switch (typeof(TDriver).Name)
{
case "ChromeDriver":
if (options == null)
{
options = new ChromeOptions();
}
break;
case "FirefoxDriver":
if (options == null)
{
options = new FirefoxOptions();
}
break;
default:
throw new NotImplementedException("unknown Driver");
}
options.AddAdditionalCapability(CapabilityType.Platform, os.GetDescription(), true);
// //options.AcceptInsecureCertificates = true;
// sauce
string assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
options.AddAdditionalCapability("build", assemblyVersion, true);
options.AddAdditionalCapability("username", SauceDriverKeys.SAUCELABS_USERNAME, true);
options.AddAdditionalCapability("accessKey", SauceDriverKeys.SAUCELABS_ACCESSKEY, true);
options.AddAdditionalCapability("name", testName, true);
//iWebDriver = (RemoteWebDriver)Activator.CreateInstance(typeof(RemoteWebDriver),
// args: new object[] { new Uri("http://ondemand.saucelabs.com:80/wd/hub"), options.ToCapabilities() });
iWebDriver = new RemoteWebDriver(new Uri("http://ondemand.saucelabs.com:80/wd/hub"), options.ToCapabilities());
if (!string.IsNullOrEmpty(url))
{
iWebDriver.Navigate().GoToUrl(url);
}
return((RemoteWebDriver)iWebDriver);
}
public static Image Image(OSType OSImage)
{
Image img = Properties.Resources.Windows;
switch (OSImage)
{
case OSType.Linux:
img = Properties.Resources.Linux;
break;
case OSType.MacOSX:
img = Properties.Resources.MacOSX;
break;
}
if (OS.Type != OSImage)
{
img = img.GetOpacityImage();
}
return img;
}
public static extern OSResultCode Gestalt(OSType selector, out int response);
private bool IsAzureDiskEncryptionExtension(OSType osType, VirtualMachineExtension vmExtension)
{
switch (osType)
{
case OSType.Windows:
if ((vmExtension != null) &&
(vmExtension.Publisher != null) &&
(vmExtension.VirtualMachineExtensionType != null) &&
(vmExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase)) &&
(vmExtension.VirtualMachineExtensionType.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}
return false;
case OSType.Linux:
if ((vmExtension != null) &&
(vmExtension.Publisher != null) &&
(vmExtension.VirtualMachineExtensionType != null) &&
(vmExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase)) &&
(vmExtension.VirtualMachineExtensionType.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}
return false;
case OSType.Unknown:
return false;
default:
return false;
}
}
/// <inheritdoc />
public Collection<string> ListAvailableLocations(OSType osType)
{
return this.ListAvailableLocationsAsync(osType).WaitForResult();
}
private string GetLogDirectory (OSType type)
{
string homeDirectory = Environment.GetEnvironmentVariable("HOME");
if (String.IsNullOrEmpty(homeDirectory))
{
homeDirectory = Environment.GetEnvironmentVariable("TMP");
if (String.IsNullOrEmpty(homeDirectory))
{
homeDirectory = ".";
}
}
if (String.IsNullOrEmpty(ApplicationName))
{
ApplicationName = "Unity3D-Project";
}
switch(type)
{
case OSType.MacOS:
{
return homeDirectory + "/Library/Logs/" + ApplicationName;
}
case OSType.WindowsXP:
{
return Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + ApplicationName + "/Logs";
}
case OSType.WindowsVista7:
{
return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "/" + ApplicationName + "/Logs";
}
}
// Unix and all others ...
return homeDirectory + "/." + ApplicationName;
}
internal static Dictionary<string, Dictionary<string, string>> GetMetastoreConfig(Metastore metastore,
OSType osType, string metastoreType)
{
var server = "";
if (metastore.Server != null)
{
server = metastore.Server;
}
var index = server.LastIndexOf(".database.windows.net", StringComparison.OrdinalIgnoreCase);
if (index > 0)
{
server = server.Substring(0, index);
}
var connectionUrl =
string.Format(
"jdbc:sqlserver://{0}.database.windows.net;database={1};encrypt=true;trustServerCertificate=true;create=false;loginTimeout=300;sendStringParametersAsUnicode=true;prepareSQL=0",
server, metastore.Database);
var configurations = new Dictionary<string, Dictionary<string, string>>();
if (metastoreType.Equals("hive", StringComparison.OrdinalIgnoreCase))
{
configurations.Add(ConfigurationKey.HiveSite, new Dictionary<string, string>
{
{"javax.jdo.option.ConnectionURL", connectionUrl},
{"javax.jdo.option.ConnectionUserName", metastore.User},
{"javax.jdo.option.ConnectionPassword", metastore.Password},
{"javax.jdo.option.ConnectionDriverName", "com.microsoft.sqlserver.jdbc.SQLServerDriver"}
});
if (osType == OSType.Windows)
{
return configurations;
}
configurations.Add(ConfigurationKey.HiveEnv, new Dictionary<string, string>
{
{"hive_database", "Existing MSSQL Server database with SQL authentication"},
{"hive_database_name", metastore.Database},
{"hive_database_type", "mssql"},
{"hive_existing_mssql_server_database", metastore.Database},
{"hive_existing_mssql_server_host", string.Format("{0}.database.windows.net", server)},
{"hive_hostname", string.Format("{0}.database.windows.net", server)}
});
}
else
{
configurations.Add(ConfigurationKey.OozieSite, new Dictionary<string, string>
{
{"oozie.service.JPAService.jdbc.url", connectionUrl},
{"oozie.service.JPAService.jdbc.username", metastore.User},
{"oozie.service.JPAService.jdbc.password", metastore.Password},
{"oozie.service.JPAService.jdbc.driver", "com.microsoft.sqlserver.jdbc.SQLServerDriver"}
});
if (osType == OSType.Windows)
{
return configurations;
}
configurations[ConfigurationKey.OozieSite].Add("oozie.db.schema.name", "oozie");
configurations.Add(ConfigurationKey.OozieEnv, new Dictionary<string, string>
{
{"oozie_database", "Existing MSSQL Server database with SQL authentication"},
{"oozie_database_name", metastore.Database},
{"oozie_database_type", "mssql"},
{"oozie_existing_mssql_server_database", metastore.Database},
{"oozie_existing_mssql_server_host", string.Format("{0}.database.windows.net", server)},
{"oozie_hostname", string.Format("{0}.database.windows.net", server)}
});
}
return configurations;
}
private bool IsExtensionInstalled(OSType currentOSType)
{
if (OSType.Windows.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.ExtensionDefaultName;
}
else if (OSType.Linux.Equals(currentOSType))
{
this.Name = this.Name ?? AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName;
}
AzureOperationResponse<VirtualMachineExtension> extensionResult = this.VirtualMachineExtensionClient.GetWithInstanceView(this.ResourceGroupName, this.VMName, this.Name);
if (extensionResult == null)
{
return false;
}
PSVirtualMachineExtension returnedExtension = extensionResult.ToPSVirtualMachineExtension(
this.ResourceGroupName, this.VMName);
if ((returnedExtension == null) ||
(string.IsNullOrWhiteSpace(returnedExtension.Publisher)) ||
(string.IsNullOrWhiteSpace(returnedExtension.ExtensionType)))
{
return false;
}
bool publisherMatch = false;
if (OSType.Linux.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(AzureDiskEncryptionExtensionContext.LinuxExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
else if (OSType.Windows.Equals(currentOSType))
{
if (returnedExtension.Publisher.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultPublisher, StringComparison.InvariantCultureIgnoreCase) &&
returnedExtension.ExtensionType.Equals(AzureDiskEncryptionExtensionContext.ExtensionDefaultName, StringComparison.InvariantCultureIgnoreCase))
{
publisherMatch = true;
}
}
if (publisherMatch)
{
return true;
}
return false;
}
public static Icon Icon(OSType OSImage)
{
return Image(OSImage).GetIcon();
}
/// <summary>
/// Check if the current OS is compatible with the given type
/// </summary>
/// <param name="type">The type of OS to check for compatibility with</param>
/// <returns>True if compatible</returns>
public static bool IsCompatible(OSType type)
{
if (type == OSType.All)
return true;
if (type == OS)
return true;
if (type == OSType.Linux || type == OSType.Mac && OS == OSType.Nix)
return true;
return false;
}
public static extern OSErr Gestalt(OSType selector, out IntPtr response);
public void UpdateNetcardInfo(string hostName, string systemName, netcardinfo[] cardInfos)
{
lock (_syncRoot)
{
_hostName = hostName;
_systemName = systemName;
_operationSystem = OSType.Linux;
if (_systemName != null)
{
if (_systemName.Contains("windows"))
{
_operationSystem = OSType.Windows;
}
else if (_systemName.Contains("linux"))
{
_operationSystem = OSType.Linux;
}
}
lock (_networkCards.SyncRoot)
{
_networkCards.Clear();
for (int i = 0; i < cardInfos.Length; i++)
{
NetworkCardInfo card = new NetworkCardInfo(cardInfos[i]);
_networkCards.Add(card);
}
}
}
}
internal static Dictionary <string, Dictionary <string, string> > GetMetastoreConfig(Metastore metastore,
OSType osType, string metastoreType)
{
var server = "";
if (metastore.Server != null)
{
server = metastore.Server;
}
var index = server.LastIndexOf(".database.windows.net", StringComparison.OrdinalIgnoreCase);
if (index > 0)
{
server = server.Substring(0, index);
}
var connectionUrl =
string.Format(
"jdbc:sqlserver://{0}.database.windows.net;database={1};encrypt=true;trustServerCertificate=true;create=false;loginTimeout=300;sendStringParametersAsUnicode=true;prepareSQL=0",
server, metastore.Database);
var configurations = new Dictionary <string, Dictionary <string, string> >();
if (metastoreType.Equals("hive", StringComparison.OrdinalIgnoreCase))
{
configurations.Add(ConfigurationKey.HiveSite, new Dictionary <string, string>
{
{ "javax.jdo.option.ConnectionURL", connectionUrl },
{ "javax.jdo.option.ConnectionUserName", metastore.User },
{ "javax.jdo.option.ConnectionPassword", metastore.Password },
{ "javax.jdo.option.ConnectionDriverName", "com.microsoft.sqlserver.jdbc.SQLServerDriver" }
});
if (osType == OSType.Windows)
{
return(configurations);
}
configurations.Add(ConfigurationKey.HiveEnv, new Dictionary <string, string>
{
{ "hive_database", "Existing MSSQL Server database with SQL authentication" },
{ "hive_database_name", metastore.Database },
{ "hive_database_type", "mssql" },
{ "hive_existing_mssql_server_database", metastore.Database },
{ "hive_existing_mssql_server_host", string.Format("{0}.database.windows.net", server) },
{ "hive_hostname", string.Format("{0}.database.windows.net", server) }
});
}
else
{
configurations.Add(ConfigurationKey.OozieSite, new Dictionary <string, string>
{
{ "oozie.service.JPAService.jdbc.url", connectionUrl },
{ "oozie.service.JPAService.jdbc.username", metastore.User },
{ "oozie.service.JPAService.jdbc.password", metastore.Password },
{ "oozie.service.JPAService.jdbc.driver", "com.microsoft.sqlserver.jdbc.SQLServerDriver" }
});
if (osType == OSType.Windows)
{
return(configurations);
}
configurations[ConfigurationKey.OozieSite].Add("oozie.db.schema.name", "oozie");
configurations.Add(ConfigurationKey.OozieEnv, new Dictionary <string, string>
{
{ "oozie_database", "Existing MSSQL Server database with SQL authentication" },
{ "oozie_database_name", metastore.Database },
{ "oozie_database_type", "mssql" },
{ "oozie_existing_mssql_server_database", metastore.Database },
{ "oozie_existing_mssql_server_host", string.Format("{0}.database.windows.net", server) },
{ "oozie_hostname", string.Format("{0}.database.windows.net", server) }
});
}
return(configurations);
}
static extern NavStatus NavCreatePutFileDialog (ref NavDialogCreationOptionsData options, OSType inFileType, OSType inFileCreator, NavEventUPP inEventProc, IntPtr inClientData, out IntPtr navDialogRef);
private bool CompareOSType(OSType osType)
{
OSType filterOSType;
if (Enum.TryParse(Value, out filterOSType))
{
switch (Comparison)
{
case FilterComparison.Equals:
case FilterComparison.NotEquals:
return osType == filterOSType;
default:
throw new Exception("Invalid comparison for OSType column: " + Comparison);
}
}
else
{
// Invalid value for OSType column
return false;
}
}
public OSImageContext AddAzureVMImage(string imageName, string mediaLocation, OSType os, string label = null)
{
AddAzureVMImageCmdletInfo addAzureVMImageCmdlet = new AddAzureVMImageCmdletInfo(imageName, mediaLocation, os, label);
return OSImageContextRun(new WindowsAzurePowershellCmdlet(addAzureVMImageCmdlet));
}
