static async Task <int> Main(string[] args) { try { if (args.Length == 0) { Console.WriteLine(AppConfig.help); Console.WriteLine(">> press enter to exit"); Console.ReadLine(); return(0); } var valid = AppConfig.ParseArgs(args); AppConfig.semaphore = new System.Threading.SemaphoreSlim(AppConfig.maxPara); if (valid == false) { Console.WriteLine(">> press enter to exit"); Console.ReadLine(); return(0); } chromeOpts = await Browser.StartPuppeteer(); await using var browser = await Puppeteer.LaunchAsync(chromeOpts); if (!await Browser.LoginToTiqa(browser)) { AppConfig.ErrHand(null, "XX couldn't log in"); return(0); } //await Task.WhenAll(AppConfig.allTasks); //AppConfig.WriteOut($">> null page responses: {AppConfig.NullResponse}\tpage response handler errors: {AppConfig.HandledErrs}"); AppConfig.WriteOut(">> press enter to exit", true); if (AppConfig.silent) { } return(1); } catch (Exception ex) { AppConfig.ErrHand(ex); AppConfig.WriteOut(">> press enter to exit", true); return(0); } finally { if (browser != null) { await browser.DisposeAsync(); } if (AppConfig.ol != null) { AppConfig.ol.Close(); AppConfig.ol.Dispose(); } } }
public Browser(Connection connection, LaunchOptions options, Func <Task> closeCallBack) { Connection = connection; IgnoreHTTPSErrors = options.IgnoreHTTPSErrors; AppMode = options.AppMode; _targets = new Dictionary <string, Target>(); ScreenshotTaskQueue = new TaskQueue(); Connection.Closed += (object sender, EventArgs e) => Disconnected?.Invoke(this, new EventArgs()); Connection.MessageReceived += Connect_MessageReceived; _closeCallBack = closeCallBack; }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options) { if (_chromiumLaunched) { throw new InvalidOperationException("Unable to create or connect to another chromium process"); } _chromiumLaunched = true; var chromeArguments = InitChromeArgument(options); var chromeExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(chromeExecutable)) { var browserFetcher = new BrowserFetcher(); chromeExecutable = browserFetcher.RevisionInfo(BrowserFetcher.DefaultRevision).ExecutablePath; } if (!File.Exists(chromeExecutable)) { throw new FileNotFoundException("Failed to launch chrome! path to executable does not exist", chromeExecutable); } CreateChromeProcess(options, chromeArguments, chromeExecutable); try { var connectionDelay = options.SlowMo; var browserWSEndpoint = await WaitForEndpoint(_chromeProcess, options.Timeout).ConfigureAwait(false); var keepAliveInterval = 0; _connection = await Connection.Create(browserWSEndpoint, connectionDelay, keepAliveInterval, _loggerFactory).ConfigureAwait(false); _processLoaded = true; if (options.LogProcess) { _logger.LogInformation("Process Count: {ProcessCount}", Interlocked.Increment(ref _processCount)); } var browser = await Browser.CreateAsync(_connection, options.IgnoreHTTPSErrors, !options.AppMode, _chromeProcess, GracefullyCloseChrome).ConfigureAwait(false); await EnsureInitialPageAsync(browser).ConfigureAwait(false); return(browser); } catch (Exception ex) { KillChrome(); throw new ChromeProcessException("Failed to create connection", ex); } }
private async Task <string> GetOrFetchBrowserExecutableAsync(LaunchOptions options) { var browserExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(browserExecutable)) { browserExecutable = await ResolveExecutablePathAsync().ConfigureAwait(false); } if (!File.Exists(browserExecutable)) { throw new FileNotFoundException("Failed to launch browser! path to executable does not exist", browserExecutable); } return(browserExecutable); }
private static string GetOrFetchChromeExecutable(LaunchOptions options) { var chromeExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(chromeExecutable)) { chromeExecutable = ResolveExecutablePath(); } if (!File.Exists(chromeExecutable)) { throw new FileNotFoundException("Failed to launch chrome! path to executable does not exist", chromeExecutable); } return(chromeExecutable); }
private static string GetOrFetchBrowserExecutable(LaunchOptions options) { string browserExecutable = options.ExecutablePath; //if (string.IsNullOrEmpty(browserExecutable)) //{ // browserExecutable = ResolveExecutablePath(); //} if (!File.Exists(browserExecutable)) { throw new FileNotFoundException("Failed to launch browser! path to executable does not exist", browserExecutable); } return(browserExecutable); }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching the browser</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } EnsureSingleLaunchOrConnect(); _product = options.Product; var executable = await GetOrFetchBrowserExecutableAsync(options).ConfigureAwait(false); Process = options.Product switch { Product.Chrome => new ChromiumLauncher(executable, options), Product.Firefox => new FirefoxLauncher(executable, options), _ => throw new ArgumentException("Invalid product"), }; try { await Process.StartAsync().ConfigureAwait(false); try { var connection = await Connection .Create(Process.EndPoint, options, _loggerFactory) .ConfigureAwait(false); var browser = await Browser .CreateAsync(connection, Array.Empty <string>(), options.IgnoreHTTPSErrors, options.DefaultViewport, Process, options.TargetFilter) .ConfigureAwait(false); await browser.WaitForTargetAsync(t => t.Type == TargetType.Page).ConfigureAwait(false); return(browser); } catch (Exception ex) { throw new ProcessException("Failed to create connection", ex); } } catch { await Process.KillAsync().ConfigureAwait(false); throw; } }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="chromiumRevision">The revision of Chrome to launch.</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options, int chromiumRevision) { if (_chromiumLaunched) { throw new InvalidOperationException("Unable to create or connect to another chromium process"); } _chromiumLaunched = true; var chromeArguments = InitChromeArgument(options); var chromeExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(chromeExecutable)) { var downloader = Downloader.CreateDefault(); var revisionInfo = downloader.RevisionInfo(Downloader.CurrentPlatform, chromiumRevision); chromeExecutable = revisionInfo.ExecutablePath; } if (!File.Exists(chromeExecutable)) { throw new FileNotFoundException("Failed to launch chrome! path to executable does not exist", chromeExecutable); } CreateChromeProcess(options, chromeArguments, chromeExecutable); try { var connectionDelay = options.SlowMo; var browserWSEndpoint = await WaitForEndpoint(_chromeProcess, options.Timeout, options.DumpIO); var keepAliveInterval = options.KeepAliveInterval; _connection = await Connection.Create(browserWSEndpoint, connectionDelay, keepAliveInterval, _loggerFactory); _processLoaded = true; if (options.LogProcess) { _logger.LogInformation("Process Count: {ProcessCount}", Interlocked.Increment(ref _processCount)); } return(await Browser.CreateAsync(_connection, options, _chromeProcess, KillChrome)); } catch (Exception ex) { ForceKillChrome(); throw new ChromeProcessException("Failed to create connection", ex); } }
private static string GetOrFetchChromeExecutable(LaunchOptions options) { var chromeExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(chromeExecutable)) { var browserFetcher = new BrowserFetcher(); chromeExecutable = browserFetcher.RevisionInfo(BrowserFetcher.DefaultRevision).ExecutablePath; } if (!File.Exists(chromeExecutable)) { throw new FileNotFoundException("Failed to launch chrome! path to executable does not exist", chromeExecutable); } return(chromeExecutable); }
/// <summary> /// Creates a new <see cref="LauncherBase"/> instance. /// </summary> /// <param name="executable">Full path of executable.</param> /// <param name="options">Options for launching Base.</param> /// <param name="loggerFactory">Logger factory</param> public LauncherBase(string executable, LaunchOptions options) { _options = options; Process = new Process { EnableRaisingEvents = true }; Process.StartInfo.UseShellExecute = false; Process.StartInfo.FileName = executable; Process.StartInfo.RedirectStandardError = true; SetEnvVariables(Process.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); if (options.DumpIO) { Process.ErrorDataReceived += (sender, e) => Console.Error.WriteLine(e.Data); } }
private void CreateChromeProcess(LaunchOptions options, List <string> chromeArguments, string chromeExecutable) { _chromeProcess = new Process(); _chromeProcess.EnableRaisingEvents = true; _chromeProcess.StartInfo.UseShellExecute = false; _chromeProcess.StartInfo.FileName = chromeExecutable; _chromeProcess.StartInfo.Arguments = string.Join(" ", chromeArguments); SetEnvVariables(_chromeProcess.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); if (!options.DumpIO) { _chromeProcess.StartInfo.RedirectStandardOutput = false; _chromeProcess.StartInfo.RedirectStandardError = false; } _chromeProcess.Exited += async(sender, e) => { await AfterProcessExit(); }; }
private Process CreateChromeProcess(LaunchOptions options, List <string> chromeArguments, string chromeExecutable) { var chromeProcess = new Process { EnableRaisingEvents = true }; chromeProcess.StartInfo.UseShellExecute = false; chromeProcess.StartInfo.FileName = chromeExecutable; chromeProcess.StartInfo.Arguments = string.Join(" ", chromeArguments); chromeProcess.StartInfo.RedirectStandardError = true; SetEnvVariables(chromeProcess.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); chromeProcess.Exited += OnChromeProcessExited; if (options.DumpIO) { chromeProcess.ErrorDataReceived += OnChromeProcessErrorDataReceived; } return(chromeProcess); }
/// <summary> /// Creates a new <see cref="LauncherBase"/> instance. /// </summary> /// <param name="executable">Full path of executable.</param> /// <param name="options">Options for launching Base.</param> public LauncherBase(string executable, LaunchOptions options) { _stateManager = new StateManager(); _stateManager.Starting = new ChromiumStartingState(_stateManager); Options = options ?? throw new ArgumentNullException(nameof(options)); Process = new Process { EnableRaisingEvents = true }; Process.StartInfo.UseShellExecute = false; Process.StartInfo.FileName = executable; Process.StartInfo.RedirectStandardError = true; SetEnvVariables(Process.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); if (options.DumpIO) { Process.ErrorDataReceived += (_, e) => Console.Error.WriteLine(e.Data); } }
/// <summary> /// Creates a new <see cref="LauncherBase"/> instance. /// </summary> /// <param name="executable">Full path of executable.</param> /// <param name="options">Options for launching Base.</param> /// <param name="loggerFactory">Logger factory</param> public LauncherBase(string executable, LaunchOptions options, ILoggerFactory loggerFactory) { _options = options; _logger = options.LogProcess ? loggerFactory.CreateLogger <LauncherBase>() : null; Process = new Process { EnableRaisingEvents = true }; Process.StartInfo.UseShellExecute = false; Process.StartInfo.FileName = executable; Process.StartInfo.RedirectStandardError = true; SetEnvVariables(Process.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); if (options.DumpIO) { Process.ErrorDataReceived += (_, e) => Console.Error.WriteLine(e.Data); } }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching the browser</param> /// <param name="product">The browser to launch (Chrome, Firefox)</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options) { EnsureSingleLaunchOrConnect(); string executable = GetOrFetchBrowserExecutable(options); Process = new ChromiumLauncher(executable, options); try { await Process.StartAsync().ConfigureAwait(false); try { var connection = await Connection .Create(Process.EndPoint, options) .ConfigureAwait(false); var browser = await Browser .CreateAsync(connection, Array.Empty <string>(), options.IgnoreHTTPSErrors, options.DefaultViewport, Process) .ConfigureAwait(false); await browser.WaitForTargetAsync(t => t.Type == TargetType.Page).ConfigureAwait(false); return(browser); } catch (Exception ex) { throw new ProcessException("Failed to create connection", ex); } } catch { await Process.KillAsync().ConfigureAwait(false); throw; } }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options) { EnsureSingleLaunchOrConnect(); var chromiumExecutable = GetOrFetchChromeExecutable(options); Process = new ChromiumProcess(chromiumExecutable, options, _loggerFactory); try { await Process.StartAsync().ConfigureAwait(false); try { var connection = await Connection .Create(Process.EndPoint, options, _loggerFactory) .ConfigureAwait(false); var browser = await Browser .CreateAsync(connection, Array.Empty <string>(), options.IgnoreHTTPSErrors, options.DefaultViewport, Process) .ConfigureAwait(false); await EnsureInitialPageAsync(browser).ConfigureAwait(false); return(browser); } catch (Exception ex) { throw new ChromiumProcessException("Failed to create connection", ex); } } catch { await Process.KillAsync().ConfigureAwait(false); throw; } }
/// <summary> /// Creates a new <see cref="ChromiumProcess"/> instance. /// </summary> /// <param name="chromiumExecutable">Full path of Chromium executable.</param> /// <param name="options">Options for launching Chromium.</param> /// <param name="loggerFactory">Logger factory</param> public ChromiumProcess(string chromiumExecutable, LaunchOptions options, ILoggerFactory loggerFactory) { _options = options; List <string> chromiumArgs; (chromiumArgs, _tempUserDataDir) = PrepareChromiumArgs(options); Process = new Process { EnableRaisingEvents = true }; Process.StartInfo.UseShellExecute = false; Process.StartInfo.FileName = chromiumExecutable; Process.StartInfo.Arguments = string.Join(" ", chromiumArgs); Process.StartInfo.RedirectStandardError = true; SetEnvVariables(Process.StartInfo.EnvironmentVariables, options.Env, Environment.GetEnvironmentVariables()); if (options.DumpIO) { Process.ErrorDataReceived += (sender, e) => Console.Error.WriteLine(e.Data); } }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="loggerFactory">The logger factory</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public static Task <Browser> LaunchAsync(LaunchOptions options, ILoggerFactory loggerFactory = null) => new Launcher(loggerFactory).LaunchAsync(options);
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="chromiumRevision">The revision of Chrome to launch.</param> /// <param name="loggerFactory">The logger factory</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public static Task <Browser> LaunchAsync(LaunchOptions options, int chromiumRevision, ILoggerFactory loggerFactory = null) => new Launcher(loggerFactory).LaunchAsync(options, chromiumRevision);
private List <string> InitChromeArgument(LaunchOptions options) { var chromeArguments = new List <string>(DefaultArgs); _options = options; if (options.AppMode) { options.Headless = false; } else { chromeArguments.AddRange(AutomationArgs); } if (!options.IgnoreDefaultArgs || !chromeArguments.Any(argument => argument.StartsWith("--remote-debugging-", StringComparison.Ordinal))) { chromeArguments.Add("--remote-debugging-port=0"); } var userDataDirOption = options.Args.FirstOrDefault(i => i.StartsWith(UserDataDirArgument, StringComparison.Ordinal)); if (string.IsNullOrEmpty(userDataDirOption)) { if (string.IsNullOrEmpty(options.UserDataDir)) { _temporaryUserDataDir = GetTemporaryDirectory(); chromeArguments.Add($"{UserDataDirArgument}={_temporaryUserDataDir.Quote()}"); } else { chromeArguments.Add($"{UserDataDirArgument}={options.UserDataDir.Quote()}"); } } else { _options.UserDataDir = userDataDirOption.Replace($"{UserDataDirArgument}=", string.Empty).UnQuote(); } if (options.Devtools) { chromeArguments.Add("--auto-open-devtools-for-tabs"); options.Headless = false; } if (options.Headless) { chromeArguments.AddRange(new[] { "--headless", "--disable-gpu", "--hide-scrollbars", "--mute-audio" }); } if (!options.IgnoreDefaultArgs && options.Args.Any() && options.Args.All(arg => arg.StartsWith("-"))) { chromeArguments.Add("about:blank"); } if (options.Args.Any()) { chromeArguments.AddRange(options.Args); } return(chromeArguments); }
private static (List <string> firefoxArgs, TempDirectory tempUserDataDirectory) PrepareFirefoxArgs(LaunchOptions options) { var firefoxArgs = new List <string>(); if (!options.IgnoreDefaultArgs) { firefoxArgs.AddRange(GetDefaultArgs(options)); } else if (options.IgnoredDefaultArgs?.Length > 0) { firefoxArgs.AddRange(GetDefaultArgs(options).Except(options.IgnoredDefaultArgs)); } else { firefoxArgs.AddRange(options.Args); } if (!firefoxArgs.Any(a => a.StartsWith("-remote-debugging", StringComparison.OrdinalIgnoreCase))) { firefoxArgs.Add("--remote-debugging-port=0"); } TempDirectory tempUserDataDirectory = null; if (!firefoxArgs.Contains("-profile") && !firefoxArgs.Contains("--profile")) { tempUserDataDirectory = new TempDirectory(); CreateProfile(tempUserDataDirectory); firefoxArgs.Add("--profile"); firefoxArgs.Add($"{tempUserDataDirectory.Path.Quote()}"); } return(firefoxArgs, tempUserDataDirectory); }
private static (List <string> ChromiumArgs, TempDirectory TempUserDataDirectory) PrepareChromiumArgs(LaunchOptions options) { var chromiumArgs = new List <string>(); if (!options.IgnoreDefaultArgs) { chromiumArgs.AddRange(GetDefaultArgs(options)); } else if (options.IgnoredDefaultArgs?.Length > 0) { chromiumArgs.AddRange(GetDefaultArgs(options).Except(options.IgnoredDefaultArgs)); } else { chromiumArgs.AddRange(options.Args); } TempDirectory tempUserDataDirectory = null; if (!chromiumArgs.Any(argument => argument.StartsWith("--remote-debugging-", StringComparison.Ordinal))) { chromiumArgs.Add("--remote-debugging-port=0"); } var userDataDirOption = chromiumArgs.FirstOrDefault(i => i.StartsWith(UserDataDirArgument, StringComparison.Ordinal)); if (string.IsNullOrEmpty(userDataDirOption)) { tempUserDataDirectory = new TempDirectory(); chromiumArgs.Add($"{UserDataDirArgument}={tempUserDataDirectory.Path.Quote()}"); } return(chromiumArgs, tempUserDataDirectory); }
public static async Task <Browser> LaunchAsync(LaunchOptions options, int chromiumRevision) { return(await new Launcher().LaunchAsync(options, chromiumRevision)); }
private static (List <string> firefoxArgs, TempDirectory tempUserDataDirectory) PrepareFirefoxArgs(LaunchOptions options) { var firefoxArgs = new List <string>(); if (!options.IgnoreDefaultArgs) { firefoxArgs.AddRange(GetDefaultArgs(options)); } else if (options.IgnoredDefaultArgs?.Length > 0) { firefoxArgs.AddRange(GetDefaultArgs(options).Except(options.IgnoredDefaultArgs)); } else { firefoxArgs.AddRange(options.Args); } TempDirectory tempUserDataDirectory = null; if (!firefoxArgs.Contains("-profile") && !firefoxArgs.Contains("--profile")) { tempUserDataDirectory = new TempDirectory(); firefoxArgs.Add("--profile"); firefoxArgs.Add($"{tempUserDataDirectory.Path.Quote()}"); } return(firefoxArgs, tempUserDataDirectory); }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="chromiumRevision">The revision of Chrome to launch.</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public static Task <Browser> LaunchAsync(LaunchOptions options, int chromiumRevision) => new Launcher().LaunchAsync(options, chromiumRevision);
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="chromiumRevision">The revision of Chrome to launch.</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// </remarks> public async Task <Browser> LaunchAsync(LaunchOptions options, int chromiumRevision) { var chromeArguments = new List <string>(DefaultArgs); _options = options; if (options.AppMode) { options.Headless = false; } else { chromeArguments.AddRange(AutomationArgs); } var userDataDirOption = options.Args.FirstOrDefault(i => i.StartsWith(UserDataDirArgument, StringComparison.Ordinal)); if (string.IsNullOrEmpty(userDataDirOption)) { if (string.IsNullOrEmpty(options.UserDataDir)) { _temporaryUserDataDir = GetTemporaryDirectory(); chromeArguments.Add($"{UserDataDirArgument}={_temporaryUserDataDir}"); } else { chromeArguments.Add($"{UserDataDirArgument}={options.UserDataDir}"); } } else { _options.UserDataDir = userDataDirOption.Replace($"{UserDataDirArgument}=", string.Empty); } if (options.Devtools) { chromeArguments.Add("--auto-open-devtools-for-tabs"); options.Headless = false; } if (options.Headless) { chromeArguments.AddRange(new[] { "--headless", "--disable-gpu", "--hide-scrollbars", "--mute-audio" }); } var chromeExecutable = options.ExecutablePath; if (string.IsNullOrEmpty(chromeExecutable)) { var downloader = Downloader.CreateDefault(); var revisionInfo = downloader.RevisionInfo(Downloader.CurrentPlatform, chromiumRevision); chromeExecutable = revisionInfo.ExecutablePath; } if (!File.Exists(chromeExecutable)) { throw new FileNotFoundException("Failed to launch chrome! path to executable does not exist", chromeExecutable); } if (options.Args.Any()) { chromeArguments.AddRange(options.Args); } _chromeProcess = new Process(); _chromeProcess.EnableRaisingEvents = true; _chromeProcess.StartInfo.UseShellExecute = false; _chromeProcess.StartInfo.FileName = chromeExecutable; _chromeProcess.StartInfo.Arguments = string.Join(" ", chromeArguments); SetEnvVariables(_chromeProcess.StartInfo.Environment, options.Env, Environment.GetEnvironmentVariables()); if (!options.DumpIO) { _chromeProcess.StartInfo.RedirectStandardOutput = false; _chromeProcess.StartInfo.RedirectStandardError = false; } _chromeProcess.Exited += async(sender, e) => { await AfterProcessExit(); }; try { var connectionDelay = options.SlowMo; var browserWSEndpoint = await WaitForEndpoint(_chromeProcess, options.Timeout, options.DumpIO); var keepAliveInterval = options.KeepAliveInterval; _connection = await Connection.Create(browserWSEndpoint, connectionDelay, keepAliveInterval); _processLoaded = true; if (options.LogProcess) { Console.WriteLine($"PROCESS COUNT: {Interlocked.Increment(ref _processCount)}"); } return(await Browser.CreateAsync(_connection, options, _chromeProcess, KillChrome)); } catch (Exception ex) { ForceKillChrome(); throw new ChromeProcessException("Failed to create connection", ex); } }
/// <summary> /// The method launches a browser instance with given arguments. The browser will be closed when the Browser is disposed. /// </summary> /// <param name="options">Options for launching Chrome</param> /// <param name="loggerFactory">The logger factory</param> /// <param name="product">The browser to be used (Chrome, Firefox)</param> /// <returns>A connected browser.</returns> /// <remarks> /// See <a href="https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/">this article</a> /// for a description of the differences between Chromium and Chrome. /// <a href="https://chromium.googlesource.com/chromium/src/+/lkcr/docs/chromium_browser_vs_google_chrome.md">This article</a> describes some differences for Linux users. /// /// Environment Variables /// Puppeteer looks for certain <see href="https://en.wikipedia.org/wiki/Environment_variable">environment variables</see>() to aid its operations. /// - <c>PUPPETEER_CHROMIUM_REVISION</c> - specify a certain version of Chromium you'd like Puppeteer to use. See <see cref="Puppeteer.LaunchAsync(LaunchOptions, ILoggerFactory, Product)"/> on how executable path is inferred. /// **BEWARE**: Puppeteer is only <see href="https://github.com/GoogleChrome/puppeteer/#q-why-doesnt-puppeteer-vxxx-work-with-chromium-vyyy">guaranteed to work</see> with the bundled Chromium, use at your own risk. /// - <c>PUPPETEER_EXECUTABLE_PATH</c> - specify an executable path to be used in <see cref="Puppeteer.LaunchAsync(LaunchOptions, ILoggerFactory, Product)"/>. /// **BEWARE**: Puppeteer is only <see href="https://github.com/GoogleChrome/puppeteer/#q-why-doesnt-puppeteer-vxxx-work-with-chromium-vyyy">guaranteed to work</see> with the bundled Chromium, use at your own risk. /// </remarks> public static Task <Browser> LaunchAsync(LaunchOptions options, ILoggerFactory loggerFactory = null, Product product = Product.Chrome) => new Launcher(loggerFactory).LaunchAsync(options, product);
/// <summary> /// Returns an array of argument based on the options provided and the platform where the library is running /// </summary> /// <returns>Chromium arguments.</returns> /// <param name="options">Options.</param> public static string[] GetDefaultArgs(LaunchOptions options = null) => ChromiumLauncher.GetDefaultArgs(options ?? new LaunchOptions());
public static async Task Main(string[] args) { var currentDirectory = Directory.GetCurrentDirectory(); var downloadPath = Path.Combine(currentDirectory, "CustomChromium"); Console.WriteLine($"Attemping to set up puppeteer to use Chromium found under directory {downloadPath} "); if (!Directory.Exists(downloadPath)) { Console.WriteLine("Custom directory not found. Creating directory"); Directory.CreateDirectory(downloadPath); } Console.WriteLine("Downloading Chromium..."); var browserFetcherOptions = new BrowserFetcherOptions { Path = downloadPath }; var browserFetcher = new BrowserFetcher(browserFetcherOptions); await browserFetcher.DownloadAsync(BrowserFetcher.DefaultRevision); var executablePath = browserFetcher.GetExecutablePath(BrowserFetcher.DefaultRevision); if (string.IsNullOrEmpty(executablePath)) { Console.WriteLine("Custom Chromium location is empty. Unable to start Chromium. Exiting.\n Press any key to continue"); Console.ReadLine(); return; } Console.WriteLine($"Attemping to start Chromium using executable path: {executablePath}"); var options = new LaunchOptions { Headless = true, ExecutablePath = executablePath }; using (var browser = await Puppeteer.LaunchAsync(options)) using (var page = await browser.NewPageAsync()) { await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision); await page.SetViewportAsync(new ViewPortOptions { Width = 1920, Height = 1080 }); var waitUntil = new NavigationOptions { Timeout = 0, WaitUntil = new[] { WaitUntilNavigation.Networkidle0 } }; string url = "https://github.com/puppeteer/puppeteer/issues/1345"; await page.GoToAsync(url, waitUntil); #region Screenshot Dashboard: var optionsScreenShot = new ScreenshotOptions { FullPage = true }; //Đường dẫn lưu file var savePath = Path.Combine(currentDirectory, "Capture"); if (!Directory.Exists(savePath)) { Console.WriteLine("SavePath directory not found. Creating directory"); Directory.CreateDirectory(savePath); } string date = DateTime.Now.ToString("yyyyMMddHHmmss"); var outputfile = savePath + "/capture_" + date + ".png"; await page.ScreenshotAsync(outputfile, optionsScreenShot); Console.WriteLine("Capture completed! Path: " + outputfile, ConsoleColor.Green); #endregion await page.CloseAsync(); } return; }
/// <summary> /// Returns an array of argument based on the options provided and the platform where the library is running /// </summary> /// <returns>Chromium arguments.</returns> /// <param name="options">Options.</param> public static string[] GetDefaultArgs(LaunchOptions options = null) => (options?.Product ?? Product.Chrome) == Product.Chrome ? ChromiumLauncher.GetDefaultArgs(options ?? new LaunchOptions()) : FirefoxLauncher.GetDefaultArgs(options ?? new LaunchOptions());