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
])
