class ViewOfEntireCumulusSystem(ComputedGraph.Location):
viewOfSystem_ = ComputedGraph.Mutable(object, lambda: ())
recentGlobalUserFacingLogMessages_ = ComputedGraph.Mutable(
object, lambda: ())
totalMessageCountsEver_ = ComputedGraph.Mutable(object, lambda: 0)
@ComputedGraph.ExposedProperty()
def mostRecentMessages(self):
return self.recentGlobalUserFacingLogMessages_
@ComputedGraph.ExposedProperty()
def totalMessagesEver(self):
return self.totalMessageCountsEver_
@ComputedGraph.ExposedFunction()
def clearMostRecentMessages(self, arg):
self.recentGlobalUserFacingLogMessages_ = ()
@ComputedGraph.ExposedFunction()
def clearAndReturnMostRecentMessages(self, arg):
messages = self.recentGlobalUserFacingLogMessages_
self.recentGlobalUserFacingLogMessages_ = ()
return messages
@ComputedGraph.ExposedProperty()
def viewOfCumulusSystem(self):
return self.viewOfSystem_
@ComputedGraph.ExposedFunction()
def pushNewGlobalUserFacingLogMessage(self, msg):
self.totalMessageCountsEver_ = self.totalMessageCountsEver_ + 1
self.recentGlobalUserFacingLogMessages_ = (
self.recentGlobalUserFacingLogMessages_ + \
({"timestamp": msg.timestamp, "message": msg.message, "isDeveloperFacing": msg.isDeveloperFacing, },)
)
def convertResponseToJson(self, jsonCandidate):
try:
def raiseException():
guid = uuid.uuid4()
logging.error("%s of type %s is not valid json. guid = %s", jsonCandidate, type(jsonCandidate), guid)
raise Exceptions.SubscribableWebObjectsException("result was not valid json. Guid = %s" % guid)
if jsonCandidate is None:
return jsonCandidate
if isinstance(jsonCandidate, (int,str,unicode,float,bool,long)):
return jsonCandidate
if isinstance(jsonCandidate, (list, tuple)):
return [self.convertResponseToJson(r) for r in jsonCandidate]
if isinstance(jsonCandidate, dict):
newDict = {}
for k,v in jsonCandidate.iteritems():
if not isinstance(k,str):
raiseException()
newDict[k] = self.convertResponseToJson(v)
return newDict
objDefPopulated = False
try:
if ComputedGraph.isLocation(jsonCandidate):
if jsonCandidate in self.objectToIdCache_:
objDef = {
'objectId_': self.lookupObjectId(jsonCandidate)
}
else:
objDef = {
"objectId_": self.lookupObjectId(jsonCandidate),
"objectDefinition_": {
'type': AllObjectClassesToExpose.typenameFromType(
ComputedGraph.getLocationTypeFromLocation(jsonCandidate)
),
'args': jsonCandidate.__reduce__()[1][0]
}
}
objDefPopulated = True
else:
objDef = jsonCandidate.objectDefinition_
objDefPopulated = True
except AttributeError:
objDefPopulated = False
if objDefPopulated:
return self.convertResponseToJson(objDef)
raiseException()
except:
logging.error("%s of type %s is not valid json.", jsonCandidate, type(jsonCandidate))
raise
def convertResponseToJson(self, jsonCandidate):
try:
def raiseException():
guid = uuid.uuid4()
logging.error("%s of type %s is not valid json. guid = %s", jsonCandidate, type(jsonCandidate), guid)
raise Exceptions.SubscribableWebObjectsException("result was not valid json. Guid = %s" % guid)
if jsonCandidate is None:
return jsonCandidate
if isinstance(jsonCandidate, (int, str, unicode, float, bool, long)):
return jsonCandidate
if isinstance(jsonCandidate, (list, tuple)):
return [self.convertResponseToJson(r) for r in jsonCandidate]
if isinstance(jsonCandidate, dict):
newDict = {}
for k, v in jsonCandidate.iteritems():
if not isinstance(k, str):
raiseException()
newDict[k] = self.convertResponseToJson(v)
return newDict
objDefPopulated = False
try:
if ComputedGraph.isLocation(jsonCandidate):
if jsonCandidate in self.objectToIdCache_:
objDef = {"objectId_": self.lookupObjectId(jsonCandidate)}
else:
objDef = {
"objectId_": self.lookupObjectId(jsonCandidate),
"objectDefinition_": {
"type": AllObjectClassesToExpose.typenameFromType(
ComputedGraph.getLocationTypeFromLocation(jsonCandidate)
),
"args": jsonCandidate.__reduce__()[1][0],
},
}
objDefPopulated = True
else:
objDef = jsonCandidate.objectDefinition_
objDefPopulated = True
except AttributeError:
objDefPopulated = False
if objDefPopulated:
return self.convertResponseToJson(objDef)
raiseException()
except:
logging.error("%s of type %s is not valid json.", jsonCandidate, type(jsonCandidate))
raise
class PersistentCacheIndex(ComputedGraph.Location):
totalBytesInCache = ComputedGraph.Mutable(object, lambda: 0)
totalObjectsInCache = ComputedGraph.Mutable(object, lambda: 0)
totalComputationsInCache = ComputedGraph.Mutable(object, lambda: 0)
totalReachableComputationsInCache = ComputedGraph.Mutable(
object, lambda: 0)
@ComputedGraph.ExposedProperty()
def persistentCacheState(self):
return {
"totalBytesInCache":
self.totalBytesInCache,
"totalObjectsInCache":
self.totalObjectsInCache,
"totalComputationsInCache":
self.totalComputationsInCache,
"totalReachableComputationsInCache":
self.totalReachableComputationsInCache
}
@ComputedGraph.ExposedFunction()
def triggerGarbageCollectionImmediately(self, completePurge):
ComputedValueGateway.getGateway(
).triggerPerstistentCacheGarbageCollection(
True if completePurge else False)
@ComputedGraph.ExposedFunction()
def setMaxBytesInCache(self, *args):
ComputedValueGateway.getGateway().getPersistentCacheIndex(
).setMaxBytesInCache(args[0])
@ComputedGraph.ExposedProperty()
def maxBytesInCache(self):
if ComputedValueGateway.getGateway().getPersistentCacheIndex() is None:
return 0
return ComputedValueGateway.getGateway().getPersistentCacheIndex(
).getMaxBytesInCache()
@ComputedGraph.Function
def update(self):
if ComputedValueGateway.getGateway().getPersistentCacheIndex() is None:
return
self.totalBytesInCache = ComputedValueGateway.getGateway(
).getPersistentCacheIndex().totalBytesInCache()
self.totalObjectsInCache = ComputedValueGateway.getGateway(
).getPersistentCacheIndex().totalObjectsInCache()
self.totalComputationsInCache = ComputedValueGateway.getGateway(
).getPersistentCacheIndex().totalComputationsInCache()
self.totalReachableComputationsInCache = ComputedValueGateway.getGateway(
).getPersistentCacheIndex().totalReachableComputationsInCache()
class TestCGLocation(ComputedGraph.Location):
definition = ComputedGraph.Key(object)
aValue = ComputedGraph.Mutable(lambda: None, exposeToProtocol=True)
def sharedStateSubspace(self):
return CGSS.Node.Keyspace(keyspacePath=("public", "writeable",
"TestCGLocation")).subspace
aValueInSharedState = CGSS.Property.Property(default=lambda: False,
exposeToProtocol=True)
bValueInSharedState = CGSS.Property.Property(default=lambda: False,
exposeToProtocol=True)
cValueInSharedState = CGSS.Property.Property(default=lambda: False,
exposeToProtocol=True)
@ComputedGraph.ExposedProperty()
def depth(self):
if isinstance(self.definition, Test):
return self.definition.depth + 1
elif isinstance(self.definition, list):
res = 0
for x in self.definition:
res += x.depth
return res
else:
return 0
@ComputedGraph.ExposedProperty()
def testCgLocation(self):
return self
@ComputedGraph.ExposedFunction()
def aFunction(self, jsonArg):
self.aValue = jsonArg
@ComputedGraph.Function
def anUnexposedFunction(self, jsonArg):
self.aValue = jsonArg
@ComputedGraph.ExposedFunction()
def testFunction(self, arg):
return arg
@ComputedGraph.ExposedFunction(wantsCallback=True)
def aFunctionExpectingCallback(self, callback, jsonArg):
def aThread():
time.sleep(1)
callback(jsonArg)
threading.Thread(target=aThread).start()
def waitForSync(self, predicate, *synchronizers):
if not synchronizers:
synchronizers = [self.synchronizer]
ComputedGraph.assertHasGraph()
passes = 0
while passes < 100:
for s in synchronizers:
s.update()
if predicate():
break
time.sleep(.1)
passes += 1
self.assertTrue(predicate())
def waitForSync(self, predicate, *synchronizers):
if not synchronizers:
synchronizers = [self.synchronizer]
ComputedGraph.assertHasGraph()
passes = 0
while passes < 100:
for s in synchronizers:
s.update()
if predicate():
break
time.sleep(.1)
passes += 1
self.assertTrue(predicate())
class SubscriptionKeys(ComputedGraph.Location):
subscriptionKeys = ComputedGraph.Mutable(object)
def keys(self):
if self.subscriptionKeys is None:
return []
return self.subscriptionKeys
def testCreate(self):
testGraph = ComputedGraph()
def thing(x):
print "thing called for onUpdate"
class X(Location):
k = Key()
v = Mutable(int, lambda: 8, onUpdate = thing)
u = 9000
@Function
def testFunc(self, x):
print 'here is testFunc'
print 'testFunc has self.v =', self.v
print 'testFunc has x =', x
print 'testFunc returning', self.v + x
return self.v + x
@NotCached
def testNC(self):
return self.k*4
with testGraph:
n = X(k = 902)
pass
print "inital value: n.v =", n.v
print "about to change value.."
n.v = 33
print "n.v =", n.v
print "Accessing key.."
print "n.k =", n.k
print "testing func:", n.testFunc(-3)
print n.testNC
print n.u # 'passing class member on directly'
def testLocKey(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
v3 = Mutable(dict, lambda: dict())
def product(self):
print "self =", self
return self.v1*self.v2
def func2(self):
print "self =", self
return 1.0*self.product
def func3(self):
print "self =", self
return 1.0*self.func2
class Y(Location):
v = Key() #X(k1 = 0, k2 = 0) # Key which holds LocRef
v2 = Mutable(int, lambda: 3)
v3 = Mutable(str, lambda: str(''))
def number(self):
return self.v2*self.v.func3
with testGraph:
nodeX1 = X(k1 = 20, k2 = 25)
nodeX1.v3 = {'h':1, 'e':2, 'l':3, 'p':4}
nodeY = Y(v = nodeX1)
print nodeY.number
print "CHANGING"
nodeX1.v1 = 11
print nodeY.number
def testOrphan(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
def product(self):
return self.v1*self.v2
class Y(Location):
k = Key()
v = Mutable(X, lambda: X(k1 = 0, k2 = 0))
v2 = Mutable(int, lambda: 3)
def number(self):
return self.v2*self.v.product
with testGraph:
nodeX1 = X(k1 = 20, k2 = 25)
nodeX2 = X(k1 = 21, k2 = 26)
nodeY = Y(k = 10)
nodeX1.v1 = 11
nodeX2.v2 = 12
nodeY.v = nodeX1
print nodeY.number
print "CHANGING"
nodeY.v = nodeX2
print nodeY.number
def testCached(self):
factor = 1
val = 2
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
def product(self):
return factor*self.v1*self.v2
class Y(Location):
k = Key()
v = Mutable(X, lambda: X(k1 = 0, k2 = 0))
v2 = Mutable(int, lambda: 3)
def number(self):
return self.v2*(self.v.v1 + self.v.v2) + val
with testGraph:
node = X(k1 = 20, k2 = 25)
node2 = Y(k = 9)
node2.v = node
self.assert_(node.product == node.v1*node.v2, "First access to property gives the wrong value")
self.assert_(node2.number == node2.v2*(node2.v.v1 + node2.v.v2) + val, "First access to property gives the wrong value")
factor += 1
val += 1
self.assert_(node.product == node.v1*node.v2, "Property did not correctly return cached value")
self.assert_(node2.number == node2.v2*(node2.v.v1 + node2.v.v2) + val - 1, "Property did not correctly return cached value")
node.v1 = 90000
self.assert_(node.product == factor*node.v1*node.v2, "After adjusting mutable, property was not recomputed")
self.assert_(node2.number == node2.v2*(node2.v.v1 + node2.v.v2) + val, "After adjusting mutable, property was not recomputed")
def extractObjectDefinition(self, objDefJson):
if "objectId_" in objDefJson or "objectDefinition_" in objDefJson:
return self.convertObjectArgs(objDefJson)
if "type" not in objDefJson or "args" not in objDefJson:
raise MalformedMessageException("Malformed object definition given")
objType = objDefJson["type"]
objectArgs = objDefJson["args"]
objectArgs = self.convertObjectArgs(objectArgs)
if objType not in AllObjectClassesToExpose.classMap:
raise InvalidObjectDefinitionException("Unknown object type")
try:
objectCls = AllObjectClassesToExpose.classMap[objType]
result = objectCls(objectArgs)
if not ComputedGraph.isLocation(result):
result.__dict__["objectDefinition_"] = objDefJson
return result
except Exceptions.SubscribableWebObjectsException as e:
raise InvalidObjectDefinitionException(e.message)
def extractObjectDefinition(self, objDefJson):
if 'objectId_' in objDefJson or 'objectDefinition_' in objDefJson:
return self.convertObjectArgs(objDefJson)
if 'type' not in objDefJson or 'args' not in objDefJson:
raise MalformedMessageException("Malformed object definition given")
objType = objDefJson['type']
objectArgs = objDefJson['args']
objectArgs = self.convertObjectArgs(objectArgs)
if objType not in AllObjectClassesToExpose.classMap:
raise InvalidObjectDefinitionException("Unknown object type")
try:
objectCls = AllObjectClassesToExpose.classMap[objType]
result = objectCls(objectArgs)
if not ComputedGraph.isLocation(result):
result.__dict__['objectDefinition_'] = objDefJson
return result
except Exceptions.SubscribableWebObjectsException as e:
raise InvalidObjectDefinitionException(e.message)
class PyforaDictionaryElement(PyforaComputedValue):
#the base PyforaComputedValue of which we are one of the dictionary members
baseCV = ComputedGraph.Key(object)
#the keyname in self.baseCV.pyforaDictToStringDict we are tied to
keyname = ComputedGraph.Key(object)
def argIds(self):
return ()
def args(self):
return (self.baseCV,
ForaNative.makeSymbol("RawGetItemByString"),
ForaNative.ImplValContainer(self.keyname))
def __str__(self):
return "PyforaDictionaryElement(baseCV=%s,keyname=%s)" % (self.baseCV, self.keyname)
class PyforaTupleElement(PyforaComputedValue):
#the base PyforaComputedValue of which we are one of the tuple members
baseCV = ComputedGraph.Key(object)
#the index in self.baseCV.pyforaTupleToTuple we are tied to
index = ComputedGraph.Key(object)
def argIds(self):
return ()
def args(self):
return (self.baseCV,
ForaNative.makeSymbol("RawGetItemByInt"),
ForaNative.ImplValContainer(self.index))
def __str__(self):
return "PyforaTupleElement(baseCV=%s,index=%s)" % (self.baseCV, self.index)
def testMutableDefaults(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
with testGraph:
node = X(k1 = 20, k2 = 25)
self.assert_((node.v1 == 10) and (node.v2 == 20), "Mutables are not correctly set to default values")
class WriteToS3Task(ComputedGraph.Location):
#the computation we want to write
computedValue = object
bucketname = object
keyname = object
#either None if it's uploading, or {'success': True/False, ['message': msg]}
successOrError = ComputedGraph.Mutable(object,
lambda: None,
exposeToProtocol=True)
@ComputedGraph.Function
def trigger(self):
if self.successOrError is not None:
return
if self.computedValue.valueIVC is None:
self.successOrError = {
'success':
False,
'message':
"Tried to trigger write before calculation was finished."
}
return
if not self.computedValue.valueIVC.isVectorOfChar():
self.successOrError = {
'success': False,
'message': "Result should have been a string."
}
return
if self.computedValue.isException:
self.successOrError = {
'success':
False,
'message':
"Result should have been a string. Got an exception instead."
}
return
def callback(result):
if result.isSuccess():
self.successOrError = {'success': True}
else:
self.successOrError = {
'success': False,
'message': str(result)
}
ComputedValueGateway.getGateway().createExternalIoTask(
CumulusNative.ExternalIoTask.WriteCharBigvecToS3(
self.computedValue.valueIVC.getVectorBigvecGuid(),
CumulusNative.S3KeyAndCredentials(self.bucketname,
self.keyname, "", "", "")),
callback)
def testProperty(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
def product(self):
return self.v1*self.v2
with testGraph:
node = X(k1 = 20, k2 = 25)
self.assert_(node.product == node.v1 * node.v2, "Property does not return correct value")
def testInitializer(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
v3 = Mutable(int, lambda: 9)
@Initializer
def initialize(self):
self.v3 = 200
with testGraph:
node = X(k1 = 21, k2 = 25)
self.assert_(node.v3 == 200, "Initializer function did not set the value correctly")
def testChangeMutable(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
def product(self):
return self.v1*self.v2
with testGraph:
node = X(k1 = 20, k2 = 25)
node.v1 = 15
self.assert_(node.v1 == 15, "Mutable has the wrong value after attempting to change it")
self.assert_(node.product == node.v1 * node.v2, "Property does not return correct value after changing mutable")
def setUpComputedValueTest(tester):
tester.graph = ComputedGraph.ComputedGraph()
tester.graph.__enter__()
def gatewayFactory(callbackScheduler, vdm):
return CumulusGatewayInProcess.InProcessGateway(callbackSchedulerFactory, callbackScheduler, vdm)
tester.computedValueGateway = \
ComputedValueGateway.CumulusComputedValueGateway(
callbackSchedulerFactory,
callbackScheduler,
gatewayFactory
)
tester.computedValueGateway.__enter__()
def testTemp(self):
testGraph = ComputedGraph()
class Z(Location):
k1 = Key()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
v3 = Mutable(Location, lambda: Z(k1 = 20) )
def product(self):
return self.v1*self.v2
def func(self):
return self.product + self.v3.v2
class Y(Location):
k = Key()
v = Mutable(X, lambda: X(k1 = 0, k2 = 0))
v2 = Mutable(int, lambda: 3)
def number(self):
return self.v2*self.v.product
def yfunc(self):
return self.v.func*self.number
with testGraph:
node = X(k1 = 20, k2 = 25)
node2 = Y(k = 9)
node2.v = node
node.v3 = node2
print "node2.yfunc:", node2.yfunc
node2.v2 = 9
print "node2.yfunc:", node2.yfunc
self.assert_(node.product == node.v1*node.v2, "First access to property gives the wrong value")
self.assert_(node2.number == node2.v2*node2.v.product, "First access to property gives the wrong value")
print node2.number
node.v1 = 15
print node2.number
self.assert_(node2.number == node2.v2*node2.v.product, "After adjusting mutable, property was not recomputed")
print "UP/DOWN TEST"
print "Up from Y number:", node2.propUp("number")
print "Down from X v1:", node.propDown("v1")
print "Up from X product:", node.propUp("product")
print "UP/DOWN TEST DONE"
print "Depth 2 prop up from number"
l = node2.propUp("number")
print "Level 1:", l
for l2 in l:
print "Level 2 from", l2, "is", l2[0].propUp(l2[2])
def testNotCached(self):
factor = 1.0
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
@NotCached
def product(self):
return factor*self.v1*self.v2
with testGraph:
node = X(k1 = 20, k2 = 25)
self.assert_(node.product == factor*node.v1*node.v2, "Accessing NotCached property gives the wrong value")
factor = 2.0
self.assert_(node.product == factor*node.v1*node.v2, "NotCached property did not change from the previous value")
def testKeys(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
with testGraph:
node = X(k1 = 20, k2 = 25)
self.assert_(node.k1 == 20 and node.k2 == 25, "Keys do not have correct values")
try:
node.k1 = 31
except:
pass
else:
self.assert_(False, "Exception not thrown when attempting to change key values")
self.assert_(node.k1 == 20 and node.k2 == 25, "Keys did not retain correct values")
def testFunction(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
@Function
def testFunc(self, val):
return val*self.v1 + self.v2
with testGraph:
node = X(k1 = 20, k2 = 25)
self.assert_(node.testFunc(3) == 3*node.v1 + node.v2, "Function returns the wrong value")
node.v1 = 903
node.v2 = -8
self.assert_(node.testFunc(3) == 3*node.v1 + node.v2, "Function returns the wrong value after changing mutables")
class SimpleLocation(ComputedGraph.Location):
"""A very simple computed graph location for testing"""
value = object
mutVal = ComputedGraph.Mutable(object, lambda: 0)
def property1(self):
return self.value
def property2(self):
return self.property1 * 2
def mutValTimes2(self):
return self.mutVal * 2
def mutValTimes4(self):
return self.mutValTimes2 * 2
class ComputedValueHeldByHash(ComputedValue.ComputedValue):
args = None
hash = object
valueIVC_ = ComputedGraph.Mutable(object)
def valueIVC(self):
if self.valueIVC_ is None:
return ForaNative.ImplValContainer()
return self.valueIVC_
isException = object
isFinished = True
workerCount = 0
cacheloadCount = 0
computationStatistics = None
def handleReadMessage(self, jsonMessage, objectToRead):
fieldFun = self.getFieldExtractorForReadMessage(jsonMessage, objectToRead)
try:
return [{
"messageId": jsonMessage["messageId"],
"responseType": "ReadResponse",
"value": self.outgoingObjectCache.convertResponseToJson(fieldFun(objectToRead))
}]
except Exception as e:
try:
objectType = objectToRead.__location_class__ if ComputedGraph.isLocation(objectToRead) else str(objectToRead)
logging.info("converting %s of type %s", fieldFun(objectToRead), objectType)
except:
pass
return [unexpectedExceptionJson(jsonMessage, Exceptions.wrapException(e).message)]
def testLocationAccess(self):
testGraph = ComputedGraph()
class X(Location):
k1 = Key()
k2 = Key()
v1 = Mutable(int, lambda: 10)
v2 = Mutable(int, lambda: 20)
def product(self):
return self.v1*self.v2
with testGraph:
node = X(k1 = 20, k2 = 25)
node.v1 = 15
with testGraph:
node2 = X(k1 = 20, k2 = 25)
self.assert_(node.v1 == node2.v1, "Accessing same location through different location references gives incorrect mutable values")
self.assert_(node.v2 == node2.v2, "Accessing same location through different location references gives incorrect mutable values")
self.assert_(node.product == node2.product, "Accessing same location through different location references gives incorrect property values")
def validateComputedValueArgs(args):
"""check that every argument to a ComputedValue is either an ImplValContainer or
another ComputedValue"""
if not args:
return False
if not isinstance(args, tuple):
return False
for ix, a in enumerate(args):
if ComputedGraph.isLocation(a):
if not issubclass(a.__location_class__, ComputedValue):
logging.error("Failed validation of args[%s].__location_class__ = '%s'", ix, a.__location_class__)
return False
else:
if not isinstance(a, (ImplValContainer_, long, int, str, bool)):
logging.error("Failed validation of args[%s].__class__ = '%s'", ix, a.__class__)
return False
return True
def testLocKey2(self):
testGraph = ComputedGraph()
class Chr(Location):
strIn = Key()
chrVal = Key()
def position(self):
d = {}
for s in range(len(self.strIn.v3)):
d[self.strIn.v3[s]] = s
return d[self]
class Str(Location):
k1 = Key()
v3 = Mutable(list, lambda: list())
@Function
def setString(self, strText):
v = list()
for i in range(len(strText)):
v.append(Chr(strIn = self, chrVal = strText[i]))
self.v3 = v
def getStr(self):
#print self.v3
s = ''
for i in range(len(self.v3)):
s += self.v3[i].chrVal
return s
with testGraph:
testStr = Str(k1 = 20)
print "Setting string"
testStr.setString("hello")
print "Printing string"
print testStr.getStr
#print "Reprinting string"
#print testStr.getStr
#print "Reprinting string again"
#print testStr.getStr
print "position:", testStr.v3[2].position
#print "position again:", testStr.v3[2].position
#print "char:", testStr.v3[2].chrVal
print "Setting string"
testStr.setString("some other string")
print "Printing string"
print testStr.getStr
def unfinishedDependentCodeLocationsAsJson(self):
res = []
for cv in self.rootComputedValueDependencies:
if not cv.isFinished:
#each computed value we depend on might be a visualize. If so, we want
#the actual script computation (if available)
cv = cv.unwrapVisualizable
cv = cv.unwrapMember
#only some ComputedValue objects have this property
loc = cv.codeLocationDefinitionAsJson
if loc is not None:
res.append(loc)
else:
res.append(str(ComputedGraph.getLocationTypeFromLocation(cv)))
return tuple(res)
def handleReadMessage(self, jsonMessage, objectToRead):
fieldFun = self.getFieldExtractorForReadMessage(jsonMessage, objectToRead)
try:
return [
{
"messageId": jsonMessage["messageId"],
"responseType": "ReadResponse",
"value": self.outgoingObjectCache.convertResponseToJson(fieldFun(objectToRead)),
}
]
except Exception as e:
try:
objectType = (
objectToRead.__location_class__ if ComputedGraph.isLocation(objectToRead) else str(objectToRead)
)
logging.info("converting %s of type %s", fieldFun(objectToRead), objectType)
except:
pass
return [unexpectedExceptionJson(jsonMessage, Exceptions.wrapException(e).message)]
def __init__(self, callbackSchedulerFactory, callbackScheduler, cumulusGatewayFactory):
self.callbackScheduler = callbackScheduler
ComputedValueGateway.__init__(self)
Stoppable.Stoppable.__init__(self)
CacheLoader.__init__(
self,
callbackSchedulerFactory,
callbackScheduler,
Setup.config().computedValueGatewayRAMCacheMB * 1024 * 1024
)
logging.info("cumulusGatewayFactory is %s", cumulusGatewayFactory)
self.cumulusGateway = cumulusGatewayFactory(self.callbackScheduler, self.vdm)
self.externalIoTaskCallbacks_ = {}
self.refcountTracker = self.cumulusGateway.cumulusClient.getSystemwidePageRefcountTracker()
self.cumulusGateway.onNewGlobalUserFacingLogMessage = self.onNewGlobalUserFacingLogMessage
self.cumulusGateway.onExternalIoTaskCompleted = self.onExternalIoTaskCompleted
self.cumulusGateway.onCPUCountChanged = self.onCPUCountChanged
self.cumulusGateway.onCacheLoad = self.onCacheLoad
self.cumulusGateway.onComputationResult = self.onComputationResult
self.cumulusGateway.onMachineCountWentToZero = self.onMachineCountWentToZero
self.refcountsForCompIds_ = DefaultDict.DefaultDict(lambda computedValue: 0)
self.computedValuesForComputations = {}
self.finishedResultsForComputations = {}
self.curPriorityIndex = 0
self.lock_ = threading.RLock()
assert ComputedGraph.currentGraph() is not None
self.cumulusGateway.onJsonViewOfSystemChanged = self.onJsonViewOfSystemChanged
def isComputedValue(o):
return ComputedGraph.isLocation(o) and issubclass(o.__location_class__, ComputedValue)
def getObjectClass(o):
if ComputedGraph.isLocation(o):
return ComputedGraph.getLocationTypeFromLocation(o)
return o.__class__
