def test_basic_query(self): qstr = 'find me again ' + str(random.random()) # call quilt_submit "find me again" (check return code) quilt_test_core.call_quilt_script('quilt_submit.py', [qstr, '-y'], checkCall=False) # sleep a small amount quilt_test_core.sleep_small() # Use QuiltConfig, Call GetSourceManagers, for each one # use pyro, create proxy for the smd # call GetLastQuery() # assure it is equal to "find me again [uniqueval]" cfg = quilt_core.QuiltConfig() with quilt_core.GetQueryMasterProxy(cfg) as qm: smgrs = qm.GetClients("SourceManager") for smgr in smgrs: clientRec = qm.GetClientRec("SourceManager", smgr) with query_master.get_client_proxy(clientRec) as smgrClient: lastQuery = smgrClient.GetLastQuery() # after more functionality was added sources won't be called # unless referenced in the query. we should no longer # see the unique query string down on the source # we wouldn't anyway because it isn't the ID. The # last query stuff was just a hack to get testing in # 0.1.c1, and is added to issue list to remove # TODO see ISSUE004 self.assertTrue(lastQuery != qstr) # check qmd to be sure that all quilt_submit's have unregistered # do this by accessing Config, finding qmd name, qs = qm.GetClients("QuiltSubmit") # make sure list is empty self.assertTrue(len(qs) == 0)
def OnRegisterEnd(self): """ Retrieve the querySpec from the query master and issue the srcQueries to the source """ qid = None try: # use query id passed in arguments if self._args.query_id is not None: qid = self._args.query_id[0] else: raise Exception("Query ID is required") # Access the QuiltQuery's registrar's host and port from the config config = quilt_core.QuiltConfig() rport = config.GetValue("registrar", "port", None, int) if rport is not None: rport = int(rport) rhost = config.GetValue("registrar", "host", None) self._registrarPort = rport self._registrarHost = rhost # set the state to ACTIVE by calling BeginQuery # store pattern and query as a data member with self.GetQueryMasterProxy() as qm: self._patternSpec, self._querySpec = qm.BeginQuery(qid) # get the query spec from query master queryState = quilt_data.query_spec_get(self._querySpec, state=True) if queryState != quilt_data.STATE_ACTIVE: raise Exception("Query: " + qid + ", must be in " + quilt_data.STATE_ACTIVE + " state. It is currently in " + queryState + " state.") # iterate the sourceQuerySpec's in srcQueries list srcQuerySpecs = quilt_data.query_spec_tryget( self._querySpec, sourceQuerySpecs=True) # there are no source query specs specified if srcQuerySpecs is None: # so just don't do anything self._processEvents = False return self._srcQuerySpecs = srcQuerySpecs for srcQuerySpec in srcQuerySpecs.values(): # mark the sourceQuery ACTIVE quilt_data.src_query_spec_set(srcQuerySpec, state=quilt_data.STATE_ACTIVE) # get proxy to the source manager source = quilt_data.src_query_spec_get( srcQuerySpec, source=True) smgrRec = qm.GetClientRec("smd", source) # TODO make more efficient by recycling proxies to same source # in the case when making multi source queries to same source with query_master.get_client_proxy(smgrRec) as smgr: # query the source by sending it the source query specs as # asynchronous call Pyro4.async(smgr).Query( qid, srcQuerySpec, self.localname, rhost, rport) # Note: no locking needed # asynchronous call, and returning messages not # processed until this function exits self._processEvents = True except Exception, error: try: with self.GetQueryMasterProxy() as qm: qm.OnQueryError(qid, error) except Exception, error2: logging.error( "Unable to send query startup error to query master") logging.exception(error2)