def findMessages(mc,custid,count):
print 'findMessages() find ',count
amsm = mc.getActiveMailboxStoreManager()
ids = HashSet()
msgs = HashSet()
retries = 30
while msgs.size() < count and retries > 0:
for p in mc.getPartitionManager().listPartitions():
if p.isReadOnly():
continue
print 'searching for messages to be stored in',p
tm = amsm.findMessages([SearchConstraint(IActiveMailboxStoreManager.PROP_CUST_ID, SearchConstraintOperator.CONSTRAINT_EQUALS,int(custid))],p)
if tm.size() > 0:
msgs.addAll(filter(lambda x : not ids.contains(x.getMessageId()),tm))
ids.addAll(map(lambda x : x.getMessageId(), tm))
if msgs.size() < count:
time.sleep(10)
retries = retries - 1
print 'findMessages found',msgs.size(),'ids',ids.size()
if msgs.isEmpty():
print 'Failed to find any messages in DB'
raise Exception('Failed to find any messages in DB')
if msgs.size() < count:
print 'Warning, did not find all messages expected'
return msgs
def findMessages(mc,custid,count, includeCategorizedRecipients=False):
print 'findMessages() should find ',count
amsm = mc.getActiveMailboxStoreManager()
msgs = HashSet()
retries = 15
while msgs.size() < count and retries > 0:
for p in mc.getPartitionManager().listPartitions():
if p.isReadOnly():
continue
print 'searching for messages to be stored in',p
tm = amsm.findMessages([SearchConstraint(IActiveMailboxStoreManager.PROP_CUST_ID, SearchConstraintOperator.CONSTRAINT_EQUALS,int(custid))],p,includeCategorizedRecipients)
if tm.size() > 0:
msgs.addAll(tm)
if msgs.size() < count:
time.sleep(10)
retries = retries - 1
print 'findMessages() found',msgs.size()
if msgs.isEmpty():
print 'Failed to find any messages in DB'
raise Exception('Failed to find any messages in DB')
if msgs.size() < count:
print 'Warning, did not find all messages expected'
return msgs
def runJob(cmdArray, hosts, sleepTime=60, maxWaits=60, interimResult=None):
finished = HashSet()
failures = HashSet()
pb = ProcessBuilder(cmdArray)
done = False
# first wait is short in case job finishes quickly
waitTime = 10
while not done:
p = pb.start()
dataOut = DataOutputStream(p.getOutputStream())
try:
for host in hosts:
dataOut.writeBytes(host + "\n")
finally:
dataOut.close()
p.waitFor()
(curFinished, curFailures) = processJobResults(p.getInputStream(), interimResult)
finished.addAll(curFinished)
failures.addAll(curFailures)
done = finished.size() == len(hosts)
if not done:
maxWaits = maxWaits - 1
done == maxWaits == 0
if not done:
time.sleep(waitTime)
waitTime = sleepTime
return failures
def get_conf_mbean(conn, mbean_class, sessionId):
conf_name = ObjectName("com.bea:Name=" + mbean_class.NAME + sessionId +
",Type=" + mbean_class.TYPE)
mbeans = HashSet()
mbeans.addAll(conn.queryNames(conf_name, None))
return MBeanServerInvocationHandler.newProxyInstance(
conn,
mbeans.iterator().next(), mbean_class, false)
def sliceSpaces( spaces):
checked = HashSet()
slices = []
for i, space in enumerate(spaces):
if not checked.contains(space):
current = MeshMaker.createNewVerticalSlice(spaces, i)
checked.addAll(current.tiles)
slices.append(current)
return slices
def getUniqueSrcIps(self, protocol=6):
uniqueIps = HashSet()
srcAddrSqlBuilder = SelectSqlBuilder('Agg_V5', 'srcAddr as ip', distinct=1)
srcAddrSqlBuilder.where('prot=%d' % protocol)
srcIps = self._sqlClient.execute(srcAddrSqlBuilder)
if srcIps:
uniqueIps.addAll(Arrays.asList([ipEntry.ip for ipEntry in srcIps]))
return uniqueIps.toArray()
def getVarsInLiveConjuncts(cls, rule, constantSentenceForms):
""" generated source for method getVarsInLiveConjuncts """
result = HashSet()
for literal in rule.getBody():
if isinstance(literal, (GdlRelation, )):
if not SentenceModelUtils.inSentenceFormGroup(literal, constantSentenceForms):
result.addAll(GdlUtils.getVariables(literal))
elif isinstance(literal, (GdlNot, )):
if not SentenceModelUtils.inSentenceFormGroup(inner, constantSentenceForms):
result.addAll(GdlUtils.getVariables(literal))
return result
def getUniqueSrcIps(self, protocol=6):
uniqueIps = HashSet()
srcAddrSqlBuilder = SelectSqlBuilder('Agg_V5',
'srcAddr as ip',
distinct=1)
srcAddrSqlBuilder.where('prot=%d' % protocol)
srcIps = self._sqlClient.execute(srcAddrSqlBuilder)
if srcIps:
uniqueIps.addAll(Arrays.asList([ipEntry.ip for ipEntry in srcIps]))
return uniqueIps.toArray()
def applyCondensation(cls, condensationSet, rule, sentenceNameSource):
""" generated source for method applyCondensation """
varsInCondensationSet = HashSet()
for literal in condensationSet:
varsInCondensationSet.addAll(GdlUtils.getVariables(literal))
varsToKeep = HashSet()
for literal in condensationSet:
varsToKeep.addAll(GdlUtils.getVariables(literal))
varsToKeep2 = HashSet()
varsToKeep2.addAll(GdlUtils.getVariables(rule.getHead()))
for literal in rule.getBody():
if not condensationSet.contains(literal):
varsToKeep2.addAll(GdlUtils.getVariables(literal))
varsToKeep.retainAll(varsToKeep2)
orderedVars = ArrayList(varsToKeep)
condenserName = sentenceNameSource.getNameWithPrefix(rule.getHead().__name__)
condenserHead = GdlSentence()
if orderedVars.isEmpty():
condenserHead = GdlPool.getProposition(condenserName)
else:
condenserHead = GdlPool.getRelation(condenserName, orderedVars)
condenserBody = ArrayList(condensationSet)
condenserRule = GdlPool.getRule(condenserHead, condenserBody)
remainingLiterals = ArrayList()
for literal in rule.getBody():
if not condensationSet.contains(literal):
remainingLiterals.add(literal)
remainingLiterals.add(condenserHead)
modifiedRule = GdlPool.getRule(rule.getHead(), remainingLiterals)
newRules = ArrayList(2)
newRules.add(condenserRule)
newRules.add(modifiedRule)
return newRules
def findAllInstancesOf_1(self, var, gdl, loc):
""" generated source for method findAllInstancesOf_1 """
if not self.domains.containsKey(loc):
self.domains.put(loc, self.Domain(loc))
rval = HashSet()
if isinstance(gdl, (GdlRelation, )):
while i < relation.arity():
parent.name = relation.__name__
parent.idx = i
rval.addAll(self.findAllInstancesOf(var, relation.get(i), parent))
i += 1
elif isinstance(gdl, (GdlDistinct, )):
# GdlDistinct distinct = (GdlDistinct)gdl;
# Negative context, ignore it for now
elif isinstance(gdl, (GdlNot, )):
# GdlNot not = (GdlNot)gdl;
# Negative context, ignore it for now
elif isinstance(gdl, (GdlOr, )):
# TODO: check that this is right, I think it may not be
while i < or_.arity():
pass
i += 1
elif isinstance(gdl, (GdlProposition, )):
# GdlProposition prop = (GdlProposition)gdl;
# I think these can safely be ignored, they have no body
elif isinstance(gdl, (GdlConstant, )):
# GdlConstant constant = (GdlConstant)gdl;
# Just a constant
elif isinstance(gdl, (GdlFunction, )):
while i < func.arity():
parent.name = func.__name__
parent.idx = i
rval.addAll(self.findAllInstancesOf(var, func.get(i), parent))
i += 1
elif isinstance(gdl, (GdlVariable, )):
# This is the interesting one
if variable == var:
# Found what we're looking for (base case of recursion)
if loc == None:
raise RuntimeException("Parent missing for a variable.")
rval.add(self.domains.get(loc))
elif isinstance(gdl, (GdlRule, )):
raise RuntimeException("Shouldn't nest rules.")
return rval
def findSatisfyingInstantiations_0(self, conditions, idx, instantiation):
""" generated source for method findSatisfyingInstantiations_0 """
rval = HashSet()
if idx == len(conditions):
rval.add(instantiation)
return rval
cond = conditions.get(idx)
dom = cond.dom
assignments = None
i = 0
while i < len(cond.template):
if isinstance(t, (GdlVariable, )):
if instantiation.containsKey(v):
c = instantiation.get(v)
elif isinstance(t, (GdlConstant, )):
c = t
if c != None:
if assignments == None:
assignments = self.Assignments()
if len(dom.indices) > i:
if index.containsKey(c):
assignments.addAll(index.get(c))
else:
if len(dom.indices) > i:
if index.containsKey(c):
assignments.retainAll(index.get(c))
else:
assignments.clear()
i += 1
if assignments == None:
assignments = dom.assignments
for a in assignments:
while i < len(a):
if isinstance(t, (GdlVariable, )):
if not instantiation.containsKey(var):
newInstantiation.put(var, a.get(i))
i += 1
rval.addAll(self.findSatisfyingInstantiations(conditions, idx + 1, newInstantiation))
return rval
def search(metaclasses, regexp, options):
print "Searching ..."
rawResults = HashSet()
session = Modelio.getInstance().getModelingSession()
#--- (1) Add all instances of selected metaclasses
for metaclass in metaclasses:
print " searching for instance of metaclass ",metaclass.getSimpleName()," ... ",
metaclassInstances = session.findByClass(metaclass)
print unicode(len(metaclassInstances)),"elements found"
rawResults.addAll(metaclassInstances)
# remove predefined types
predefTypes = Modelio.getInstance().getModelingSession().getModel().getUmlTypes().getBOOLEAN().getOwner()
rawResults.remove(predefTypes)
rawResults.remove(predefTypes.getOwner())
print " ==>",unicode(len(rawResults)),"elements found (primitive types excluded)"
#--- (2) Check for name matching
filteredResults = []
try:
if options[0] == 1:
p = Pattern.compile(regexp)
for result in rawResults:
name = result.getName()
if (p.matcher(name).matches()):
filteredResults.append(result)
else:
for result in rawResults:
if result.getName().find(regexp) != -1:
filteredResults.append(result)
except PatternSyntaxException:
messageBox("The entered regular expression: '"+regexp+"' has a syntax error.")
except IllegalArgumentException:
messageBox("Illegal Argument Exception.")
print " "+unicode(len(filteredResults))+" elements selected after name filtering"
#--- (3) sort results by name
filteredResults.sort(key=lambda x:x.getName())
return filteredResults
def translateAttributes(self, context, configurationAttributes):
print "Idp extension. Method: translateAttributes"
# Return False to use default method
#return False
request = context.getRequest()
userProfile = context.getUserProfile()
principalAttributes = self.defaultNameTranslator.produceIdpAttributePrincipal(
userProfile.getAttributes())
print "Idp extension. Converted user profile: '%s' to attribute principal: '%s'" % (
userProfile, principalAttributes)
if not principalAttributes.isEmpty():
print "Idp extension. Found attributes from oxAuth. Processing..."
# Start: Custom part
# Add givenName attribute
givenNameAttribute = IdPAttribute("oxEnrollmentCode")
givenNameAttribute.setValues(
ArrayList(Arrays.asList(StringAttributeValue("Dummy"))))
principalAttributes.add(IdPAttributePrincipal(givenNameAttribute))
print "Idp extension. Updated attribute principal: '%s'" % principalAttributes
# End: Custom part
principals = HashSet()
principals.addAll(principalAttributes)
principals.add(UsernamePrincipal(userProfile.getId()))
request.setAttribute(
ExternalAuthentication.SUBJECT_KEY,
Subject(False, Collections.singleton(principals),
Collections.emptySet(), Collections.emptySet()))
print "Created an IdP subject instance with principals containing attributes for: '%s'" % userProfile.getId(
)
if False:
idpAttributes = ArrayList()
for principalAttribute in principalAttributes:
idpAttributes.add(principalAttribute.getAttribute())
request.setAttribute(ExternalAuthentication.ATTRIBUTES_KEY,
idpAttributes)
authenticationKey = context.getAuthenticationKey()
profileRequestContext = ExternalAuthentication.getProfileRequestContext(
authenticationKey, request)
authContext = profileRequestContext.getSubcontext(
AuthenticationContext)
extContext = authContext.getSubcontext(
ExternalAuthenticationContext)
extContext.setSubject(
Subject(False, Collections.singleton(principals),
Collections.emptySet(), Collections.emptySet()))
extContext.getSubcontext(
AttributeContext,
True).setUnfilteredIdPAttributes(idpAttributes)
extContext.getSubcontext(AttributeContext).setIdPAttributes(
idpAttributes)
else:
print "No attributes released from oxAuth. Creating an IdP principal for: '%s'" % userProfile.getId(
)
request.setAttribute(ExternalAuthentication.PRINCIPAL_NAME_KEY,
userProfile.getId())
#Return True to specify that default method is not needed
return False
def findAllInstancesOf(self, var, RHS):
""" generated source for method findAllInstancesOf """
rval = HashSet()
for literal in RHS:
rval.addAll(self.findAllInstancesOf(var, literal))
return rval
class GameFlow(object):
""" generated source for class GameFlow """
INIT = GdlPool.getConstant("init")
TRUE = GdlPool.getConstant("true")
NEXT = GdlPool.getConstant("next")
turnAfterLast = int()
# We end with a loop
sentencesTrueByTurn = ArrayList()
# The non-constant ones
formsControlledByFlow = Set()
constantForms = Set()
constantChecker = ConstantChecker()
def __init__(self, description):
""" generated source for method __init__ """
description = GdlCleaner.run(description)
description = DeORer.run(description)
description = VariableConstrainer.replaceFunctionValuedVariables(description)
# First we use a sentence model to get the relevant sentence forms
model = SentenceDomainModelFactory.createWithCartesianDomains(description)
self.formsControlledByFlow = HashSet()
self.formsControlledByFlow.addAll(model.getIndependentSentenceForms())
self.formsControlledByFlow.removeAll(model.getConstantSentenceForms())
self.constantForms = model.getConstantSentenceForms()
self.constantChecker = ConstantCheckerFactory.createWithForwardChaining(model)
# Figure out which of these sentences are true at each stage
solveTurns(model)
def solveTurns(self, model):
""" generated source for method solveTurns """
# Before we can do anything else, we need a topological ordering on our forms
ordering = getTopologicalOrdering(model.getIndependentSentenceForms(), model.getDependencyGraph())
ordering.retainAll(self.formsControlledByFlow)
# Let's add function info to the consideration...
functionInfoMap = HashMap()
for form in constantForms:
functionInfoMap.put(form, FunctionInfoImpl.create(form, self.constantChecker))
# First we set the "true" values, then we get the forms controlled by the flow...
# Use "init" values
trueFlowSentences = HashSet()
for form in constantForms:
if form.__name__ == self.INIT:
for initSentence in constantChecker.getTrueSentences(form):
trueFlowSentences.add(trueSentence)
# Go through ordering, adding to trueFlowSentences
addSentenceForms(ordering, trueFlowSentences, model, functionInfoMap)
self.sentencesTrueByTurn.add(trueFlowSentences)
while True:
# Now we use the "next" values from the previous turn
trueFlowSentences = HashSet()
for sentence in sentencesPreviouslyTrue:
if sentence.__name__ == self.NEXT:
trueFlowSentences.add(trueSentence)
addSentenceForms(ordering, trueFlowSentences, model, functionInfoMap)
# Test if this turn's flow is the same as an earlier one
while i < len(self.sentencesTrueByTurn):
if prevSet == trueFlowSentences:
# Complete the loop
self.turnAfterLast = i
break
i += 1
self.sentencesTrueByTurn.add(trueFlowSentences)
@SuppressWarnings("unchecked")
def addSentenceForms(self, ordering, trueFlowSentences, model, functionInfoMap):
""" generated source for method addSentenceForms """
for curForm in ordering:
# Check against trueFlowSentences, add to trueFlowSentences
# or check against constantForms if necessary
# Use basic Assignments class, of course
for alwaysTrueSentences in model.getSentencesListedAsTrue(curForm):
trueFlowSentences.add(alwaysTrueSentences)
for rule in model.getRules(curForm):
while asnItr.hasNext():
if trueFlowSentences.contains(transformedHead):
asnItr.changeOneInNext(varsInHead, assignment)
# Go through the conjuncts
for literal in rule.getBody():
if isinstance(literal, (GdlSentence, )):
if curForm.matches(literal):
raise RuntimeException("Haven't implemented recursion in the game flow")
if self.constantForms.contains(conjForm):
if not self.constantChecker.isTrueConstant(transformed):
isGoodAssignment = False
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment)
else:
if not trueFlowSentences.contains(transformed):
# False sentence
isGoodAssignment = False
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment)
elif isinstance(literal, (GdlNot, )):
if self.constantForms.contains(conjForm):
if self.constantChecker.isTrueConstant(transformed):
isGoodAssignment = False
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment)
else:
if trueFlowSentences.contains(transformed):
# False sentence
isGoodAssignment = False
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment)
# Nothing else needs attention, really
# We've gone through all the conjuncts and are at the
# end of the rule
if isGoodAssignment:
trueFlowSentences.add(transformedHead)
if varsInHead.isEmpty():
break
else:
asnItr.changeOneInNext(varsInHead, assignment)
# We've gone through all the rules
def getNumTurns(self):
""" generated source for method getNumTurns """
return len(self.sentencesTrueByTurn)
@classmethod
def getTopologicalOrdering(cls, forms, dependencyGraph):
""" generated source for method getTopologicalOrdering """
# We want each form as a key of the dependency graph to
# follow all the forms in the dependency graph, except maybe itself
queue = LinkedList(forms)
ordering = ArrayList(len(forms))
alreadyOrdered = HashSet()
while not queue.isEmpty():
# Don't add if there are dependencies
for dependency in dependencyGraph.get(curForm):
if not dependency == curForm and not alreadyOrdered.contains(dependency):
readyToAdd = False
break
# Add it
if readyToAdd:
ordering.add(curForm)
alreadyOrdered.add(curForm)
else:
queue.add(curForm)
# TODO: Add check for an infinite loop here
# Or replace with code that does stratification of loops
return ordering
def getTurnsConjunctsArePossible(self, body):
""" generated source for method getTurnsConjunctsArePossible """
# We want to identify the conjuncts that are used by the
# game flow.
relevantLiterals = ArrayList()
for literal in body:
if isinstance(literal, (GdlSentence, )):
if SentenceModelUtils.inSentenceFormGroup(sentence, self.formsControlledByFlow):
relevantLiterals.add(literal)
elif isinstance(literal, (GdlNot, )):
if SentenceModelUtils.inSentenceFormGroup(innerSentence, self.formsControlledByFlow):
relevantLiterals.add(literal)
# If none are related to the game flow, then that's it. It can
# happen on any turn.
# if(relevantLiterals.isEmpty())
# return getCompleteTurnSet();
turnsPossible = HashSet(getCompleteTurnSet())
# For each of the relevant literals, we need to see if there are assignments
# such that
for literal in relevantLiterals:
if isinstance(literal, (GdlSentence, )):
while t < self.getNumTurns():
if self.sentencesTrueByTurn.get(t).contains(literal):
turns.add(t)
else:
for s in sentencesTrueByTurn.get(t):
# Could be true if there's an assignment
if None != GdlUtils.getAssignmentMakingLeftIntoRight(literal, s):
turns.add(t)
break
t += 1
elif isinstance(literal, (GdlNot, )):
while t < self.getNumTurns():
if not self.sentencesTrueByTurn.get(t).contains(internal):
turns.add(t)
else:
for s in sentencesTrueByTurn.get(t):
if None != GdlUtils.getAssignmentMakingLeftIntoRight(internal, s):
turns.add(t)
break
t += 1
# Accumulate turns
# Note that all relevant conjuncts must be true, so this
# is an intersection of when the individual conjuncts
# could be true.
turnsPossible.retainAll(turns)
return turnsPossible
completeTurnSet = None
def getCompleteTurnSet(self):
""" generated source for method getCompleteTurnSet """
if self.completeTurnSet == None:
self.completeTurnSet = HashSet()
while i < self.getNumTurns():
self.completeTurnSet.add(i)
i += 1
self.completeTurnSet = Collections.unmodifiableSet(self.completeTurnSet)
return self.completeTurnSet
def getSentenceForms(self):
""" generated source for method getSentenceForms """
return self.formsControlledByFlow
def getSentencesTrueOnTurn(self, i):
""" generated source for method getSentencesTrueOnTurn """
return self.sentencesTrueByTurn.get(i)
def getTurnAfterLast(self):
""" generated source for method getTurnAfterLast """
return self.turnAfterLast
