dotnet/src/webdriver/DriverService.cs - external/github.com/SeleniumHQ/selenium - Git at Google

 // <copyright file="DriverService.cs" company="Selenium Committers">
 // Licensed to the Software Freedom Conservancy (SFC) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The SFC licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 // </copyright>

 using OpenQA.Selenium.Remote;
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using OpenQA.Selenium.Internal.Logging;

 namespace OpenQA.Selenium;

 /// <summary>
 /// Exposes the service provided by a native WebDriver server executable.
 /// </summary>
 public abstract class DriverService : ICommandServer
 {
     private bool isDisposed;
     private Process? driverServiceProcess;

     private static readonly ILogger _logger = Log.GetLogger(typeof(DriverService));

     /// <summary>
     /// Initializes a new instance of the <see cref="DriverService"/> class.
     /// </summary>
     /// <param name="servicePath">The full path to the directory containing the executable providing the service to drive the browser.</param>
     /// <param name="port">The port on which the driver executable should listen.</param>
     /// <param name="driverServiceExecutableName">The file name of the driver service executable.</param>
     /// <exception cref="ArgumentException">
     /// If the path specified is <see langword="null"/> or an empty string.
     /// </exception>
     /// <exception cref="DriverServiceNotFoundException">
     /// If the specified driver service executable does not exist in the specified directory.
     /// </exception>
     protected DriverService(string? servicePath, int port, string? driverServiceExecutableName)
     {
         this.DriverServicePath = servicePath;
         this.DriverServiceExecutableName = driverServiceExecutableName;
         this.Port = port;
     }

     /// <summary>
     /// Occurs when the driver process is starting.
     /// </summary>
     public event EventHandler<DriverProcessStartingEventArgs>? DriverProcessStarting;

     /// <summary>
     /// Occurs when the driver process has completely started.
     /// </summary>
     public event EventHandler<DriverProcessStartedEventArgs>? DriverProcessStarted;

     /// <summary>
     /// Gets the Uri of the service.
     /// </summary>
     public Uri ServiceUrl
     {
         get
         {
             string url = string.Format(CultureInfo.InvariantCulture, "http://{0}:{1}", this.HostName, this.Port);
             return new Uri(url);
         }
     }

     /// <summary>
     /// Gets or sets the host name of the service. Defaults to "localhost."
     /// </summary>
     /// <remarks>
     /// Most driver service executables do not allow connections from remote
     /// (non-local) machines. This property can be used as a workaround so
     /// that an IP address (like "127.0.0.1" or "::1") can be used instead.
     /// </remarks>
     public string HostName { get; set; } = "localhost";

     /// <summary>
     /// Gets or sets the port of the service.
     /// </summary>
     public int Port { get; set; }

     /// <summary>
     /// Gets or sets a value indicating whether the initial diagnostic information is suppressed
     /// when starting the driver server executable. Defaults to <see langword="false"/>, meaning
     /// diagnostic information should be shown by the driver server executable.
     /// </summary>
     public bool SuppressInitialDiagnosticInformation { get; set; }

     /// <summary>
     /// Gets a value indicating whether the service is running.
     /// </summary>
     [MemberNotNullWhen(true, nameof(driverServiceProcess))]
     public bool IsRunning => this.driverServiceProcess != null && !this.driverServiceProcess.HasExited;

     /// <summary>
     /// Gets or sets a value indicating whether the command prompt window of the service should be hidden.
     /// </summary>
     public bool HideCommandPromptWindow { get; set; } = true;

     /// <summary>
     /// Gets the process ID of the running driver service executable. Returns 0 if the process is not running.
     /// </summary>
     public int ProcessId
     {
         get
         {
             if (this.IsRunning)
             {
                 // There's a slight chance that the Process object is running,
                 // but does not have an ID set. This should be rare, but we
                 // definitely don't want to throw an exception.
                 try
                 {
                     return this.driverServiceProcess.Id;
                 }
                 catch (InvalidOperationException)
                 {
                 }
             }

             return 0;
         }
     }

     /// <summary>
     /// Gets or sets a value indicating the time to wait for an initial connection before timing out.
     /// </summary>
     public TimeSpan InitializationTimeout { get; set; } = TimeSpan.FromSeconds(20);

     /// <summary>
     /// Gets or sets the executable file name of the driver service.
     /// </summary>
     public string? DriverServiceExecutableName { get; set; }

     /// <summary>
     /// Gets or sets the path of the driver service.
     /// </summary>
     public string? DriverServicePath { get; set; }

     /// <summary>
     /// Gets the command-line arguments for the driver service.
     /// </summary>
     protected virtual string CommandLineArguments => string.Format(CultureInfo.InvariantCulture, "--port={0}", this.Port);

     /// <summary>
     /// Gets a value indicating the time to wait for the service to terminate before forcing it to terminate.
     /// </summary>
     protected virtual TimeSpan TerminationTimeout => TimeSpan.FromSeconds(10);

     /// <summary>
     /// Gets a value indicating whether the service has a shutdown API that can be called to terminate
     /// it gracefully before forcing a termination.
     /// </summary>
     protected virtual bool HasShutdown => true;

     /// <summary>
     /// Gets a value indicating whether process redirection is enforced regardless of other settings.
     /// </summary>
     /// <remarks>Set this property to <see langword="true"/> to force all process output and error streams to
     /// be redirected, even if redirection is not required by default behavior. This can be useful in scenarios where
     /// capturing process output is necessary for logging or analysis.</remarks>
     protected virtual internal bool EnableProcessRedirection { get; } = false;

     /// <summary>
     /// Gets a value indicating whether the service is responding to HTTP requests.
     /// </summary>
     protected virtual bool IsInitialized
     {
         get
         {
             bool isInitialized = false;

             try
             {
                 using (var httpClient = new HttpClient())
                 {
                     httpClient.DefaultRequestHeaders.ConnectionClose = true;
                     httpClient.Timeout = TimeSpan.FromSeconds(5);

                     Uri serviceHealthUri = new Uri(this.ServiceUrl, new Uri(DriverCommand.Status, UriKind.Relative));
                     using (var response = Task.Run(async () => await httpClient.GetAsync(serviceHealthUri)).GetAwaiter().GetResult())
                     {
                         // Checking the response from the 'status' end point. Note that we are simply checking
                         // that the HTTP status returned is a 200 status, and that the response has the correct
                         // Content-Type header. A more sophisticated check would parse the JSON response and
                         // validate its values. At the moment we do not do this more sophisticated check.
                         isInitialized = response.StatusCode == HttpStatusCode.OK && response.Content.Headers.ContentType is { MediaType: string mediaType } && mediaType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
                     }
                 }
             }
             catch (Exception ex) when (ex is HttpRequestException || ex is TaskCanceledException)
             {
                 // Do nothing. The exception is expected, meaning driver service is not initialized.
             }

             return isInitialized;
         }
     }

     /// <summary>
     /// Releases all resources associated with this <see cref="DriverService"/>.
     /// </summary>
     public void Dispose()
     {
         this.Dispose(true);
         GC.SuppressFinalize(this);
     }

     /// <summary>
     /// Starts the DriverService if it is not already running.
     /// </summary>
     [MemberNotNull(nameof(driverServiceProcess))]
     public void Start()
     {
         if (this.driverServiceProcess != null)
         {
             return;
         }

         this.driverServiceProcess = new Process();

         if (this.DriverServicePath != null)
         {
             if (this.DriverServiceExecutableName is null)
             {
                 throw new InvalidOperationException("If the driver service path is specified, the driver service executable name must be as well");
             }

             this.driverServiceProcess.StartInfo.FileName = Path.Combine(this.DriverServicePath, this.DriverServiceExecutableName);
         }
         else
         {
             this.driverServiceProcess.StartInfo.FileName = new DriverFinder(this.GetDefaultDriverOptions()).GetDriverPath();
         }

         this.driverServiceProcess.StartInfo.Arguments = this.CommandLineArguments;
         this.driverServiceProcess.StartInfo.UseShellExecute = false;
         this.driverServiceProcess.StartInfo.CreateNoWindow = this.HideCommandPromptWindow;

         this.driverServiceProcess.StartInfo.RedirectStandardOutput = true;
         this.driverServiceProcess.StartInfo.RedirectStandardError = true;

         if (this.EnableProcessRedirection)
         {
             this.driverServiceProcess.OutputDataReceived += this.OnDriverProcessDataReceived;
             this.driverServiceProcess.ErrorDataReceived += this.OnDriverProcessDataReceived;
         }

         DriverProcessStartingEventArgs eventArgs = new DriverProcessStartingEventArgs(this.driverServiceProcess.StartInfo);
         this.OnDriverProcessStarting(eventArgs);

         this.driverServiceProcess.Start();

         // Important: Start the process and immediately begin reading the output and error streams to avoid IO deadlocks.
         this.driverServiceProcess.BeginOutputReadLine();
         this.driverServiceProcess.BeginErrorReadLine();

         bool serviceAvailable = this.WaitForServiceInitialization();

         DriverProcessStartedEventArgs processStartedEventArgs = new DriverProcessStartedEventArgs(this.driverServiceProcess);
         this.OnDriverProcessStarted(processStartedEventArgs);

         if (!serviceAvailable)
         {
             throw new WebDriverException($"Cannot start the driver service on {this.ServiceUrl}");
         }
     }

     /// <summary>
     /// The browser options instance that corresponds to the driver service
     /// </summary>
     /// <returns></returns>
     protected abstract DriverOptions GetDefaultDriverOptions();

     /// <summary>
     /// Releases all resources associated with this <see cref="DriverService"/>.
     /// </summary>
     /// <param name="disposing"><see langword="true"/> if the Dispose method was explicitly called; otherwise, <see langword="false"/>.</param>
     protected virtual void Dispose(bool disposing)
     {
         if (!this.isDisposed)
         {
             if (disposing)
             {
                 this.Stop();

                 if (EnableProcessRedirection && this.driverServiceProcess is not null)
                 {
                     this.driverServiceProcess.OutputDataReceived -= this.OnDriverProcessDataReceived;
                     this.driverServiceProcess.ErrorDataReceived -= this.OnDriverProcessDataReceived;
                 }
             }

             this.isDisposed = true;
         }
     }

     /// <summary>
     /// Raises the <see cref="DriverProcessStarting"/> event.
     /// </summary>
     /// <param name="eventArgs">A <see cref="DriverProcessStartingEventArgs"/> that contains the event data.</param>
     protected virtual void OnDriverProcessStarting(DriverProcessStartingEventArgs eventArgs)
     {
         if (eventArgs == null)
         {
             throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
         }

         this.DriverProcessStarting?.Invoke(this, eventArgs);
     }

     /// <summary>
     /// Raises the <see cref="DriverProcessStarted"/> event.
     /// </summary>
     /// <param name="eventArgs">A <see cref="DriverProcessStartedEventArgs"/> that contains the event data.</param>
     protected virtual void OnDriverProcessStarted(DriverProcessStartedEventArgs eventArgs)
     {
         if (eventArgs == null)
         {
             throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
         }

         this.DriverProcessStarted?.Invoke(this, eventArgs);
     }

     /// <summary>
     /// Handles the output and error data received from the driver process.
     /// </summary>
     /// <param name="sender">The sender of the event.</param>
     /// <param name="args">The data received event arguments.</param>
     protected virtual void OnDriverProcessDataReceived(object sender, DataReceivedEventArgs args)
     {

     }

     /// <summary>
     /// Stops the DriverService.
     /// </summary>
     private void Stop()
     {
         if (this.IsRunning)
         {
             if (this.HasShutdown)
             {
                 Uri shutdownUrl = new Uri(this.ServiceUrl, "/shutdown");
                 DateTime timeout = DateTime.Now.Add(this.TerminationTimeout);
                 using (var httpClient = new HttpClient())
                 {
                     httpClient.DefaultRequestHeaders.ConnectionClose = true;

                     while (this.IsRunning && DateTime.Now < timeout)
                     {
                         try
                         {
                             // Issue the shutdown HTTP request, then wait a short while for
                             // the process to have exited. If the process hasn't yet exited,
                             // we'll retry. We wait for exit here, since catching the exception
                             // for a failed HTTP request due to a closed socket is particularly
                             // expensive.
                             using (var response = Task.Run(async () => await httpClient.GetAsync(shutdownUrl)).GetAwaiter().GetResult())
                             {

                             }

                             this.driverServiceProcess.WaitForExit(3000);
                         }
                         catch (Exception ex) when (ex is HttpRequestException || ex is TimeoutException)
                         {
                         }
                     }
                 }
             }

             // If at this point, the process still hasn't exited, wait for one
             // last-ditch time, then, if it still hasn't exited, kill it. Note
             // that falling into this branch of code should be exceedingly rare.
             if (this.IsRunning)
             {
                 this.driverServiceProcess.WaitForExit(Convert.ToInt32(this.TerminationTimeout.TotalMilliseconds));
                 if (!this.driverServiceProcess.HasExited)
                 {
                     this.driverServiceProcess.Kill();
                 }
             }

             this.driverServiceProcess.Dispose();
             this.driverServiceProcess = null;
         }
     }

     /// <summary>
     /// Waits until a the service is initialized, or the timeout set
     /// by the <see cref="InitializationTimeout"/> property is reached.
     /// </summary>
     /// <returns><see langword="true"/> if the service is properly started and receiving HTTP requests;
     /// otherwise; <see langword="false"/>.</returns>
     private bool WaitForServiceInitialization()
     {
         bool isInitialized = false;
         DateTime timeout = DateTime.Now.Add(this.InitializationTimeout);
         while (!isInitialized && DateTime.Now < timeout)
         {
             // If the driver service process has exited, we can exit early.
             if (!this.IsRunning)
             {
                 break;
             }

             isInitialized = this.IsInitialized;
         }

         return isInitialized;
     }
 }
	// <copyright file="DriverService.cs" company="Selenium Committers">
	// Licensed to the Software Freedom Conservancy (SFC) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The SFC licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	// </copyright>

	using OpenQA.Selenium.Remote;
	using System;
	using System.Diagnostics;
	using System.Diagnostics.CodeAnalysis;
	using System.Globalization;
	using System.IO;
	using System.Net;
	using System.Net.Http;
	using System.Threading.Tasks;
	using OpenQA.Selenium.Internal.Logging;

	namespace OpenQA.Selenium;

	/// <summary>
	/// Exposes the service provided by a native WebDriver server executable.
	/// </summary>
	public abstract class DriverService : ICommandServer
	{
	private bool isDisposed;
	private Process? driverServiceProcess;

	private static readonly ILogger _logger = Log.GetLogger(typeof(DriverService));

	/// <summary>
	/// Initializes a new instance of the <see cref="DriverService"/> class.
	/// </summary>
	/// <param name="servicePath">The full path to the directory containing the executable providing the service to drive the browser.</param>
	/// <param name="port">The port on which the driver executable should listen.</param>
	/// <param name="driverServiceExecutableName">The file name of the driver service executable.</param>
	/// <exception cref="ArgumentException">
	/// If the path specified is <see langword="null"/> or an empty string.
	/// </exception>
	/// <exception cref="DriverServiceNotFoundException">
	/// If the specified driver service executable does not exist in the specified directory.
	/// </exception>
	protected DriverService(string? servicePath, int port, string? driverServiceExecutableName)
	{
	this.DriverServicePath = servicePath;
	this.DriverServiceExecutableName = driverServiceExecutableName;
	this.Port = port;
	}

	/// <summary>
	/// Occurs when the driver process is starting.
	/// </summary>
	public event EventHandler<DriverProcessStartingEventArgs>? DriverProcessStarting;

	/// <summary>
	/// Occurs when the driver process has completely started.
	/// </summary>
	public event EventHandler<DriverProcessStartedEventArgs>? DriverProcessStarted;

	/// <summary>
	/// Gets the Uri of the service.
	/// </summary>
	public Uri ServiceUrl
	{
	get
	{
	string url = string.Format(CultureInfo.InvariantCulture, "http://{0}:{1}", this.HostName, this.Port);
	return new Uri(url);
	}
	}

	/// <summary>
	/// Gets or sets the host name of the service. Defaults to "localhost."
	/// </summary>
	/// <remarks>
	/// Most driver service executables do not allow connections from remote
	/// (non-local) machines. This property can be used as a workaround so
	/// that an IP address (like "127.0.0.1" or "::1") can be used instead.
	/// </remarks>
	public string HostName { get; set; } = "localhost";

	/// <summary>
	/// Gets or sets the port of the service.
	/// </summary>
	public int Port { get; set; }

	/// <summary>
	/// Gets or sets a value indicating whether the initial diagnostic information is suppressed
	/// when starting the driver server executable. Defaults to <see langword="false"/>, meaning
	/// diagnostic information should be shown by the driver server executable.
	/// </summary>
	public bool SuppressInitialDiagnosticInformation { get; set; }

	/// <summary>
	/// Gets a value indicating whether the service is running.
	/// </summary>
	[MemberNotNullWhen(true, nameof(driverServiceProcess))]
	public bool IsRunning => this.driverServiceProcess != null && !this.driverServiceProcess.HasExited;

	/// <summary>
	/// Gets or sets a value indicating whether the command prompt window of the service should be hidden.
	/// </summary>
	public bool HideCommandPromptWindow { get; set; } = true;

	/// <summary>
	/// Gets the process ID of the running driver service executable. Returns 0 if the process is not running.
	/// </summary>
	public int ProcessId
	{
	get
	{
	if (this.IsRunning)
	{
	// There's a slight chance that the Process object is running,
	// but does not have an ID set. This should be rare, but we
	// definitely don't want to throw an exception.
	try
	{
	return this.driverServiceProcess.Id;
	}
	catch (InvalidOperationException)
	{
	}
	}

	return 0;
	}
	}

	/// <summary>
	/// Gets or sets a value indicating the time to wait for an initial connection before timing out.
	/// </summary>
	public TimeSpan InitializationTimeout { get; set; } = TimeSpan.FromSeconds(20);

	/// <summary>
	/// Gets or sets the executable file name of the driver service.
	/// </summary>
	public string? DriverServiceExecutableName { get; set; }

	/// <summary>
	/// Gets or sets the path of the driver service.
	/// </summary>
	public string? DriverServicePath { get; set; }

	/// <summary>
	/// Gets the command-line arguments for the driver service.
	/// </summary>
	protected virtual string CommandLineArguments => string.Format(CultureInfo.InvariantCulture, "--port={0}", this.Port);

	/// <summary>
	/// Gets a value indicating the time to wait for the service to terminate before forcing it to terminate.
	/// </summary>
	protected virtual TimeSpan TerminationTimeout => TimeSpan.FromSeconds(10);

	/// <summary>
	/// Gets a value indicating whether the service has a shutdown API that can be called to terminate
	/// it gracefully before forcing a termination.
	/// </summary>
	protected virtual bool HasShutdown => true;

	/// <summary>
	/// Gets a value indicating whether process redirection is enforced regardless of other settings.
	/// </summary>
	/// <remarks>Set this property to <see langword="true"/> to force all process output and error streams to
	/// be redirected, even if redirection is not required by default behavior. This can be useful in scenarios where
	/// capturing process output is necessary for logging or analysis.</remarks>
	protected virtual internal bool EnableProcessRedirection { get; } = false;

	/// <summary>
	/// Gets a value indicating whether the service is responding to HTTP requests.
	/// </summary>
	protected virtual bool IsInitialized
	{
	get
	{
	bool isInitialized = false;

	try
	{
	using (var httpClient = new HttpClient())
	{
	httpClient.DefaultRequestHeaders.ConnectionClose = true;
	httpClient.Timeout = TimeSpan.FromSeconds(5);

	Uri serviceHealthUri = new Uri(this.ServiceUrl, new Uri(DriverCommand.Status, UriKind.Relative));
	using (var response = Task.Run(async () => await httpClient.GetAsync(serviceHealthUri)).GetAwaiter().GetResult())
	{
	// Checking the response from the 'status' end point. Note that we are simply checking
	// that the HTTP status returned is a 200 status, and that the response has the correct
	// Content-Type header. A more sophisticated check would parse the JSON response and
	// validate its values. At the moment we do not do this more sophisticated check.
	isInitialized = response.StatusCode == HttpStatusCode.OK && response.Content.Headers.ContentType is { MediaType: string mediaType } && mediaType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase);
	}
	}
	}
	catch (Exception ex) when (ex is HttpRequestException \|\| ex is TaskCanceledException)
	{
	// Do nothing. The exception is expected, meaning driver service is not initialized.
	}

	return isInitialized;
	}
	}

	/// <summary>
	/// Releases all resources associated with this <see cref="DriverService"/>.
	/// </summary>
	public void Dispose()
	{
	this.Dispose(true);
	GC.SuppressFinalize(this);
	}

	/// <summary>
	/// Starts the DriverService if it is not already running.
	/// </summary>
	[MemberNotNull(nameof(driverServiceProcess))]
	public void Start()
	{
	if (this.driverServiceProcess != null)
	{
	return;
	}

	this.driverServiceProcess = new Process();

	if (this.DriverServicePath != null)
	{
	if (this.DriverServiceExecutableName is null)
	{
	throw new InvalidOperationException("If the driver service path is specified, the driver service executable name must be as well");
	}

	this.driverServiceProcess.StartInfo.FileName = Path.Combine(this.DriverServicePath, this.DriverServiceExecutableName);
	}
	else
	{
	this.driverServiceProcess.StartInfo.FileName = new DriverFinder(this.GetDefaultDriverOptions()).GetDriverPath();
	}

	this.driverServiceProcess.StartInfo.Arguments = this.CommandLineArguments;
	this.driverServiceProcess.StartInfo.UseShellExecute = false;
	this.driverServiceProcess.StartInfo.CreateNoWindow = this.HideCommandPromptWindow;

	this.driverServiceProcess.StartInfo.RedirectStandardOutput = true;
	this.driverServiceProcess.StartInfo.RedirectStandardError = true;

	if (this.EnableProcessRedirection)
	{
	this.driverServiceProcess.OutputDataReceived += this.OnDriverProcessDataReceived;
	this.driverServiceProcess.ErrorDataReceived += this.OnDriverProcessDataReceived;
	}

	DriverProcessStartingEventArgs eventArgs = new DriverProcessStartingEventArgs(this.driverServiceProcess.StartInfo);
	this.OnDriverProcessStarting(eventArgs);

	this.driverServiceProcess.Start();

	// Important: Start the process and immediately begin reading the output and error streams to avoid IO deadlocks.
	this.driverServiceProcess.BeginOutputReadLine();
	this.driverServiceProcess.BeginErrorReadLine();

	bool serviceAvailable = this.WaitForServiceInitialization();

	DriverProcessStartedEventArgs processStartedEventArgs = new DriverProcessStartedEventArgs(this.driverServiceProcess);
	this.OnDriverProcessStarted(processStartedEventArgs);

	if (!serviceAvailable)
	{
	throw new WebDriverException($"Cannot start the driver service on {this.ServiceUrl}");
	}
	}

	/// <summary>
	/// The browser options instance that corresponds to the driver service
	/// </summary>
	/// <returns></returns>
	protected abstract DriverOptions GetDefaultDriverOptions();

	/// <summary>
	/// Releases all resources associated with this <see cref="DriverService"/>.
	/// </summary>
	/// <param name="disposing"><see langword="true"/> if the Dispose method was explicitly called; otherwise, <see langword="false"/>.</param>
	protected virtual void Dispose(bool disposing)
	{
	if (!this.isDisposed)
	{
	if (disposing)
	{
	this.Stop();

	if (EnableProcessRedirection && this.driverServiceProcess is not null)
	{
	this.driverServiceProcess.OutputDataReceived -= this.OnDriverProcessDataReceived;
	this.driverServiceProcess.ErrorDataReceived -= this.OnDriverProcessDataReceived;
	}
	}

	this.isDisposed = true;
	}
	}

	/// <summary>
	/// Raises the <see cref="DriverProcessStarting"/> event.
	/// </summary>
	/// <param name="eventArgs">A <see cref="DriverProcessStartingEventArgs"/> that contains the event data.</param>
	protected virtual void OnDriverProcessStarting(DriverProcessStartingEventArgs eventArgs)
	{
	if (eventArgs == null)
	{
	throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
	}

	this.DriverProcessStarting?.Invoke(this, eventArgs);
	}

	/// <summary>
	/// Raises the <see cref="DriverProcessStarted"/> event.
	/// </summary>
	/// <param name="eventArgs">A <see cref="DriverProcessStartedEventArgs"/> that contains the event data.</param>
	protected virtual void OnDriverProcessStarted(DriverProcessStartedEventArgs eventArgs)
	{
	if (eventArgs == null)
	{
	throw new ArgumentNullException(nameof(eventArgs), "eventArgs must not be null");
	}

	this.DriverProcessStarted?.Invoke(this, eventArgs);
	}

	/// <summary>
	/// Handles the output and error data received from the driver process.
	/// </summary>
	/// <param name="sender">The sender of the event.</param>
	/// <param name="args">The data received event arguments.</param>
	protected virtual void OnDriverProcessDataReceived(object sender, DataReceivedEventArgs args)
	{

	}

	/// <summary>
	/// Stops the DriverService.
	/// </summary>
	private void Stop()
	{
	if (this.IsRunning)
	{
	if (this.HasShutdown)
	{
	Uri shutdownUrl = new Uri(this.ServiceUrl, "/shutdown");
	DateTime timeout = DateTime.Now.Add(this.TerminationTimeout);
	using (var httpClient = new HttpClient())
	{
	httpClient.DefaultRequestHeaders.ConnectionClose = true;

	while (this.IsRunning && DateTime.Now < timeout)
	{
	try
	{
	// Issue the shutdown HTTP request, then wait a short while for
	// the process to have exited. If the process hasn't yet exited,
	// we'll retry. We wait for exit here, since catching the exception
	// for a failed HTTP request due to a closed socket is particularly
	// expensive.
	using (var response = Task.Run(async () => await httpClient.GetAsync(shutdownUrl)).GetAwaiter().GetResult())
	{

	}

	this.driverServiceProcess.WaitForExit(3000);
	}
	catch (Exception ex) when (ex is HttpRequestException \|\| ex is TimeoutException)
	{
	}
	}
	}
	}

	// If at this point, the process still hasn't exited, wait for one
	// last-ditch time, then, if it still hasn't exited, kill it. Note
	// that falling into this branch of code should be exceedingly rare.
	if (this.IsRunning)
	{
	this.driverServiceProcess.WaitForExit(Convert.ToInt32(this.TerminationTimeout.TotalMilliseconds));
	if (!this.driverServiceProcess.HasExited)
	{
	this.driverServiceProcess.Kill();
	}
	}

	this.driverServiceProcess.Dispose();
	this.driverServiceProcess = null;
	}
	}

	/// <summary>
	/// Waits until a the service is initialized, or the timeout set
	/// by the <see cref="InitializationTimeout"/> property is reached.
	/// </summary>
	/// <returns><see langword="true"/> if the service is properly started and receiving HTTP requests;
	/// otherwise; <see langword="false"/>.</returns>
	private bool WaitForServiceInitialization()
	{
	bool isInitialized = false;
	DateTime timeout = DateTime.Now.Add(this.InitializationTimeout);
	while (!isInitialized && DateTime.Now < timeout)
	{
	// If the driver service process has exited, we can exit early.
	if (!this.IsRunning)
	{
	break;
	}

	isInitialized = this.IsInitialized;
	}

	return isInitialized;
	}
	}