def query(self, _query): if not self.columns: self.columns = [] alias_done = set() metadata = self._es.get_metadata() for index, meta in qb.sort(metadata.indices.items(), { "value": 0, "sort": -1 }): for _, properties in meta.mappings.items(): columns = _parse_properties(index, properties.properties) for c in columns: c.cube = index c.property = c.name c.name = None c.useSource = None self.columns.extend(columns) for a in meta.aliases: # ONLY THE LATEST ALIAS IS CHOSEN TO GET COLUMNS if a in alias_done: continue alias_done.add(a) for c in columns: self.columns.append(set_default( {"cube": a}, c)) # ENSURE WE COPY return qb.run( set_default({ "from": self.columns, "sort": ["cube", "property"] }, _query.as_dict()))
def list_s3(settings, filter): """ LIST THE KEYS AND TIMESTAMPS FOUND IN AN S3 BUCKET """ with Timer("get all metadata"): metas = Bucket(settings).metas() filtered = qb.run({ "from": metas, "where": filter, "sort": "last_modified" }) for meta in filtered: Log.note("Read {{key}} {{timestamp}}", key= meta.key, timestamp= meta.last_modified)
def list_s3(settings, filter): """ LIST THE KEYS AND TIMESTAMPS FOUND IN AN S3 BUCKET """ with Timer("get all metadata"): metas = Bucket(settings).metas() filtered = qb.run({ "from": metas, "where": filter, "sort": "last_modified" }) for meta in filtered: Log.note("Read {{key}} {{timestamp}}", key=meta.key, timestamp=meta.last_modified)
def query(self, _query): try: if not self.ready: Log.error("Must use with clause for any instance of FromES") query = Query(_query, schema=self) # try: # frum = self.get_columns(query["from"]) # mvel = _MVEL(frum) # except Exception, e: # mvel = None # Log.warning("TODO: Fix this", e) # for s in listwrap(query.select): if not aggregates1_4[s.aggregate]: Log.error("ES can not aggregate " + self.select[0].name + " because '" + self.select[0].aggregate + "' is not a recognized aggregate") frum = query["from"] if isinstance(frum, Query): result = self.query(frum) q2 = query.copy() q2.frum = result return qb.run(q2) if is_aggsop(self._es, query): return es_aggsop(self._es, frum, query) if is_fieldop(self._es, query): return es_fieldop(self._es, query) if is_setop(self._es, query): return es_setop(self._es, query) Log.error("Can not handle") except Exception, e: e = Except.wrap(e) if "Data too large, data for" in e: http.post(self._es.cluster.path + "/_cache/clear") Log.error("Problem (Tried to clear Elasticsearch cache)", e) Log.error("problem", e)
def query(self, _query): try: query = Query(_query, schema=self) for n in self.namespaces: query = n.convert(query) if self.typed: query = Typed().convert(query) for s in listwrap(query.select): if not aggregates1_4.get(s.aggregate): Log.error("ES can not aggregate " + s.name + " because '" + s.aggregate + "' is not a recognized aggregate") frum = query["from"] if isinstance(frum, Query): result = self.query(frum) q2 = query.copy() q2.frum = result return qb.run(q2) if is_deepop(self._es, query): return es_deepop(self._es, query) if is_aggsop(self._es, query): return es_aggsop(self._es, frum, query) if is_setop(self._es, query): return es_setop(self._es, query) if es09_setop.is_setop(query): return es09_setop.es_setop(self._es, None, query) if es09_aggop.is_aggop(query): return es09_aggop.es_aggop(self._es, None, query) Log.error("Can not handle") except Exception, e: e = Except.wrap(e) if "Data too large, data for" in e: http.post(self._es.cluster.path+"/_cache/clear") Log.error("Problem (Tried to clear Elasticsearch cache)", e) Log.error("problem", e)
def full_etl(settings, sink, bugs): with Timer("process block {{start}}", {"start": min(bugs)}): es = elasticsearch.Index(settings.source) with FromES(es) as esq: versions = esq.query({ "from": "bugs", "select": "*", "where": {"terms": {"bug_id": bugs}} }) starts = qb.run({ "select": [ "bug_id", "bug_status", {"name": "attach_id", "value": "attachments.attach_id"}, {"name": "request_time", "value": "modified_ts"}, {"name": "request_type", "value": "attachments.flags.request_type"}, {"name": "reviewer", "value": "attachments.flags.requestee"}, {"name": "created_by", "value": "attachments.created_by"}, "product", "component" ], "from": versions, "where": {"and": [ {"terms": {"attachments.flags.request_status": ["?"]}}, {"terms": {"attachments.flags.request_type": TYPES}}, {"equal": ["attachments.flags.modified_ts", "modified_ts"]}, {"term": {"attachments.isobsolete": 0}} ]}, "sort": ["bug_id", "attach_id", "created_by"] }) ends = qb.run({ "select": [ {"name": "bug_id", "value": "bug_id"}, "bug_status", {"name": "attach_id", "value": "attachments.attach_id"}, {"name": "modified_ts", "value": lambda r: Math.max(r.modified_ts, r.attachments.modified_ts, r.attachments.flags.modified_ts)}, {"name": "reviewer", "value": "attachments.flags.requestee"}, {"name": "request_type", "value": "attachments.flags.request_type"}, {"name": "modified_by", "value": "attachments.flags.modified_by"}, {"name": "product", "value": "product"}, {"name": "component", "value": "component"}, {"name": "review_end_reason", "value": lambda r: 'done' if r.attachments.flags.request_status != '?' else ('obsolete' if r.attachments.isobsolete == 1 else 'closed')}, {"name": "review_result", "value": lambda r: '+' if r.attachments.flags.request_status == '+' else ('-' if r.attachments.flags.request_status == '-' else '?')} ], "from": versions, "where": {"and": [ {"terms": {"attachments.flags.request_type": TYPES}}, {"or": [ {"and": [# IF THE REQUESTEE SWITCHED THE ? FLAG, THEN IT IS DONE {"term": {"attachments.flags.previous_status": "?"}}, {"not": {"term": {"attachments.flags.request_status": "?"}}}, {"equal": ["attachments.flags.modified_ts", "modified_ts"]} ]}, {"and": [# IF OBSOLETED THE ATTACHMENT, IT IS DONE {"term": {"attachments.isobsolete": 1}}, {"term": {"previous_values.isobsolete_value": 0}} ]}, {"and": [# SOME BUGS ARE CLOSED WITHOUT REMOVING REVIEW {"terms": {"bug_status": ["resolved", "verified", "closed"]}}, {"not": {"terms": {"previous_values.bug_status_value": ["resolved", "verified", "closed"]}}} ]} ]} ]} }) # SOME ATTACHMENTS GO MISSING, CLOSE THEM TOO closed_bugs = {b.bug_id: b for b in qb.filter(versions, {"and": [# SOME BUGS ARE CLOSED WITHOUT REMOVING REVIEW {"terms": {"bug_status": ["resolved", "verified", "closed"]}}, {"range": {"expires_on": {"gte": Date.now().milli}}} ]})} for s in starts: if s.bug_id in closed_bugs: e = closed_bugs[s.bug_id] ends.append({ "bug_id": e.bug_id, "bug_status": e.bug_status, "attach_id": s.attach_id, "modified_ts": e.modified_ts, "reviewer": s.reviewer, "request_type": s.request_type, "modified_by": e.modified_by, "product": e.product, "component": e.component, "review_end_reason": 'closed', "review_result": '?' }) # REVIEWS END WHEN REASSIGNED TO SOMEONE ELSE changes = qb.run({ "select": [ "bug_id", {"name": "attach_id", "value": "changes.attach_id"}, "modified_ts", {"name": "reviewer", "value": lambda r: r.changes.old_value.split("?")[1]}, {"name": "request_type", "value": lambda r: r.changes.old_value.split("?")[0]}, {"name": "modified_by", "value": "null"}, "product", "component", {"name": "review_end_reason", "value": "'reassigned'"} ], "from": versions, "where": {"and": [# ONLY LOOK FOR NAME CHANGES IN THE "review?" FIELD {"term": {"changes.field_name": "flags"}}, {"or": [{"prefix": {"changes.old_value": t + "?"}} for t in TYPES]} ]} }) ends.extend(changes) # PYTHON VERSION NOT CAPABLE OF THIS JOIN, YET # reviews = qb.run({ # "from": # starts, # "select": [ # {"name": "bug_status", "value": "bug_status", "aggregate": "one"}, # {"name": "review_time", "value": "doneReview.modified_ts", "aggregate": "minimum"}, # {"name": "review_result", "value": "doneReview.review_result", "aggregate": "minimum"}, # {"name": "product", "value": "coalesce(doneReview.product, product)", "aggregate": "minimum"}, # {"name": "component", "value": "coalesce(doneReview.component, component)", "aggregate": "minimum"}, # # {"name": "keywords", "value": "(coalesce(keywords, '')+' '+ETL.parseWhiteBoard(whiteboard)).trim()+' '+flags", "aggregate": "one"}, # {"name": "requester_review_num", "value": "-1", "aggregate": "one"} # ], # "analytic": [ # {"name": "is_first", "value": "rownum==0 ? 1 : 0", "sort": "request_time", "edges": ["bug_id"]} # ], # "edges": [ # "bug_id", # "attach_id", # {"name": "reviewer", "value": "requestee"}, # {"name": "requester", "value": "created_by"}, # {"name": "request_time", "value": "modified_ts"}, # { # "name": "doneReview", # "test": # "bug_id==doneReview.bug_id && " + # "attach_id==doneReview.attach_id && " + # "requestee==doneReview.requestee && " + # "!(bug_status=='closed' && doneReview.review_end_reason=='closed') && " + # "modified_ts<=doneReview.modified_ts", # "allowNulls": True, # "domain": {"type": "set", "key":["bug_id", "attach_id", "requestee", "modified_ts"], "partitions": ends} # } # ] # }) with Timer("match starts and ends for block {{start}}", {"start":min(*bugs)}): reviews = [] ends = Index(data=ends, keys=["bug_id", "attach_id", "request_type", "reviewer"]) for g, s in qb.groupby(starts, ["bug_id", "attach_id", "request_type", "reviewer"]): start_candidates = qb.sort(s, {"value": "request_time", "sort": 1}) end_candidates = qb.sort(ends[g], {"value": "modified_ts", "sort": 1}) #ZIP, BUT WITH ADDED CONSTRAINT s.modified_ts<=e.modified_ts if len(start_candidates) > 1: Log.note("many reviews on one attachment") ei = 0 for i, s in enumerate(start_candidates): while ei < len(end_candidates) and end_candidates[ei].modified_ts < coalesce(s.request_time, convert.datetime2milli(Date.MAX)): ei += 1 e = end_candidates[ei] s.review_time = e.modified_ts s.review_duration = e.modified_ts - s.request_time s.review_result = e.review_result s.review_end_reason = e.review_end_reason s.product = coalesce(e.product, s.product) s.component = coalesce(e.component, s.component) s.requester_review_num = -1 ei += 1 if s.bug_status == 'closed' and e.review_end_reason == 'closed': #reviews on closed bugs are ignored continue reviews.append(s) qb.run({ "from": reviews, "window": [{ "name": "is_first", "value": "rownum == 0", "edges": ["bug_id"], "sort": ["request_time"], "aggregate": "none" }] }) with Timer("add {{num}} reviews to ES for block {{start}}", {"start": min(*bugs), "num": len(reviews)}): sink.extend({"json": convert.value2json(r)} for r in reviews)
def replicate(source, destination, pending, last_updated): """ COPY THE DEPENDENCY RECORDS TO THE destination NOTE THAT THE PUBLIC CLUSTER HAS HOLES, SO WE USE blocked TO FILL THEM """ for g, bugs in qb.groupby(pending, max_size=BATCH_SIZE): with Timer("Replicate {{num_bugs}} bug versions", {"num_bugs": len(bugs)}): data = source.search({ "query": {"filtered": { "query": {"match_all": {}}, "filter": {"and": [ {"terms": {"bug_id": set(bugs)}}, {"range": {"expires_on": {"gte": convert.datetime2milli(last_updated)}}}, {"or": [ {"exists": {"field": "dependson"}}, {"exists": {"field": "blocked"}} ]} ]} }}, "from": 0, "size": 200000, "sort": [], "fields": ["bug_id", "modified_ts", "expires_on", "dependson", "blocked"] }) with Timer("Push to destination"): d2 = [ { "id": str(x.bug_id) + "_" + str(x.modified_ts)[:-3], "value": { "bug_id": x.bug_id, "modified_ts": x.modified_ts, "expires_on": x.expires_on, "dependson": x.dependson } } for x in data.hits.hits.fields if x.dependson ] destination.extend(d2) with Timer("filter"): d4 = qb.run({ "from": data.hits.hits.fields, "where": {"exists": {"field": "blocked"}} }) with Timer("select"): d3 = qb.run({ "from": d4, "select": [ {"name": "bug_id", "value": "blocked."}, # SINCE blocked IS A LIST, ARE SELECTING THE LIST VALUES, AND EFFECTIVELY PERFORMING A JOIN "modified_ts", "expires_on", {"name": "dependson", "value": "bug_id"} ] }) with Timer("Push to destination"): destination.extend([ { "id": str(x.bug_id) + "_" + str(x.dependson) + "_" + str(x.modified_ts)[:-3], "value": x } for x in d3 if x.dependson ])