public static InstallerPhase ExecuteChildProcess(OSPlatform platform, string arguments, bool uploadErrors) { Logger.Log(LogLevel.Debug, "ExecuteChildProcess starting: " + platform + ", " + arguments); StringBuilder sb = new StringBuilder(); Process p = new Process(); string thisDir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); #if DEBUG if (platform == OSPlatform.x86) p.StartInfo.FileName = Path.Combine(thisDir, @"..\..\x86\Debug\rhiexec.exe"); else if (platform == OSPlatform.x64) p.StartInfo.FileName = Path.Combine(thisDir, @"..\..\x64\Debug\rhiexec.exe"); #else if (platform == OSPlatform.x86) p.StartInfo.FileName = Path.Combine(thisDir, @"..\x86\rhiexec.exe"); else if (platform == OSPlatform.x64) p.StartInfo.FileName = Path.Combine(thisDir, @"..\x64\rhiexec.exe"); #endif sb.Append("/loglevel=").Append(m_options.LogLevel.ToString()).Append(" "); sb.Append("/logfile=\"").Append(Logger.LogFile).Append("\" "); if (m_options.SilentInstall) { sb.Append("/silent "); p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; p.StartInfo.CreateNoWindow = true; } if (!uploadErrors) sb.Append("/noerrorreports "); sb.Append(arguments); p.StartInfo.Arguments = sb.ToString(); p.StartInfo.UseShellExecute = false; Logger.Log(LogLevel.Debug, "Starting: " + p.StartInfo.FileName + " " + p.StartInfo.Arguments); if (!p.Start()) return InstallerPhase.Unknown; // Fix for http://dev.mcneel.com/bugtrack/?q=68426 // Add more time before cancelling operation int timeout = 10 * 60*1000; // 10 minutes p.WaitForExit(timeout); // Fix for http://dev.mcneel.com/bugtrack/?q=68426 // Don't reference p.ExitCode property after calling p.Close - it crashes. int exitCode = 0; if (p.HasExited) { exitCode = p.ExitCode; } else { p.Close(); Logger.Log(LogLevel.Warning, string.Format("Forcing closed after {0} seconds: {1}", timeout / 1000, p.StartInfo.FileName)); } Logger.Log(LogLevel.Debug, "ExecuteChildProcess complete. Child process returned: " + (InstallerPhase)exitCode); return (InstallerPhase)exitCode; }
public void CheckOSPlatform() { OSPlatform winObj = OSPlatform.Create("WINDOWS"); OSPlatform winProp = OSPlatform.Windows; OSPlatform randomObj = OSPlatform.Create("random"); OSPlatform defaultObj = default(OSPlatform); OSPlatform conObj = new OSPlatform(); Assert.Throws<ArgumentNullException>(() => { OSPlatform nullObj = OSPlatform.Create(null); }); Assert.Throws<ArgumentException>(() => { OSPlatform emptyObj = OSPlatform.Create(""); }); Assert.True(winObj == winProp); Assert.True(winObj != randomObj); Assert.True(defaultObj == conObj); Assert.False(winObj == defaultObj); Assert.False(winObj == randomObj); Assert.False(winObj != winProp); Assert.True(winObj.Equals(winProp)); Assert.True(conObj.Equals(defaultObj)); Assert.False(defaultObj.Equals(winProp)); Assert.False(winObj.Equals(null)); Assert.False(winObj.Equals("something")); Assert.Equal("WINDOWS", winObj.ToString()); Assert.Equal("WINDOWS", winProp.ToString()); Assert.Equal("", defaultObj.ToString()); Assert.Equal("", conObj.ToString()); Assert.Equal("random", randomObj.ToString()); Assert.Equal(winObj.GetHashCode(), winProp.GetHashCode()); Assert.Equal(0, defaultObj.GetHashCode()); Assert.Equal(defaultObj.GetHashCode(), conObj.GetHashCode()); }
private void CheckOSPlatforms( OSPlatform os, string expectedPlatforms ) { CheckPlatforms( new PlatformHelper( os, RuntimeFramework.CurrentFramework ), expectedPlatforms, PlatformHelper.OSPlatforms ); }
public static PreferenceStore GetStoreForPlatform( OSPlatform platform, Func <PreferenceStore> factory) { if (RuntimeInformation.IsOSPlatform(platform)) { return(factory()); } return(new MemoryOnlyPreferenceStore()); }
public static KeycodeAttribute GetKeycode(this Key key) { var enumType = typeof(Key); var memberInfos = enumType.GetMember(key.ToString()); var enumValueMemberInfo = memberInfos.FirstOrDefault(m => m.DeclaringType == enumType); return(enumValueMemberInfo .GetCustomAttributes(typeof(KeycodeAttribute), false) .Cast <KeycodeAttribute>() .First(k => RuntimeInformation.IsOSPlatform(OSPlatform.Create(k.Platform)))); }
public async Task TestExtractCoreRunLibAsync(string osPlatformStr, string expectedDllFilename) { var osPlatform = OSPlatform.Create(osPlatformStr); using var tempDir = _baseFixture.WithDisposableTempDirectory(_snapFilesystem); var expectedDllFilenameAbsolute = _snapFilesystem.PathCombine(tempDir.WorkingDirectory, expectedDllFilename); await _snapEmbeddedResources.ExtractCoreRunLibAsync(_snapFilesystem, _snapCryptoProvider, tempDir.WorkingDirectory, osPlatform); Assert.True(_snapFilesystem.FileExists(expectedDllFilenameAbsolute)); Assert.True(_snapFilesystem.FileStat(expectedDllFilenameAbsolute).Length > 0); }
public void Constructor_works(OSPlatform platform, Architecture processArchitecture) { // arrange // act var runtimeInformation = new RuntimeInformation(platform, processArchitecture); // assert _output.WriteLine(runtimeInformation.ToString()); Assert.Equal(platform, runtimeInformation.Platform); Assert.Equal(processArchitecture, runtimeInformation.ProcessArchitecture); }
public void TestGetCoreRunForSnapApp(string osPlatform, string appId, string expectedExeFilename) { var snapApp = _baseFixture.BuildSnapApp(appId); snapApp.Target.Os = OSPlatform.Create(osPlatform); var(memoryStream, coreRunFilename, coreRunOsPlatform) = _snapEmbeddedResources.GetCoreRunForSnapApp(snapApp, _snapFilesystem, _coreRunLibMock.Object); Assert.NotNull(memoryStream); Assert.True(memoryStream.Length > 0); Assert.Equal(expectedExeFilename, coreRunFilename); Assert.Equal(snapApp.Target.Os, coreRunOsPlatform); }
/// <summary> /// Adds <see cref="IHxMessengerService"/> support to be able to add messages to HxMessenger. /// </summary> public static IServiceCollection AddHxMessenger(this IServiceCollection services) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER"))) { // allows gRPC Interceptors and HttpMessageHandlers to pass error-messages to the HxMessenger without having to struggle with different DI Scope return(services.AddSingleton <IHxMessengerService, HxMessengerService>()); } else { return(services.AddScoped <IHxMessengerService, HxMessengerService>()); } }
public static bool TestPlatformApplies(TestPlatforms platforms) => (platforms.HasFlag(TestPlatforms.Any)) || (platforms.HasFlag(TestPlatforms.FreeBSD) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"))) || (platforms.HasFlag(TestPlatforms.Linux) && RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) || (platforms.HasFlag(TestPlatforms.NetBSD) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("NETBSD"))) || (platforms.HasFlag(TestPlatforms.OSX) && RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) || (platforms.HasFlag(TestPlatforms.SunOS) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("SUNOS"))) || (platforms.HasFlag(TestPlatforms.iOS) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("IOS"))) || (platforms.HasFlag(TestPlatforms.tvOS) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("TVOS"))) || (platforms.HasFlag(TestPlatforms.Android) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("ANDROID"))) || (platforms.HasFlag(TestPlatforms.Browser) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER"))) || (platforms.HasFlag(TestPlatforms.Windows) && RuntimeInformation.IsOSPlatform(OSPlatform.Windows));
public string GetOsPlatformDescription() { StringBuilder retval = new StringBuilder(1024); OSPlatform os = GetOSPlatform(); retval.AppendLine($"OSPlatform: {os.ToString()}"); retval.AppendLine($"RTI.FrameworkDescription: {RuntimeInformation.FrameworkDescription}"); retval.AppendLine($"RTI.OSArchitecture: {RuntimeInformation.OSArchitecture}"); retval.AppendLine($"RTI.OSDescription: {RuntimeInformation.OSDescription}"); return(retval.ToString()); }
public CoreRunLib([JetBrains.Annotations.NotNull] ISnapFilesystem filesystem, OSPlatform osPlatform, [JetBrains.Annotations.NotNull] string workingDirectory) { if (filesystem == null) { throw new ArgumentNullException(nameof(filesystem)); } if (workingDirectory == null) { throw new ArgumentNullException(nameof(workingDirectory)); } if (!osPlatform.IsSupportedOsVersion()) { throw new PlatformNotSupportedException(); } _osPlatform = osPlatform; var filename = filesystem.PathCombine(workingDirectory, "libcorerun-"); #if SNAP_BOOTSTRAP return; #endif var rid = osPlatform.BuildRid(); if (osPlatform == OSPlatform.Windows) { filename += $"{rid}.dll"; _libPtr = NativeMethodsWindows.dlopen(filename); } else if (osPlatform == OSPlatform.Linux) { filename += $"{rid}.so"; _libPtr = NativeMethodsUnix.dlopen(filename, NativeMethodsUnix.libdl_RTLD_NOW | NativeMethodsUnix.libdl_RTLD_LOCAL); } if (_libPtr == IntPtr.Zero) { throw new FileNotFoundException($"Failed to load corerun: {filename}. " + $"OS: {osPlatform}. " + $"64-bit OS: {Environment.Is64BitOperatingSystem}. " + $"Last error: {Marshal.GetLastWin32Error()}."); } // generic pal_is_elevated = new Delegate <pal_is_elevated_delegate>(_libPtr, osPlatform); pal_set_icon = new Delegate <pal_set_icon_delegate>(_libPtr, osPlatform); // filesystem pal_fs_chmod = new Delegate <pal_fs_chmod_delegate>(_libPtr, osPlatform); pal_fs_file_exists = new Delegate <pal_fs_file_exists_delegate>(_libPtr, osPlatform); }
public static async Task <Device> Create(string deviceID, string orgID) { OSPlatform platform = OSUtils.GetPlatform(); var systemDrive = DriveInfo.GetDrives().FirstOrDefault(x => x.IsReady && x.RootDirectory.FullName.Contains(Path.GetPathRoot(Environment.SystemDirectory ?? Environment.CurrentDirectory))); var device = new Device() { ID = deviceID, DeviceName = Environment.MachineName, Platform = platform.ToString(), ProcessorCount = Environment.ProcessorCount, OSArchitecture = RuntimeInformation.OSArchitecture, OSDescription = RuntimeInformation.OSDescription, Is64Bit = Environment.Is64BitOperatingSystem, IsOnline = true, Drives = DriveInfo.GetDrives().Where(x => x.IsReady).Select(x => new Drive() { DriveFormat = x.DriveFormat, DriveType = x.DriveType, Name = x.Name, RootDirectory = x.RootDirectory.FullName, FreeSpace = x.TotalSize > 0 ? x.TotalFreeSpace / x.TotalSize : 0, TotalSize = x.TotalSize > 0 ? Math.Round((double)(x.TotalSize / 1024 / 1024 / 1024), 2) : 0, VolumeLabel = x.VolumeLabel }).ToList(), OrganizationID = orgID, CurrentUser = DeviceInformation.GetCurrentUser() }; if (systemDrive != null && systemDrive.TotalSize > 0 && systemDrive.TotalFreeSpace > 0) { device.TotalStorage = Math.Round((double)(systemDrive.TotalSize / 1024 / 1024 / 1024), 2); device.UsedStorage = Math.Round((double)((systemDrive.TotalSize - systemDrive.TotalFreeSpace) / 1024 / 1024 / 1024), 2); } var(usedMemory, totalMemory) = GetMemoryInGB(); device.UsedMemory = usedMemory; device.TotalMemory = totalMemory; device.CpuUtilization = await GetCpuUtilization(); if (File.Exists("Remotely_Agent.dll")) { device.AgentVersion = FileVersionInfo.GetVersionInfo("Remotely_Agent.dll")?.FileVersion?.ToString()?.Trim(); } return(device); }
protected virtual ServiceManager CreateServiceManager() { var sm = new ServiceManager(); var platform = new OSPlatform(); sm .AddService(TestLogger) .AddService(platform) .AddService(new FileSystem(platform)); return(sm); }
public static string[] GetPortNames() { #if NETCOREAPP return(OperatingSystem.IsLinux() ? GetPortNames_Linux() : OperatingSystem.IsMacOS() ? GetPortNames_OSX() : OperatingSystem.IsFreeBSD() ? GetPortNames_FreeBSD() #else return RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? GetPortNames_Linux() : RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? GetPortNames_OSX() : RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD")) ? GetPortNames_FreeBSD() #endif : throw new PlatformNotSupportedException(SR.PlatformNotSupported_SerialPort_GetPortNames)); }
private void InitializeControls() { OSPlatform platform = ProcessUtils.GetOSPlatform(); if (platform != OSPlatform.Linux) { ButtonCopyClipboard = AddButton("Copy to Clipboard", Icons.Streams.PadNote); } ButtonSave = AddButton("Save", Icons.Streams.Save); AddSeparator(); ButtonClose = AddButton("Close Snapshot", Icons.Streams.Delete); }
public static int[] GetFieldOffsets(OSPlatform platform, bool is64Bit, NativeCapabilities nativeCapabilities) { var fieldTypes = new RfbType[FieldTypes.Length]; Array.Copy(FieldTypes, fieldTypes, fieldTypes.Length); if (nativeCapabilities.HaveWin32Threads) { fieldTypes[(int)RfbScreenInfoPtrField.CursorMutex] = RfbType.Win32Mutex; } return(NativeLayout.GetFieldOffsets(fieldTypes, platform, is64Bit)); }
private static HttpMessageHandler CreateDefaultHandler() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER"))) { return(new HttpClientHandler()); } #if NETCOREAPP return(new SocketsHttpHandler()); #else return(new HttpClientHandler()); #endif }
public void Configure(IBlazorApplicationBuilder app) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("WEBASSEMBLY"))) { // Needed because the test server runs on a different port than the client app, // and we want to test sending/receiving cookies underling this config BrowserHttpMessageHandler.DefaultCredentials = FetchCredentialsOption.Include; GC.KeepAlive(ActivateMonoJSRuntime.EnsureActivated()); } app.AddComponent <Index>("root"); }
public void CheckOSX() { Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.OSX)); Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Create("OSX"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Linux)); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("osx"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("mac"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("DARWIN"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("MACOSX"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); }
protected override ITarget GetTarget() { _dataTarget = DataTarget.LoadDump(DumpFile); OSPlatform targetPlatform = _dataTarget.DataReader.TargetPlatform; if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { targetPlatform = OSPlatform.OSX; } _symbolService.AddDirectoryPath(Path.GetDirectoryName(DumpFile)); return(new TargetFromDataReader(_dataTarget.DataReader, targetPlatform, this, _targetIdFactory++, DumpFile)); }
public ICpuMetrics GetCpuMetricsCollector(OSPlatform osPlatform) { if (osPlatform == OSPlatform.Windows) { return(new WindowsCpuMetrics()); } else if (osPlatform == OSPlatform.Linux) { return(new LinuxCpuMetrics(new LinuxCommandsHelper(), new LinuxCpuMetricsHelpers())); } throw new PlatformNotSupportedException($"Not supported platform {osPlatform}"); }
[Fact, PlatformSpecific(TestPlatforms.Windows)] // Tests RuntimeInformation OS platform public void CheckWindows() { Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Create("WINDOWS"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("NETBSD"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("NetBSD"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("netbsd"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Linux)); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.OSX)); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("windows"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("Windows NT"))); }
public void CheckLinux() { Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Linux)); Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Create("LINUX"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("linux"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("UNIX"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("DARWIN"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Create("ubuntu"))); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.OSX)); }
static ClipboardService() { #if NET5_0 if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("Browser"))) { throw new($"The static class ClipboardService is not supported on Blazor. Instead inject an {nameof(IClipboard)} using {nameof(ServiceExtensions)}{nameof(ServiceExtensions.InjectClipboard)}."); } #endif getAsyncFunc = CreateAsyncGet(); getFunc = CreateGet(); setAsyncAction = CreateAsyncSet(); setAction = CreateSet(); }
string BuildRuntimeIdentifier() { string rid; if (OSPlatform == OSPlatform.Windows) { rid = "win"; } else if (OSPlatform == OSPlatform.OSX) { rid = "osx"; } else if (OSPlatform == OSPlatform.Linux) { rid = "linux"; } else { rid = OSPlatform.ToString().ToLowerInvariant(); } if (Architecture == null) { return(rid); } switch (Architecture.Value) { case X86: rid += "-x86"; break; case X64: rid += "-x64"; break; case Arm: rid += "-arm"; break; case Arm64: rid += "-arm64"; break; default: rid += "-" + Architecture.Value.ToString().ToLowerInvariant(); break; } return(rid); }
InstallerPhase InstallPackage(string package_filename) { OSPlatform p = OSPlatform.x86; if (InstallerEngine.Is64BitProcess()) { p = OSPlatform.x64; } string quotedFile = package_filename.Trim("\"".ToCharArray()); Logger.Log(LogLevel.Info, string.Format("Installing Package: '{0}'", package_filename)); return(Program.ExecuteChildProcess(p, "\"" + quotedFile + "\"", true)); }
public static bool TestPlatformApplies(TestPlatforms platforms) => (platforms.HasFlag(TestPlatforms.Any)) || (platforms.HasFlag(TestPlatforms.FreeBSD) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD"))) || (platforms.HasFlag(TestPlatforms.Linux) && RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) || (platforms.HasFlag(TestPlatforms.NetBSD) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("NETBSD"))) || (platforms.HasFlag(TestPlatforms.OSX) && RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) || (platforms.HasFlag(TestPlatforms.illumos) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("ILLUMOS"))) || (platforms.HasFlag(TestPlatforms.Solaris) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("SOLARIS"))) || (platforms.HasFlag(TestPlatforms.iOS) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("IOS"))) || (platforms.HasFlag(TestPlatforms.tvOS) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("TVOS"))) || (platforms.HasFlag(TestPlatforms.MacCatalyst) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("MACCATALYST"))) || (platforms.HasFlag(TestPlatforms.Android) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("ANDROID"))) || (platforms.HasFlag(TestPlatforms.Browser) && RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER"))) || (platforms.HasFlag(TestPlatforms.Windows) && RuntimeInformation.IsOSPlatform(OSPlatform.Windows));
/// <summary> /// Returns the file name of the DAC dll according to the specified parameters. /// </summary> public static string GetDacFileName(ClrFlavor flavor, OSPlatform platform) { if (platform == OSPlatform.Linux) { return(c_linuxCoreDacFileName); } if (platform == OSPlatform.OSX) { return(c_macOSCoreDacFileName); } return(flavor == ClrFlavor.Core ? c_coreDacFileName : c_desktopDacFileName); }
public static OSPlatform GetOSPlatform() { OSPlatform result = OSPlatform.OSX; if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { result = OSPlatform.Windows; } else if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { result = OSPlatform.Linux; } return(result); }
public static bool IsOSPlatform (OSPlatform osPlatform) { switch (Environment.OSVersion.Platform) { case PlatformID.Win32NT: return osPlatform == OSPlatform.Windows; case PlatformID.Unix: if (File.Exists ("/usr/lib/libc.dylib")) return osPlatform == OSPlatform.OSX; return osPlatform == OSPlatform.Linux; default: return false; } }
protected ServiceManager CreateServiceManager() { Services = new ServiceManager(); var platform = new OSPlatform(); Services .AddService(TestLogger) .AddService(platform) .AddService(new ProcessServices()) .AddService(new FileSystem(platform)); return(Services); }
public ShellService(IEnvironmentService envService) { OS = envService.OSType(); if (OS == OSPlatform.Windows) { cmdString = "cmd.exe"; cmdArgument = "/c"; } else { cmdString = "/bin/bash"; cmdArgument = "-c"; } }
private void TestPlatform(string brokerSubPath, string hostSubPath, OSPlatform platform) { var locator = new BrokerExecutableLocator(_fs, platform); var brokerPath = Path.Combine(locator.BaseDirectory, brokerSubPath); var hostPath = Path.Combine(locator.BaseDirectory, hostSubPath); _fs.FileExists(brokerPath).Returns(true); locator.GetBrokerExecutablePath().Should().Be(brokerPath); locator.GetHostExecutablePath().Should().BeNull(); _fs.FileExists(hostPath).Returns(true); locator.GetBrokerExecutablePath().Should().Be(brokerPath); locator.GetHostExecutablePath().Should().Be(hostPath); }
public static bool IsOSPlatform (OSPlatform osPlatform) { // TODO: very barebones implementation if (Environment.OSVersion.Platform == PlatformID.Win32NT) return osPlatform == OSPlatform.Windows; if (Environment.OSVersion.Platform == PlatformID.Unix && File.Exists ("/usr/lib/libc.dylib")) return osPlatform == OSPlatform.OSX; if (Environment.OSVersion.Platform == PlatformID.Unix) return osPlatform == OSPlatform.Linux; return false; }
public static bool IsOSPlatform(OSPlatform osPlatform) { return OSPlatform.Linux == osPlatform; }
public void Inspect(string PathToRhino) { Logger.Log(LogLevel.Debug, "InspectRhino\tConstructing new RhinoInfo: " + PathToRhino); RhinoExePath = PathToRhino; if (IntPtr.Size == 4) OS = OSPlatform.x86; else if (IntPtr.Size == 8) OS = OSPlatform.x64; AssemblyResolver.AddSearchPath(RhinoExePath, true); GetRhinoDotNetVersion(); GetRhinoCommonVersion(); GetCppSdkVersions(); }
public static bool IsOSPlatform(OSPlatform osPlatform) { return s_freeBSD == osPlatform; }
private void ReadXml101(XmlDocument doc) { XmlNode package = doc.SelectSingleNode("/RhinoInstaller/Package"); if (package == null) return; this.VersionNumber = new Version(XmlHelper.SelectSingleNodeInnerText(package, "Version")); this.Title = XmlHelper.SelectSingleNodeInnerText(package, "Title"); // GUID string sGuid = XmlHelper.SelectSingleNodeInnerText(package, "ID"); try { this.ID = new Guid(sGuid); } catch { throw new PackageAuthoringException(string.Format("GUID malformed: '{0}'", sGuid)); } this.UpdateUrl = XmlHelper.SelectSingleNodeInnerText(package, "UpdateUrl"); string os = XmlHelper.SelectSingleNodeInnerText(package, "OS"); try { OS = (OSPlatform)Enum.Parse(OS.GetType(), os); } catch { throw new InvalidOperatingSystemException(os); } XmlNode contentType = package.SelectSingleNode("ContentType"); if (contentType != null) { this.ContentType = PackageContentType.Unknown; PackageContentType t; if (Enum.TryParse(contentType.InnerText, out t)) { this.ContentType = t; } } // Platform, if it exists XmlNodeList platforms = package.SelectNodes("RhinoPlatform"); if (platforms != null) { foreach (XmlNode platform in platforms) { RhinoPlatform p = RhinoPlatform.Unknown; p = (RhinoPlatform) Enum.Parse(p.GetType(), platform.InnerText); if (p != RhinoPlatform.Unknown) SupportedPlatforms.Add(p); } } // Culture, if it exists XmlNode culture = package.SelectSingleNode("Locale"); if (null != culture) { if ( 0 != System.String.CompareOrdinal(culture.InnerText.ToUpperInvariant(), "LOCALEINVARIANT") && 0 != System.String.CompareOrdinal(culture.InnerText.ToUpperInvariant(), "UNKNOWN") ) { Locale = new CultureInfo(culture.InnerText); } } ReadFromDocument(package); }
public static bool IsOSPlatform(OSPlatform osPlatform) { throw new PlatformNotSupportedException(); }
public static bool IsOSPlatform(OSPlatform osPlatform) { return OSPlatform.Windows == osPlatform; }
public static bool IsOSPlatform(OSPlatform osPlatform) { string name = s_osPlatformName ?? (s_osPlatformName = Interop.Sys.GetUnixName()); return osPlatform.Equals(name); }
public bool ReadXml(string XmlPath) { Logger.Log(LogLevel.Debug, "InspectRhino\tReadXml: " + XmlPath); XmlDocument doc = new XmlDocument(); doc.Load(XmlPath); XmlNode node = doc.SelectSingleNode("/RhinoExeInfo"); if (node == null) return false; if (node.Attributes == null) return false; XmlAttribute verAttr = node.Attributes["Version"]; if (verAttr == null) return false; string version = verAttr.Value; if (version != "1.0.1") return false; XmlNode exeinfo = doc.SelectSingleNode("/RhinoExeInfo"); RhinoVersion = new Version(XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoVersion", XmlPath)); RhinoSdkVersion = XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoSdkVersion", XmlPath); Edition = XmlHelper.SelectSingleNodeInnerText(exeinfo, "Edition", XmlPath); RhinoSdkServiceRelease = XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoSdkServiceRelease", XmlPath); RhinoDotNetVersion = XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoDotNetVersion", XmlPath); RhinoCommonVersion = XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoCommonVersion", XmlPath); RhinoExePath = XmlHelper.SelectSingleNodeInnerText(exeinfo, "RhinoExePath", XmlPath); string platform = XmlHelper.SelectSingleNodeInnerText(exeinfo, "OSPlatform", XmlPath); try { OS = (OSPlatform)Enum.Parse(OS.GetType(), platform); } catch { throw new InvalidOperatingSystemException("Unsupported OS Platform: " + platform); } return true; }