private static void Main(string[] args) { //Process command-line args processArgs(args); //Register minidump dumper only if the app isn't being debugged. No use filling up hard drives with s***e //Minidump is Windows-only, so we need a platform check here if (PlatformDetector.DetectPlatform() == Platform.Windows && !System.Diagnostics.Debugger.IsAttached) { MiniDump.Register("crashdump-" + Guid.NewGuid().ToString("N") + ".dmp", fullDump ? MiniDump.MINIDUMP_TYPE.MiniDumpWithFullMemory : MiniDump.MINIDUMP_TYPE.MiniDumpNormal); } var main = new EntryPoint(); main._server = new SS14Server(); LogManager.Log("Server -> Starting"); if (main._server.Start()) { LogManager.Log("Server -> Can not start server", LogLevel.Fatal); //Not like you'd see this, haha. Perhaps later for logging. Environment.Exit(0); } string strVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(); LogManager.Log("Server Version " + strVersion + " -> Ready"); main._server.MainLoop(); }
private FileStream WindowsCreateFile(string fileName, bool allowConcurrentWrite) { int fileShare = Win32FileNativeMethods.FILE_SHARE_READ; if (allowConcurrentWrite) { fileShare |= Win32FileNativeMethods.FILE_SHARE_WRITE; } if (this.CreateFileParameters.EnableFileDelete && PlatformDetector.GetCurrentRuntimeOS() != RuntimeOS.Windows) { fileShare |= Win32FileNativeMethods.FILE_SHARE_DELETE; } IntPtr handle = Win32FileNativeMethods.CreateFile( fileName, Win32FileNativeMethods.FileAccess.GenericWrite, fileShare, IntPtr.Zero, Win32FileNativeMethods.CreationDisposition.OpenAlways, this.CreateFileParameters.FileAttributes, IntPtr.Zero); if (handle.ToInt32() == -1) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } var safeHandle = new Microsoft.Win32.SafeHandles.SafeFileHandle(handle, true); var returnValue = new FileStream(safeHandle, FileAccess.Write, this.CreateFileParameters.BufferSize); returnValue.Seek(0, SeekOrigin.End); return(returnValue); }
private FileStream TryCreateFileStream(bool allowConcurrentWrite) { FileShare fileShare = FileShare.Read; if (allowConcurrentWrite) { fileShare = FileShare.ReadWrite; } #if !NET_CF if (this.CreateFileParameters.EnableFileDelete && PlatformDetector.GetCurrentRuntimeOS() != RuntimeOS.Windows) { fileShare |= FileShare.Delete; } #endif #if !NET_CF && !SILVERLIGHT if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.WindowsNT) || PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Windows)) { return(this.WindowsCreateFile(this.FileName, allowConcurrentWrite)); } #endif return(new FileStream( this.FileName, FileMode.Append, FileAccess.Write, fileShare, this.CreateFileParameters.BufferSize)); }
public void Android_GalaxyTab() { var userAgentSpan = UserAgents.Chrome_GalaxyTabS4.AsSpan(); var actual = PlatformDetector.GetPlatformAndOS(userAgentSpan); Assert.Equal(OperatingSystems.Android, actual.OS); }
/// <summary> /// Scans the specified assembly for types marked with <see cref="ConditionMethodsAttribute" /> and adds /// them to the factory. Optionally it prepends the specified text to layout renderer names to avoid /// naming collisions. /// </summary> /// <param name="theAssembly">The assembly to be scanned for layout renderers.</param> /// <param name="prefix">The prefix to be prepended to layout renderer names.</param> public static void AddConditionMethodsFromAssembly(Assembly theAssembly, string prefix) { try { InternalLogger.Debug("AddLogEventConditionsFromAssembly('{0}')", theAssembly.FullName); foreach (Type t in theAssembly.GetTypes()) { if (t.IsDefined(typeof(ConditionMethodsAttribute), false)) { if (PlatformDetector.IsSupportedOnCurrentRuntime(t)) { foreach (MethodInfo mi in t.GetMethods(BindingFlags.Public | BindingFlags.Static)) { ConditionMethodAttribute[] malist = (ConditionMethodAttribute[])mi.GetCustomAttributes(typeof(ConditionMethodAttribute), false); foreach (ConditionMethodAttribute ma in malist) { if (PlatformDetector.IsSupportedOnCurrentRuntime(mi)) { AddConditionMethod(ma.Name, mi); } } } } } } } catch (Exception ex) { InternalLogger.Error("Failed to add LogEventConditions from '" + theAssembly.FullName + "': {0}", ex); } }
/// <summary> /// Scans the specified assembly for types marked with <see cref="TargetAttribute" /> and adds /// them to the factory. Optionally it prepends the specified text to the target names to avoid /// naming collisions. /// </summary> /// <param name="theAssembly">The assembly to be scanned for targets.</param> /// <param name="prefix">The prefix to be prepended to target names.</param> public static void AddTargetsFromAssembly(Assembly theAssembly, string prefix) { try { InternalLogger.Debug("AddTargetsFromAssembly('{0}')", theAssembly.FullName); foreach (Type t in theAssembly.GetTypes()) { TargetAttribute[] attributes = (TargetAttribute[])t.GetCustomAttributes(typeof(TargetAttribute), false); if (attributes != null) { foreach (TargetAttribute attr in attributes) { if (PlatformDetector.IsSupportedOnCurrentRuntime(t)) { AddTarget(prefix + attr.Name, t); } } } } } catch (Exception ex) { InternalLogger.Error("Failed to add targets from '" + theAssembly.FullName + "': {0}", ex); } }
public void Macintosh() { var userAgentSpan = UserAgents.Chrome_OSX.AsSpan(); var actual = PlatformDetector.GetPlatformAndOS(userAgentSpan); Assert.Equal(Platforms.Macintosh, actual.Platform); Assert.Equal(OperatingSystems.MacOSX, actual.OS); }
public void iPad() { var userAgentSpan = UserAgents.Chrome_IPad.AsSpan(); var actual = PlatformDetector.GetPlatformAndOS(userAgentSpan); Assert.Equal(Platforms.iPad, actual.Platform); Assert.Equal(OperatingSystems.IOS, actual.OS); }
public void Linux_Pixel3() { var userAgentSpan = UserAgents.Chrome_Pixel3.AsSpan(); var actual = PlatformDetector.GetPlatformAndOS(userAgentSpan); //Assert.Equal(Platforms.Pixel3, actual.Platform); Assert.Equal(OperatingSystems.Android, actual.OS); }
public string GetConfigEditorPath() { if (PlatformDetector.IsWindows() && StringExt.IsNullOrWhiteSpace(_userData.ConfigEditorPath) == false && Path.Combine(Path.GetDirectoryName(Environment.GetFolderPath(Environment.SpecialFolder.System)), "NOTEPAD.EXE").ToUpperInvariant() == _userData.ConfigEditorPath.ToUpperInvariant()) { return(Path.GetFileName(_userData.ConfigEditorPath).ToLowerInvariant()); } return(_userData.ConfigEditorPath); }
public static void FreeUsbResources() { // Free usb resources if (PlatformDetector.RunningPlatform() == PlatformDetector.Platform.Linux) { UsbDevice.Exit(); } }
public void Windows10_Win64() { var userAgentSpan = UserAgents.Chrome_Windows.AsSpan(); var actual = PlatformDetector.GetPlatformAndOS(userAgentSpan); Assert.Equal(Platforms.Windows10, actual.Platform); Assert.Equal(OperatingSystems.Windows, actual.OS); }
static HidSelector() { if (Instance != null) { return; } switch (PlatformDetector.RunningPlatform()) { case PlatformDetector.Platform.Linux: Instance = new Libusb.LibusbHidManager(); break; case PlatformDetector.Platform.Mac: Instance = new MacOS.MacHidManager(); break; case PlatformDetector.Platform.Windows: Instance = new Windows.WinHidManager(); break; } var readyEvent = new ManualResetEvent(false); ManagerThread = new Thread(Instance.RunImpl); ManagerThread.IsBackground = true; ManagerThread.Start(readyEvent); readyEvent.WaitOne(); /* * foreach (var hidManager in new HidManager[] * { * new Windows.WinHidManager(), * //new Linux.LinuxHidManager(), //Disabled, because BlinkStick does not use this * new MacOS.MacHidManager(), * new Libusb.LibusbHidManager(), * new Unsupported.UnsupportedHidManager() * }) * { * if (hidManager.IsSupported) * { * var readyEvent = new ManualResetEvent(false); * * Instance = hidManager; * ManagerThread = new Thread(Instance.RunImpl); * ManagerThread.IsBackground = true; * ManagerThread.Start(readyEvent); * readyEvent.WaitOne(); * * break; * } * } */ }
protected Browser(ReadOnlySpan <char> userAgent, string version) { var platform = PlatformDetector.GetPlatformAndOS(userAgent); this.platform = platform.Platform; this.OS = platform.OS; this.DeviceType = GetDeviceType(platform); this.Version = version; }
static void Main(string[] args) { Console.WriteLine("Boondocks bootstrap starting..."); try { var platformDetector = new PlatformDetector(); IPathFactory pathFactory = platformDetector.CreatePathFactory(); var deviceConfigurationProvider = new DeviceConfigurationProvider(pathFactory); if (deviceConfigurationProvider.Exists()) { //Get the device configuration var deviceConfiguration = deviceConfigurationProvider.GetDeviceConfiguration(); //Create the container using (var container = ContainerFactory.Create(pathFactory, deviceConfiguration, new BootstrapModule())) { //Get the agent host var host = container.Resolve <BootstrapHost>(); var cancellationTokenSource = new CancellationTokenSource(); //We shall cancel on the keypress Console.CancelKeyPress += (sender, eventArgs) => cancellationTokenSource.Cancel(); try { //Run the host host.RunAsync(cancellationTokenSource.Token).GetAwaiter().GetResult(); } catch (TaskCanceledException) { } } } else { //There is no sense is attempting to run without a configuration. SleepForever("Unable to find device configuration."); } } catch (Exception ex) { Console.WriteLine($"An exception occurred: {ex.Message}"); Console.WriteLine(ex.ToString()); } finally { Console.WriteLine("Bootstrap exiting."); } }
public MainLoopTimer() { if (PlatformDetector.DetectPlatform() == Platform.Windows) { mainLoopTimer = new TimerQueue(); } else { mainLoopTimer = new TimerMainLoopTimer(); } }
void OnTriggerEnter(Collider other) { //Try to find a PlatformDetector on the touching object: PlatformDetector detector = other.GetComponent <PlatformDetector>(); //If there is a detector, if (detector != null) { //Set this Transform as its 'platform' variable: detector.platform = transform; } }
void OnTriggerExit(Collider other) { //Try to find a PlatformDetector on the touching object: PlatformDetector detector = other.GetComponent <PlatformDetector>(); //If there is a detector, if (detector != null) { //Null out its 'platform' variable: detector.platform = null; } }
/// <summary> /// Initializes file logging by creating data structures that /// enable efficient multi-file logging. /// </summary> protected override void InitializeTarget() { base.InitializeTarget(); if (!this.KeepFileOpen) { this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else { if (this.ArchiveAboveSize != -1 || this.ArchiveEvery != FileArchivePeriod.None) { if (this.NetworkWrites) { this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else if (this.ConcurrentWrites) { #if NET_CF || SILVERLIGHT this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory; #elif MONO // // mono on Windows uses mutexes, on Unix - special appender // if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix)) { this.appenderFactory = UnixMultiProcessFileAppender.TheFactory; } else { this.appenderFactory = MutexMultiProcessFileAppender.TheFactory; } #else this.appenderFactory = MutexMultiProcessFileAppender.TheFactory; #endif } else { this.appenderFactory = CountingSingleProcessFileAppender.TheFactory; } } else { if (this.NetworkWrites) { this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else if (this.ConcurrentWrites) { #if NET_CF || SILVERLIGHT this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory; #elif MONO // // mono on Windows uses mutexes, on Unix - special appender // if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix)) { this.appenderFactory = UnixMultiProcessFileAppender.TheFactory; } else { this.appenderFactory = MutexMultiProcessFileAppender.TheFactory; } #else this.appenderFactory = MutexMultiProcessFileAppender.TheFactory; #endif } else { this.appenderFactory = SingleProcessFileAppender.TheFactory; } } } this.recentAppenders = new BaseFileAppender[this.OpenFileCacheSize]; if ((this.OpenFileCacheSize > 0 || this.EnableFileDelete) && this.OpenFileCacheTimeout > 0) { this.autoClosingTimer = new Timer( this.AutoClosingTimerCallback, null, this.OpenFileCacheTimeout * 1000, this.OpenFileCacheTimeout * 1000); } // Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, this.appenderFactory.GetType().FullName); }
/// <summary> /// Initializes file logging by creating data structures that /// enable efficient multi-file logging. /// </summary> public override void Initialize() { base.Initialize(); if (!KeepFileOpen) { _appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else { if (_archiveAboveSize != -1 || _archiveEvery != ArchiveEveryMode.None) { if (NetworkWrites) { _appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else if (ConcurrentWrites) { #if NETCF _appenderFactory = RetryingMultiProcessFileAppender.TheFactory; #elif MONO // // mono on Windows uses mutexes, on Unix - special appender // if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix)) { _appenderFactory = UnixMultiProcessFileAppender.TheFactory; } else { _appenderFactory = MutexMultiProcessFileAppender.TheFactory; } #else _appenderFactory = MutexMultiProcessFileAppender.TheFactory; #endif } else { _appenderFactory = CountingSingleProcessFileAppender.TheFactory; } } else { if (NetworkWrites) { _appenderFactory = RetryingMultiProcessFileAppender.TheFactory; } else if (ConcurrentWrites) { #if NETCF _appenderFactory = RetryingMultiProcessFileAppender.TheFactory; #elif MONO // // mono on Windows uses mutexes, on Unix - special appender // if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix)) { _appenderFactory = UnixMultiProcessFileAppender.TheFactory; } else { _appenderFactory = MutexMultiProcessFileAppender.TheFactory; } #else _appenderFactory = MutexMultiProcessFileAppender.TheFactory; #endif } else { _appenderFactory = SingleProcessFileAppender.TheFactory; } } } _recentAppenders = new BaseFileAppender[OpenFileCacheSize]; if ((OpenFileCacheSize > 0 || EnableFileDelete) && OpenFileCacheTimeout > 0) { _autoClosingTimer = new Timer(new TimerCallback(this.AutoClosingTimerCallback), null, OpenFileCacheTimeout * 1000, OpenFileCacheTimeout * 1000); } // Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, _appenderFactory.GetType().FullName); }