sourceEventIDs = rel,
value = c.cost,
reason = c.reason,
- userId = event.userId,
+ userId = event.userID,
resource = event.resource,
- instanceId = event.instanceId,
+ instanceId = event.instanceID,
finalized = isFinal
)
}
def currentResourceEvent = resourceEvents.head
def resource = currentResourceEvent.resource
- def instanceId = currentResourceEvent.instanceId
+ def instanceId = currentResourceEvent.instanceID
def chargslotCount = chargeslots.length
def isOutOfSync = currentResourceEvent.isOutOfSyncForBillingMonth(yearOfBillingMonth, billingMonth)
override val id: String, // The id at the client side (the sender) TODO: Rename to remoteId or something...
override val occurredMillis: Long, // When it occurred at client side (the sender)
override val receivedMillis: Long, // When it was received by Aquarium
- userId: String, // The user for which this resource is relevant
- clientId: String, // The unique client identifier (usually some hash)
+ userID: String, // The user for which this resource is relevant
+ clientID: String, // The unique client identifier (usually some hash)
resource: String, // String representation of the resource type (e.g. "bndup", "vmtime").
- instanceId: String, // String representation of the resource instance id
+ instanceID: String, // String representation of the resource instance id
eventVersion: String,
value: Double,
details: ResourceEvent.Details)
}
def safeResource = if(resource eq null) "" else resource
- def safeInstanceId = if(instanceId eq null) "" else instanceId
+ def safeInstanceId = if(instanceID eq null) "" else instanceID
def hasResource = !safeResource.isEmpty
def hasInstanceId = !safeInstanceId.isEmpty
}
def toDebugString(useOnlyInstanceId: Boolean = false): String = {
- val instanceInfo = if(useOnlyInstanceId) instanceId else "%s::%s".format(resource, instanceId)
+ val instanceInfo = if(useOnlyInstanceId) instanceID else "%s::%s".format(resource, instanceID)
val occurredFormatted = new MutableDateCalc(occurredMillis).toYYYYMMDDHHMMSS
if(occurredMillis == receivedMillis) {
"%sEVENT(%s, [%s], %s, %s, %s, %s, %s)".format(
value,
instanceInfo,
details,
- userId,
- clientId
+ userID,
+ clientID
)
} else {
"%sEVENT(%s, [%s], [%s], %s, %s, %s, %s, %s)".format(
value,
instanceInfo,
details,
- userId,
- clientId
+ userID,
+ clientID
)
}
}
"rc-%s-[%s]-[%s]-[%s]-[%s].%s.json".format(
occurredString,
event.id,
- event.userId,
+ event.userID,
event.resource,
- event.instanceId,
+ event.instanceID,
uid))
writeToFile(parsedJsonFile, event.toJson)
def findResourceEventsByUserId(userId: String)
(sortWith: Option[(ResourceEvent, ResourceEvent) => Boolean]): List[ResourceEvent] = {
- val byUserId = _resourceEvents.filter(_.userId == userId).toArray
+ val byUserId = _resourceEvents.filter(_.userID == userId).toArray
val sorted = sortWith match {
case Some(sorter) ⇒
byUserId.sortWith(sorter)
def findResourceEventsByUserIdAfterTimestamp(userId: String, timestamp: Long): List[ResourceEvent] = {
_resourceEvents.filter { ev ⇒
- ev.userId == userId &&
+ ev.userID == userId &&
(ev.occurredMillis > timestamp)
}.toList
}
startTimeMillis: Long,
stopTimeMillis: Long): List[ResourceEvent] = {
_resourceEvents.filter { ev ⇒
- ev.userId == userId &&
+ ev.userID == userId &&
ev.isReceivedWithinMillis(startTimeMillis, stopTimeMillis)
}.toList
}
LatestResourceEventsSnapshot(latestEventsMap.valuesIterator.toList, snapshotTime)
def updateResourceEvent(resourceEvent: ResourceEvent): Unit = {
- latestEventsMap((resourceEvent.resource, resourceEvent.instanceId)) = resourceEvent
+ latestEventsMap((resourceEvent.resource, resourceEvent.instanceID)) = resourceEvent
}
def findResourceEvent(resource: String, instanceId: String): Maybe[ResourceEvent] = {
}
def updateResourceEvent(resourceEvent: ResourceEvent): Unit = {
- ignoredFirstEventsMap((resourceEvent.resource, resourceEvent.instanceId)) = resourceEvent
+ ignoredFirstEventsMap((resourceEvent.resource, resourceEvent.instanceID)) = resourceEvent
}
def size = ignoredFirstEventsMap.size
def onProcessResourceEvent(event: ProcessResourceEvent): Unit = {
val resourceEvent = event.rce
- if(resourceEvent.userId != this._userId) {
+ if(resourceEvent.userID != this._userId) {
ERROR("Received %s but my userId = %s".format(event, this._userId))
} else {
//ensureUserState()
_forwardToUserActor(userId, m)
case m @ ProcessResourceEvent(resourceEvent) ⇒
- _forwardToUserActor(resourceEvent.userId, m)
+ _forwardToUserActor(resourceEvent.userID, m)
case m @ ProcessUserEvent(userEvent) ⇒
_forwardToUserActor(userEvent.userID, m)
n =>
var event = nextResourceEvent
publisher ! Message(event.toBytes,
- "%s.%s.%s".format("",event.clientId, event.resource))
+ "%s.%s.%s".format("",event.clientID, event.resource))
}
}
}
}
val mostUsedId = events
- .map{x => x.userId}
+ .map{x => x.userID}
.groupBy(identity)
.mapValues(_.size)
.foldLeft(("",0))((acc, kv) => if (kv._2 > acc._2) kv else acc)._1
val result = store.findResourceEventsByUserId(mostUsedId)(None)
- assertEquals(events.filter(p => p.userId.equals(mostUsedId)).size, result.size)
+ assertEquals(events.filter(p => p.userID.equals(mostUsedId)).size, result.size)
}
@Test