server: Redesigning driver factory to check if driver providers can instantiate new drivers.

This is the ground to implement more specific driver providers that can check for presence of executable drivers that are required to run a browser.

Author: barancev

java/server/src/org/openqa/selenium/remote/server/DefaultDriverFactory.java

@@ -19,30 +19,37 @@
 
 import static com.google.common.base.Preconditions.checkState;
 
+import com.google.common.annotations.VisibleForTesting;
+
 import org.openqa.selenium.Capabilities;
 import org.openqa.selenium.WebDriver;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
 
 public class DefaultDriverFactory implements DriverFactory {
 
+  private static final Logger LOG = Logger.getLogger(DefaultDriverFactory.class.getName());
+
   private Map<Capabilities, DriverProvider> capabilitiesToDriverProvider =
       new ConcurrentHashMap<Capabilities, DriverProvider>();
 
-  public void registerDriver(Capabilities capabilities, Class<? extends WebDriver> implementation) {
-    registerDriverProvider(capabilities, new DefaultDriverProvider(capabilities, implementation));
-  }
-
-  public void registerDriverProvider(Capabilities capabilities, DriverProvider implementation) {
-    capabilitiesToDriverProvider.put(capabilities, implementation);
+  @Deprecated
+  public void registerDriver(Capabilities capabilities, Class<? extends WebDriver> driverClass) {
+    registerDriverProvider(new DefaultDriverProvider(capabilities, driverClass));
   }
 
-  protected Class<? extends WebDriver> getBestMatchFor(Capabilities desired) {
-    return getProviderMatching(desired).getDriverClass();
+  public void registerDriverProvider(DriverProvider driverProvider) {
+    if (driverProvider.canCreateDriverInstances()) {
+      capabilitiesToDriverProvider.put(driverProvider.getProvidedCapabilities(), driverProvider);
+    } else {
+      LOG.info(String.format("Driver provider %s is not registered", driverProvider));
+    }
   }
 
-  protected DriverProvider getProviderMatching(Capabilities desired) {
+  @VisibleForTesting
+  DriverProvider getProviderMatching(Capabilities desired) {
     // We won't be able to make a match if no drivers have been registered.
     checkState(!capabilitiesToDriverProvider.isEmpty(),
                "No drivers have been registered, will be unable to match %s", desired);

java/server/src/org/openqa/selenium/remote/server/DefaultDriverProvider.java

@@ -30,40 +30,45 @@ public class DefaultDriverProvider implements DriverProvider {
   private static final Logger LOG = Logger.getLogger(DefaultDriverProvider.class.getName());
 
   private Capabilities capabilities;
-  private Class<? extends WebDriver> implementation;
-  private String driverClass;
+  private Class<? extends WebDriver> driverClass;
+  private String driverClassName;
 
-  public DefaultDriverProvider(Capabilities capabilities, Class<? extends WebDriver> implementation) {
+  public DefaultDriverProvider(Capabilities capabilities, Class<? extends WebDriver> driverClass) {
     this.capabilities = capabilities;
-    this.implementation = implementation;
+    this.driverClass = driverClass;
   }
 
-  public DefaultDriverProvider(Capabilities capabilities, String driverClass) {
+  public DefaultDriverProvider(Capabilities capabilities, String driverClassName) {
     this.capabilities = capabilities;
-    this.driverClass = driverClass;
+    this.driverClassName = driverClassName;
   }
 
   @Override
   public Capabilities getProvidedCapabilities() {
     return capabilities;
   }
 
+  @Override
+  public boolean canCreateDriverInstances() {
+    return getDriverClass() != null;
+  }
+
   @Override
   public Class<? extends WebDriver> getDriverClass() {
-    if (implementation != null) {
-      return implementation;
+    if (driverClass != null) {
+      return driverClass;
     }
     try {
-      return Class.forName(driverClass).asSubclass(WebDriver.class);
+      return Class.forName(driverClassName).asSubclass(WebDriver.class);
     } catch (ClassNotFoundException e) {
-      LOG.log(Level.INFO, "Driver class not found: " + driverClass);
-      throw new WebDriverException("Driver class not found: " + driverClass, e);
+      LOG.log(Level.INFO, "Driver class not found: " + driverClassName);
+      return null;
     } catch (NoClassDefFoundError e) {
-      LOG.log(Level.INFO, "Driver class not found: " + driverClass);
-      throw new WebDriverException("Driver class not found: " + driverClass, e);
+      LOG.log(Level.INFO, "Driver class not found: " + driverClassName);
+      return null;
     } catch (UnsupportedClassVersionError e) {
-      LOG.log(Level.INFO, "Driver class is built for higher Java version: " + driverClass);
-      throw new WebDriverException("Driver class is built for higher Java version: " + driverClass, e);
+      LOG.log(Level.INFO, "Driver class is built for higher Java version: " + driverClassName);
+      return null;
     }
   }
 
@@ -97,6 +102,6 @@ private WebDriver callConstructor(Class<? extends WebDriver> from, Capabilities
 
   @Override
   public String toString() {
-    return implementation != null ? implementation.toString() : driverClass;
+    return driverClass != null ? driverClass.toString() : driverClassName;
   }
 }

java/server/src/org/openqa/selenium/remote/server/DefaultDriverSessions.java

@@ -26,14 +26,12 @@
 import org.openqa.selenium.remote.SessionId;
 
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
 import java.util.logging.Logger;
 
 public class DefaultDriverSessions implements DriverSessions {
@@ -114,7 +112,7 @@ private void registerDriverProvider(Platform current, DriverProvider provider) {
       return;
     }
 
-    factory.registerDriverProvider(caps, provider);
+    factory.registerDriverProvider(provider);
   }
 
   private boolean platformMatches(Platform current, Capabilities caps) {
@@ -123,9 +121,8 @@ private boolean platformMatches(Platform current, Capabilities caps) {
            || current.is(caps.getPlatform());
   }
 
-  public void registerDriver(Capabilities capabilities, Class<? extends WebDriver> implementation) {
-    factory.registerDriverProvider(
-      capabilities, new DefaultDriverProvider(capabilities, implementation));
+  public void registerDriver(Capabilities capabilities, Class<? extends WebDriver> driverClass) {
+    factory.registerDriverProvider(new DefaultDriverProvider(capabilities, driverClass));
   }
 
   public SessionId newSession(Capabilities desiredCapabilities) throws Exception {

java/server/src/org/openqa/selenium/remote/server/DriverFactory.java

@@ -20,9 +20,14 @@
 import org.openqa.selenium.WebDriver;
 
 public interface DriverFactory {
+
+  /**
+   * @deprecated Use registerDriverProvider instead
+   */
+  @Deprecated
   void registerDriver(Capabilities capabilities, Class<? extends WebDriver> implementation);
 
-  void registerDriverProvider(Capabilities capabilities, DriverProvider implementation);
+  void registerDriverProvider(DriverProvider implementation);
 
   WebDriver newInstance(Capabilities capabilities);
 

java/server/src/org/openqa/selenium/remote/server/DriverProvider.java

@@ -19,10 +19,50 @@
 import org.openqa.selenium.Capabilities;
 import org.openqa.selenium.WebDriver;
 
+/**
+ * Classes that implement this interface are used by {org.openqa.selenium.remote.server.DriverFactory}
+ * to create new driver instances associated with specific set of capabilities.
+ *
+ * When a driver factory registers a driver provider it checks ability of the provider to create
+ * instances by a call to its isDriverAvailable method. Default driver provide implementation
+ * checks for presence of the driver class in the classpath. Other driver provider classes may
+ * perform more sophisiticated verification.
+ *
+ * If the driver provides is verified successfully it is registered as the driver provider
+ * associated with the capabilities returned by getProvidedCapabilities method.
+ *
+ * Selenium Server trusts the driver providers, it does not check that a driver provider actually
+ * creates driver instances that have the specified capabilities.
+ */
 public interface DriverProvider {
+
+  /**
+   * The provider "promices" that created driver instances will have (at least) this set of
+   * capabilities. The grid uses this information to match the capabilites requested by the client
+   * against the capabilities provided by all registered providers to pick the "best" one.
+   */
   Capabilities getProvidedCapabilities();
 
+  /**
+   * This method was used for testing purposes only and will be removed from the interface soon.
+   * @deprecated
+   */
+  @Deprecated
   Class<? extends WebDriver> getDriverClass();
 
+  /**
+   * Checks if the provider can create driver instances.
+   *
+   * @return true if the provider can create driver instances.
+   */
+  boolean canCreateDriverInstances();
+
+  /**
+   * Creates a new driver instance. The specified capabilities are to be passed to the driver
+   * constructor.
+   *
+   * @param capabilities Capabilities are to be passed to the driver constructor.
+   * @return A new driver instance
+   */
   WebDriver newInstance(Capabilities capabilities);
 }