//public bool Connected { get; set; } = false;
public override async Task Connect()
{
var sessions = await GetSessions(Port).ConfigureAwait(false);
var endpointUrl = sessions.FirstOrDefault(s => s.Type == "page")?.WebSocketDebuggerUrl;
if (endpointUrl == null)
{
throw new Exception("Cannot get page session from Chrome");
}
//var dir = wsProxyConfig.DevToolsFilesDir ?? Directory.GetCurrentDirectory();
//await LoadDevToolsFiles(dir);
if (_wsProxyConfig?.DoProxyHttpTraffic == true)
{
if (_wsProxyConfig.DevToolsFilesDir == null)
{
_wsProxyConfig.DevToolsFilesDir = Directory.GetCurrentDirectory();
}
_wsProxyConfig.ChromePort = Port;
_httpServer = new HttpServer(_wsProxyConfig); // dir, wsProxyConfig.HTTPServerPort, Port);
}
_proxyEndpointUrl = await OpenProxyWS(endpointUrl).ConfigureAwait(false);
Session = new ChromeSession(_proxyEndpointUrl);
}
public async Task EnsureCaptureScreenshotHasData()
{
var s = new SemaphoreSlim(0, 1);
var fileName = $".\\{m_testContext.TestName}.png";
using (var session = new ChromeSession(m_currentChromeSessionInfo.WebSocketDebuggerUrl))
{
await session.Page.Enable();
session.Page.SubscribeToLoadEventFiredEvent(async(e) =>
{
var screenshot = await session.Page.CaptureScreenshot(new Page.CaptureScreenshotCommand());
if (!string.IsNullOrWhiteSpace(screenshot.Data))
{
File.WriteAllBytes(fileName, Convert.FromBase64String(screenshot.Data));
m_testContext.WriteLine($"saved to {fileName}");
s.Release();
}
});
var navigateResult = await session.Page.Navigate(new Page.NavigateCommand
{
Url = "https://www.google.com"
});
await s.WaitAsync();
Assert.IsTrue(File.Exists(fileName));
}
}
/// <summary>
/// Connects to the specified chrome session.
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="sessionInfo"></param>
/// <returns></returns>
public static async Task <SkraprDevTools> Connect(IServiceProvider serviceProvider, ChromeSessionInfo sessionInfo)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (sessionInfo == null)
{
throw new ArgumentNullException(nameof(sessionInfo));
}
var chromeSessionLogger = serviceProvider
.GetService <ILoggerFactory>()
.CreateLogger <ChromeSession>();
var devToolsLogger = serviceProvider
.GetService <ILoggerFactory>()
.CreateLogger <SkraprDevTools>();
//Create a new session using the information in the session info.
var session = new ChromeSession(chromeSessionLogger, sessionInfo.WebSocketDebuggerUrl);
var devTools = new SkraprDevTools(devToolsLogger, session, sessionInfo.Id);
await devTools.Initialize();
return(devTools);
}
private static ChromeSession CreateChromeSession(string sessionInfoUrl, List <string> titleClues, out List <ChromeSessionInfo> otherWsUrls)
{
otherWsUrls = null;
var qnSessions = GetWebSocketSessionInfos(sessionInfoUrl);
otherWsUrls = qnSessions.Where(k => !string.IsNullOrEmpty(k.WebSocketDebuggerUrl)).ToList();
ChromeSessionInfo webSocketSessionInfo = null;
foreach (var title in titleClues)
{
webSocketSessionInfo = otherWsUrls.FirstOrDefault(k => k.Title == title);
if (webSocketSessionInfo != null)
{
otherWsUrls.Remove(webSocketSessionInfo);
break;
}
}
ChromeSession chromeSession = null;
if (webSocketSessionInfo != null)
{
chromeSession = new ChromeSessionFactory().Create(webSocketSessionInfo.WebSocketDebuggerUrl, webSocketSessionInfo.Title);
}
return(chromeSession);
}
public ChromeOperator(string sessionInfoUrl, HashSet <string> titles, bool isChatRecord)
{
this.hadevalinsertjs = false;
this.Id = RandomEx.Rand.Next();
this._isEnableChromeConsoleListening = false;
this._isEnableChromeInspectorListening = false;
this.Session = CreateChromeSession(sessionInfoUrl, titles, isChatRecord);
}
private ChromeOperator(ChromeSession session)
{
this.hadevalinsertjs = false;
this.Id = RandomEx.Rand.Next();
this._isEnableChromeConsoleListening = false;
this._isEnableChromeInspectorListening = false;
this.Session = session;
}
public virtual async Task Connect()
{
var sessions = await GetSessions(Port).ConfigureAwait(false);
var endpointUrl = sessions.FirstOrDefault(s => s.Type == "page")?.WebSocketDebuggerUrl;
Session = new ChromeSession(endpointUrl);
}
//Launch Chrome With
//"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9223
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var sessions = await GetSessions("http://localhost:9223/");
using (var session = new ChromeSession(sessions.First(s => s.Type == "page").WebSocketDebuggerUrl))
{
//Get the frame resource tree
var resource = await session.Page.GetResourceTree(new Page.GetResourceTreeCommand());
//Navigate to winamp.com
var navigateResult = await session.Page.Navigate(new Page.NavigateCommand
{
Url = "http://www.amazon.com"
});
long executionContextId = -1;
var s = new SemaphoreSlim(0, 1);
//Subscribe to the eval command and determine the execution context id to use which
//correlates to the page we navigated to.
session.Runtime.SubscribeToExecutionContextCreatedEvent((e) =>
{
var auxData = e.Context.AuxData as JObject;
var frameId = auxData["frameId"].Value <string>();
if (e.Context.Origin == "https://www.amazon.com" && frameId == navigateResult.FrameId)
{
executionContextId = e.Context.Id;
s.Release();
}
});
//Enable the runtime so that execution context events are raised.
var result1 = await session.Runtime.Enable(new Runtime.EnableCommand());
await s.WaitAsync();
//Evaluate a complex answer.
var result2 = await session.Runtime.Evaluate(new Runtime.EvaluateCommand
{
ContextId = executionContextId,
ObjectGroup = "test123",
Expression = "6*7"
});
Console.WriteLine(result2.Result.Description);
// New in Chrome 69, get a DOM snapshot.
var result3 = await session.DOMSnapshot.CaptureSnapshot(new BaristaLabs.ChromeDevTools.Runtime.DOMSnapshot.CaptureSnapshotCommand()
{
ComputedStyles = new string[0]
});
}
}
private void cmbQnAccount_SelectedIndexChanged(object sender, EventArgs e)
{
var selectedItem = cmbQnAccount.Items[cmbQnAccount.SelectedIndex].ToString();
var qnHwnd = QnAccounts.First(k => k.Key == selectedItem).Value;
var sessionInfoUrl = GetSessionInfoUrl(qnHwnd);
if (!ChromeSessions.ContainsKey(selectedItem))
{
ChromeSessions[selectedItem] = CreateChromeSession(sessionInfoUrl, ChatlogChromeTitles);
}
CurrentChromeSession = ChromeSessions[selectedItem];
}
public ChromeSession Create(string endpointUrl, string title)
{
// Sometimes binding to localhost might resolve wrong AddressFamily, force IPv4
endpointUrl = endpointUrl.Replace("ws://localhost", "ws://127.0.0.1");
var methodTypeMap = new MethodTypeMap();
var commandFactory = new CommandFactory();
var responseFactory = new CommandResponseFactory(methodTypeMap, commandFactory);
var eventFactory = new EventFactory(methodTypeMap);
var session = new ChromeSession(endpointUrl, commandFactory, responseFactory, eventFactory, title);
return(session);
}
public async Task <string> NavigateToPageInNewSession(ChromeSessionInfo sessionInfo, string address)
{
TestContext.WriteLine($"ThreadId: {Thread.CurrentThread.ManagedThreadId}");
var s = new SemaphoreSlim(0, 1);
string body = null;
string requestId = null;
using (var session = new ChromeSession(sessionInfo.WebSocketDebuggerUrl))
{
await session.Page.Enable();
await session.Network.Enable(new Network.EnableCommand()
{
});
session.Network.SubscribeToResponseReceivedEvent((e2) =>
{
if (e2.Response.Url != address)
{
return;
}
requestId = e2.RequestId;
});
session.Page.SubscribeToLoadEventFiredEvent(async(e) =>
{
if (String.IsNullOrWhiteSpace(requestId))
{
throw new InvalidOperationException("RequestId not set");
}
var response = await session.Network.GetResponseBody(new Network.GetResponseBodyCommand()
{
RequestId = requestId
});
body = response.Body;
s.Release();
});
var navigateResult = await session.Page.Navigate(new Page.NavigateCommand
{
Url = address
});
await s.WaitAsync();
return(body);
}
}
/// <summary>Opens a session to the chromium instance hosting MediaMonkey.</summary>
public async Task OpenSessionAsync()
{
using (var webClient = new HttpClient())
{
webClient.BaseAddress = new Uri(RemoteDebuggingUri);
string remoteSessions = await webClient.GetStringAsync("/json").ConfigureAwait(false);
var webSockets = JsonConvert.DeserializeObject <ICollection <ChromeSessionInfo> >(remoteSessions);
EndpointAddress = (webSockets.First(s => s.Url == mmWebsocketUrl)).WebSocketDebuggerUrl.Replace("ws://localhost", "ws://127.0.0.1");
mmSession = new ChromeSession(EndpointAddress);
mmSession.CommandTimeout = mmSessionTimeout;
}
}
public static async Task<bool> hiveWaitUntilValueEquals<T>(this ChromeSession s, string key, T value, int timeout = 1000) where T : struct
{
return await asyncSpinlock.WaitUntil(async () =>
{
try
{
return value.Equals(await s.EvalValue<T>(string.Format(hiveGetString, key)));
}
catch (Exception)
{
return false;
}
}, timeout);
}
public NavigatorWatcher(ChromeSession session)
{
Session = session ?? throw new ArgumentNullException(nameof(session));
session.Page.SubscribeToLoadEventFiredEvent((e) =>
{
if (m_loadSemaphore != null)
{
lock (m_syncRoot)
{
if (m_loadSemaphore != null)
{
m_loadSemaphore.Release();
}
}
}
});
session.Page.SubscribeToDomContentEventFiredEvent((e) =>
{
if (m_domContentLoadedSemaphore != null)
{
lock (m_syncRoot)
{
if (m_domContentLoadedSemaphore != null)
{
m_domContentLoadedSemaphore.Release();
}
}
}
});
session.Network.SubscribeToRequestWillBeSentEvent((e) =>
{
m_networkActivityCount++;
});
session.Network.SubscribeToResponseReceivedEvent((e) =>
{
m_networkActivityCount++;
});
session.Network.SubscribeToDataReceivedEvent((e) =>
{
m_networkActivityCount++;
});
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
//if (disposing)
//{
// // dispose managed state (managed objects).
//}
if (mmSession != null)
{
mmSession.Dispose();
mmSession = null;
}
disposedValue = true;
}
}
public async Task AssertWSErrorExceptionCanBeCaught()
{
bool exceptionThrown = false;
//Create a new chrome instance
var chrome = Chrome.OpenChrome(9226);
var sessionInfo = await chrome.CreateNewSession();
ChromeSession session = null;
try
{
session = new ChromeSession(sessionInfo.WebSocketDebuggerUrl);
await session.Page.Navigate(new Page.NavigateCommand {
Url = "https://www.google.com"
});
//Dispose of the chrome process, thus killing it.
chrome.Dispose();
//Wait a bit to ensure that the chrome process has been terminated.
Thread.Sleep(2000);
//Try another navigation -- this will raise the socket exception
await session.Page.Navigate(new Page.NavigateCommand
{
Url = "https://www.winamp.com"
});
}
catch (System.Net.Sockets.SocketException)
{
exceptionThrown = true;
}
finally
{
//Ensure the session is disposed
if (session != null)
{
session.Dispose();
}
}
Assert.IsTrue(exceptionThrown);
}
public SkraprWorker(ILogger logger, SkraprDefinition definition, ChromeSession session, SkraprDevTools devTools, bool isDebugEnabled = false)
{
m_logger = logger ?? throw new ArgumentNullException(nameof(logger));
m_logger = logger;
m_cts = new CancellationTokenSource();
m_mainFlow = new ActionBlock <ISkraprTask>(ProcessMainSkraprTask, new ExecutionDataflowBlockOptions
{
CancellationToken = m_cts.Token,
EnsureOrdered = true,
MaxDegreeOfParallelism = 1
});
m_devTools = devTools ?? throw new ArgumentNullException(nameof(devTools));
m_session = session;
m_definition = definition;
m_isDebugEnabled = isDebugEnabled;
}
static void Main(string[] args)
{
//Launch Chrome With
//"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9223
Console.WriteLine("Hello World!");
var sessions = GetSessions("http://localhost:9223/").GetAwaiter().GetResult();
using (var session = new ChromeSession(sessions.First(s => s.Type == "page").WebSocketDebuggerUrl))
{
try
{
//session.Page.SubscribeToLoadEventFiredEvent((e) =>
session.Page.SubscribeToDomContentEventFiredEvent((e) =>
{
Console.WriteLine("Page loaded");
////NOT WORKS
//var screenshot = session.Page.CaptureScreenshot(new Page.CaptureScreenshotCommand(), new System.Threading.CancellationToken(), 5000).GetAwaiter().GetResult();
//SaveScreenshot(screenshot.Data);
// WORKS
Task.Run(() =>
{
var screenshot = session.Page.CaptureScreenshot(new Page.CaptureScreenshotCommand(), new System.Threading.CancellationToken(), 5000).GetAwaiter().GetResult();
SaveScreenshot(screenshot.Data);
});
});
session.Page.Enable(new Page.EnableCommand()).GetAwaiter().GetResult();
var navigateResult = session.Page.Navigate(new Page.NavigateCommand
{
Url = "https://www.google.com/"
}).GetAwaiter().GetResult();
Console.ReadLine();
session.Page.Disable(new Page.DisableCommand()).GetAwaiter().GetResult();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
public static async Task<dynamic> hiveWaitUntilGet(this ChromeSession s, string key, int timeout) {
dynamic result = null;
if (await asyncSpinlock.WaitUntil(async () =>
{
try
{
result = await s.EvalObject(string.Format(hiveGetString, key));
return true;
}
catch (Exception)
{
return false;
}
}, timeout))
{
return result;
}
throw new TimeoutException("The desired response was not ready.");
}
public static async Task<T> hiveWaitUntilGetValue<T>(this ChromeSession s, string key, int timeout = 1000) where T : struct
{
T result = default(T);
if (await asyncSpinlock.WaitUntil(async () =>
{
try
{
result = await s.EvalValue<T>(string.Format(hiveGetString, key));
return true;
}
catch (Exception)
{
return false;
}
},timeout))
{
return result;
}
throw new TimeoutException("The desired response was not ready.");
}
public DatabaseAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public BackgroundServiceAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public HeapProfilerAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public TetheringAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public DOMSnapshotAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public CacheStorageAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public virtual void Disconnect()
{
Session?.Dispose();
Session = null;
}
/// <summary>
/// Creates a new instance of the SkraprDevTools using the provided sesion.
/// </summary>
/// <param name="session"></param>
private SkraprDevTools(ILogger logger, ChromeSession session, string targetId)
{
m_logger = logger ?? throw new ArgumentNullException(nameof(logger));
m_session = session ?? throw new ArgumentNullException(nameof(session));
m_targetId = targetId;
}
public WebAudioAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
public IndexedDBAdapter(ChromeSession session)
{
m_session = session ?? throw new ArgumentNullException(nameof(session));
}
