def OnRegisterEnd(self):
"""After registration is complete submit the query to the
query master"""
# create a partial query spec dictionary
# set pattern name from args
# set notification address in spec
# set state as UNINITIALIZED
querySpec = quilt_data.query_spec_create(
name='new ' + self._args.pattern,
state=quilt_data.STATE_UNINITIALIZED,
patternName=self._args.pattern,
notificationEmail=self._args.notifcation_email)
# set variables/values from args
if self._args.variable is not None and len(self._args.variable) > 0:
variables = quilt_data.var_specs_create()
for v in self._args.variable:
vname = v[0]
vval = v[1]
quilt_data.var_specs_add(variables,
quilt_data.var_spec_create(name=vname, value=vval))
quilt_data.query_spec_set(querySpec, variables=variables)
logging.info('Submiting query: ' + pprint.pformat(querySpec))
# call remote method asyncronysly, this will return right away
Pyro4.async(self._qm).Query(self._remotename, querySpec)
# Validate query will be remote called from query master
# return True to allow event loop to start running, which
# should soon recieve a validation callback from query master
import time
ns = Pyro4.locateNS()
uri = ns.lookup(self._remotename)
for i in range(10):
print "loop being"
time.sleep(1)
with Pyro4.Proxy(uri) as p:
print "Sending", i
Pyro4.async(p).TestMsg(i)
print "sent", i
print "loop end"
return True
def OnRegisterEnd(self):
"""After registration is complete submit the query to the
query master"""
# create a partial query spec dictionary
# set pattern name from args
# set notification address in spec
# set state as UNINITIALIZED
querySpec = quilt_data.query_spec_create(
name='new ' + self._args.pattern,
state=quilt_data.STATE_UNINITIALIZED,
patternName=self._args.pattern,
notificationEmail=self._args.notification_email)
# set variables/values from args
if self._args.variable is not None and len(self._args.variable) > 0:
variables = quilt_data.var_specs_create()
for v in self._args.variable:
vname = v[0]
vval = v[1]
quilt_data.var_specs_add(variables,
quilt_data.var_spec_create(name=vname, value=vval))
quilt_data.query_spec_set(querySpec, variables=variables)
logging.info('Submitting query: ' + pprint.pformat(querySpec))
# call remote method asynchronously, this will return right away
with self.GetQueryMasterProxy() as qm:
Pyro4.async(qm).Query(self._remotename, querySpec)
logging.info('Query Submitted')
# Validate query will be remote called from query master
# return True to allow event loop to start running, which
# should soon receive a validation callback from query master
return True
def create_src_query_spec(
srcPatSpec, srcPatInstance, varSpecs, patVarSpecs, qid, source,
patternName,
varDict):
"""Helper function for filling out a srcQuerySpec with variable values"""
srcPatVars = quilt_data.src_pat_spec_get(
srcPatSpec, variables=True)
if srcPatVars is None:
return
srcVarToVarDict = varDict[source][patternName][srcPatInstance]
logging.debug("srcVarToVarDict: " + str(srcVarToVarDict))
logging.debug("varDict is " + str(varDict))
srcQueryVarSpecs = None
# iterate the variables in the "new"
# sourceQuerySpec
for srcVarName, srcPatVarSpec in srcPatVars.items():
# find that source variable in the pattern's
# mappings
# get the name of the query variable that maps to it
varValue = None
if srcVarName in srcVarToVarDict:
varName = srcVarToVarDict[srcVarName]
# get the value of the query variable from the
# querySpec, if it was given in the query spec
varSpec = quilt_data.var_specs_tryget(varSpecs, varName)
if varSpec is not None:
varValue = quilt_data.var_spec_tryget(varSpec, value=True)
if (varValue is None and patVarSpecs is not None
and varName in patVarSpecs):
# user did not supply value for the variable in the
# query, but there is a default set in pattern definition
patVarSpec = quilt_data.var_specs_tryget(
patVarSpecs, varName)
# use the default in the pattern
varValue = quilt_data.var_spec_tryget(
patVarSpec, default=True)
if varValue is None:
# pattern definer did not supply a default, check
# to see if there is a default in the source pattern
varValue = quilt_data.var_spec_tryget(
srcPatVarSpec, default=True)
if varValue is None:
# could not determine a value for this variable
# must throw error
raise Exception("""No value set or default found
for the variable: """ + srcVarName)
# create a source query variable value with the determined value
srcQueryVarSpec = quilt_data.var_spec_create(
name=srcVarName, value=varValue)
# append it to a list of src query variables
srcQueryVarSpecs = quilt_data.var_specs_add(
srcQueryVarSpecs, srcQueryVarSpec)
# Combine strings to get a name for this source query
srcQueryName = '_'.join([qid, source, patternName])
if srcPatInstance is not None:
srcQueryName += "_" + str(srcPatInstance)
# create and return a src query spec
# TODO see Issue I001, this name may not be unique
# logging.info("srcPatSpec looks like: " + str(srcPatSpec))
srcPatName = quilt_data.src_pat_spec_get(srcPatSpec, name=True)
# get whether src pattern is ordered
ordered = quilt_data.src_pat_spec_get(srcPatSpec, ordered=True)
logging.debug("Creating " + srcQueryName + " from " + srcPatName)
return quilt_data.src_query_spec_create(
name=srcQueryName,
srcPatternName=srcPatName,
srcPatternInstance=srcPatInstance,
source=source,
ordered=ordered,
variables=srcQueryVarSpecs)
def OnRegisterEnd(self):
"""Create a patternSpec dict from arguments (name,
VARIABLES, and VARIABLE to SOURCE_VARIABLE mappings), register
this pattern with the query master"""
# create the spec with it's requested name
requestedName = self._args.name
if requestedName is None:
requestedName = "pattern"
else:
requestedName = self._args.name[0]
patternSpec = quilt_data.pat_spec_create(name=requestedName)
# create the specs for the variables
variables = None
if self._args.variable is not None:
for v in self._args.variable:
# create the variables section if it does not exist
# first position of the cmd line argument is name of variable
varName = v[0]
varSpec = quilt_data.var_spec_create(name=varName)
# if description was specified on cmd line, load it in the spec
if len(v) > 1:
varDesc = v[1]
quilt_data.var_spec_set(varSpec, description=varDesc)
# if default was specified on cmd line, load it in spec
if len(v) > 2:
varDef = v[2]
quilt_data.var_spec_set(varSpec, default=varDef)
variables = quilt_data.var_specs_add(variables, varSpec)
quilt_data.pat_spec_set(patternSpec, variables=variables)
mappings = None
# create the specs for the variable mappings
if self._args.mapping is not None:
for m in self._args.mapping:
varName = m[0]
src = m[1]
srcPat = m[2]
srcVar = m[3]
srcPatInstance = None
if len(m) > 4:
srcPatInstance = m[4]
# query variables are allowed to map to multiple
# source variables. Initialize a blank list if it isn't present
# then append the new mapping information
srcVarMappingSpec = quilt_data.src_var_mapping_spec_create(
name=varName,
sourceName=src,
sourcePattern=srcPat,
sourceVariable=srcVar,
sourcePatternInstance=srcPatInstance)
mappings = quilt_data.src_var_mapping_specs_add(
mappings, srcVarMappingSpec)
if mappings is not None:
quilt_data.pat_spec_set(patternSpec, mappings=mappings)
# if the pattern code is specified, set it in the pattern as
# a string
if self._args.code is not None:
# perform first pass parse on the pattern to ensure syntax
# call get_pattern_vars from parser, but ignore the result
# this will check the syntax
codestr = str(self._args.code)
# store the code in the pattern
quilt_data.pat_spec_set(patternSpec, code=codestr)
# syntax parsing may be dependent on variables in the pattern, so
# generate the code str after replacing any pattern variables
codestr = quilt_data.generate_query_code(patternSpec, None)
quilt_parse.get_pattern_src_refs(codestr)
# define patternSpec in the query master as a synchronous call
# return will be the pattern name
with self.GetQueryMasterProxy() as qm:
patName = qm.DefinePattern(patternSpec)
# print out pattern Name
print 'Pattern', patName, ' defined'
# return false (prevent event loop from beginning)
return False
