• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

mozilla / relman-auto-nag / #5164

15 Jul 2024 06:24PM CUT coverage: 21.876%. Remained the same
#5164

push

coveralls-python

benjaminmah
Moved PHID retrieval into conditional

716 of 3602 branches covered (19.88%)

0 of 1 new or added line in 1 file covered. (0.0%)

1933 of 8836 relevant lines covered (21.88%)

0.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/bugbot/rules/not_landed.py
1
# This Source Code Form is subject to the terms of the Mozilla Public
2
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
3
# You can obtain one at http://mozilla.org/MPL/2.0/.
4

5
import base64
×
6
import random
×
7
import re
×
8

9
from libmozdata import utils as lmdutils
×
10
from libmozdata.bugzilla import Bugzilla, BugzillaUser
×
11
from libmozdata.phabricator import (
×
12
    PhabricatorAPI,
13
    PhabricatorBzNotFoundException,
14
    PhabricatorRevisionNotFoundException,
15
)
16

17
from bugbot import utils
×
18
from bugbot.bzcleaner import BzCleaner
×
19

20
PHAB_URL_PAT = re.compile(r"https://phabricator\.services\.mozilla\.com/D([0-9]+)")
×
21

22

23
class NotLanded(BzCleaner):
×
24
    def __init__(self):
×
25
        super(NotLanded, self).__init__()
×
26
        self.nweeks = utils.get_config(self.name(), "number_of_weeks", 2)
×
27
        self.nyears = utils.get_config(self.name(), "number_of_years", 2)
×
28
        self.phab = PhabricatorAPI(utils.get_login_info()["phab_api_key"])
×
29
        self.extra_ni = {}
×
30

31
    def description(self):
×
32
        return "Open bugs with no activity for {} weeks and a r+ patch which hasn't landed".format(
×
33
            self.nweeks
34
        )
35

36
    def has_assignee(self):
×
37
        return True
×
38

39
    def get_extra_for_template(self):
×
40
        return {"nweeks": self.nweeks}
×
41

42
    def get_extra_for_needinfo_template(self):
×
43
        self.extra_ni.update(self.get_extra_for_template())
×
44
        return self.extra_ni
×
45

46
    def columns(self):
×
47
        return ["id", "summary", "assignee"]
×
48

49
    def handle_bug(self, bug, data):
×
50
        if self.has_bot_set_ni(bug):
×
51
            return None
×
52

53
        bugid = str(bug["id"])
×
54
        assignee = bug.get("assigned_to", "")
×
55
        if utils.is_no_assignee(assignee):
×
56
            assignee = ""
×
57
            nickname = ""
×
58
        else:
59
            nickname = bug["assigned_to_detail"]["nick"]
×
60

61
        data[bugid] = {
×
62
            "assigned_to": assignee,
63
            "nickname": nickname,
64
            "deps": set(bug["depends_on"]),
65
        }
66

67
        return bug
×
68

69
    def filter_bugs(self, bugs):
×
70
        # We must remove bugs which have open dependencies (except meta bugs)
71
        # because devs may wait for those bugs to be fixed before their patch
72
        # can land.
73

74
        all_deps = set(dep for info in bugs.values() for dep in info["deps"])
×
75

76
        def bug_handler(bug, data):
×
77
            if (
×
78
                bug["status"] in {"RESOLVED", "VERIFIED", "CLOSED"}
79
                or "meta" in bug["keywords"]
80
            ):
81
                data.add(bug["id"])
×
82

83
        useless = set()
×
84
        Bugzilla(
×
85
            bugids=list(all_deps),
86
            include_fields=["id", "keywords", "status"],
87
            bughandler=bug_handler,
88
            bugdata=useless,
89
        ).get_data().wait()
90

91
        for bugid, info in bugs.items():
×
92
            # finally deps will contain open bugs which are not meta
93
            info["deps"] -= useless
×
94

95
        # keep bugs with no deps
96
        bugs = {bugid: info for bugid, info in bugs.items() if not info["deps"]}
×
97

98
        return bugs
×
99

100
    def check_phab(self, attachment, reviewers_phid):
×
101
        """Check if the patch in Phabricator has been r+"""
102
        if attachment["is_obsolete"] == 1:
×
103
            return None
×
104

105
        phab_url = base64.b64decode(attachment["data"]).decode("utf-8")
×
106

107
        # extract the revision
108
        rev = PHAB_URL_PAT.search(phab_url).group(1)
×
109
        try:
×
110
            data = self.phab.load_revision(
×
111
                rev_id=int(rev), queryKey="all", attachments={"reviewers": 1}
112
            )
113
        except PhabricatorRevisionNotFoundException:
×
114
            return None
×
115

116
        # this is a timestamp
117
        last_modified = data["fields"]["dateModified"]
×
118
        last_modified = lmdutils.get_date_from_timestamp(last_modified)
×
119
        if (self.date - last_modified).days <= self.nweeks * 7:
×
120
            # Do not do anything if recent changes in the bug
121
            return False
×
122

123
        reviewers = data["attachments"]["reviewers"]["reviewers"]
×
124

125
        if not reviewers:
×
126
            return False
×
127

128
        for reviewer in reviewers:
×
129
            if reviewer["status"] != "accepted":
×
130
                return False
×
131
            reviewers_phid.add(reviewer["reviewerPHID"])
×
132

133
        value = data["fields"]["status"].get("value", "")
×
134
        if value == "changes-planned":
×
135
            # even if the patch is r+ and not published, some changes may be required
136
            # so with the value 'changes-planned', the dev can say it's still a wip
137
            return False
×
138

139
        if value != "published":
×
140
            return True
×
141

142
        return False
×
143

144
    def handle_attachment(self, attachment, res):
×
145
        ct = attachment["content_type"]
×
146
        c = None
×
147
        if ct == "text/x-phabricator-request":
×
148
            if "phab" not in res or res["phab"]:
×
149
                c = self.check_phab(attachment, res["reviewers_phid"])
×
150
                if c is not None:
×
151
                    res["phab"] = c
×
152

153
        if c is not None:
×
154
            attacher = attachment["creator"]
×
155
            if "author" in res:
×
156
                if attacher in res["author"]:
×
157
                    res["author"][attacher] += 1
×
158
                else:
159
                    res["author"][attacher] = 1
×
160
            else:
161
                res["author"] = {attacher: 1}
×
162

163
            if "count" in res:
×
164
                res["count"] += 1
×
165
            else:
166
                res["count"] = 1
×
167

168
    def get_patch_data(self, bugs):
×
169
        """Get patch information in bugs"""
170
        nightly_pat = Bugzilla.get_landing_patterns(channels=["nightly"])[0][0]
×
171

172
        def comment_handler(bug, bugid, data):
×
173
            # if a comment contains a backout: don't nag
174
            for comment in bug["comments"]:
×
175
                comment = comment["text"].lower()
×
176
                if nightly_pat.match(comment) and (
×
177
                    "backed out" in comment or "backout" in comment
178
                ):
179
                    data[bugid]["backout"] = True
×
180

181
                    # If the the bug has been backed out, we can mark it as "changes-planned" to prevent further nagging in the future
182
                    if not self.dryrun:
×
NEW
183
                        phid = data["phid"]
×
184
                        transactions = [{"type": "status", "value": "changes-planned"}]
×
185
                        self.phab.edit_revision(phid, transactions)
×
186

187
        def attachment_id_handler(attachments, bugid, data):
×
188
            for a in attachments:
×
189
                if (
×
190
                    a["content_type"] == "text/x-phabricator-request"
191
                    and a["is_obsolete"] == 0
192
                ):
193
                    data.append(a["id"])
×
194

195
        def attachment_handler(attachments, data):
×
196
            for attachment in attachments:
×
197
                bugid = str(attachment["bug_id"])
×
198
                if bugid in data:
×
199
                    data[bugid].append(attachment)
×
200
                else:
201
                    data[bugid] = [attachment]
×
202

203
        bugids = list(bugs.keys())
×
204
        data = {
×
205
            bugid: {"backout": False, "author": None, "count": 0} for bugid in bugids
206
        }
207

208
        # Get the ids of the attachments of interest
209
        # to avoid to download images, videos, ...
210
        attachment_ids = []
×
211
        Bugzilla(
×
212
            bugids=bugids,
213
            attachmenthandler=attachment_id_handler,
214
            attachmentdata=attachment_ids,
215
            attachment_include_fields=["is_obsolete", "content_type", "id"],
216
        ).get_data().wait()
217

218
        # Once we've the ids we can get the data
219
        attachments_by_bug = {}
×
220
        Bugzilla(
×
221
            attachmentids=attachment_ids,
222
            attachmenthandler=attachment_handler,
223
            attachmentdata=attachments_by_bug,
224
            attachment_include_fields=[
225
                "bug_id",
226
                "data",
227
                "is_obsolete",
228
                "content_type",
229
                "id",
230
                "creator",
231
            ],
232
        ).get_data().wait()
233

234
        for bugid, attachments in attachments_by_bug.items():
×
235
            res = {"reviewers_phid": set()}
×
236
            for attachment in attachments:
×
237
                self.handle_attachment(attachment, res)
×
238

239
            if "phab" in res:
×
240
                if res["phab"]:
×
241
                    data[bugid]["reviewers_phid"] = res["reviewers_phid"]
×
242
                    data[bugid]["author"] = res["author"]
×
243
                    data[bugid]["count"] = res["count"]
×
244

245
        data = {bugid: v for bugid, v in data.items() if v["author"]}
×
246

247
        if not data:
×
248
            return data
×
249

250
        Bugzilla(
×
251
            bugids=list(data.keys()),
252
            commenthandler=comment_handler,
253
            commentdata=data,
254
            comment_include_fields=["text"],
255
        ).get_data().wait()
256

257
        data = {bugid: v for bugid, v in data.items() if not v["backout"]}
×
258

259
        return data
×
260

261
    def get_bz_userid(self, phids):
×
262
        if not phids:
×
263
            return {}
×
264

265
        try:
×
266
            data = self.phab.load_bz_account(user_phids=list(phids))
×
267
            users = {x["phid"]: x["id"] for x in data}
×
268
        except PhabricatorBzNotFoundException:
×
269
            return {}
×
270

271
        def handler(user, data):
×
272
            data[str(user["id"])] = user["name"]
×
273

274
        data = {}
×
275
        BugzillaUser(
×
276
            user_names=list(users.values()),
277
            include_fields=["id", "name"],
278
            user_handler=handler,
279
            user_data=data,
280
        ).wait()
281

282
        return {phid: data[id] for phid, id in users.items()}
×
283

284
    def get_nicks(self, nicknames):
×
285
        def handler(user, data):
×
286
            data[user["name"]] = user["nick"]
×
287

288
        users = set(nicknames.values())
×
289
        data = {}
×
290
        if users:
×
291
            BugzillaUser(
×
292
                user_names=list(users),
293
                include_fields=["name", "nick"],
294
                user_handler=handler,
295
                user_data=data,
296
            ).wait()
297

298
        for bugid, name in nicknames.items():
×
299
            nicknames[bugid] = (name, data[name])
×
300

301
        return nicknames
×
302

303
    def get_bz_params(self, date):
×
304
        self.date = lmdutils.get_date_ymd(date)
×
305
        fields = ["flags", "depends_on"]
×
306
        params = {
×
307
            "include_fields": fields,
308
            "resolution": "---",
309
            "f1": "attachment.ispatch",
310
            "n2": 1,
311
            "f2": "attachments.isobsolete",
312
            "f3": "attachments.mimetype",
313
            "o3": "anywordssubstr",
314
            "v3": "text/x-phabricator-request",
315
            "f4": "creation_ts",
316
            "o4": "greaterthan",
317
            "v4": f"-{self.nyears}y",
318
            "f5": "days_elapsed",
319
            "o5": "greaterthaneq",
320
            "v5": self.nweeks * 7,
321
            "n6": 1,
322
            "f6": "longdesc",
323
            "o6": "casesubstring",
324
            "v6": "which didn't land and no activity in this bug for",
325
            "f7": "status_whiteboard",
326
            "o7": "notsubstring",
327
            "v7": "[reminder-test ",
328
        }
329

330
        return params
×
331

332
    def get_bugs(self, date="today", bug_ids=[]):
×
333
        bugs = super(NotLanded, self).get_bugs(date=date, bug_ids=bug_ids)
×
334
        bugs = self.filter_bugs(bugs)
×
335
        bugs_patch = self.get_patch_data(bugs)
×
336
        res = {}
×
337

338
        reviewers_phid = set()
×
339
        nicknames = {}
×
340
        for bugid, data in bugs_patch.items():
×
341
            reviewers_phid |= data["reviewers_phid"]
×
342
            assignee = bugs[bugid]["assigned_to"]
×
343
            if not assignee:
×
344
                assignee = max(data["author"], key=data["author"].get)
×
345
                nicknames[bugid] = assignee
×
346

347
        bz_reviewers = self.get_bz_userid(reviewers_phid)
×
348
        all_reviewers = set(bz_reviewers.keys())
×
349
        nicknames = self.get_nicks(nicknames)
×
350

351
        for bugid, data in bugs_patch.items():
×
352
            res[bugid] = d = bugs[bugid]
×
353
            self.extra_ni[bugid] = data["count"]
×
354
            assignee = d["assigned_to"]
×
355
            nickname = d["nickname"]
×
356

357
            if not assignee:
×
358
                assignee, nickname = nicknames[bugid]
×
359

360
            if not assignee:
×
361
                continue
×
362

363
            self.add_auto_ni(bugid, {"mail": assignee, "nickname": nickname})
×
364

365
            common = all_reviewers & data["reviewers_phid"]
×
366
            if common:
×
367
                reviewer = random.choice(list(common))
×
368
                self.add_auto_ni(
×
369
                    bugid, {"mail": bz_reviewers[reviewer], "nickname": None}
370
                )
371

372
        return res
×
373

374

375
if __name__ == "__main__":
×
376
    NotLanded().run()
×
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc