/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { if (commandToExecute == null) { throw new ArgumentNullException("commandToExecute", "Command to execute cannot be null"); } Response toReturn = null; if (commandToExecute.Name == DriverCommand.NewSession) { this.service.Start(); } // Use a try-catch block to catch exceptions for the Quit // command, so that we can get the finally block. try { toReturn = this.internalExecutor.Execute(commandToExecute); } finally { if (commandToExecute.Name == DriverCommand.Quit) { this.service.Dispose(); } } return toReturn; }
/// <summary> /// Creates a web request for your command /// </summary> /// <param name="baseUri">Uri that will have the command run against</param> /// <param name="commandToExecute">Command to execute</param> /// <returns>A web request of what has been run</returns> public HttpWebRequest CreateWebRequest(Uri baseUri, Command commandToExecute) { HttpWebRequest request = null; string[] urlParts = this.resourcePath.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < urlParts.Length; i++) { string urlPart = urlParts[i]; if (urlPart.StartsWith("{", StringComparison.OrdinalIgnoreCase) && urlPart.EndsWith("}", StringComparison.OrdinalIgnoreCase)) { urlParts[i] = GetCommandPropertyValue(urlPart, commandToExecute); } } Uri fullUri; string relativeUrl = string.Join("/", urlParts); bool uriCreateSucceeded = Uri.TryCreate(baseUri, relativeUrl, out fullUri); if (uriCreateSucceeded) { request = HttpWebRequest.Create(fullUri) as HttpWebRequest; request.Method = this.method; } else { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unable to create URI from base {0} and relative path {1}", baseUri == null ? string.Empty : baseUri.ToString(), relativeUrl)); } return request; }
public Response Execute(Command commandToExecute) { Response result = null; if (commandToExecute.Name == DriverCommand.NewSession && this.Service != null) { this.Service.Start(); } try { result = RealExecutor.Execute(commandToExecute); return result; } catch (Exception e) { if ((commandToExecute.Name == DriverCommand.NewSession) && (this.Service != null)) { this.Service.Dispose(); } throw e; } finally { if (result != null && result.Status != WebDriverResult.Success && commandToExecute.Name == DriverCommand.NewSession && this.Service != null) { this.Service.Dispose(); } if (commandToExecute.Name == DriverCommand.Quit && this.Service != null) { this.Service.Dispose(); } } }
/// <summary> /// Sends a command to the SafariDriver and waits for a response. /// </summary> /// <param name="command">The <see cref="Command"/> to send to the driver.</param> /// <returns>The <see cref="Response"/> from the command.</returns> public Response Send(Command command) { SafariCommand wrappedCommand = new SafariCommand(command); this.commandQueue.Enqueue(wrappedCommand); string commandJson = JsonConvert.SerializeObject(wrappedCommand); this.connection.Send(commandJson); return this.WaitForResponse(TimeSpan.FromSeconds(30)); }
private static Dictionary<string, object> ExtractParameters(Command command) { if (command == null) { throw new ArgumentNullException("command", "command must not be null"); } return command.Parameters; }
private static string ExtractName(Command command) { if (command == null) { throw new ArgumentNullException("command", "command must not be null"); } return command.Name; }
private static SessionId ExtractSessionId(Command command) { if (command == null) { throw new ArgumentNullException("command", "command must not be null"); } return command.SessionId; }
public string ForwardCommand(Command commandToForward, bool verbose = true, int timeout = 0) { var serializedCommand = JsonConvert.SerializeObject(commandToForward); var response = this.SendRequest(serializedCommand, verbose, timeout); if (response.Key == HttpStatusCode.OK) { return response.Value; } throw new InnerDriverRequestException(response.Value, response.Key); }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { CommandInfo info = CommandInfoRepository.Instance.GetCommandInfo(commandToExecute.Name); HttpWebRequest request = info.CreateWebRequest(this.remoteServerUri, commandToExecute); request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds; request.Accept = RequestAcceptHeader; if (request.Method == CommandInfo.PostCommand) { string payload = commandToExecute.ParametersAsJsonString; byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = JsonMimeType; System.IO.Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } return CreateResponse(request); }
protected override string DoImpl() { // It is easier to reparse desired capabilities as JSON instead of re-mapping keys to attributes and calling type conversions, // so we will take possible one time performance hit by serializing Dictionary and deserializing it as Capabilities object var serializedCapability = JsonConvert.SerializeObject(this.ExecutedCommand.Parameters["desiredCapabilities"]); this.Automator.ActualCapabilities = Capabilities.CapabilitiesFromJsonString(serializedCapability); var innerIp = this.InitializeApplication(this.Automator.ActualCapabilities.DebugConnectToRunningApp); this.Automator.CommandForwarder = new Requester(innerIp, this.Automator.ActualCapabilities.InnerPort); long timeout = this.Automator.ActualCapabilities.LaunchTimeout; const int PingStep = 500; var stopWatch = new Stopwatch(); while (timeout > 0) { stopWatch.Restart(); Logger.Trace("Ping inner driver"); var pingCommand = new Command(null, "ping", null); var responseBody = this.Automator.CommandForwarder.ForwardCommand(pingCommand, false, 2000); if (responseBody.StartsWith("<pong>", StringComparison.Ordinal)) { break; } Thread.Sleep(PingStep); stopWatch.Stop(); timeout -= stopWatch.ElapsedMilliseconds; } // TODO throw AutomationException with SessionNotCreatedException if timeout and uninstall the app Console.WriteLine(); // Gives sometime to load visuals (needed only in case of slow emulation) Thread.Sleep(this.Automator.ActualCapabilities.LaunchDelay); var jsonResponse = this.JsonResponse(ResponseStatus.Success, this.Automator.ActualCapabilities); return jsonResponse; }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { CommandInfo info = CommandInfoRepository.Instance.GetCommandInfo(commandToExecute.Name); HttpWebRequest.DefaultMaximumErrorResponseLength = -1; HttpWebRequest request = info.CreateWebRequest(remoteServerUri, commandToExecute); request.Timeout = 15000; request.Accept = "application/json, image/png"; if (request.Method == CommandInfo.PostCommand) { string payload = commandToExecute.ParametersAsJsonString; byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = "application/json"; System.IO.Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } return CreateResponse(request); }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { CommandInfo info = commandDictionary[commandToExecute.Name]; HttpWebRequest.DefaultMaximumErrorResponseLength = -1; HttpWebRequest request = info.CreateWebRequest(remoteServerUri, commandToExecute); request.Accept = "application/json, image/png"; string payload = JsonConvert.SerializeObject(commandToExecute.Parameters, new JsonConverter[] { new PlatformJsonConverter(), new CookieJsonConverter(), new CharArrayJsonConverter() }); if (request.Method == CommandInfo.PostCommand) { byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = "application/json"; request.KeepAlive = false; System.IO.Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } return CreateResponse(request); }
private void ConnectToApp() { long timeout = this.Automator.ActualCapabilities.LaunchTimeout; const int PingStep = 500; var stopWatch = new Stopwatch(); while (timeout > 0) { stopWatch.Restart(); Logger.Trace("Ping inner driver"); var pingCommand = new Command(null, "ping", null); var responseBody = this.Automator.CommandForwarder.ForwardCommand(pingCommand, false, 2000); if (responseBody.StartsWith("<pong>", StringComparison.Ordinal)) { break; } Thread.Sleep(PingStep); stopWatch.Stop(); timeout -= stopWatch.ElapsedMilliseconds; } }
public Response Execute(Command commandToExecute) { if (commandToExecute == null) { throw new ArgumentNullException("commandToExecute", "Command may not be null"); } if (commandToExecute.Name == DriverCommand.NewSession) { this.service.Start(); } try { return this.internalExecutor.Execute(commandToExecute); } finally { if (commandToExecute.Name == DriverCommand.Quit) { this.service.Dispose(); } } }
/// <summary> /// Executes a command with the ChromeDriver. /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public override Response Execute(Command commandToExecute) { Response toReturn = null; if (commandToExecute.Name == DriverCommand.NewSession) { this.service.Start(); } // Use a try-catch block to catch exceptions for the Quit // command, so that we can get the finally block. try { toReturn = base.Execute(commandToExecute); } finally { if (commandToExecute.Name == DriverCommand.Quit) { this.service.Dispose(); } } return toReturn; }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { return this.connection.Send(commandToExecute); }
/// <summary> /// Executes a command with this driver . /// </summary> /// <param name="driverCommandToExecute">A <see cref="DriverCommand"/> value representing the command to execute.</param> /// <param name="parameters">A <see cref="Dictionary{K, V}"/> containing the names and values of the parameters of the command.</param> /// <returns>A <see cref="Response"/> containing information about the success or failure of the command and any data returned by the command.</returns> protected virtual Response Execute(string driverCommandToExecute, Dictionary<string, object> parameters) { Command commandToExecute = new Command(this.sessionId, driverCommandToExecute, parameters); Response commandResponse = new Response(); try { commandResponse = this.executor.Execute(commandToExecute); } catch (System.Net.WebException e) { commandResponse.Status = WebDriverResult.UnhandledError; commandResponse.Value = e; } if (commandResponse.Status != WebDriverResult.Success) { UnpackAndThrowOnError(commandResponse); } return commandResponse; }
/// <summary> /// Sends a command to the server. /// </summary> /// <param name="commandToSend">The <see cref="Command"/> to send.</param> /// <returns>The command <see cref="Response"/>.</returns> public Response SendCommand(Command commandToSend) { return this.connection.Send(commandToSend); }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public virtual Response Execute(Command commandToExecute) { if (commandToExecute == null) { throw new ArgumentNullException("commandToExecute", "commandToExecute cannot be null"); } CommandInfo info = CommandInfoRepository.Instance.GetCommandInfo(commandToExecute.Name); HttpWebRequest request = info.CreateWebRequest(this.remoteServerUri, commandToExecute); request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds; request.Accept = RequestAcceptHeader; request.KeepAlive = this.enableKeepAlive; request.ServicePoint.ConnectionLimit = 2000; if (request.Method == CommandInfo.PostCommand) { string payload = commandToExecute.ParametersAsJsonString; byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = ContentTypeHeader; Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } return this.CreateResponse(request); }
private void SendMessage(Command commandToExecute) { // Wait for a POST request to be pending from the Chrome extension. // When one is received, get the packet from the queue. bool signalReceived = postRequestReceived.WaitOne(TimeSpan.FromSeconds(ExtensionTimeoutInSeconds)); if (pendingRequestQueue.Count == 0) { throw new FatalChromeException("No pending requests from the extension in the queue"); } // ExtensionRequestPacket packet = pendingRequestQueue.Dequeue(); ExtensionRequestPacket packet = pendingRequestQueue[0]; pendingRequestQueue.RemoveAt(0); // Get the parameter names to correctly serialize the command to JSON. commandToExecute.Parameters.Add("request", commandNameMap[commandToExecute.Name]); string commandStringToSend = commandToExecute.ParametersAsJsonString; // Send the response to the Chrome extension. Send(packet, commandStringToSend, "application/json; charset=UTF-8"); }
/// <summary> /// Executes the Command in the browser /// </summary> /// <param name="commandToExecute">Command to execute</param> /// <returns>The response from the Browser</returns> public Response Execute(Command commandToExecute) { Response commandResponse = new Response(new SessionId("[No Session ID]")); if (commandToExecute.Name == DriverCommand.NewSession) { DesiredCapabilities capabilities = DesiredCapabilities.Chrome(); Dictionary<string, object> capabilitiesMap = new Dictionary<string, object>(); capabilitiesMap.Add("browserName", capabilities.BrowserName); capabilitiesMap.Add("version", capabilities.Version); capabilitiesMap.Add("platform", capabilities.Platform.Type.ToString()); capabilitiesMap.Add("javascriptEnabled", true); commandResponse.Value = capabilitiesMap; } else { SendMessage(commandToExecute); commandResponse = HandleResponse(); } return commandResponse; }
private static string GetCommandPropertyValue(string propertyName, Command commandToExecute) { string propertyValue = string.Empty; // Strip the curly braces propertyName = propertyName.Substring(1, propertyName.Length - 2); if (propertyName == SessionIdPropertyName) { if (commandToExecute.SessionId != null) { propertyValue = commandToExecute.SessionId.ToString(); } } else if (commandToExecute.Parameters != null && commandToExecute.Parameters.Count > 0) { // Extract the URL parameter, and remove it from the parameters dictionary // so it doesn't get transmitted as a JSON parameter. if (commandToExecute.Parameters.ContainsKey(propertyName)) { if (commandToExecute.Parameters[propertyName] != null) { propertyValue = commandToExecute.Parameters[propertyName].ToString(); commandToExecute.Parameters.Remove(propertyName); } } } return propertyValue; }
/// <summary> /// Initializes a new instance of the <see cref="SafariCommand"/> class. /// </summary> /// <param name="command">The <see cref="Command"/> object used as a base for this <see cref="SafariCommand"/>.</param> public SafariCommand(Command command) : base(ExtractSessionId(command), ExtractName(command), ExtractParameters(command)) { this.id = Guid.NewGuid(); }
private CommandResponse ProcessCommand(Command command) { Logger.Info("COMMAND {0}\r\n{1}", command.Name, command.ParametersAsJsonString); var executor = this.executorDispatcher.GetExecutor(command.Name); executor.ExecutedCommand = command; var response = executor.Do(); Logger.Debug("RESPONSE:\r\n{0}", response); return response; }
private string HandleRequest(HttpRequest acceptedRequest) { if (string.IsNullOrEmpty(acceptedRequest.StartingLine)) { return HttpResponseHelper.ResponseString( HttpStatusCode.BadRequest, "Bad request URL"); } var firstHeaderTokens = acceptedRequest.StartingLine.Split(' '); var method = firstHeaderTokens[0]; var resourcePath = firstHeaderTokens[1]; var uriToMatch = new Uri(this.Prefix, resourcePath); var matched = this.dispatcher.Match(method, uriToMatch); if (matched == null) { Logger.Warn("Unknown command recived: {0}", uriToMatch); return HttpResponseHelper.ResponseString(HttpStatusCode.NotFound, "Unknown command " + uriToMatch); } var commandName = matched.Data.ToString(); var commandToExecute = new Command(commandName, acceptedRequest.MessageBody); foreach (string variableName in matched.BoundVariables.Keys) { commandToExecute.Parameters[variableName] = matched.BoundVariables[variableName]; } var commandResponse = this.ProcessCommand(commandToExecute); return HttpResponseHelper.ResponseString(commandResponse.HttpStatusCode, commandResponse.Content); }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public virtual Response Execute(Command commandToExecute) { if (commandToExecute == null) { throw new ArgumentNullException("commandToExecute", "commandToExecute cannot be null"); } CommandInfo info = this.commandInfoRepository.GetCommandInfo(commandToExecute.Name); HttpWebRequest request = info.CreateWebRequest(this.remoteServerUri, commandToExecute); request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds; request.Accept = RequestAcceptHeader; request.KeepAlive = this.enableKeepAlive; request.ServicePoint.ConnectionLimit = 2000; if (request.Method == CommandInfo.PostCommand) { string payload = commandToExecute.ParametersAsJsonString; byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = ContentTypeHeader; Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } Response toReturn = this.CreateResponse(request); if (commandToExecute.Name == DriverCommand.NewSession) { // If we are creating a new session, sniff the response to determine // what protocol level we are using. If the response contains a // capability called "specificationLevel" that's an integer value // and that's greater than 0, that means we're using the W3C protocol // dialect. // TODO(jimevans): Reverse this test to make it the default path when // most remote ends speak W3C, then remove it entirely when legacy // protocol is phased out. Dictionary<string, object> capabilities = toReturn.Value as Dictionary<string, object>; if (capabilities != null) { if (capabilities.ContainsKey("specificationLevel")) { int returnedSpecLevel = Convert.ToInt32(capabilities["specificationLevel"]); if (returnedSpecLevel > 0) { this.commandInfoRepository = new W3CWireProtocolCommandInfoRepository(); } } } } return toReturn; }
private static string GetCommandPropertyValue(string propertyName, Command commandToExecute) { string propertyValue = string.Empty; // Strip the leading colon propertyName = propertyName.Substring(1); if (propertyName == "sessionId") { if (commandToExecute.SessionId != null) { propertyValue = commandToExecute.SessionId.ToString(); } } else if (propertyName == "context") { if (commandToExecute.Context != null) { propertyValue = commandToExecute.Context.ToString(); } } else if (commandToExecute.Parameters != null && commandToExecute.Parameters.Length > 0) { Dictionary<string, object> parameterDictionary = commandToExecute.Parameters[0] as Dictionary<string, object>; if (parameterDictionary != null && parameterDictionary.ContainsKey(propertyName)) { if (parameterDictionary[propertyName] != null) { propertyValue = parameterDictionary[propertyName].ToString(); } } } return propertyValue; }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public Response Execute(Command commandToExecute) { return executor.Execute(commandToExecute); }
/// <summary> /// Initializes a new instance of the <see cref="SafariCommand"/> class. /// </summary> /// <param name="command">The <see cref="Command"/> object used as a base for this <see cref="SafariCommand"/>.</param> public SafariCommand(Command command) : base(command.SessionId, command.Name, command.Parameters) { this.id = Guid.NewGuid(); }
/// <summary> /// Executes a command /// </summary> /// <param name="commandToExecute">The command you wish to execute</param> /// <returns>A response from the browser</returns> public virtual Response Execute(Command commandToExecute) { if (commandToExecute == null) { throw new ArgumentNullException("commandToExecute", "commandToExecute cannot be null"); } CommandInfo info = this.commandInfoRepository.GetCommandInfo(commandToExecute.Name); HttpWebRequest request = info.CreateWebRequest(this.remoteServerUri, commandToExecute); request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds; request.Accept = RequestAcceptHeader; request.KeepAlive = this.enableKeepAlive; request.ServicePoint.ConnectionLimit = 2000; if (request.Method == CommandInfo.PostCommand) { string payload = commandToExecute.ParametersAsJsonString; byte[] data = Encoding.UTF8.GetBytes(payload); request.ContentType = ContentTypeHeader; Stream requestStream = request.GetRequestStream(); requestStream.Write(data, 0, data.Length); requestStream.Close(); } Response toReturn = this.CreateResponse(request); if (commandToExecute.Name == DriverCommand.NewSession && toReturn.IsSpecificationCompliant) { // If we are creating a new session, sniff the response to determine // what protocol level we are using. If the response contains a // field called "status", it's not a spec-compliant response. // Each response is polled for this, and sets a property describing // whether it's using the W3C protocol dialect. // TODO(jimevans): Reverse this test to make it the default path when // most remote ends speak W3C, then remove it entirely when legacy // protocol is phased out. this.commandInfoRepository = new W3CWireProtocolCommandInfoRepository(); } return toReturn; }