Share
In het tweede deel van deze serie, zag je hoe je de commit-informatie verzamelt uit de git-logs en evaluatieverzoeken verzendt naar willekeurige ontwikkelaars geselecteerd uit de projectledenlijst.
In dit deel ziet u hoe u de codebeoordelingsinformatie opslaat die moet worden opgevolgd telkens wanneer de codeplanner wordt uitgevoerd. U zult ook zien hoe u e-mails kunt lezen om te controleren of de recensent heeft gereageerd op het beoordelingsverzoek.
Begin met het klonen van de broncode uit het tweede deel van de zelfstudiereeks.
git clone https://github.com/royagasthyan/CodeReviewer-Part2 CodeReviewer
Wijzig de config.json bestand om enkele relevante e-mailadressen op te nemen, de [email protected] e-mailadres. Het is omdat het git commits heeft gerelateerd aan het specifieke e-mailadres dat nodig is om de code uit te voeren zoals verwacht. Wijzig de SMTP referenties in de schedule.py het dossier:
FROM_EMAIL = "[email protected]" FROM_PWD = "your_password"
Navigeer naar de projectdirectory CodeReviewer en probeer de volgende opdracht in de terminal uit te voeren.
python scheduler.py -n 20 -p "project_x"
Het moet het verzoek om codewaarneming naar willekeurige ontwikkelaars sturen ter beoordeling.
Als u de informatie over de beoordelingsverzoek wilt opvolgen, moet u deze ter referentie bewaren. U kunt selecteren waar u de aanvraag voor codeverklaring wilt houden. Het kan elke database zijn of een bestand zijn. In het belang van deze zelfstudie houden we de informatie over het verzoek om een recensie binnen een reviewer.json het dossier. Telkens wanneer de planner wordt uitgevoerd, controleert deze het infobestand om gevolg te geven aan de beoordelingsverzoeken waarop niet is gereageerd.
Maak een methode genaamd save_review_info waarmee de informatie over het beoordelingsverzoek in een bestand wordt opgeslagen. Binnen in de save_review_info methode, maak een info object met de recensent, onderwerp en een unieke id.
def save_review_info (reviewer, onderwerp): info = 'reviewer': reviewer, 'subject': subject, 'id': str (uuid.uuid4 ()), 'sendDate': str (datetime.date.today ())
Voor een unieke id importeert u de uuid Python-module.
voer uuid in
Je hebt ook de datum Tijd Python-module om de huidige datum te krijgen. Importeer de datum Tijd Python-module.
import datetime
U moet de initialiseren reviewer.json bestand wanneer het programma start als het nog niet bestaat.
Accentsconagua
if not os.path.exists ('reviewer.json'): met open ('reviewer.json', 'w +') als outfile: json.dump ([], outfile)Als het bestand niet bestaat, moet u een bestand maken met de naam reviewer.json en vul het met een lege JSON-array zoals te zien in de bovenstaande code.
Deze methode wordt elke keer dat een beoordelingsverzoek wordt verzonden aangeroepen. Dus, binnen de save_review_info methode, open de reviewer.json bestand in de leesmodus en lees de inhoud. Voeg de nieuwe inhoudsinformatie toe aan de bestaande inhoud en schrijf deze terug naar de reviewer.json het dossier. Hier is hoe de code eruit zou zien:
def save_review_info (reviewer, onderwerp): info = 'reviewer': reviewer, 'subject': subject, 'id': str (uuid.uuid4 ()), 'sendDate': str (datetime.date.today ()) met open ('reviewer.json', 'r') als infile: review_data = json.load (infile) review_data.append (info) met open ('reviewer.json', 'w') als outfile: json.dump (review_data, outfile)Binnen in de schedule_review_request methode, voor het verzenden van de code beoordeling verzoek mail, bel de save_review_info methode om de beoordelingsinformatie op te slaan.
def schedule_review_request (commits): date = time.strftime ("% Y-% m-% d") voor commit in commits: reviewer = select_reviewer (commit.Author, project_members) subject = date + "Code Review [commit:" + commit.Id + "]" body = "Hallo '" + reviewer + "', je bent geselecteerd om de code voor commit te bekijken \ n" body + = "gedaan door '" + commit.Author + "'. \ n "body + =" \ n "body + = format_review_commit (commit) save_review_info (recensent, onderwerp); send_email (recensent, onderwerp, lichaam)Sla de bovenstaande wijzigingen op en voer het planningsprogramma uit. Nadat de planner is uitgevoerd, zou u de reviewer.json bestand in de projectdirectory met de codeverklagende verzoekinformatie. Hier is hoe het eruit zou zien:
["reviewer": "[email protected]", "id": "8ca7da84-9da7-4a17-9843-be293ea8202c", "sendDate": "2017-02-24", "onderwerp": "2017-02 -24 Code Review [commit: 16393106c944981f57b2b48a9180a33e217faacc] ", " reviewer ":" [email protected] "," id ":" 68765291-1891-4b50-886e-e30ab41a8810 "," sendDate ":" 2017-02- 24 "," subject ":" 2017-02-24 Code Review [commit: 04d11e21fb625215c5e672a93d955f4a176e16e4] "]
U hebt alle informatie over de codeaanvraag verzameld en opgeslagen in de reviewer.json het dossier. Telkens wanneer de planner wordt uitgevoerd, moet u uw Postvak IN controleren om te zien of de revisor heeft gereageerd op het verzoek om codeherziening. Dus eerst moet je een methode definiëren om je Gmail-inbox te lezen.
Maak een methode genaamd read_email waarbij het aantal dagen duurt om de inbox als parameter te controleren. U zult gebruik maken van de imaplib Python-module om de e-mailinbox te lezen. Importeer de imaplib Python-module:
import imaplib
Om de e-mail te lezen met behulp van de imaplib module, moet u eerst de server maken.
email_server = imaplib.IMAP4_SSL (SERVER)
Log in op de server met het e-mailadres en wachtwoord:
email_server.login (FROM_EMAIL, FROM_PWD)
Nadat u bent ingelogd, selecteert u de inbox om de e-mails te lezen:
email_server.select ( 'inbox')
U leest de e-mails voor het afgelopen aantal dagen sinds het verzoek tot codeverificatie werd verzonden. Importeer de timedelta Python-module.
tijdstempel importeren
Maak de e-maildatum zoals getoond:
email_date = datetime.date.today () - timedelta (days = num_days) formatted_date = email_date.strftime ('% d-% b-% Y')De ... gebruiken FORMATTED_DATE, zoek in de e-mailserver naar e-mails.
typ, data = email_server.search (None, '(SINCE "' + formatted_date + '")')
Hiermee worden de unieke ID's voor elke e-mail geretourneerd en met behulp van de unieke ID's ontvangt u de e-mailgegevens.
ids = data [0] id_list = ids.split () first_email_id = int (id_list [0]) last_email_id = int (id_list [-1])
Nu maakt u gebruik van de first_email_id en de last_email_id om de e-mails te doorlopen en het onderwerp en het "van" -adres van de e-mails op te halen.
voor i in bereik (last_email_id, first_email_id, -1): typ, data = email_server.fetch (i, '(RFC822)')
gegevens zal de e-mailinhoud bevatten, dus herhaler het datagedeelte en controleer op een tuple. U maakt gebruik van de module Python e-mail om de details op te halen. Dus importeer de e-mail Python-module.
importeer email
U kunt het onderwerp van de e-mail en het "van" -adres extraheren zoals getoond:
voor response_part in data: if isinstance (response_part, tuple): msg = email.message_from_string (response_part [1]) print 'From:' + msg ['from'] print '\ n' print 'Onderwerp:' + msg [' onderwerp '] afdrukken' \ n 'afdrukken' ---------------------------------------- --------'
Hier is het complete read_email methode:
def read_email (num_days): try: email_server = imaplib.IMAP4_SSL (SERVER) email_server.login (FROM_EMAIL, FROM_PWD) email_server.select ('inbox') email_date = datetime.date.today () - timedelta (days = num_days) formatted_date = email_date.strftime ('% d-% b-% Y') typ, data = email_server.search (Geen, '(SINCE "' + formatted_date + '")') ids = data [0] id_list = ids.split ( ) first_email_id = int (id_list [0]) last_email_id = int (id_list [-1]) voor i in bereik (last_email_id, first_email_id, -1): typ, data = email_server.fetch (i, '(RFC822)') voor response_part in data: if isinstance (response_part, tuple): msg = email.message_from_string (response_part [1]) print 'From:' + msg ['from'] print '\ n' print 'Onderwerp:' + msg ['subject '] print' \ n 'print' ----------------------------------------- ------- 'behalve uitzondering, e: print str (e)Sla de bovenstaande wijzigingen op en voer het bovenstaande uit read_email methode:
read_email (1)
Het moet het onderwerp van de e-mail en het "van" -adres op de terminal afdrukken.
Laten we nu het 'van'-adres en onderwerp verzamelen in een email_info lijst en retourneer de gegevens.
email_info = []
In plaats van het onderwerp en het "van" -adres af te drukken, voegt u de gegevens toe aan de email_info lijst en retourneer de email_info lijst.
email_info.append ( 'Van': msg [ 'uit'], 'Subject':. msg [subject] vervangen ( "\ r \ n", ""))
Dit is het aangepaste read_email methode:
def read_email (num_days): try: email_info = [] email_server = imaplib.IMAP4_SSL (SERVER) email_server.login (FROM_EMAIL, FROM_PWD) email_server.select ('inbox') email_date = datetime.date.today () - timedelta (days = num_days) formatted_date = email_date.strftime ('% d-% b-% Y') typ, data = email_server.search (Geen, '(SINCE "' + formatted_date + '")') ids = data [0] id_list = ids.split () first_email_id = int (id_list [0]) last_email_id = int (id_list [-1]) voor i in bereik (last_email_id, first_email_id, -1): typ, data = email_server.fetch (i, '(RFC822 ) ') voor response_part in data: if isinstance (response_part, tuple): msg = email.message_from_string (response_part [1]) email_info.append (' From ': msg [' from '],' Subject ': msg [' subject ']. replace ("\ r \ n", "")) behalve uitzondering, e: print str (e) return email_infoFoutafhandeling is een belangrijk aspect van softwareontwikkeling. Het is echt handig tijdens de foutopsporingsfase om bugs te traceren. Als u geen foutafhandeling hebt, wordt het erg moeilijk om de fout op te sporen. Omdat je met een aantal nieuwe methoden groeit, denk ik dat dit het juiste moment is om foutafhandeling toe te voegen aan de schedulercode.
Als u aan de slag wilt gaan met het afhandelen van fouten, heeft u de logging Python-module en de RotatingFileHandler klasse. Importeer ze zoals getoond:
import logging van logging.handlers importeert RotatingFileHandler
Zodra u de vereiste import heeft, initialiseert u de logger zoals getoond:
logger = logging.getLogger ("Code Review Log") logger.setLevel (logging.INFO)In de bovenstaande code hebt u de logger geïnitialiseerd en het logniveau ingesteld op INFO.
Maak een roterende logboekhandler voor bestanden die een nieuw bestand maakt telkens wanneer het logbestand een maximale grootte heeft bereikt.
logHandler = RotatingFileHandler ('app.log', maxBytes = 3000, backupCount = 2)Bevestig de LogHandler naar de houthakker voorwerp.
logger.addHandler (LogHandler)
Laten we de foutlogger toevoegen om fouten te loggen wanneer een uitzondering wordt betrapt. In de read_email methode uitzonderingsgedeelte, voeg de volgende code toe:
logger.error (str (datetime.datetime.now ()) + "- Fout tijdens het lezen van mail:" + str (e) + "\ n") logger.exception (str (e))
De eerste regel logt het foutbericht met de huidige datum en tijd in het logbestand. De tweede regel registreert de stapeltracering naar de fout.
Op dezelfde manier kunt u de foutafhandeling toevoegen aan het hoofdgedeelte van de code. Hier is hoe de code met foutafhandeling eruit zou zien:
try: commits = process_commits () if len (commits) == 0: print 'Geen commits gevonden' anders: schedule_review_request (commits) except Exception, e: print 'Fout opgetreden. Controleer log voor details. ' logger.error (str (datetime.datetime.now ()) + "- Fout tijdens het lezen van mail:" + str (e) + "\ n") logger.exception (str (e))
In dit deel van de serie hebt u de informatie over het beoordelingsverzoek in de reviewer.json het dossier. Je hebt ook een methode gemaakt om de e-mails te lezen. Je zult deze beide functies gebruiken om de codeaanvragen in het laatste deel van deze serie op te volgen.
Aarzel niet om te zien wat we te koop aanbieden en om te studeren op de markt, en aarzel niet om vragen te stellen en uw waardevolle feedback te geven met behulp van de onderstaande feed.
Broncode van deze tutorial is beschikbaar op GitHub.
Laat ons uw mening en suggesties weten in de opmerkingen hieronder.
