import com.ckkloverdos.convert.Converters.{DefaultConverters => TheDefaultConverters}
import gr.grnet.aquarium.actor.provider.ActorProvider
-import gr.grnet.aquarium.service.{UserEventProcessorService, ResourceEventProcessorService}
+import gr.grnet.aquarium.service.{IMEventProcessorService, ResourceEventProcessorService}
import gr.grnet.aquarium.util.{Lifecycle, Loggable}
import gr.grnet.aquarium.store._
}
}
- private[this] lazy val _userEventStoreM: Maybe[UserEventStore] = {
+ private[this] lazy val _userEventStoreM: Maybe[IMEventStore] = {
props.get(Keys.user_event_store_class) map { className ⇒
- val instance = newInstance[UserEventStore](className)
- logger.info("Overriding UserEventStore provisioning. Implementation given by: %s".format(instance.getClass))
+ val instance = newInstance[IMEventStore](className)
+ logger.info("Overriding IMEventStore provisioning. Implementation given by: %s".format(instance.getClass))
instance
}
}
private[this] lazy val _resEventProc: ResourceEventProcessorService = new ResourceEventProcessorService
- private[this] lazy val _imEventProc: UserEventProcessorService = new UserEventProcessorService
+ private[this] lazy val _imEventProc = new IMEventProcessorService
def get(key: String, default: String = ""): String = props.getOr(key, default)
final val events_store_folder = "events.store.folder"
/**
- * If set to `true`, then an IM event that cannot be parsed to [[gr.grnet.aquarium.logic.events.UserEvent]] is
- * saved to the [[gr.grnet.aquarium.store.UserEventStore]].
+ * If set to `true`, then an IM event that cannot be parsed to [[gr.grnet.aquarium.events.IMEvent]] is
+ * saved to the [[gr.grnet.aquarium.store.IMEventStore]].
*/
final val save_unparsed_event_im = "save.unparsed.event.im"
import gr.grnet.aquarium.user.UserState
import gr.grnet.aquarium.util.json.JsonSupport
-import gr.grnet.aquarium.events.{UserEvent, ResourceEvent}
+import gr.grnet.aquarium.events.{IMEvent, ResourceEvent}
import gr.grnet.aquarium.converter.{PrettyJsonTextFormat, StdConverters}
*
* Note that the prefix `Process` means that no reply is created or needed.
*/
-case class ProcessResourceEvent(rce: ResourceEvent) extends DispatcherMessage
+case class ProcessResourceEvent(rcEvent: ResourceEvent) extends DispatcherMessage
/**
* Dispatcher message that triggers the user event processing pipeline.
*
* Note that the prefix `Process` means that no reply is created or needed.
*/
-case class ProcessUserEvent(ue: UserEvent) extends DispatcherMessage
+case class ProcessUserEvent(imEvent: IMEvent) extends DispatcherMessage
case class AdminRequestPingAll() extends DispatcherMessage
import gr.grnet.aquarium.actor.message.config.user.UserActorInitWithUserId
import gr.grnet.aquarium.actor.message.service.dispatcher._
import message.config.{ActorProviderConfigured, AquariumPropertiesLoaded}
-import gr.grnet.aquarium.events.{WalletEntry, UserEvent}
+import gr.grnet.aquarium.events.{WalletEntry, IMEvent}
/**
//Rebuild state from user events
val usersDB = _configurator.storeProvider.userEventStore
- val userEvents = usersDB.findUserEventsByUserId(_userId)
+ val userEvents = usersDB.findIMEventsByUserId(_userId)
val numUserEvents = userEvents.size
- _userState = replayUserEvents(_userState, userEvents, from, to)
+ _userState = replayIMEvents(_userState, userEvents, from, to)
//Rebuild state from resource events
val eventsDB = _configurator.storeProvider.resourceEventStore
/**
* Replay user events on the provided user state
*/
- def replayUserEvents(initState: UserState, events: List[UserEvent],
+ def replayIMEvents(initState: UserState, events: List[IMEvent],
from: Long, to: Long): UserState = {
initState
}
}
def onProcessResourceEvent(event: ProcessResourceEvent): Unit = {
- val resourceEvent = event.rce
+ val resourceEvent = event.rcEvent
if(resourceEvent.userID != this._userId) {
ERROR("Received %s but my userId = %s".format(event, this._userId))
} else {
}
}
- private[this] def processCreateUser(event: UserEvent): Unit = {
+ private[this] def processCreateUser(event: IMEvent): Unit = {
val userId = event.userID
DEBUG("Creating user from state %s", event)
val usersDB = _configurator.storeProvider.userStateStore
}
}
- private[this] def processModifyUser(event: UserEvent): Unit = {
+ private[this] def processModifyUser(event: IMEvent): Unit = {
val now = TimeHelpers.nowMillis
val newActive = ActiveStateSnapshot(event.isStateActive, now)
}
def onProcessUserEvent(event: ProcessUserEvent): Unit = {
- val userEvent = event.ue
+ val userEvent = event.imEvent
if(userEvent.userID != this._userId) {
ERROR("Received %s but my userId = %s".format(userEvent, this._userId))
} else {
}
def onProcessResourceEvent(m: ProcessResourceEvent): Unit = {
- _forwardToUserActor(m.rce.userID, m)
+ _forwardToUserActor(m.rcEvent.userID, m)
}
def onProcessUserEvent(m: ProcessUserEvent): Unit = {
- _forwardToUserActor(m.ue.userID, m)
+ _forwardToUserActor(m.imEvent.userID, m)
}
override def postStop = {
import converter.{StdConverters, JsonTextFormat}
/**
- * Represents an incoming user event.
+ * Represents an event from the `Identity Management` (IM) external system.
*
* @author Georgios Gousios <gousiosg@gmail.com>
*/
-case class UserEvent(
+case class IMEvent(
override val id: String, // The id at the sender side
override val occurredMillis: Long, // When it occurred at the sender side
override val receivedMillis: Long, // When it was received by Aquarium
role: String,
eventVersion: String,
eventType: String,
- details: UserEvent.Details)
+ details: IMEvent.Details)
extends AquariumEvent(id, occurredMillis, receivedMillis) {
-// assert(eventType.equalsIgnoreCase(UserEvent.EventTypes.create) ||
-// eventType.equalsIgnoreCase(UserEvent.EventTypes.modify))
+// assert(eventType.equalsIgnoreCase(IMEvent.EventTypes.create) ||
+// eventType.equalsIgnoreCase(IMEvent.EventTypes.modify))
// assert(!role.isEmpty)
MasterConfigurator.userStateStore.findUserStateByUserId(userID) match {
case Just(x) =>
- if (eventType.equalsIgnoreCase(UserEvent.EventTypes.create)){
+ if (eventType.equalsIgnoreCase(IMEvent.EventTypes.create)){
logger.warn("User to create exists: IMEvent".format(this.toJson));
return false
}
case NoVal =>
- if (!eventType.equalsIgnoreCase(UserEvent.EventTypes.modify)){
+ if (!eventType.equalsIgnoreCase(IMEvent.EventTypes.modify)){
logger.warn("Inexistent user to modify. IMEvent:".format(this.toJson))
return false
}
def copyWithReceivedMillis(millis: Long) = copy(receivedMillis = millis)
- def isCreateUser = eventType.equalsIgnoreCase(UserEvent.EventTypes.create)
+ def isCreateUser = eventType.equalsIgnoreCase(IMEvent.EventTypes.create)
- def isModifyUser = eventType.equalsIgnoreCase(UserEvent.EventTypes.modify)
+ def isModifyUser = eventType.equalsIgnoreCase(IMEvent.EventTypes.modify)
def isStateActive = isActive
def isStateSuspended = !isActive
}
-object UserEvent {
+object IMEvent {
object EventTypes {
val create = "create"
type Details = Map[String, String]
- def fromJson(json: String): UserEvent = {
- StdConverters.StdConverters.convertEx[UserEvent](JsonTextFormat(json))
+ def fromJson(json: String): IMEvent = {
+ StdConverters.StdConverters.convertEx[IMEvent](JsonTextFormat(json))
}
- def fromBytes(bytes: Array[Byte]): UserEvent = {
- StdConverters.StdConverters.convertEx[UserEvent](JsonTextFormat(makeString(bytes)))
+ def fromBytes(bytes: Array[Byte]): IMEvent = {
+ StdConverters.StdConverters.convertEx[IMEvent](JsonTextFormat(makeString(bytes)))
}
object JsonNames {
package gr.grnet.aquarium.service
+import com.ckkloverdos.maybe.{Maybe, NoVal, Failed, Just}
+
import gr.grnet.aquarium.actor.DispatcherRole
import gr.grnet.aquarium.Configurator.Keys
import gr.grnet.aquarium.store.LocalFSEventStore
import gr.grnet.aquarium.util.makeString
-import com.ckkloverdos.maybe.{Maybe, NoVal, Failed, Just}
import gr.grnet.aquarium.Configurator
import gr.grnet.aquarium.actor.message.service.dispatcher.ProcessUserEvent
-import gr.grnet.aquarium.events.UserEvent
+import gr.grnet.aquarium.events.IMEvent
/**
* An event processor service for user events coming from the IM system
*
* @author Georgios Gousios <gousiosg@gmail.com>
*/
-class UserEventProcessorService extends EventProcessorService[UserEvent] {
+class IMEventProcessorService extends EventProcessorService[IMEvent] {
- override def decode(data: Array[Byte]) = UserEvent.fromBytes(data)
+ override def decode(data: Array[Byte]) = IMEvent.fromBytes(data)
- override def forward(event: UserEvent) = {
+ override def forward(event: IMEvent) = {
if(event ne null) {
_configurator.actorProvider.actorForRole(DispatcherRole) ! ProcessUserEvent(event)
}
}
- override def exists(event: UserEvent) =
- _configurator.userEventStore.findUserEventById(event.id).isJust
+ override def exists(event: IMEvent) =
+ _configurator.userEventStore.findIMEventById(event.id).isJust
- override def persist(event: UserEvent, initialPayload: Array[Byte]) = {
+ override def persist(event: IMEvent, initialPayload: Array[Byte]) = {
Maybe {
- LocalFSEventStore.storeUserEvent(_configurator, event, initialPayload)
+ LocalFSEventStore.storeIMEvent(_configurator, event, initialPayload)
} match {
case Just(_) ⇒
- _configurator.userEventStore.storeUserEvent(event) match {
+ _configurator.userEventStore.storeIMEvent(event) match {
case Just(x) => true
case x: Failed =>
logger.error("Could not save user event: %s".format(event))
protected def persistUnparsed(initialPayload: Array[Byte], exception: Throwable): Unit = {
val json = makeString(initialPayload)
- LocalFSEventStore.storeUnparsedUserEvent(_configurator, initialPayload, exception)
+ LocalFSEventStore.storeUnparsedIMEvent(_configurator, initialPayload, exception)
_configurator.props.getBoolean(Configurator.Keys.save_unparsed_event_im) match {
case Just(true) ⇒
package gr.grnet.aquarium.store
import com.ckkloverdos.maybe.Maybe
-import gr.grnet.aquarium.events.UserEvent
+import gr.grnet.aquarium.events.IMEvent
/**
* Store for external user events
*
* @author Georgios Gousios <gousiosg@gmail.com>
*/
-trait UserEventStore {
+trait IMEventStore {
def storeUnparsed(json: String): Maybe[RecordID]
/**
* Store an event
*/
- def storeUserEvent(event: UserEvent): Maybe[RecordID]
+ def storeIMEvent(event: IMEvent): Maybe[RecordID]
/**
* Find a user event by event ID
*/
- def findUserEventById(id: String): Maybe[UserEvent]
+ def findIMEventById(id: String): Maybe[IMEvent]
/**
* Find all user events by user ID
*/
- def findUserEventsByUserId(userId: String): List[UserEvent]
+ def findIMEventsByUserId(userId: String): List[IMEvent]
}
\ No newline at end of file
import gr.grnet.aquarium.util.{Loggable, stringOfStackTrace}
import gr.grnet.aquarium.util.date.{TimeHelpers, MutableDateCalc}
import gr.grnet.aquarium.simulation.uid.{EAIOUUIDGenerator, UIDGenerator}
-import gr.grnet.aquarium.events.{UserEvent, ResourceEvent}
+import gr.grnet.aquarium.events.{IMEvent, ResourceEvent}
/**
* This is used whenever the property `events.store.folder` is setup in aquarium configuration.
*
- * The public methods guarantee they will not propagate any failure.
- *
* @author Christos KK Loverdos <loverdos@gmail.com>
*/
logger.debug("Wrote to file {}", file.getCanonicalPath)
}
- private[this] def resourceEventsFolder(root: File): File = {
+ private[this] def createResourceEventsFolder(root: File): File = {
val folder = new File(root, "rc")
folder.mkdirs()
folder
}
- private[this] def userEventsFolder(root: File): File = {
+ private[this] def createIMEventsFolder(root: File): File = {
val folder = new File(root, "im")
folder.mkdirs()
folder
val uid = UIDGen.nextUID()
val occurredMDC = new MutableDateCalc(TimeHelpers.nowMillis)
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
- val rcEventsFolder = resourceEventsFolder(root)
+ val rcEventsFolder = createResourceEventsFolder(root)
val trace = stringOfStackTrace(exception)
writeJson("rc", rcEventsFolder, initialPayload, occurredString, uid, None, false, Some(trace))
val occurredMDC = new MutableDateCalc(event.occurredMillis)
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
- val rcEventsFolder = resourceEventsFolder(root)
+ val rcEventsFolder = createResourceEventsFolder(root)
// Store parsed file
writeJson(
}
}
- def storeUnparsedUserEvent(mc: Configurator, initialPayload: Array[Byte], exception: Throwable): Unit = {
+ def storeUnparsedIMEvent(mc: Configurator, initialPayload: Array[Byte], exception: Throwable): Unit = {
for(root <- mc.eventsStoreFolder) {
val uid = UIDGen.nextUID()
val occurredMDC = new MutableDateCalc(TimeHelpers.nowMillis)
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
- val rcEventsFolder = userEventsFolder(root)
+ val imEventsFolder = createIMEventsFolder(root)
val trace = stringOfStackTrace(exception)
- writeJson("im", rcEventsFolder, initialPayload, occurredString, uid, None, false, Some(trace))
+ writeJson("im", imEventsFolder, initialPayload, occurredString, uid, None, false, Some(trace))
}
}
- def storeUserEvent(mc: Configurator, event: UserEvent, initialPayload: Array[Byte]): Unit = {
- require(event ne null, "User event must be not null")
+ def storeIMEvent(mc: Configurator, event: IMEvent, initialPayload: Array[Byte]): Unit = {
+ require(event ne null, "IM event must be not null")
for(root <- mc.eventsStoreFolder) {
val uid = UIDGen.nextUID()
val occurredMDC = new MutableDateCalc(event.occurredMillis)
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
- val imEventsFolder = userEventsFolder(root)
+ val imEventsFolder = createIMEventsFolder(root)
writeJson(
"im",
def userStateStore: UserStateStore
def resourceEventStore: ResourceEventStore
def walletEntryStore: WalletEntryStore
- def userEventStore: UserEventStore
+ def userEventStore: IMEventStore
def policyStore: PolicyStore
}
\ No newline at end of file
import gr.grnet.aquarium.user.UserState
import gr.grnet.aquarium.simulation.uid.ConcurrentVMLocalUIDGenerator
import gr.grnet.aquarium.{AquariumException, Configurable}
-import gr.grnet.aquarium.events.{UserEvent, WalletEntry, ResourceEvent, PolicyEntry}
+import gr.grnet.aquarium.events.{IMEvent, WalletEntry, ResourceEvent, PolicyEntry}
/**
* An implementation of various stores that persists data in memory.
class MemStore extends UserStateStore
with Configurable with PolicyStore
- with ResourceEventStore with UserEventStore
+ with ResourceEventStore with IMEventStore
with WalletEntryStore
with StoreProvider {
private[this] var _resourceEvents = List[ResourceEvent]()
private[this] val walletEntriesById: ConcurrentMap[String, WalletEntry] = new ConcurrentHashMap[String, WalletEntry]()
- private val userEventById: ConcurrentMap[String, UserEvent] = new ConcurrentHashMap[String, UserEvent]()
+ private[this] val imEventById: ConcurrentMap[String, IMEvent] = new ConcurrentHashMap[String, IMEvent]()
def configure(props: Props) = {
}
val map = Map(
"UserState" -> _userStates.size,
"ResourceEvent" -> _resourceEvents.size,
- "UserEvent" -> userEventById.size,
+ "IMEvent" -> imEventById.size,
"PolicyEntry" -> _policyEntries.size,
"WalletEntry" -> walletEntriesById.size
)
}
//- ResourceEventStore
- //+ UserEventStore
+ //+ IMEventStore
def storeUnparsed(json: String) = throw new AquariumException("Not implemented")
- def storeUserEvent(event: UserEvent) = {userEventById += (event.id -> event); Just(RecordID(event.id))}
+ def storeIMEvent(event: IMEvent) = {imEventById += (event.id -> event); Just(RecordID(event.id))}
- def findUserEventById(id: String) = Maybe{userEventById.getOrElse(id, null)}
+ def findIMEventById(id: String) = Maybe{imEventById.getOrElse(id, null)}
- def findUserEventsByUserId(userId: String) = userEventById.valuesIterator.filter{v => v.userID == userId}.toList
- //- UserEventStore
+ def findIMEventsByUserId(userId: String) = imEventById.valuesIterator.filter{v => v.userID == userId}.toList
+ //- IMEventStore
def loadPolicyEntriesAfter(after: Long) =
_policyEntries.filter(p => p.validFrom > after)
import collection.mutable.ListBuffer
import gr.grnet.aquarium.store._
import gr.grnet.aquarium.events.ResourceEvent.{JsonNames => ResourceJsonNames}
-import gr.grnet.aquarium.events.UserEvent.{JsonNames => UserEventJsonNames}
+import gr.grnet.aquarium.events.IMEvent.{JsonNames => UserEventJsonNames}
import gr.grnet.aquarium.events.WalletEntry.{JsonNames => WalletJsonNames}
import gr.grnet.aquarium.events.PolicyEntry.{JsonNames => PolicyJsonNames}
import java.util.Date
extends ResourceEventStore
with UserStateStore
with WalletEntryStore
- with UserEventStore
+ with IMEventStore
with PolicyStore
with Loggable {
}
//-WalletEntryStore
- //+UserEventStore
+ //+IMEventStore
def storeUnparsed(json: String): Maybe[RecordID] = {
MongoDBStore.storeJustJson(json, unparsedUserEvents)
}
- def storeUserEvent(event: UserEvent): Maybe[RecordID] =
- MongoDBStore.storeAny[UserEvent](event, userEvents, UserEventJsonNames.userID,
+ def storeIMEvent(event: IMEvent): Maybe[RecordID] =
+ MongoDBStore.storeAny[IMEvent](event, userEvents, UserEventJsonNames.userID,
_.userID, MongoDBStore.jsonSupportToDBObject)
- def findUserEventById(id: String): Maybe[UserEvent] =
- MongoDBStore.findById[UserEvent](id, userEvents, MongoDBStore.dbObjectToUserEvent)
+ def findIMEventById(id: String): Maybe[IMEvent] =
+ MongoDBStore.findById[IMEvent](id, userEvents, MongoDBStore.dbObjectToUserEvent)
- def findUserEventsByUserId(userId: String): List[UserEvent] = {
+ def findIMEventsByUserId(userId: String): List[IMEvent] = {
val query = new BasicDBObject(UserEventJsonNames.userID, userId)
MongoDBStore.runQuery(query, userEvents)(MongoDBStore.dbObjectToUserEvent)(Some(_sortByTimestampAsc))
}
- //-UserEventStore
+ //-IMEventStore
//+PolicyStore
def loadPolicyEntriesAfter(after: Long): List[PolicyEntry] = {
final val USER_STATES_COLLECTION = "userstates"
/**
- * Collection holding [[gr.grnet.aquarium.events.UserEvent]]s.
+ * Collection holding [[gr.grnet.aquarium.events.IMEvent]]s.
*
* User events are coming from the IM module (external).
*/
final val USER_EVENTS_COLLECTION = "userevents"
/**
- * Collection holding [[gr.grnet.aquarium.events.UserEvent]]s that could not be parsed to normal objects.
+ * Collection holding [[gr.grnet.aquarium.events.IMEvent]]s that could not be parsed to normal objects.
*
* We of course assume at least a valid JSON representation.
*
WalletEntry.fromJson(JSON.serialize(dbObj))
}
- def dbObjectToUserEvent(dbObj: DBObject): UserEvent = {
- UserEvent.fromJson(JSON.serialize(dbObj))
+ def dbObjectToUserEvent(dbObj: DBObject): IMEvent = {
+ IMEvent.fromJson(JSON.serialize(dbObj))
}
def dbObjectToPolicyEntry(dbObj: DBObject): PolicyEntry = {
import gr.grnet.aquarium.logic.accounting.dsl.DSLAgreement
import com.ckkloverdos.maybe.{Failed, Maybe}
import gr.grnet.aquarium.util.date.MutableDateCalc
-import gr.grnet.aquarium.events.{UserEvent, NewWalletEntry, WalletEntry}
+import gr.grnet.aquarium.events.{IMEvent, NewWalletEntry, WalletEntry}
import gr.grnet.aquarium.converter.{JsonTextFormat, StdConverters}
final val NoSpecificChangeCode = 2
final val MonthlyBillingCode = 3
final val RealtimeBillingCode = 4
- final val UserEventArrivalCode = 5
+ final val IMEventArrivalCode = 5
}
case object InitialUserStateCalculation extends UserStateChangeReason {
def code = UserStateChangeReasonCodes.RealtimeBillingCode
}
-case class UserEventArrival(userEvent: UserEvent) extends UserStateChangeReason {
+case class IMEventArrival(imEvent: IMEvent) extends UserStateChangeReason {
def shouldStoreUserState = true
def shouldStoreCalculatedWalletEntries = false
def calculateCreditsForImplicitlyTerminated = false
- def code = UserStateChangeReasonCodes.UserEventArrivalCode
+ def code = UserStateChangeReasonCodes.IMEventArrivalCode
}
[DEBUG] 2012-02-13 12:54:53,668 main - findUserStateAtEndOfBillingMonth(2011-10) END
[DEBUG] 2012-02-13 12:54:53,672 main - doFullMonthlyBilling(2011-11) previousResourceEvents = LatestResourceEventsWorker(Map())
[DEBUG] 2012-02-13 12:54:53,673 main - doFullMonthlyBilling(2011-11) theImplicitOFFs = ImplicitlyIssuedResourceEventsWorker(Map())
- [DEBUG] 2012-02-13 12:54:53,680 main - doFullMonthlyBilling(2011-11) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, UserEvent -> 0))
+ [DEBUG] 2012-02-13 12:54:53,680 main - doFullMonthlyBilling(2011-11) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, IMEvent -> 0))
[DEBUG] 2012-02-13 12:54:53,681 main - doFullMonthlyBilling(2011-11) Found 0 resource events, starting processing...
[DEBUG] 2012-02-13 12:54:53,683 main - doFullMonthlyBilling(2011-11) END
[DEBUG] 2012-02-13 12:54:53,683 main - findUserStateAtEndOfBillingMonth(2011-11) END
[DEBUG] 2012-02-13 12:54:53,684 main - doFullMonthlyBilling(2011-12) previousResourceEvents = LatestResourceEventsWorker(Map())
[DEBUG] 2012-02-13 12:54:53,684 main - doFullMonthlyBilling(2011-12) theImplicitOFFs = ImplicitlyIssuedResourceEventsWorker(Map())
- [DEBUG] 2012-02-13 12:54:53,685 main - doFullMonthlyBilling(2011-12) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, UserEvent -> 0))
+ [DEBUG] 2012-02-13 12:54:53,685 main - doFullMonthlyBilling(2011-12) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, IMEvent -> 0))
[DEBUG] 2012-02-13 12:54:53,686 main - doFullMonthlyBilling(2011-12) Found 0 resource events, starting processing...
[DEBUG] 2012-02-13 12:54:53,686 main - doFullMonthlyBilling(2011-12) END
[DEBUG] 2012-02-13 12:54:53,687 main - findUserStateAtEndOfBillingMonth(2011-12) END
[DEBUG] 2012-02-13 12:54:53,687 main - doFullMonthlyBilling(2012-01) previousResourceEvents = LatestResourceEventsWorker(Map())
[DEBUG] 2012-02-13 12:54:53,688 main - doFullMonthlyBilling(2012-01) theImplicitOFFs = ImplicitlyIssuedResourceEventsWorker(Map())
- [DEBUG] 2012-02-13 12:54:53,688 main - doFullMonthlyBilling(2012-01) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, UserEvent -> 0))
+ [DEBUG] 2012-02-13 12:54:53,688 main - doFullMonthlyBilling(2012-01) resourceEventStore = MemStore(Map(UserState -> 0, WalletEntry -> 0, ResourceEvent -> 5, PolicyEntry -> 0, IMEvent -> 0))
[DEBUG] 2012-02-13 12:54:53,689 main - doFullMonthlyBilling(2012-01) Found 4 resource events, starting processing...
[DEBUG] 2012-02-13 12:54:53,690 main - doFullMonthlyBilling(2012-01) Processing EVENT(2, [2012-01-01 03:00:00.000], 99.0 [MB/Hr], diskspace::pithos/diskspace/DISK.1, Map(), Christos, pithos)
[DEBUG] 2012-02-13 12:54:53,691 main - doFullMonthlyBilling(2012-01) 0 previousResourceEvents
import akka.amqp._
import util.Random
-import gr.grnet.aquarium.events.{UserEvent, ResourceEvent}
+import gr.grnet.aquarium.events.{IMEvent, ResourceEvent}
import scopt.OptionParser
import gr.grnet.aquarium.messaging.AkkaAMQP
import java.lang.StringBuffer
/**
* Generate a random resource event
*/
- def nextUserEvent(): UserEvent = {
+ def nextUserEvent(): IMEvent = {
val ts = tsFrom + (scala.math.random * ((tsTo - tsFrom) + 1)).asInstanceOf[Long]
- UserEvent(
+ IMEvent(
id = CryptoUtils.sha1(genRndAsciiString(35)),
occurredMillis = ts.toLong,
receivedMillis = ts.toLong,
userIds.filter(_ < num).foreach {
i =>
val ts = tsFrom + (scala.math.random * ((tsTo - tsFrom) + 1)).asInstanceOf[Long]
- val user = UserEvent(
+ val user = IMEvent(
id = CryptoUtils.sha1(genRndAsciiString(35)),
occurredMillis = ts.toLong,
receivedMillis = ts.toLong,
projects / aquarium / commitdiff