GitHub மெர்ஜ் வரிசையை இயக்க PyGithub உடன் விதிகள் மற்றும் கிளைப் பாதுகாப்பு விதிகளைப் பயன்படுத்தவும்

GitHub உடன் ஒன்றிணைக்கும் செயல்முறைகளை நெறிப்படுத்துதல்: ஒன்றிணைக்கும் வரிசைகளை இயக்குவதற்கான வழிகாட்டி

மென்பொருள் மேம்பாட்டுக் குழுக்கள் வளரும்போது, ​​அவற்றின் Git பணிப்பாய்வுகளின் சிக்கலான தன்மையும் அதிகரிக்கிறது. பல களஞ்சியங்களை நிர்வகிப்பது, இழுக்கும் கோரிக்கைகளைக் கையாள்வது மற்றும் சீரான ஒருங்கிணைப்பை உறுதி செய்வது ஒரு சவாலாக இருக்கலாம். இந்தச் சிக்கல்களைத் தீர்ப்பதை நோக்கமாகக் கொண்ட சமீபத்திய முன்னேற்றங்களில் ஒன்று GitHub இன் Merge Queue ஆகும். இந்த அம்சம், கட்டுப்படுத்தப்பட்ட மற்றும் யூகிக்கக்கூடிய முறையில் இழுத்தல் கோரிக்கைகளை ஒன்றிணைக்கும் செயல்முறையை தானியங்குபடுத்த உங்களை அனுமதிக்கிறது, குறியீடு முரண்பாடுகளை ஏற்படுத்தாமல் எப்போதும் புதுப்பித்த நிலையில் இருப்பதை உறுதிசெய்கிறது. 🚀

இருப்பினும், Merge Quee ஐ இயக்குவது மற்றும் கட்டமைப்பது ஒரு சுவிட்சை புரட்டுவது போல் நேரடியானதல்ல. இதற்கு GitHub GraphQL API ஐப் பயன்படுத்த வேண்டும், குறிப்பாக விதிகள் மூலம் சரியான அமைப்பிற்கு. டெவலப்பர்கள், என்னைப் போலவே, இந்த அம்சங்களை அளவில் செயல்படுத்த முயற்சிக்கும்போது, ​​குறிப்பாக நூற்றுக்கணக்கான களஞ்சியங்களை நிர்வகிக்கும் போது, ​​அடிக்கடி சவால்களை எதிர்கொள்கின்றனர். கிட்ஹப் விவாதங்களில் ஆழமாக மூழ்கி, இணைப்பு வரிசைகள் தொடர்பான பயனுள்ள ஆனால் இன்னும் சிக்கலான விளக்கங்களில் தடுமாறியது எனக்கு நினைவிருக்கிறது. ஆனால் இந்த அம்சத்தை திறம்பட செயல்படுத்த சரியான GraphQL பிறழ்வை எவ்வாறு எழுதுவது என்பதைப் புரிந்துகொள்வதே உண்மையான தந்திரம். 🤔

கிளை பாதுகாப்பு விதிகள் பற்றிய எனது முதல் அனுபவம் ஒரு புதிர் போன்றது. GraphQL ஐப் பயன்படுத்தி என்னால் கிளைகளை வெற்றிகரமாகப் பாதுகாக்க முடிந்தது, ஆனால் ஒன்றிணைப்பு வரிசை செயல்பாட்டை உள்ளமைக்க இன்னும் குறிப்பிட்ட அணுகுமுறை தேவை. இந்த வழிகாட்டியின் குறிக்கோள், உங்கள் களஞ்சியங்களில் ஒன்றிணைக்கும் வரிசையை எவ்வாறு இயக்குவது, வழியில் உள்ள சில பொதுவான சாலைத் தடைகளை நிவர்த்தி செய்வது மற்றும் இந்த பணிகளை எளிதாக்குவதில் PyGithub எவ்வாறு முக்கிய பங்கு வகிக்கிறது என்பதை விளக்குவது. இது விதிகளைச் சேர்ப்பது மட்டுமல்ல, அவற்றைச் சீராகச் செயல்பட வைப்பதும் ஆகும். 💻

இந்த இடுகையில், GraphQL APIகள் மற்றும் விதிகள் ஆகியவற்றைப் பயன்படுத்தி Merge Queue ஐ இயக்கும் செயல்முறையை ஆராய்வோம். API அழைப்புகள் மூலம் கிளைப் பாதுகாப்பு விதிகளை எவ்வாறு தானியங்குபடுத்துவது என்பதை நீங்கள் பார்க்கலாம், மேலும் பிறழ்வுகள் மூலம் நீங்கள் சவால்களை எதிர்கொண்டாலும் கூட, இந்த வழிகாட்டி தெளிவை வழங்கும். கூடுதலாக, இந்த அம்சத்தை உள்ளமைப்பதற்கான மாற்று வழிகளைப் பற்றி நாங்கள் விவாதிப்போம், குறிப்பாக நீங்கள் GraphQL உடன் நேரடியாக வேலை செய்வதற்குப் பதிலாக PyGithub ஐப் பயன்படுத்தி மேலும் அணுகக்கூடிய அணுகுமுறையைத் தேடுகிறீர்கள் என்றால். நடைமுறை எடுத்துக்காட்டுகள் மற்றும் சில பிழைகாணல் உதவிக்குறிப்புகள் மூலம், உங்கள் GitHub அனுபவத்தை மேலும் திறம்படச் செய்வதை நோக்கமாகக் கொண்டுள்ளோம். 🔧

ஸ்கிரிப்ட் எவ்வாறு இயங்குகிறது மற்றும் எதற்காகப் பயன்படுத்தப்படுகிறது

இந்த ஸ்கிரிப்ட்டில், ஒரு களஞ்சியத்திற்கு கிளை பாதுகாப்பு விதிகளை உள்ளமைக்க GitHub இன் GraphQL API ஐப் பயன்படுத்துவதே குறிக்கோள். GraphQL வினவல் ஐப் பயன்படுத்தி களஞ்சிய ஐடியைப் பெற GitHub இன் API க்கு கோரிக்கையை அனுப்புவதன் மூலம் செயல்முறை தொடங்குகிறது. இது இன்றியமையாதது, ஏனெனில் கிளை பாதுகாப்பு அல்லது இணைப்பு வரிசைகளை இயக்குதல் போன்ற எந்த மாற்றங்களையும் பயன்படுத்த ஐடி தேவைப்படுகிறது. `get_repository_id()` செயல்பாட்டில், களஞ்சியத்தின் பெயர் மற்றும் உரிமையாளருடன் கோரிக்கை வைக்கப்பட்டு, களஞ்சியத்தின் தனிப்பட்ட ஐடியை மீட்டெடுக்கிறது. இந்த ஐடியுடன் API பதிலளிக்கிறது, இது பாதுகாப்பு விதிகளை உருவாக்குவதைத் தொடர அனுமதிக்கிறது.

கிளை பாதுகாப்பு விதிகளைப் பயன்படுத்துவதற்கு களஞ்சிய ஐடியைப் பயன்படுத்துவது அடுத்த படியாகும். `create_branch_protection_rule()` செயல்பாடு ஒரு கிளைக்கான பாதுகாப்பை அமைக்க GraphQL பிறழ்வை உருவாக்குகிறது. இந்த வழக்கில், பாதுகாக்கப்பட வேண்டிய கிளையானது `BRANCH_PATTERN` மாறியால் வரையறுக்கப்படுகிறது, மேலும் பாதுகாப்பு விதிகளில் மதிப்புரைகளை அங்கீகரித்தல், நிலை சரிபார்ப்புகளை உறுதி செய்தல் மற்றும் நிர்வாக அனுமதிகளைச் செயல்படுத்துதல் போன்ற தேவைகள் அடங்கும். இந்த அமைப்புகள் களஞ்சியத்தின் தேவைகளின் அடிப்படையில் தனிப்பயனாக்கப்படுகின்றன, அதாவது பாஸிங் பில்ட்களை மட்டுமே ஒன்றிணைக்க முடியும் என்பதை உறுதிப்படுத்துவது அல்லது கண்டிப்பான ஒப்புதல் பணிப்பாய்வுகளைச் செயல்படுத்துவது போன்றவை.

பிறழ்வு வரையறுக்கப்பட்டவுடன், ஸ்கிரிப்ட் `requests.post` முறையைப் பயன்படுத்தி GitHub இன் GraphQL API க்கு கோரிக்கையை அனுப்புகிறது. இது பிறழ்வு வினவல் மற்றும் தொடர்புடைய அளவுருக்களுடன் POST கோரிக்கைஐ அனுப்புகிறது. கோரிக்கை வெற்றிகரமாக இருந்தால், உருவாக்கப்பட்ட பாதுகாப்பு விதியின் விவரங்களை API வழங்கும். `response.status_code` செயல்பாடு வெற்றிகரமாக இருப்பதை உறுதிசெய்ய சரிபார்க்கப்பட்டது, மேலும் ஏதேனும் பிழை ஏற்பட்டால், விதிவிலக்கு எழுப்பப்படும். ஏதேனும் தவறு நடந்தால், ஸ்கிரிப்ட் பயனரை ஒரு பயனுள்ள பிழை செய்தியுடன் எச்சரிக்க முடியும் என்பதை உறுதிப்படுத்த இந்த வழிமுறை உதவுகிறது.

இறுதியாக, ஸ்கிரிப்ட் மாடுலர் மற்றும் பல களஞ்சியங்களுக்கு மீண்டும் பயன்படுத்தக்கூடியதாக வடிவமைக்கப்பட்டுள்ளது. `REPOSITORY_OWNER` மற்றும் `REPOSITORY_NAME` போன்ற அளவுருக்களை சரிசெய்வதன் மூலம் இதை 100s களஞ்சியங்கள் வரை எளிதாக அளவிடலாம். பல களஞ்சியங்களில் ஒரே பாதுகாப்பு விதிகளை நீங்கள் பயன்படுத்த வேண்டும் என்றால், உள்ளீட்டு மதிப்புகளை மாற்றுவதன் மூலம் ஸ்கிரிப்ட் நெகிழ்வுத்தன்மையை அனுமதிக்கிறது. கூடுதலாக, CI/CD பைப்லைன்கள் போன்ற பெரிய தானியங்கி பணிப்பாய்வுகளில் எளிதாக ஒருங்கிணைக்கக்கூடிய வகையில் ஸ்கிரிப்ட் கட்டமைக்கப்பட்டுள்ளது, இதில் கிளைகளைப் பாதுகாப்பது அல்லது ஒன்றிணைக்கும் வரிசையை இயக்குவது பல திட்டங்களில் நிலையான குறியீட்டுத் தரத்தை பராமரிக்க முக்கியமானது. 🚀

import requests
GITHUB_API_URL = 'https://api.github.com/graphql'
TOKEN = 'your_token_here'
headers = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json"
}
# Repository and Branch details
REPOSITORY_OWNER = "your_owner_name"
REPOSITORY_NAME = "your_repo_name"
BRANCH_PATTERN = "main"
# GraphQL mutation for creating a merge queue rule
mutation = """
mutation($repositoryId: ID!, $branchPattern: String!) {
  createMergeQueueRule(input: {
    repositoryId: $repositoryId,
    pattern: $branchPattern,
    requiresStatusChecks: true,
    allowsMergeQueue: true,
  }) {
    mergeQueueRule {
      id
      pattern
      requiresStatusChecks
      allowsMergeQueue
    }
  }
}"""
# Query to fetch repository ID
repository_query = """
query($owner: String!, $name: String!) {
  repository(owner: $owner, name: $name) {
    id
  }
}"""
def get_repository_id():
    variables = {"owner": REPOSITORY_OWNER, "name": REPOSITORY_NAME}
    response = requests.post(
        GITHUB_API_URL,
        json={"query": repository_query, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        return response.json()["data"]["repository"]["id"]
    else:
        raise Exception(f"Failed to fetch repository ID: {response.json()}")
def enable_merge_queue(repository_id):
    variables = {
        "repositoryId": repository_id,
        "branchPattern": BRANCH_PATTERN,
    }
    response = requests.post(
        GITHUB_API_URL,
        json={"query": mutation, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        print("Merge queue rule created:", response.json()["data"]["createMergeQueueRule"]["mergeQueueRule"])
    else:
        raise Exception(f"Failed to create merge queue rule: {response.json()}")
# Execute
try:
    repository_id = get_repository_id()
    enable_merge_queue(repository_id)
except Exception as e:
    print("Error:", e)

from github import Github
import os
# GitHub access token and repository details
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
g = Github(GITHUB_TOKEN)
# Define the repository and branch pattern
repo_name = "your_repo_name"
branch_name = "main"
# Get the repository object
repo = g.get_repo(repo_name)
# Fetch the branch protection rule
branch = repo.get_branch(branch_name)
protection = branch.get_protection()
# Update branch protection to enable merge queue
protection.update(
    required_status_checks={"strict": True, "contexts": []},
    enforce_admins=True,
    allow_force_pushes=False,
    dismiss_stale_reviews=True,
    required_pull_request_reviews={"dismissal_restrictions": {}, "require_code_owner_reviews": True},
    merge_queue_enabled=True
)
# Display status
print(f"Merge queue enabled for branch {branch_name}")

GitHub இன் GraphQL API மற்றும் Rulesets உடன் வரிசையை ஒன்றிணைத்தல்

பெரிய களஞ்சியங்களை நிர்வகிக்கும் போது, ​​குறிப்பாக பல குழுக்கள் மற்றும் திட்டங்களில், ஒன்றிணைக்கும் செயல்முறையை சீரமைக்க ஒரு இணைப்பு வரிசையை செயல்படுத்துவது முக்கியமானது. இது வெவ்வேறு கிளைகளில் செய்யப்பட்ட மாற்றங்கள் மதிப்பாய்வு செய்யப்பட்டு, சோதிக்கப்பட்டு, முரண்பாடுகளை ஏற்படுத்தாமல் அல்லது முக்கிய கிளையை உடைக்காமல் ஒருங்கிணைக்கப்படுவதை இது உறுதி செய்கிறது. GitHub இன் ஒன்றிணைப்பு வரிசை ஒரு சிறந்த தீர்வாகும், ஏனெனில் இது நூற்றுக்கணக்கான களஞ்சியங்களைக் கையாளும் போது, ​​பாதுகாப்பான மற்றும் ஒழுங்கான முறையில் இழுக்கும் கோரிக்கைகளை ஒன்றிணைக்கும் செயல்முறையை தானியக்கமாக்குகிறது. தேவையான மதிப்புரைகள் மற்றும் நிலை சரிபார்ப்புகள் போன்ற காசோலைகளைச் செயல்படுத்தும் பாரம்பரிய கிளைப் பாதுகாப்பு விதிகளைப் போலல்லாமல், ஒன்றிணைப்பு வரிசையானது கட்டுப்படுத்தப்பட்ட, தொடர்ச்சியான இழுவை கோரிக்கைகளை ஒன்றிணைக்க அனுமதிக்கிறது, இது ஒரு மென்மையான CI/CD பைப்லைனை உறுதி செய்கிறது.

இருப்பினும், பல களஞ்சியங்களுக்கு இந்த அம்சத்தை இயக்குவதற்கு GitHub இன் GraphQL API பற்றிய உறுதியான புரிதல் தேவைப்படுகிறது, இது ஒன்றிணைப்பு வரிசையை இயக்குவது உட்பட களஞ்சிய அமைப்புகளின் மீது அதிக நுணுக்கமான கட்டுப்பாட்டை எளிதாக்குகிறது. கிளைப் பாதுகாப்பு விதிகளை உருவாக்கும் செயல்முறையானது GraphQL பிறழ்வுகளைப் பயன்படுத்தி ஒப்பீட்டளவில் நேரடியானதாக இருந்தாலும், இணைத்தல் வரிசை செயல்பாட்டைச் சேர்ப்பதற்கு விதிமுறைகளில் ஆழமாகச் செல்ல வேண்டும். ரூல்செட்டுகள் அடிப்படையில் GitHub இன் GraphQL API க்குள் உள்ள ஒரு உள்ளமைவு கருவியாகும், இது நீங்கள் வரையறுக்கும் அளவுகோல்களின் அடிப்படையில் PR களை தானாக வரிசைப்படுத்துவது உட்பட, இழுக்க கோரிக்கை ஒன்றிணைப்பதற்கான சிக்கலான நிபந்தனைகளை செயல்படுத்த உங்களை அனுமதிக்கிறது.

விதிமுறைகளை இணைத்தல் வரிசை செயல்பாட்டுடன் ஒருங்கிணைப்பதன் மூலம், ஒருங்கிணைப்புச் செயல்பாட்டில் சாத்தியமான இடையூறுகள் அல்லது பிழைகளைத் தவிர்த்து, ஒவ்வொரு இழுக்கும் கோரிக்கையும் ஒழுங்கான முறையில் கையாளப்படுவதை உறுதிசெய்யலாம். GitHub இன் GraphQL API உடன் ஊடாடும் மறுபயன்படுத்தக்கூடிய ஸ்கிரிப்ட்களை எழுதுவதன் மூலம் பல களஞ்சியங்களில் இந்தச் செயல்பாட்டைச் செயல்படுத்தலாம், இது உங்கள் நிறுவனத்தில் உள்ள நூற்றுக்கணக்கான களஞ்சியங்களுக்கு இந்த அமைப்புகளை செயல்படுத்துவதைத் தானியங்குபடுத்த அனுமதிக்கிறது. ஒன்றிணைப்பு வரிசையை வெற்றிகரமாக இயக்குவதற்கான திறவுகோல், API இன் பிறழ்வுகளை சரியாகப் பயன்படுத்துதல், ஒன்றிணைப்பு வரிசை செயல்படுத்தப்படுவதை உறுதி செய்தல் மற்றும் ஒன்றிணைக்கும் செயல்பாட்டின் போது எழக்கூடிய பல்வேறு விளிம்பு நிகழ்வுகளைக் கையாளுதல் ஆகியவற்றில் உள்ளது. 🚀