Merge pull request #13 from Hasenpfote/improve-gh-actions

Improve GitHub Actions

Author: Hasenpfote

.github/workflows/codecov_upload.yml

@@ -1,4 +1,4 @@
-name: Upload coverage reports to Codecov
+name: '📄 Upload coverage reports to Codecov'
 
 on:
   workflow_call:

.github/workflows/delete_caches.yml

@@ -0,0 +1,119 @@
+name: '🧰 Maint: Delete caches'
+
+on:
+  workflow_dispatch:
+    inputs:
+      validity-days:
+        description: 'Validity days'
+        default: '7'
+        type: choice
+        options: ['0', '1', '2', '3', '4', '5', '6', '7']
+
+      key-pattern:
+        description: 'Regular expression to match cache key'
+        required: false
+        default: ''
+        type: string
+
+      dry-run:
+        required: false
+        default: true
+        type: boolean
+
+jobs:
+  main:
+    permissions:
+      actions: write
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete caches
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.info('validity-days: ${{ inputs.validity-days }}');
+            core.info('key-pattern: ${{ inputs.key-pattern }}');
+            core.info('dry-run: ${{ inputs.dry-run }}');
+
+            let deleteActionsCacheById;
+            if (${{ inputs.dry-run }} == true) {
+              core.warning('Running in dry-run mode.');
+              deleteActionsCacheById = (owner, repo, cache_id) => undefined;
+            } else {
+              deleteActionsCacheById = github.rest.actions.deleteActionsCacheById;
+            }
+
+            const validity_days = parseInt('${{ inputs.validity-days }}', 10);
+            const re = new RegExp('${{ inputs.key-pattern }}');
+            const current_date = new Date();
+            const per_page = 30;
+
+            async function numCaches() {
+              let total_count = 0
+              try {
+                const caches = await github.rest.actions.getActionsCacheList({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  per_page: 1,
+                });
+                total_count = caches.data.total_count;
+              } catch (e) {
+              }
+              return total_count;
+            }
+
+            async function validCacheIds(num_caches) {
+              const max_pages = Math.ceil(num_caches / per_page);
+              let ids = []
+              try {
+                let num_pages = 1;
+                do {
+                  const caches = await github.rest.actions.getActionsCacheList({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    per_page: per_page,
+                    page: num_pages,
+                  });
+                  for (const cache of caches.data.actions_caches) {
+                    const has_matched = re.test(cache.key);
+                    if (!has_matched) {
+                      continue;
+                    }
+
+                    const expiry_date = new Date(cache.last_accessed_at);
+                    expiry_date.setDate(expiry_date.getDate() + validity_days);
+                    const has_expired = current_date.getTime() > expiry_date.getTime();
+                    if (!has_expired) {
+                      continue;
+                    }
+
+                    ids.push(cache.id);
+                  }
+                } while(num_pages++ < max_pages);
+              } catch (e) {
+              }
+              return ids;
+            }
+
+            let num_deleted_caches = 0;
+            const num_caches = await numCaches();
+            if (!num_caches) {
+              core.info('No caches.');
+              return;
+            }
+
+            const cache_ids = await validCacheIds(num_caches);
+            if (!cache_ids.length) {
+              core.info('Nothing matches the given conditions.');
+              return;
+            }
+
+            for (const cache_id of cache_ids) {
+              deleteActionsCacheById({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                cache_id: cache_id,
+              });
+              num_deleted_caches++;
+            }
+            core.notice(`${num_deleted_caches}/${num_caches} caches have been deleted.`);

.github/workflows/delete_wf_runs.yml

@@ -0,0 +1,132 @@
+name: '🧰 Maint: Delete workflow runs'
+
+on:
+  workflow_dispatch:
+    inputs:
+      validity-days:
+        description: 'Validity days'
+        default: '7'
+        type: choice
+        options: ['0', '1', '2', '3', '4', '5', '6', '7']
+
+      name-pattern:
+        description: 'Regular expression to match workflow name'
+        required: false
+        default: ''
+        type: string
+
+      dry-run:
+        required: false
+        default: true
+        type: boolean
+
+jobs:
+  main:
+    permissions:
+      actions: write
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete workflow runs
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.info('validity-days: ${{ inputs.validity-days }}');
+            core.info('name-pattern: ${{ inputs.name-pattern }}');
+            core.info('dry-run: ${{ inputs.dry-run }}');
+
+            let deleteWorkflowRun;
+            if (${{ inputs.dry-run }} == true) {
+              core.warning('Running in dry-run mode.');
+              deleteWorkflowRun = (owner, repo, run_id) => undefined;
+            } else {
+              deleteWorkflowRun = github.rest.actions.deleteWorkflowRun;
+            }
+
+            const validity_days = parseInt('${{ inputs.validity-days }}', 10);
+            const re = new RegExp('${{ inputs.name-pattern }}');
+            const current_date = new Date();
+            const per_page = 30;
+
+            async function numWorkflowRuns(workflow_id) {
+              let total_count = 0
+              try {
+                const wf_runs = await github.rest.actions.listWorkflowRuns({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  workflow_id: workflow_id,
+                  per_page: 1,
+                });
+                total_count = wf_runs.data.total_count;
+              } catch (e) {
+              }
+              return total_count;
+            }
+
+            async function validWorkflowRunIds(workflow_id, num_wf_runs) {
+              const max_pages = Math.ceil(num_wf_runs / per_page);
+              let ids = []
+              try {
+                let num_pages = 1;
+                do {
+                  const wf_runs = await github.rest.actions.listWorkflowRuns({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    workflow_id: workflow_id,
+                    per_page: per_page,
+                    page: num_pages,
+                  });
+                  for (const wf_run of wf_runs.data.workflow_runs) {
+                    if (wf_run.status != 'completed') {
+                      continue;
+                    }
+
+                    const expiry_date = new Date(wf_run.updated_at);
+                    expiry_date.setDate(expiry_date.getDate() + validity_days);
+                    const has_expired = current_date.getTime() > expiry_date.getTime();
+                    if (!has_expired) {
+                      continue;
+                    }
+
+                    ids.push(wf_run.id);
+                  }
+                } while(num_pages++ < max_pages);
+              } catch (e) {
+              }
+              return ids;
+            }
+
+            const wfs = await github.rest.actions.listRepoWorkflows({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            });
+            for (const wf of wfs.data.workflows) {
+              const basename = wf.path.split('/').reverse()[0];
+              const has_matched = re.test(basename);
+              if (!has_matched) {
+                continue;
+              }
+
+              let num_deleted_wf_runs = 0;
+              const num_wf_runs = await numWorkflowRuns(wf.id);
+              if (!num_wf_runs) {
+                core.info(`[${basename}] This workflow has no runs yet.`);
+                continue;
+              }
+
+              const wf_run_ids = await validWorkflowRunIds(wf.id, num_wf_runs);
+              if (!wf_run_ids.length) {
+                core.info(`[${basename}] Nothing matches the given conditions.`);
+                continue;
+              }
+
+              for (const wf_run_id of wf_run_ids) {
+                deleteWorkflowRun({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  run_id: wf_run_id,
+                });
+                num_deleted_wf_runs++;
+              }
+              core.notice(`[${basename}] ${num_deleted_wf_runs}/${num_wf_runs} workflow runs have been deleted.`);
+            }

.github/workflows/docs.yml

@@ -1,5 +1,5 @@
 # Workflow for deploying static content to GitHub Pages
-name: Deploy static content to Pages
+name: '📚 Publish docs via GitHub Pages'
 
 # build the documentation whenever there are new commits on main
 on:

.github/workflows/issue_bot.yml

@@ -1,4 +1,4 @@
-name: issue-bot
+name: '🤖 Bot: Issues'
 
 on:
   issues:

.github/workflows/lint.yml

@@ -1,4 +1,4 @@
-name: Lint
+name: '🔬 Lint'
 
 on:
   workflow_dispatch:

.github/workflows/pr_bot.yml

@@ -1,4 +1,4 @@
-name: pr-bot
+name: '🤖 Bot: PRs'
 
 on:
   pull_request_target:

.github/workflows/py_lint.yml

@@ -1,4 +1,4 @@
-name: py-lint
+name: '🔬 Lint: py'
 
 on:
   workflow_call:

.github/workflows/py_test.yml

@@ -1,4 +1,4 @@
-name: py-test
+name: '🧪 Test: py'
 
 on:
   workflow_call:

.github/workflows/report_rate_limits.yml

@@ -0,0 +1,63 @@
+name: '🧰 Maint: Report rate limits'
+
+on:
+  workflow_dispatch:
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dump rate limit
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const indicator = (function () {
+              const max_steps = 5;
+              const threshold_to_emoji = new Map([
+                [25, '🟥'], [50, '🟨'], [100, '🟩'],
+              ]);
+              const scale = max_steps / 100;
+
+              return function (value) {
+                const arr = new Array(max_steps).fill('🟫');
+                if (value <= 0) return arr.join('');
+
+                let emoji;
+                for (let entry of threshold_to_emoji) {
+                  if (value <= entry[0]) {
+                      emoji = entry[1];
+                      break;
+                  }
+                }
+                return arr.fill(emoji, 0, Math.ceil(value * scale)).join('');
+              }
+            })();
+
+            const current_date = new Date();
+            const rate_limit = await github.request('GET /rate_limit', {});
+
+            const table = [];
+            const header = Object.keys(rate_limit.data.rate).map(v => ({data: v, header: true}));
+            header.push({data: '', header: true});
+            header.push({data: 'Time until reset<br>in minutes', header: true});
+            header.push({data: '', header: true});
+            header.unshift({data: 'resource', header: true});
+            table.push(header);
+
+            for (let [key, value] of Object.entries(rate_limit.data.resources).sort()) {
+              const resource = Object.values(value).map(v => v.toString());
+              const reset = new Date(value.reset * 1000);
+              const time_left = Math.floor((reset - current_date) / 60000);
+              resource.push(reset.toISOString());
+              resource.push(value.used > 0 ? time_left.toString() : '');
+              resource.push(indicator((value.remaining / value.limit) * 100));
+              resource.unshift(key);
+              table.push(resource);
+            }
+
+            await core.summary
+              .addHeading('Current rate limit status')
+              .addTable(table)
+              .addEOL()
+              .addRaw('Created at ' + new Date().toISOString())
+              .write()