import RESTPaths.{UserBalancePath, UserStatePath, AdminPingAll}
import com.ckkloverdos.maybe.{NoVal, Just}
import message.service.dispatcher._
+import gr.grnet.aquarium.util.date.TimeHelpers
/**
* Spray-based REST service. This is the outer-world's interface to Aquarium functionality.
protected def receive = {
case RequestContext(HttpRequest(GET, "/ping", _, _, _), _, responder) ⇒
- responder.complete(stringResponse200("{\"pong\": %s}".format(System.currentTimeMillis())))
+ responder.complete(stringResponse200("{\"pong\": %s}".format(TimeHelpers.nowMillis)))
case RequestContext(HttpRequest(GET, "/stats", _, _, _), _, responder) ⇒ {
(serverActor ? GetStats).mapTo[Stats].onComplete {
case RequestContext(HttpRequest(GET, uri, headers, body, protocol), _, responder) ⇒
//+ Main business logic REST URIs are matched here
- val millis = System.currentTimeMillis()
+ val millis = TimeHelpers.nowMillis
uri match {
case UserBalancePath(userId) ⇒
callDispatcher(RequestUserBalance(userId, millis), responder)
* Replay the event log for all events that affect the user state.
*/
def rebuildState(from: Long, to: Long): Unit = {
- val start = System.currentTimeMillis()
+ val start = TimeHelpers.nowMillis
if(_userState == null)
createBlankState
"%d resource events, %d wallet entries) in %d msec").format(
numUserEvents + numResourceEvents + numWalletEntries,
numUserEvents, numResourceEvents, numWalletEntries,
- System.currentTimeMillis() - start))
+ TimeHelpers.nowMillis - start))
}
/**
val userId = event.userId
val timestamp = event.timestamp
- if(System.currentTimeMillis() - _userState.newestSnapshotTime > 60 * 1000) {
+ if(TimeHelpers.nowMillis - _userState.newestSnapshotTime > 60 * 1000) {
// calcWalletEntries()
}
self reply UserResponseGetBalance(userId, _userState.creditsSnapshot.creditAmount)
import collection.immutable.SortedMap
import java.util.Date
import com.ckkloverdos.maybe.{NoVal, Maybe, Failed, Just}
-import gr.grnet.aquarium.util.date.MutableDateCalc
import gr.grnet.aquarium.util.{ContextualLogger, CryptoUtils, Loggable}
import gr.grnet.aquarium.store.PolicyStore
import gr.grnet.aquarium.AquariumException
import gr.grnet.aquarium.events.{WalletEntry, ResourceEvent}
+import gr.grnet.aquarium.util.date.{TimeHelpers, MutableDateCalc}
/**
* A timeslot together with the algorithm and unit price that apply for this particular timeslot.
*/
val chargeChunks = calcChangeChunks(agr, amount, dslResource, timeslot)
- val timeReceived = System.currentTimeMillis
+ val timeReceived = TimeHelpers.nowMillis
val rel = event.id :: related.map{x => x.sourceEventIDs}.flatten
def id(): String =
CryptoUtils.sha1("%f%s%f%s%s%d".format(value, algorithm, price, when.toString,
- resource.name, System.currentTimeMillis()))
+ resource.name, TimeHelpers.nowMillis))
}
/** An exception raised when something goes wrong with accounting */
import gr.grnet.aquarium.Configurator
import com.ckkloverdos.maybe._
import gr.grnet.aquarium.events.AquariumEvent
+import gr.grnet.aquarium.util.date.TimeHelpers
/**
* An abstract service that retrieves Aquarium events from a queue,
persisterManager.lb ! Persist(event, payload, queueReaderManager.lb, AckData(event.id, deliveryTag, queue.get))
}
} else {
- val eventWithReceivedMillis = event.copyWithReceivedMillis(System.currentTimeMillis()).asInstanceOf[E]
+ val eventWithReceivedMillis = event.copyWithReceivedMillis(TimeHelpers.nowMillis).asInstanceOf[E]
persisterManager.lb ! Persist(eventWithReceivedMillis, payload, queueReaderManager.lb, AckData(event.id, deliveryTag, queue.get))
}
def receive = {
case Persist(event, initialPayload, sender, ackData) ⇒
logger.debug("Persister-%s attempting store".format(self.getUuid()))
- //val time = System.currentTimeMillis()
+ //val time = TimeHelpers.nowMillis
if(exists(event))
sender ! Duplicate(ackData)
else if(persist(event, initialPayload)) {
- //logger.debug("Persist time: %d ms".format(System.currentTimeMillis() - time))
+ //logger.debug("Persist time: %d ms".format(TimeHelpers.nowMillis - time))
sender ! PersistOK(ackData)
} else
sender ! PersistFailed(ackData)
import org.junit.Assume._
import gr.grnet.aquarium.LogicTestsAssumptions
import gr.grnet.aquarium.logic.accounting.dsl._
+import gr.grnet.aquarium.util.date.TimeHelpers
/**
* Performance tests for various critical path functions.
assumeTrue(LogicTestsAssumptions.EnablePerfTests)
val iter = 1000
- var start = System.currentTimeMillis()
+ var start = TimeHelpers.nowMillis
var numResolved = 0
val from = new Date(0)
numResolved += allEffectiveTimeslots(tf, Timeslot(new Date(min), new Date(max))).size
}
- var total = System.currentTimeMillis() - start
+ var total = TimeHelpers.nowMillis - start
print("allEffectiveTimeslots: %d calls in %s msec. (%s resolved)\n".format(iter, total, numResolved))
}
}
\ No newline at end of file
//Touch the file to trigger reloading with non changed state
Thread.sleep(200)
- f.setLastModified(System.currentTimeMillis)
+ f.setLastModified(TimeHelpers.nowMillis)
var polNew = Policy.reloadPolicies
assertEquals(pol.keys.size, polNew.keys.size)