diff --git a/commons/config/src/main/scala/net/shrine/config/AtomicConfigSource.scala b/commons/config/src/main/scala/net/shrine/config/AtomicConfigSource.scala
index 67956ea27..bed19b096 100644
--- a/commons/config/src/main/scala/net/shrine/config/AtomicConfigSource.scala
+++ b/commons/config/src/main/scala/net/shrine/config/AtomicConfigSource.scala
@@ -1,52 +1,59 @@
package net.shrine.config
import java.util.concurrent.atomic.AtomicReference
import com.typesafe.config.{ConfigFactory, Config}
import scala.util.{Failure, Success, Try}
/**
* Use to inject a new config without clearing and reloading a new config (for testing).
*
* @author david
* @since 4/29/15
*/
class AtomicConfigSource(baseConfig:Config) {
val atomicConfigRef = new AtomicReference[Config](ConfigFactory.empty())
/**
* Get the Atomic Config. Be sure to use defs for all config values that might be changed.
*/
def config:Config = {
atomicConfigRef.get().withFallback(baseConfig)
}
def configForBlock[T](key:String,value:AnyRef,origin:String)(block: => T):T = {
val configPairs = Map(key -> value)
configForBlock(configPairs,origin)(block)
}
def configForBlock[T](configPairs:Map[String, _ <: AnyRef],origin:String)(block: => T):T = {
import scala.collection.JavaConverters.mapAsJavaMapConverter
val configPairsJava:java.util.Map[String, _ <: AnyRef] = configPairs.asJava
val blockConfig:Config = ConfigFactory.parseMap(configPairsJava,origin)
- val originalConfig:Config = atomicConfigRef.getAndSet(blockConfig)
+
+ configForBlock(blockConfig,origin)(block)
+ }
+
+ def configForBlock[T](config:Config,origin:String)(block: => T):T = {
+
+ val originalConfig:Config = atomicConfigRef.getAndSet(config)
val tryT:Try[T] = Try(block)
- val ok = atomicConfigRef.compareAndSet(blockConfig,originalConfig)
+ val ok = atomicConfigRef.compareAndSet(config,originalConfig)
tryT match {
case Success(t) => {
if(ok) t
- else throw new IllegalStateException(s"Expected config from ${blockConfig.origin()} to be from ${atomicConfigRef.get().origin()} instead.")
+ else throw new IllegalStateException(s"Expected config from ${config.origin()} to be from ${atomicConfigRef.get().origin()} instead.")
}
case Failure(x) => {
if(ok) throw x
- else throw new IllegalStateException(s"Throwable in block and expected config from ${blockConfig.origin()} to be from ${atomicConfigRef.get().origin()} instead.",x)
+ else throw new IllegalStateException(s"Throwable in block and expected config from ${config.origin()} to be from ${atomicConfigRef.get().origin()} instead.",x)
}
}
}
+
}
diff --git a/qep/service/src/main/scala/net/shrine/qep/QepConfigSource.scala b/qep/service/src/main/scala/net/shrine/qep/QepConfigSource.scala
index 9d4789fdd..2f3b02d60 100644
--- a/qep/service/src/main/scala/net/shrine/qep/QepConfigSource.scala
+++ b/qep/service/src/main/scala/net/shrine/qep/QepConfigSource.scala
@@ -1,39 +1,43 @@
package net.shrine.qep
import com.typesafe.config.{Config, ConfigFactory}
import net.shrine.config.AtomicConfigSource
import net.shrine.log.Log
/**
* Source of config for the Qep. Put new config fields here, not in QepConfig, to enable Config-based apply() methods.
*
* @author david
* @since 8/18/15
*/
object QepConfigSource {
val atomicConfig = new AtomicConfigSource(ConfigFactory.load("shrine"))
def config:Config = {
atomicConfig.config
}
Log.debug(s"shrine.queryEntryPoint.audit.collectQepAudit is ${config.getBoolean("shrine.queryEntryPoint.audit.collectQepAudit")}")
def configForBlock[T](key:String,value:AnyRef,origin:String)(block: => T):T = {
atomicConfig.configForBlock(key,value,origin)(block)
}
-//todo move this to common code somewhere
+ def configForBlock[T](config:Config,origin:String)(block: => T):T = {
+ atomicConfig.configForBlock(config,origin)(block)
+ }
+
+ //todo move this to common code somewhere
def objectForName[T](objectName:String):T = {
import scala.reflect.runtime.universe
val runtimeMirror = universe.runtimeMirror(getClass.getClassLoader)
val module = runtimeMirror.staticModule(objectName)
val reflectedObj = runtimeMirror.reflectModule(module)
val obj = reflectedObj.instance
obj.asInstanceOf[T]
}
}
\ No newline at end of file
diff --git a/tools/adapter-queries-to-qep/src/main/scala/net/shrine/utilities/adapterqueriestoqep/AdapterQueriesToQep.scala b/tools/adapter-queries-to-qep/src/main/scala/net/shrine/utilities/adapterqueriestoqep/AdapterQueriesToQep.scala
index 789f3e7c3..dfcd07318 100644
--- a/tools/adapter-queries-to-qep/src/main/scala/net/shrine/utilities/adapterqueriestoqep/AdapterQueriesToQep.scala
+++ b/tools/adapter-queries-to-qep/src/main/scala/net/shrine/utilities/adapterqueriestoqep/AdapterQueriesToQep.scala
@@ -1,86 +1,91 @@
package net.shrine.utilities.adapterqueriestoqep
import java.io.File
import javax.sql.DataSource
import javax.xml.datatype.XMLGregorianCalendar
import com.typesafe.config.{Config, ConfigFactory}
import net.shrine.adapter.dao.AdapterDao
import net.shrine.adapter.dao.model.ShrineQuery
import net.shrine.adapter.dao.squeryl.SquerylAdapterDao
import net.shrine.dao.squeryl.{DataSourceSquerylInitializer, SquerylInitializer, SquerylDbAdapterSelecter}
import net.shrine.adapter.dao.squeryl.tables.{Tables => AdapterTables}
import net.shrine.protocol.ResultOutputTypes
+import net.shrine.qep.QepConfigSource
import net.shrine.qep.queries.{QepQueryDb, QepQuery, QepQueryFlag}
import net.shrine.slick.TestableDataSourceCreator
import org.squeryl.internals.DatabaseAdapter
import net.shrine.config.ConfigExtensions
/**
* @author dwalend
* @since 1.21
*/
object AdapterQueriesToQep {
def main(args: Array[String]): Unit = {
if(args.length < 3) throw new IllegalArgumentException("Requires three arguments: the domain to transfer, the full path to the adapter-queries-to-qep.conf file, and the full path to the shrine.conf file.")
val domain = args(0)
val localConfig = args(1)
val shrineConfig = args(2)
val config: Config = ConfigFactory.parseFile(new File(localConfig)).withFallback(ConfigFactory.parseFile(new File(shrineConfig))).withFallback(ConfigFactory.load())
+// println(config)
+
val adapterDataSource: DataSource = TestableDataSourceCreator.dataSource(config.getConfig("shrine.adapter.query.database"))
val squerylAdapter: DatabaseAdapter = SquerylDbAdapterSelecter.determineAdapter(config.getString("shrine.shrineDatabaseType"))
val squerylInitializer: SquerylInitializer = new DataSourceSquerylInitializer(adapterDataSource, squerylAdapter)
val squerylAdapterTables: AdapterTables = new AdapterTables
val breakdownTypes = config.getOptionConfigured("breakdownResultOutputTypes",ResultOutputTypes.fromConfig).getOrElse(Set.empty)
val adapterDao: AdapterDao = new SquerylAdapterDao(squerylInitializer, squerylAdapterTables)(breakdownTypes)
val adapterQueries: Seq[ShrineQuery] = adapterDao.findQueriesByDomain(domain)
- println(s"Found ${adapterQueries.mkString(",\n")}")
+// println(s"Found ${adapterQueries.mkString(",\n")}")
- //todo filter out any queries that already exist
+ QepConfigSource.configForBlock(config,getClass.getSimpleName) {
- //turn each ShrineQuery into a QepQuery and store it
- adapterQueries.map(shrineQueryToQepQuery).foreach(QepQueryDb.db.insertQepQuery)
+ //turn each ShrineQuery into a QepQuery and store it
+ //todo filter out any queries that already exist
+ adapterQueries.map(shrineQueryToQepQuery).foreach(QepQueryDb.db.insertQepQuery)
- //todo only carry over flags for queries that don't already have flag entries
+ //todo only carry over flags for queries that don't already have flag entries
- //make flags for each ShrineQuery and store that
- adapterQueries.flatMap(shrineQueryToQepQueryFlag).foreach(QepQueryDb.db.insertQepQueryFlag)
+ //make flags for each ShrineQuery and store that
+ adapterQueries.flatMap(shrineQueryToQepQueryFlag).foreach(QepQueryDb.db.insertQepQueryFlag)
+ }
}
def shrineQueryToQepQuery(shrineQuery: ShrineQuery):QepQuery = {
val date:Long = toMillis(shrineQuery.dateCreated)
new QepQuery(
networkId = shrineQuery.networkId,
userName = shrineQuery.username,
userDomain = shrineQuery.domain,
queryName = shrineQuery.name,
expression = shrineQuery.queryDefinition.expr.fold("")(expression => expression.toXml.text),
dateCreated = date,
deleted = false,
queryXml = shrineQuery.queryDefinition.toXml.text,
changeDate = date
)
}
def shrineQueryToQepQueryFlag(shrineQuery: ShrineQuery):Option[QepQueryFlag] = {
if(shrineQuery.isFlagged){
Some(new QepQueryFlag(
networkQueryId = shrineQuery.networkId,
flagged = shrineQuery.isFlagged,
flagMessage = shrineQuery.flagMessage.getOrElse(""),
changeDate = toMillis(shrineQuery.dateCreated)
))
}
else None
}
private def toMillis(xmlGc: XMLGregorianCalendar): Long = xmlGc.toGregorianCalendar.getTimeInMillis
}
\ No newline at end of file