title: How to configure EclipseLink to use HikariCP as its connection pool
body: <p>I am using EclipseLink as a Persistence Provider for our application using the Play framework and Akka. With play framework 2.3.x, the application ran properly. Now I am migrating to 2.4.x and subsequently will migrate to 2.5.x, but  I' getting issues when running the application from outside of eclipse saying: </p>
  
  <blockquote>
    <p>"No persistence provider for EntityManager named default".</p>
  </blockquote>
  
  <p>With the change of Play Framework connection pool library from BoneCP to HikariCP, I thought that I should probably use that connection pool with EclipseLink as well.</p>
  
  <p><strong>First question</strong>: Is the connection pool provided by Play meant to be used by me or is that none of my business? I actually do not see any purpose for it, in case I am not using it myself.</p>
  
  <p>Furthermore, I could not find any information on the internet on how to configure HikariCP as my connection pool provider for EclipseLink. Can this be achieved or should I stay with its own connection pool and somehow try to turn off HikariCP?</p>
  
  <p>I am a little lost here with the options. Any comments on my issue? Tell me what I should provide for you to help me resolve the issues.</p>
  
  <p><strong>persistence.xml</strong></p>
  
  <pre><code>&lt;?xml version="1.0" encoding="UTF-8" ?&gt;
  &lt;persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
               version="2.1"&gt;
  
    &lt;persistence-unit name="default" transaction-type="RESOURCE_LOCAL"&gt;
      &lt;provider&gt;org.eclipse.persistence.jpa.PersistenceProvider&lt;/provider&gt;
      &lt;!-- If &lt;non-jta-data-source&gt; is specified, the DB settings are read from application.conf (db.*.jndiName and db.default.*) --&gt;
      &lt;!-- Also, &lt;non-jta-data-source&gt; is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3. --&gt;
      &lt;non-jta-data-source&gt;DefaultDS&lt;/non-jta-data-source&gt;
  
      &lt;!-- Eclipse link needs the classes to be properly declared here whereas hibernate (seemingly) does not. 
      Keep up to date by searching for @Entity and adding all the found classes properly and add the converters. --&gt;
      &lt;class&gt;acm.data.Authorization&lt;/class&gt;     
      &lt;class&gt;acm.data.LocalUser&lt;/class&gt;
      &lt;class&gt;acm.data.ResourceAssignedRole&lt;/class&gt;
      &lt;class&gt;acm.data.UserAssignedRole&lt;/class&gt;
      &lt;class&gt;acm.data.UserRole&lt;/class&gt;
  
      &lt;class&gt;alloc.data.MacroAllocation&lt;/class&gt;
      &lt;class&gt;alloc.data.MicroAllocation&lt;/class&gt;
  
      &lt;class&gt;clf.data.ClientStore&lt;/class&gt;
  
      &lt;class&gt;fco.data.Costs&lt;/class&gt;
      &lt;class&gt;fco.data.CostsSet&lt;/class&gt;
      &lt;class&gt;fco.data.CostsType&lt;/class&gt;
  
      &lt;class&gt;platform.data.DurationConverter&lt;/class&gt;
      &lt;class&gt;platform.data.EnumType&lt;/class&gt;
      &lt;class&gt;platform.data.EnumValue&lt;/class&gt;
      &lt;class&gt;platform.data.Log&lt;/class&gt;
      &lt;class&gt;platform.data.LogSet&lt;/class&gt;
      &lt;class&gt;platform.data.Property&lt;/class&gt;
      &lt;class&gt;platform.data.PropertySet&lt;/class&gt;
      &lt;class&gt;platform.data.IntlStringConverter&lt;/class&gt;
      &lt;class&gt;platform.data.StringLocalDateTimeConverter&lt;/class&gt;
      &lt;class&gt;platform.data.LocalDateConverter&lt;/class&gt;
      &lt;class&gt;platform.data.StringLocalDateConverter&lt;/class&gt;
      &lt;class&gt;platform.data.LocalDateTimeConverter&lt;/class&gt;
      &lt;class&gt;platform.license.License&lt;/class&gt;
  
      &lt;class&gt;pm.data.Indicator&lt;/class&gt;
      &lt;class&gt;pm.data.IndicatorSet&lt;/class&gt;
      &lt;class&gt;pm.data.Phase&lt;/class&gt;
      &lt;class&gt;pm.data.PhaseDependency&lt;/class&gt;
      &lt;class&gt;pm.data.PhaseRequirement&lt;/class&gt;
      &lt;class&gt;pm.data.Project&lt;/class&gt;
      &lt;class&gt;pm.data.ProjectGuideline&lt;/class&gt;
      &lt;class&gt;pm.data.ProjectMember&lt;/class&gt;
      &lt;class&gt;pm.data.ProjectReport&lt;/class&gt;
      &lt;class&gt;pm.data.Request&lt;/class&gt;
      &lt;class&gt;pm.data.RequestSet&lt;/class&gt;
      &lt;class&gt;pm.data.Risk&lt;/class&gt;
      &lt;class&gt;pm.data.RiskSet&lt;/class&gt;
      &lt;class&gt;pm.data.Role&lt;/class&gt;
      &lt;class&gt;pm.data.Scenario&lt;/class&gt;
      &lt;class&gt;pm.data.StatusAndForecast&lt;/class&gt;
      &lt;class&gt;pm.data.StatusAndForecastSet&lt;/class&gt;
  
      &lt;class&gt;resource.data.Absence&lt;/class&gt;
      &lt;class&gt;resource.data.Availability&lt;/class&gt;
      &lt;class&gt;resource.data.Holiday&lt;/class&gt;
      &lt;class&gt;resource.data.HolidayLocale&lt;/class&gt;
      &lt;class&gt;resource.data.Resource&lt;/class&gt;
      &lt;class&gt;resource.data.ResourceGroup&lt;/class&gt;
      &lt;class&gt;resource.data.ResourceLink&lt;/class&gt;
      &lt;class&gt;resource.data.ResourceType&lt;/class&gt;
      &lt;class&gt;resource.data.ResourceTypeLink&lt;/class&gt;
      &lt;class&gt;platform.data.EclipseLinkSessionCustomizer&lt;/class&gt;
      &lt;!-- &lt;exclude-unlisted-classes&gt;false&lt;/exclude-unlisted-classes&gt;--&gt; &lt;!-- Include all classes --&gt;
      &lt;properties&gt;
        &lt;!-- MSSQL --&gt;
        &lt;!--
        &lt;property name="javax.persistence.jdbc.driver"          value="net.sourceforge.jtds.jdbc.Driver"/&gt;
        &lt;property name="javax.persistence.jdbc.url"             value="jdbc:jtds:sqlserver://SVG6030-DBTE-01/projectx_dev;instance=MSSQL2008R2"/&gt;
        &lt;property name="javax.persistence.jdbc.user"            value="projectx_dev"/&gt;
        &lt;property name="javax.persistence.jdbc.password"        value="projectx_pass"/&gt;
         --&gt;
        &lt;!-- Configuring Eclipse Link --&gt;
        &lt;property name="eclipselink.logging.level" value="OFF"/&gt; &lt;!-- How much log should be shown | from: https://wiki.eclipse.org/EclipseLink/Examples/JPA/Logging#Log_Level_Configuration--&gt;
        &lt;property name="eclipselink.logging.level.sql" value="OFF"/&gt; &lt;!-- How to show the sql queries --&gt;
        &lt;property name="eclipselink.target-database" value="SQLServer"/&gt; &lt;!-- What sql database is used | from: http://www.eclipse.org/eclipselink/documentation/2.5/jpa/extensions/p_target_database.htm--&gt;
        &lt;property name="eclipselink.ddl-generation" value="none"/&gt;
        &lt;property name="eclipselink.session.customizer" value="platform.data.EclipseLinkSessionCustomizer"/&gt; &lt;!-- Defines a naming strategy  --&gt;
  
        &lt;!-- Connection pooling for productive systems --&gt; &lt;!-- http://www.eclipse.org/eclipselink/documentation/2.5/jpa/extensions/p_connection_pool.htm --&gt;
        &lt;property name="eclipselink.connection-pool.default.initial" value="50" /&gt;
        &lt;property name="eclipselink.connection-pool.node2.min" value="5"/&gt;
        &lt;property name="eclipselink.connection-pool.node2.max" value="100"/&gt;
        &lt;!-- TODO: Add c3p0 to eclipse link: 
        http://stackoverflow.com/questions/17828377/eclipselink-pooling-equivalent-to-c3po
        http://www.eclipse.org/forums/index.php/t/172073/ --&gt;
  
      &lt;/properties&gt;
    &lt;/persistence-unit&gt;    
  &lt;/persistence&gt; 
  </code></pre>
  
  <p><strong>application.conf</strong></p>
  
  <pre><code># This is the main configuration file for the application.
  # https://www.playframework.com/documentation/latest/ConfigFile
  # ~~~~~
  # Play uses HOCON as its configuration file format.  HOCON has a number
  # of advantages over other config formats, but there are two things that
  # can be used when modifying settings.
  #
  # You can include other configuration files in this main application.conf file:
  #include "extra-config.conf"
  #
  # You can declare variables and substitute for them:
  #mykey = ${some.value}
  #
  # And if an environment variable exists when there is no other subsitution, then
  # HOCON will fall back to substituting environment variable:
  #mykey = ${JAVA_HOME}
  
  
  ## Secret key
  # http://www.playframework.com/documentation/latest/ApplicationSecret
  # ~~~~~
  # The secret key is used to sign Play's session cookie.
  # This must be changed for production, but we don't recommend you change it in this file.
  play.crypto.secret="xxx"
  
  ## Modules
  # https://www.playframework.com/documentation/latest/Modules
  # ~~~~~
  # Control which modules are loaded when Play starts.  Note that modules are
  # the replacement for "GlobalSettings", which are deprecated in 2.5.x.
  # Please see https://www.playframework.com/documentation/latest/GlobalSettings
  # for more information.
  #
  # You can also extend Play functionality by using one of the publically available
  # Play modules: https://playframework.com/documentation/latest/ModuleDirectory
  play.modules {
    # By default, Play will load any class called Module that is defined
    # in the root package (the "app" directory), or you can define them
    # explicitly below.
    # If there are any built-in modules that you want to disable, you can list them here.
    #enabled += my.application.Module
  
    # If there are any built-in modules that you want to disable, you can list them here.
    #disabled += ""
  }
  
  ## IDE
  # https://www.playframework.com/documentation/latest/IDE
  # ~~~~~
  # Depending on your IDE, you can add a hyperlink for errors that will jump you
  # directly to the code location in the IDE in dev mode. The following line makes 
  # use of the IntelliJ IDEA REST interface: 
  #play.editor="http://localhost:63342/api/file/?file=%s&amp;line=%s"
  
  ## Internationalisation
  # https://www.playframework.com/documentation/latest/JavaI18N
  # https://www.playframework.com/documentation/latest/ScalaI18N
  # ~~~~~
  # Play comes with its own i18n settings, which allow the user's preferred language
  # to map through to internal messages, or allow the language to be stored in a cookie.
  play.i18n {
    # The application languages
    langs = [ "en" ]
  
    # Whether the language cookie should be secure or not
    #langCookieSecure = true
  
    # Whether the HTTP only attribute of the cookie should be set to true
    #langCookieHttpOnly = true
  }
  
  ## Play HTTP settings
  # ~~~~~
  play.http {
    ## Router
    # https://www.playframework.com/documentation/latest/JavaRouting
    # https://www.playframework.com/documentation/latest/ScalaRouting
    # ~~~~~
    # Define the Router object to use for this application.
    # This router will be looked up first when the application is starting up,
    # so make sure this is the entry point.
    # Furthermore, it's assumed your route file is named properly.
    # So for an application router like `my.application.Router`,
    # you may need to define a router file `conf/my.application.routes`.
    # Default to Routes in the root package (aka "apps" folder) (and conf/routes)
    #router = my.application.Router
  
    ## Action Creator
    # https://www.playframework.com/documentation/latest/JavaActionCreator
    # ~~~~~
    #actionCreator = null
  
    ## ErrorHandler
    # https://www.playframework.com/documentation/latest/JavaRouting
    # https://www.playframework.com/documentation/latest/ScalaRouting
    # ~~~~~
    # If null, will attempt to load a class called ErrorHandler in the root package,
    #errorHandler = null
  
    ## Filters
    # https://www.playframework.com/documentation/latest/ScalaHttpFilters
    # https://www.playframework.com/documentation/latest/JavaHttpFilters
    # ~~~~~
    # Filters run code on every request. They can be used to perform
    # common logic for all your actions, e.g. adding common headers.
    # Defaults to "Filters" in the root package (aka "apps" folder)
    # Alternatively you can explicitly register a class here.
    #filters = my.application.Filters
  
    ## Session &amp; Flash
    # https://www.playframework.com/documentation/latest/JavaSessionFlash
    # https://www.playframework.com/documentation/latest/ScalaSessionFlash
    # ~~~~~
    session {
      # Sets the cookie to be sent only over HTTPS.
      #secure = true
  
      # Sets the cookie to be accessed only by the server.
      #httpOnly = true
  
      # Sets the max-age field of the cookie to 5 minutes.
      # NOTE: this only sets when the browser will discard the cookie. Play will consider any
      # cookie value with a valid signature to be a valid session forever. To implement a server side session timeout,
      # you need to put a timestamp in the session and check it at regular intervals to possibly expire it.
      #maxAge = 300
  
      # Sets the domain on the session cookie.
      #domain = "example.com"
    }
  
    flash {
      # Sets the cookie to be sent only over HTTPS.
      #secure = true
  
      # Sets the cookie to be accessed only by the server.
      #httpOnly = true
    }
  
    parser {
       maxMemoryBuffer = 1048576
    }
  
    requestHandler = "play.http.DefaultHttpRequestHandler"
  }
  
  ## Netty Provider
  # https://www.playframework.com/documentation/latest/SettingsNetty
  # ~~~~~
  play.server.netty {
    # Whether the Netty wire should be logged
    #log.wire = true
  
    # If you run Play on Linux, you can use Netty's native socket transport
    # for higher performance with less garbage.
    #transport = "native"
  }
  
  ## WS (HTTP Client)
  # https://www.playframework.com/documentation/latest/ScalaWS#Configuring-WS
  # ~~~~~
  # The HTTP client primarily used for REST APIs.  The default client can be
  # configured directly, but you can also create different client instances
  # with customized settings. You must enable this by adding to build.sbt:
  #
  # libraryDependencies += ws // or javaWs if using java
  #
  play.ws {
    # Sets HTTP requests not to follow 302 requests
    #followRedirects = false
  
    # Sets the maximum number of open HTTP connections for the client.
    #ahc.maxConnectionsTotal = 50
  
    ## WS SSL
    # https://www.playframework.com/documentation/latest/WsSSL
    # ~~~~~
    ssl {
      # Configuring HTTPS with Play WS does not require programming.  You can
      # set up both trustManager and keyManager for mutual authentication, and
      # turn on JSSE debugging in development with a reload.
      #debug.handshake = true
      #trustManager = {
      #  stores = [
      #    { type = "JKS", path = "exampletrust.jks" }
      #  ]
      #}
    }
  }
  
  ## Cache
  # https://www.playframework.com/documentation/latest/JavaCache
  # https://www.playframework.com/documentation/latest/ScalaCache
  # ~~~~~
  # Play comes with an integrated cache API that can reduce the operational
  # overhead of repeated requests. You must enable this by adding to build.sbt:
  #
  # libraryDependencies += cache
  #
  play.cache {
    # If you want to bind several caches, you can bind the individually
    #bindCaches = ["db-cache", "user-cache", "session-cache"]
  }
  
  ## Filters
  # https://www.playframework.com/documentation/latest/Filters
  # ~~~~~
  # There are a number of built-in filters that can be enabled and configured
  # to give Play greater security.  You must enable this by adding to build.sbt:
  #
  # libraryDependencies += filters
  #
  play.filters {
    ## CORS filter configuration
    # https://www.playframework.com/documentation/latest/CorsFilter
    # ~~~~~
    # CORS is a protocol that allows web applications to make requests from the browser
    # across different domains.
    # NOTE: You MUST apply the CORS configuration before the CSRF filter, as CSRF has
    # dependencies on CORS settings.
    cors {
      # Filter paths by a whitelist of path prefixes
      #pathPrefixes = ["/some/path", ...]
  
      # The allowed origins. If null, all origins are allowed.
      #allowedOrigins = ["http://www.example.com"]
  
      # The allowed HTTP methods. If null, all methods are allowed
      #allowedHttpMethods = ["GET", "POST"]
    }
  
    ## CSRF Filter
    # https://www.playframework.com/documentation/latest/ScalaCsrf#Applying-a-global-CSRF-filter
    # https://www.playframework.com/documentation/latest/JavaCsrf#Applying-a-global-CSRF-filter
    # ~~~~~
    # Play supports multiple methods for verifying that a request is not a CSRF request.
    # The primary mechanism is a CSRF token. This token gets placed either in the query string
    # or body of every form submitted, and also gets placed in the users session.
    # Play then verifies that both tokens are present and match.
    csrf {
      # Sets the cookie to be sent only over HTTPS
      #cookie.secure = true
  
      # Defaults to CSRFErrorHandler in the root package.
      #errorHandler = MyCSRFErrorHandler
    }
  
    ## Security headers filter configuration
    # https://www.playframework.com/documentation/latest/SecurityHeaders
    # ~~~~~
    # Defines security headers that prevent XSS attacks.
    # If enabled, then all options are set to the below configuration by default:
    headers {
      # The X-Frame-Options header. If null, the header is not set.
      #frameOptions = "DENY"
  
      # The X-XSS-Protection header. If null, the header is not set.
      #xssProtection = "1; mode=block"
  
      # The X-Content-Type-Options header. If null, the header is not set.
      #contentTypeOptions = "nosniff"
  
      # The X-Permitted-Cross-Domain-Policies header. If null, the header is not set.
      #permittedCrossDomainPolicies = "master-only"
  
      # The Content-Security-Policy header. If null, the header is not set.
      #contentSecurityPolicy = "default-src 'self'"
    }
  
    ## Allowed hosts filter configuration
    # https://www.playframework.com/documentation/latest/AllowedHostsFilter
    # ~~~~~
    # Play provides a filter that lets you configure which hosts can access your application.
    # This is useful to prevent cache poisoning attacks.
    hosts {
      # Allow requests to example.com, its subdomains, and localhost:9000.
      #allowed = [".example.com", "localhost:9000"]
    }
  }
  
  ## Evolutions
  # https://www.playframework.com/documentation/latest/Evolutions
  # ~~~~~
  # Evolutions allows database scripts to be automatically run on startup in dev mode
  # for database migrations. You must enable this by adding to build.sbt:
  #
  # libraryDependencies += evolutions
  #
  play.evolutions {
    # You can disable evolutions for a specific datasource if necessary
    #db.default.enabled = false
  }
  
  ## Database Connection Pool
  # https://www.playframework.com/documentation/latest/SettingsJDBC
  # ~~~~~
  # Play doesn't require a JDBC database to run, but you can easily enable one.
  #
  #libraryDependencies += jdbc
  #
  play.db {
    # The combination of these two settings results in "db.default" as the
    # default JDBC pool:
    config = "db"
    default = "default"
  
    # Play uses HikariCP as the default connection pool.  You can override
    # settings by changing the prototype:
    prototype {
      # hikaricp.dataSourceClassName = "default"
      # specify a connectionTestQuery. Only do this if upgrading the JDBC-Driver does not help
      hikaricp.connectionTestQuery = "SELECT 1" # a bug in the driver when used with hikaricp in Play 2.4, workaround from here: https://www.playframework.com/documentation/2.5.x/Migration24
      hikaricp.minimumIdle = 5
      hikaricp.maximumPoolSize = 100
    }
  }
  
  ## JDBC Datasource
  # https://www.playframework.com/documentation/latest/JavaDatabase
  # https://www.playframework.com/documentation/latest/ScalaDatabase
  # ~~~~~
  # Once JDBC datasource is set up, you can work with several different
  # database options:
  #
  # Slick (Scala preferred option): https://www.playframework.com/documentation/latest/PlaySlick
  # JPA (Java preferred option): https://playframework.com/documentation/latest/JavaJPA
  # EBean: https://playframework.com/documentation/latest/JavaEbean
  # Anorm: https://www.playframework.com/documentation/latest/ScalaAnorm
  #
  db {
  
    # You can declare as many datasources as you want.
    # By convention, the default datasource is named `default`
  
    # Microsoft SQL Server (using free/open jTDS driver)
    # The following is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3.
  
    default.jndiName=DefaultDS
  
    # Microsoft SQL Server (using free/open jTDS driver)
    # The following is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3.
  
    # Huenenberg
    default.driver=net.sourceforge.jtds.jdbc.Driver
    default.url="jdbc:jtds:sqlserver://xxx/xxx_dev;instance=MSSQL2008R2"
    default.username=xxx_dev
    default.password=xxx_pass
  
  
    # https://www.playframework.com/documentation/latest/Developing-with-the-H2-Database
    #default.driver = org.h2.Driver
    #default.url = "jdbc:h2:mem:play"
    #default.username = sa
    #default.password = ""
  
    # You can turn on SQL logging for any datasource
    # https://www.playframework.com/documentation/latest/Highlights25#Logging-SQL-statements
    #default.logSql=true
  }
  
  # Akka configuration 
  # ==================
  
  akka {
    # Let Akka use the same logging as Play
    loggers = ["akka.event.slf4j.Slf4jLogger"]
    loglevel = "DEBUG"
    #  This will filter the log events using the backend configuration (e.g. logback.xml) before they are published to the event bus.
    logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"
  
    actor {
      # Timeout for ask(), the max. acceptable value seems to be 30sec anyway.
      typed.timeout=3600000  
  
      # Verify that messages are serializable, only for running tests and to ensure remoting is possible. 
      # It is completely pointless to have it turned on in other scenarios.
      # serialize-messages = on
  
      # Increase timeouts for running tests, the max. timeout seems to be 30sec.
      # test.timefactor=100
  
      default-dispatcher { // Akka default config for Play 2.4 http://doc.akka.io/docs/akka/2.4.9/general/configuration.html#listing-of-the-reference-configuration
        fork-join-executor {
          parallelism-factor = 3.0
          parallelism-max = 64
          task-peeking-mode = FIFO
        }
      }
    } 
  }
  
  # Configuration for sending emails
  smtp {
      host = "xxxx" 
      port = 25 
      debug = false 
      mock = false
  }
  
  # Information about this xxx instance
  pqforce {
      url = "http://localhost:9000/"
      email = "xxx"
  }
  
  # Inactive clustering configuration, see clustering.conf for an alternative active configuration.
  projectx {
    remotes = [ ]
    accesscontrol.provider      = "acm.business.LocalAccessControlServiceImpl",
    accesscontrol.timeout       = 300000,
    accesscontrol.cachesize     = 1000,
    accesscontrol.sessionexpiry = 1200
  }
  </code></pre>