DEV Community: yeshan333

Generate Slideshow-Style Documentation Sites for GitHub Repositories with iFLOW-CLI GitHub Action and Qwen3-Coder

yeshan333 — Sat, 09 Aug 2025 17:09:10 +0000

The iFLOW team from Alibaba https://www.iflow.cn/ has recently open-sourced a terminal-based AI Agent tool iFLOW CLI, which can currently be used free of charge with powerful models like Qwen3-Coder and Kimi K2. It's another product similar to Anthropic's Claude Code.

iFlow CLI is a powerful AI assistant that runs directly in the terminal. It can seamlessly analyze code repositories, execute programming tasks, understand contextual requirements, and enhance your work efficiency through automated processing from simple file operations to complex workflows.

Since it's a terminal-based AI Agent tool, it can be well utilized with Github Actions to automatically generate slideshow-style documentation sites.

Taking advantage of the release day, I immediately vibe-coded a GitHub Actions based on GitHub Copilot Agent and iFLOW CLI to facilitate large-scale usage in isolated GitHub Actions environments.

The GitHub Actions https://github.com/marketplace/actions/iflow-cli-action has been published to GitHub's Marketplace. Feel free to try it out~

Here we'll introduce how to generate slideshow-style documentation sites based on this GitHub Actions. The final effect can be viewed at this website https://vibe-ideas.github.io/iflow-cli-action/#/, with a preview as follows:

Next, let's see how to use this GitHub Actions.

Using iFLOW CLI GitHub Action

To use this iFLOW CLI GitHub Action, you need to create a repository on GitHub https://github.com/new, then create a .github/workflows directory in the repository, and create an iflow-cli-action.yml file in the .github/workflows directory to use the iFLOW CLI GitHub Action:

git clone https://github.com/yourname/your-repo.git
cd your-repo

mkdir -p .github/workflows
touch .github/workflows/iflow-cli-action.yml

The content of the iflow-cli-action.yml file is as follows:

name: iFlow CLI Example
on: [push]

jobs:
  analyze-code:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run iFlow CLI
        uses: vibe-ideas/iflow-cli-action@v1.2.0
        with:
          prompt: "Analyze this codebase and suggest improvements"
          api_key: ${{ secrets.IFLOW_API_KEY }}
          model: "Qwen3-Coder"
          timeout: "1800"
          extra_args: "--debug"

prompt is the prompt that guides the AI Agent to complete your goal🎯.

secrets.IFLOW_API_KEY is the API access key for iFLOW CLI. You can register an account on the iFLOW CLI official website https://www.iflow.cn/, and then obtain the key through this link https://iflow.cn/?open=setting.

We save the key to the GitHub repository's Secrets to avoid key leakage. Settings -> Secrets and variables -> Actions -> New repository secret, with the secret name IFLOW_API_KEY:

After completing the above configuration, commit the workflow file to the GitHub repository to use this GitHub Actions normally:

git add .
git commit -m "add iflow-cli-action.yml"
git push

After pushing, you can generally see the execution process and results in the repository's Actions. The effect is as follows https://github.com/vibe-ideas/iflow-cli-action/actions/runs/16844856504:

Next, let's see how to generate the aforementioned slideshow-style documentation site based on the iFLOW CLI GitHub Action.

Generating Slideshow-Style Documentation Sites with iFLOW CLI GitHub Action

Assuming you already know how to use the iFLOW CLI GitHub Action through the previous text. Here we directly provide the GitHub Actions configuration file for reference. This orchestration file is also placed in a public GitHub repository :

name: Build and Deploy Homepage

on:
  # Allow manual trigger
  workflow_dispatch:
  # Also run on pushes to main branch
  push:
    branches: [ main ]

# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
permissions:
  contents: read
  pages: write
  id-token: write

# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      GITHUB_PAGES: true
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Pages
        uses: actions/configure-pages@v4

      - name: Create homepage directory
        run: mkdir -p _site

      - name: Generate homepage using iFlow CLI
        uses: vibe-ideas/iflow-cli-action@main
        with:
          prompt: |
            Please read only the README.md file content from the current repository (do not read any other files), and convert it into a beautiful slideshow-style documentation website based on Reveal.js and save it as _site/index.html.

            Requirements:

            1. Use the Reveal.js framework to build a slideshow presentation, splitting the README content into multiple slide pages according to logical structure;

            2. Slideshow structure design:
               - Homepage slide: Project title, subtitle, GitHub link, and project introduction
               - Feature highlights slide: Showcase main features and characteristics
               - Installation guide slide: Step-by-step installation process
               - Usage examples slide: Display code examples and configuration instructions
               - Advanced features slide: Show advanced usage and best practices
               - Closing slide: Acknowledgments, contribution guidelines, and contact information;

            3. Use modern Reveal.js themes and configurations:
               - Enable horizontal and vertical navigation
               - Configure slide transition animation effects (such as slide, fade, zoom)
               - Add progress bar and slide counter
               - Support keyboard navigation and touch gestures
               - Enable autoplay functionality (pausable)
               - Add slide thumbnail overview;

            4. Visual design using surreal digital collage style:
               - Use vivid color contrasts and geometric elements
               - Create layered visual effects combining text and graphic elements
               - Use irregular shapes, transparency, and overlapping effects to create depth
               - Employ dynamic backgrounds and animated transitions for visual impact
               - Use abstract graphics and digital elements as decorative elements
               - Ensure overall design has artistic appeal and visual attraction;

            5. Font size and layout optimization (important):
               - Title font sizes: Main title 2.5em, subtitle 1.8em, section title 1.5em
               - Body text font size: Use 1.2em, ensure clear readability on all devices
               - Code font size: Use 0.9em, avoid code blocks being too large causing layout issues
               - Line height settings: Body text 1.6x line height, titles 1.4x line height
               - Content area margins: Set appropriate padding for each slide (60px top/bottom, 40px left/right)
               - Ensure sufficient spacing between text and background, avoid blocking and overlap
               - Limit content amount per slide to avoid information overload
               - Implement vertical scrolling for long code blocks instead of shrinking font;

            6. Code display optimization:
               - Use Reveal.js code highlighting plugin
               - Support syntax highlighting (YAML, Bash, Markdown, etc.)
               - Add line numbers and copy buttons
               - Use appropriate maximum height (60vh) and scrollbars for code blocks
               - Implement animated display effects for code snippets;

            7. Interactive features:
               - Add navigation menu and chapter jumping
               - Implement fullscreen mode and speaker mode
               - Support ESC key to display slide overview
               - Add sharing and export functionality;

            8. Responsive design:
               - Ensure good experience on desktop, tablet, and mobile devices
               - Appropriately reduce font size on mobile devices while maintaining readability
               - Adapt fonts and layout to different screen sizes
               - Optimize interaction experience for touch devices;

            9. Technical implementation:
                - Import latest version of Reveal.js from CDN
                - Configure necessary plugins (highlight.js, notes, zoom, etc.)
                - Add custom CSS styles to enhance visual effects
                - Ensure fast loading and smooth animation performance;

            10. SEO and accessibility:
                - Add complete meta tags and structured data
                - Ensure keyboard navigation accessibility
                - Add alt text and aria labels
                - Optimize search engine indexing.

            Please directly create a complete HTML file using inline CSS and JavaScript, ensuring the file is self-contained and can run directly in browsers.

            Project URL: https://github.com/version-fox/vfox-erlang
          api_key: ${{ secrets.IFLOW_API_KEY }}
          # settings_json: ${{ secrets.IFLOW_SETTINGS_JSON }}
          model: "Qwen3-Coder"
          timeout: "1800"
          extra_args: "--debug"

      - name: Verify reveal.js presentation was generated
        run: |
          if [ -f "_site/index.html" ]; then
            echo "Reveal.js presentation generated successfully!"
            echo "Checking for reveal.js content..."
            if grep -q "reveal.js" "_site/index.html"; then
              echo "✓ Reveal.js framework detected"
            else
              echo "⚠ Warning: Reveal.js framework not found in generated file"
            fi
            ls -la _site/
          else
            echo "Error: Presentation was not generated by iFlow"
            exit 1
          fi

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: ./_site

  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    needs: build
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

Here, iFLOW CLI will generate a slideshow-style documentation site based on the repository's README and reveal.js, and then publish it to the web through GitHub Pages. The effect can be seen at this website 👀 https://version-fox.github.io/vfox-erlang/#/

Conclusion

I look forward to seeing what more creative things you can do with the iFLOW CLI Action~

Generate Slideshow-Style Documentation Sites for GitHub Repositories with iFLOW-CLI GitHub Action and Qwen3-Coder

yeshan333 — Sat, 09 Aug 2025 17:06:49 +0000

iFlow CLI is a powerful AI assistant that runs directly in the terminal. It can seamlessly analyze code repositories, execute programming tasks, understand contextual requirements, and enhance your work efficiency through automated processing from simple file operations to complex workflows.

Since it's a terminal-based AI Agent tool, it can be well utilized with Github Actions to automatically generate slideshow-style documentation sites.

Taking advantage of the release day, I immediately vibe-coded a GitHub Actions based on GitHub Copilot Agent and iFLOW CLI to facilitate large-scale usage in isolated GitHub Actions environments.

The GitHub Actions https://github.com/marketplace/actions/iflow-cli-action has been published to GitHub's Marketplace. Feel free to try it out~

https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p0wdgninzic7611qhu1b.gif

Next, let's see how to use this GitHub Actions.

Using iFLOW CLI GitHub Action

git clone https://github.com/yourname/your-repo.git
cd your-repo

mkdir -p .github/workflows
touch .github/workflows/iflow-cli-action.yml

The content of the iflow-cli-action.yml file is as follows:

name: iFlow CLI Example
on: [push]

jobs:
  analyze-code:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run iFlow CLI
        uses: vibe-ideas/iflow-cli-action@v1.2.0
        with:
          prompt: "Analyze this codebase and suggest improvements"
          api_key: ${{ secrets.IFLOW_API_KEY }}
          model: "Qwen3-Coder"
          timeout: "1800"
          extra_args: "--debug"

prompt is the prompt that guides the AI Agent to complete your goal🎯.

We save the key to the GitHub repository's Secrets to avoid key leakage. Settings -> Secrets and variables -> Actions -> New repository secret, with the secret name IFLOW_API_KEY:

After completing the above configuration, commit the workflow file to the GitHub repository to use this GitHub Actions normally:

git add .
git commit -m "add iflow-cli-action.yml"
git push

After pushing, you can generally see the execution process and results in the repository's Actions. The effect is as follows https://github.com/vibe-ideas/iflow-cli-action/actions/runs/16844856504:

Next, let's see how to generate the aforementioned slideshow-style documentation site based on the iFLOW CLI GitHub Action.

Generating Slideshow-Style Documentation Sites with iFLOW CLI GitHub Action

name: Build and Deploy Homepage

on:
  # Allow manual trigger
  workflow_dispatch:
  # Also run on pushes to main branch
  push:
    branches: [ main ]

# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
permissions:
  contents: read
  pages: write
  id-token: write

# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      GITHUB_PAGES: true
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Pages
        uses: actions/configure-pages@v4

      - name: Create homepage directory
        run: mkdir -p _site

      - name: Generate homepage using iFlow CLI
        uses: vibe-ideas/iflow-cli-action@main
        with:
          prompt: |
            Please read only the README.md file content from the current repository (do not read any other files), and convert it into a beautiful slideshow-style documentation website based on Reveal.js and save it as _site/index.html.

            Requirements:

            1. Use the Reveal.js framework to build a slideshow presentation, splitting the README content into multiple slide pages according to logical structure;

            2. Slideshow structure design:
               - Homepage slide: Project title, subtitle, GitHub link, and project introduction
               - Feature highlights slide: Showcase main features and characteristics
               - Installation guide slide: Step-by-step installation process
               - Usage examples slide: Display code examples and configuration instructions
               - Advanced features slide: Show advanced usage and best practices
               - Closing slide: Acknowledgments, contribution guidelines, and contact information;

            3. Use modern Reveal.js themes and configurations:
               - Enable horizontal and vertical navigation
               - Configure slide transition animation effects (such as slide, fade, zoom)
               - Add progress bar and slide counter
               - Support keyboard navigation and touch gestures
               - Enable autoplay functionality (pausable)
               - Add slide thumbnail overview;

            4. Visual design using surreal digital collage style:
               - Use vivid color contrasts and geometric elements
               - Create layered visual effects combining text and graphic elements
               - Use irregular shapes, transparency, and overlapping effects to create depth
               - Employ dynamic backgrounds and animated transitions for visual impact
               - Use abstract graphics and digital elements as decorative elements
               - Ensure overall design has artistic appeal and visual attraction;

            5. Font size and layout optimization (important):
               - Title font sizes: Main title 2.5em, subtitle 1.8em, section title 1.5em
               - Body text font size: Use 1.2em, ensure clear readability on all devices
               - Code font size: Use 0.9em, avoid code blocks being too large causing layout issues
               - Line height settings: Body text 1.6x line height, titles 1.4x line height
               - Content area margins: Set appropriate padding for each slide (60px top/bottom, 40px left/right)
               - Ensure sufficient spacing between text and background, avoid blocking and overlap
               - Limit content amount per slide to avoid information overload
               - Implement vertical scrolling for long code blocks instead of shrinking font;

            6. Code display optimization:
               - Use Reveal.js code highlighting plugin
               - Support syntax highlighting (YAML, Bash, Markdown, etc.)
               - Add line numbers and copy buttons
               - Use appropriate maximum height (60vh) and scrollbars for code blocks
               - Implement animated display effects for code snippets;

            7. Interactive features:
               - Add navigation menu and chapter jumping
               - Implement fullscreen mode and speaker mode
               - Support ESC key to display slide overview
               - Add sharing and export functionality;

            8. Responsive design:
               - Ensure good experience on desktop, tablet, and mobile devices
               - Appropriately reduce font size on mobile devices while maintaining readability
               - Adapt fonts and layout to different screen sizes
               - Optimize interaction experience for touch devices;

            9. Technical implementation:
                - Import latest version of Reveal.js from CDN
                - Configure necessary plugins (highlight.js, notes, zoom, etc.)
                - Add custom CSS styles to enhance visual effects
                - Ensure fast loading and smooth animation performance;

            10. SEO and accessibility:
                - Add complete meta tags and structured data
                - Ensure keyboard navigation accessibility
                - Add alt text and aria labels
                - Optimize search engine indexing.

            Please directly create a complete HTML file using inline CSS and JavaScript, ensuring the file is self-contained and can run directly in browsers.

            Project URL: https://github.com/version-fox/vfox-erlang
          api_key: ${{ secrets.IFLOW_API_KEY }}
          # settings_json: ${{ secrets.IFLOW_SETTINGS_JSON }}
          model: "Qwen3-Coder"
          timeout: "1800"
          extra_args: "--debug"

      - name: Verify reveal.js presentation was generated
        run: |
          if [ -f "_site/index.html" ]; then
            echo "Reveal.js presentation generated successfully!"
            echo "Checking for reveal.js content..."
            if grep -q "reveal.js" "_site/index.html"; then
              echo "✓ Reveal.js framework detected"
            else
              echo "⚠ Warning: Reveal.js framework not found in generated file"
            fi
            ls -la _site/
          else
            echo "Error: Presentation was not generated by iFlow"
            exit 1
          fi

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: ./_site

  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    needs: build
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

Conclusion

I look forward to seeing what more creative things you can do with the iFLOW CLI Action~

Building Your Own RSS Feed Subscription Management & AI Large Model Reading Workflow with n8n

yeshan333 — Sun, 03 Aug 2025 19:17:08 +0000

2025 is the year of explosive growth in AI applications. Recently, both in and outside of work, I've been using some visual low-code platforms to experiment with AI-based workflows. After trying several products like coze, dify, and n8n, n8n's single-step debugging experience and powerful third-party plugins really impressed me. Moreover, it can be self-deployed and is open-source (with a very high star count of 100k+, which also means the community is strong and problem-solving should be convenient). The open-source self-deployed version doesn't have too many features cut compared to the enterprise version, making it perfect for use with my newly acquired Volcengine ECS 4C8G server.

Back in April and May 2024, I built an application using Elixir for periodically tracking and using AI to summarize the latest articles from my RSS subscriptions, then pushing the summaries to my personal Telegram channel (I call it rss_generic_i18n_bot). AI can effectively consolidate blogs/podcasts in various languages (Chinese, English, Japanese, etc.) that I subscribe to into concise Chinese, making them easier to digest. My native language is still easier for absorbing information compared to other languages. I've been using this application until now. Since the code was mostly written by myself, there are still quite a few bugs remaining o(╯□╰)o, patching them up~:

Elixir's ecosystem is hard to describe~When I started operating, there weren't many good AI foundation libraries available.

Some friends might wonder why I don't use powerful software like Folo or Inoreader that can conveniently process RSS information sources. The reason is that I want to minimize opening additional software and still easily extract the information I want. So I send the processed information to instant messaging software groups like Telegram and DingTalk that I frequently open. The message display capabilities of current IM software are also quite good, and the search functionality is basically sufficient, so I don't need to build a lot of features myself.

Recently, I used n8n to orchestrate a workflow to replace my previous backend application rss_generic_i18n_bot. So I'm writing this article to document the process, which can also serve as a reference for friends using n8n to build workflows.

Deploying n8n with Docker

The first step is obviously to deploy the n8n visual workflow orchestration platform. Here's the docker-compose orchestration file I'm using, with the image sourced from m.daocloud.io (since Dockerhub is no longer accessible domestically, we need "special techniques"), and the speed is acceptable:

version: '3.8'

services:
  n8n:
    image: m.daocloud.io/docker.io/n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - ./data:/home/node/.n8n
    stdin_open: true
    tty: true
    restart: unless-stopped
    environment:
      - N8N_HOST=your-domain
      - N8N_PORT=5678
      # - N8N_PROTOCOL=https
      - NODE_ENV=production
      - N8N_LOG_OUTPUT=file
      - WEBHOOK_URL=https://your-domain/
      - GENERIC_TIMEZONE=Asia/Shanghai
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
      - N8N_RUNNERS_ENABLED=true
      - N8N_SECURE_COOKIE=false

# You can directly start using docker-compose
docker-compose up -d

I deployed it on Volcengine's ECS server, with the deployment architecture as shown in the figure below:

I put a reverse proxy in front of the n8n container, which is convenient for us to mount SSL/TLS certificates and add a firewall to monitor our traffic information.

Note that n8n enables origin validation. The reverse proxy server can fix the n8n Allow allowed Origin with proxy_set_header Origin http://127.0.0.1 to avoid frequently encountering WebSocket Connection Lost issues that prevent saving workflows in the n8n editing panel.

If you don't have a cloud server, you can also refer to this article 《Cursor一键生成n8n工作流+永久免费「n8n云部署」白嫖与效率齐飞~》 to deploy n8n overseas using Claw Cloud. You only need to register with GitHub, and if your GitHub account has been registered for more than 180 days, you can get $5 monthly credits. It's basically sufficient. You could say it's free to use Claw Cloud to deploy n8n. I use this deployment method for some workflows that need to access overseas services (like Google Sheet). Deployment is convenient, and Claw Cloud's built-in App Store marketplace has quick deployment templates.

After deployment is complete, you can enter the management page to orchestrate our workflows. Next, I'll introduce how to use n8n and Feishu multi-dimensional tables to build your own RSS subscription and AI reading workflow.

Workflow Design

Friends who frequently use RSS to manage their information sources may know that subscribing to RSS Feed links and reading RSS source articles are the two main high-frequency actions. So I mainly split these into two workflows to complete these tasks separately: RSS link subscription processing workflow and AI large model-based RSS article information acquisition, organization, and push workflow.

RSS Link Subscription Processing Workflow

The RSS link subscription processing workflow is mainly responsible for receiving messages containing "RSS Feed subscription links" sent from instant messaging software like Feishu through n8n's Webhook, storing the RSS Feed subscription links in Feishu's multi-dimensional tables. As shown in the figure below:

Webhook will listen to messages we send to the Feishu robot, triggering the execution of the entire process;
AI Agent node can process messages containing RSS Feed links in any format that we send to the Feishu robot, automatically extracting subscription links for subsequent nodes to extract RSS subscription source information and store it in Feishu multi-dimensional tables;
Feishu multi-dimensional tables: As a database, to persistently store all our subscription links for use by another workflow.

The effect of managing subscription links in Feishu is shown in the figure below, operating the multi-dimensional table as follows:

The left image shows us directly chatting with the application robot in the Feishu robot chat window, triggering the RSS subscription management workflow. After triggering is complete, you can directly see the corresponding subscription records in the multi-dimensional table in the right image.

Workflow Orchestration File Sharing

Here we directly provide the n8n json format workflow, which you can directly copy and paste into n8n's orchestration panel to use it:

{
  "name": "飞书机器人控制 RSS 订阅链接 copy",
  "nodes": [
    {
      "parameters": {
        "enableResponseOutput": true,
        "respondWith": "json",
        "responseBody": "={ \n    \"challenge\": \"{{ $json.body.challenge }}\"\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.4,
      "position": [
        -1960,
        280
      ],
      "id": "0b0f6f7e-6536-4d12-a857-1298beedad66",
      "name": "Feishu webhook challenge"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "208945ae-e6c1-4300-95c9-ec33780510cc",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [
        -2180,
        280
      ],
      "id": "75f4f05f-eb18-4872-ae7b-a3d63fe4d612",
      "name": "Feishu Webhook",
      "webhookId": "208945ae-e6c1-4300-95c9-ec33780510cc"
    },
    {
      "parameters": {
        "model": {
          "__rl": true,
          "value": "qwen3-32b",
          "mode": "list",
          "cachedResultName": "qwen3-32b"
        },
        "options": {}
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.2,
      "position": [
        -1660,
        500
      ],
      "id": "4420f524-6d40-47f7-9e65-441ca0b48689",
      "name": "OpenAI Chat Model",
      "credentials": {
        "openAiApi": {
          "id": "8Hmy9d6o6D8KLcY2",
          "name": "Qwen"
        }
      }
    },
    {
      "parameters": {
        "resource": "bitable",
        "operation": "bitable:table:record:add",
        "app_toke": "EEqtbliicaf3qRsgGPFcAxUtn1c",
        "table_id": "tbldTrKw4NsMY7Ix",
        "body": "={\n  \"fields\": {\n    \"feed_desc\": \"{{ $json.rss.channel.title }}\",\n    \"feed_url\": {\n      \"link\": \"{{ $('AI Agent 提取订阅链接').item.json.output }}\",\n      \"text\": \"{{ $('AI Agent 提取订阅链接').item.json.output }}\"\n    }\n  }\n}"
      },
      "type": "n8n-nodes-feishu-lite.feishuNode",
      "typeVersion": 1,
      "position": [
        -940,
        280
      ],
      "id": "2e265b22-9e2d-4312-8d2d-962a96b99ee1",
      "name": "新增订阅",
      "credentials": {
        "feishuCredentialsApi": {
          "id": "fxgtoinLSXcxpC2i",
          "name": "CloudysFeishu Credentials"
        }
      }
    },
    {
      "parameters": {
        "url": "={{ $json.output }}",
        "options": {}
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        -1380,
        280
      ],
      "id": "80544b7d-e0b0-4638-8f94-c70419171c3f",
      "name": "获取 RSS 订阅信息"
    },
    {
      "parameters": {
        "dataPropertyName": "=data",
        "options": {}
      },
      "type": "n8n-nodes-base.xml",
      "typeVersion": 1,
      "position": [
        -1160,
        280
      ],
      "id": "a34785d4-0113-410a-9825-80f069f801a2",
      "name": "抽取 RSS 信息"
    },
    {
      "parameters": {
        "promptType": "define",
        "text": "=You are a professional content extraction assistant. I will give you a text, and your task is to extract the URL link from the text. Then return the URL link to me as a string.\n\nPlease extract the text: {{ $json.body.event.message.content }}",
        "hasOutputParser": true,
        "options": {}
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 2,
      "position": [
        -1740,
        280
      ],
      "id": "f690bdbb-d980-43e6-862d-a0f8b3bbc30d",
      "name": "AI Agent 提取订阅链接",
      "alwaysOutputData": true
    },
    {
      "parameters": {
        "resource": "message",
        "operation": "message:send",
        "receive_id_type": "chat_id",
        "receive_id": "={{ $('Feishu Webhook').item.json.body.event.message.chat_id }}",
        "content": "={\n  \"text\": \"新增订阅成功: {{ $('AI Agent 提取订阅链接').item.json.output }}\"\n}"
      },
      "type": "n8n-nodes-feishu-lite.feishuNode",
      "typeVersion": 1,
      "position": [
        -720,
        280
      ],
      "id": "902cf65d-d202-4922-8379-da7193727258",
      "name": "订阅成功通知",
      "credentials": {
        "feishuCredentialsApi": {
          "id": "fxgtoinLSXcxpC2i",
          "name": "CloudysFeishu Credentials"
        }
      }
    }
  ],
  "pinData": {
    "Feishu Webhook": [
      {
        "json": {
          "headers": {
            "host": "127.0.0.1",
            "origin": "http://127.0.0.1",
            "x-real-ip": "182.92.128.190",
            "x-forwarded-for": "101.126.59.9, 182.92.128.190",
            "remote-host": "182.92.128.190",
            "connection": "close",
            "content-length": "740",
            "x-forwarded-proto": "https",
            "user-agent": "Go-http-client/1.1",
            "content-type": "application/json;charset=utf-8",
            "unit": "eu_nc",
            "x-lark-request-nonce": "950646929",
            "x-lark-request-timestamp": "1752346850",
            "x-lark-signature": "885f3a96d196cb195ac9fc69c0fae353dd78ffc2b9cb13c0ecfbee52b4a8f47b",
            "x-request-id": "55099ec9-214b-4276-ae4e-0500a75ef83c",
            "accept-encoding": "gzip"
          },
          "params": {},
          "query": {},
          "body": {
            "schema": "2.0",
            "header": {
              "event_id": "1290b470b9fa072e63f8f374da25caca",
              "token": "dFv0WkYeYKF7J4MK1c5tIeETHH6HZ34j",
              "create_time": "1752346850837",
              "event_type": "im.message.receive_v1",
              "tenant_key": "13d149c56acf5740",
              "app_id": "cli_a8f89f0647789013"
            },
            "event": {
              "message": {
                "chat_id": "oc_b4cf4d73e02ea650e86c4d2122ce1ec0",
                "chat_type": "p2p",
                "content": "{\"text\":\"订阅他[看]  https://supertechfans.com/cn/index.xml\"}",
                "create_time": "1752346850599",
                "message_id": "om_x100b481f40ebf8a80e3b6f49fa1a785",
                "message_type": "text",
                "update_time": "1752346850599"
              },
              "sender": {
                "sender_id": {
                  "open_id": "ou_ec81f38d6e7fdce6132f4605f7a37319",
                  "union_id": "on_9d281063b0791d2e40548e25ce854886",
                  "user_id": null
                },
                "sender_type": "user",
                "tenant_key": "13d149c56acf5740"
              }
            }
          },
          "webhookUrl": "https://n8n.shan333.cn/webhook/3cc586a2-4c62-47d4-8fd3-e371bde98ba7",
          "executionMode": "production"
        }
      }
    ]
  },
  "connections": {
    "Feishu Webhook": {
      "main": [
        [
          {
            "node": "Feishu webhook challenge",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Feishu webhook challenge": {
      "main": [
        [
          {
            "node": "AI Agent 提取订阅链接",
            "type": "main",
            "index": 0
          }
        ],
        []
      ]
    },
    "OpenAI Chat Model": {
      "ai_languageModel": [
        [
          {
            "node": "AI Agent 提取订阅链接",
            "type": "ai_languageModel",
            "index": 0
          }
        ]
      ]
    },
    "获取 RSS 订阅信息": {
      "main": [
        [
          {
            "node": "抽取 RSS 信息",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "抽取 RSS 信息": {
      "main": [
        [
          {
            "node": "新增订阅",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "AI Agent 提取订阅链接": {
      "main": [
        [
          {
            "node": "获取 RSS 订阅信息",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "新增订阅": {
      "main": [
        [
          {
            "node": "订阅成功通知",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  },
  "versionId": "9d4b7ea7-41ca-47cb-876e-321e6998f537",
  "meta": {
    "templateCredsSetupCompleted": true,
    "instanceId": "94953bffe8f887682af364b4ae4017e69e8558d5f6945655f253530415354041"
  },
  "id": "BPSFxXw7xiCf46yc",
  "tags": []
}

Workflow Usage Notes

n8n's official built-in nodes do not support operating Feishu data. After deployment, you need to first go to Settings -> community-nodes to install the community plugin: n8n-nodes-feishu-lite.
To operate Feishu multi-dimensional tables, you need to apply for Feishu's developer application, allocate corresponding operation permissions to the application. The process can refer to: Feishu Server API Call Process Overview to obtain the credentials used by the n8n-nodes-feishu-lite plugin.
The Feishu application needs to enable "robot capabilities" and allocate data record creation and reading permissions for multi-dimensional tables.
The Feishu multi-dimensional table operated by the workflow needs to add the newly created application as a "document application" and grant editable permissions.
Add the n8n Webhook callback address in the Feishu application management backend to enable processing of messages sent to the application robot by Feishu.

Next, let's look at the "AI large model-based RSS article information acquisition, organization, and push workflow."

AI Large Model-Based RSS Article Information Acquisition, Organization, and Push Workflow

The RSS Feed subscription processing is complete. The workflow shown in the figure below is mainly used to periodically obtain subscribed RSS Feed links from our Feishu multi-dimensional tables. Then it reads each subscription link one by one, obtains the newly published articles in the last 3 days, uses the AI large model to acquire the article content, organizes and refines it, and sends it to instant messaging software (Telegram, Feishu) groups. After successful sending, it will record the sent links to the multi-dimensional table, which is convenient for determining whether this new link has already been processed before sending.

This workflow will execute once every hour, obtaining newly published information from RSS sources. After AI organization and refinement, it will be sent to Telegram. The effect and AI reading refinement record multi-dimensional table structure are as follows:

The left image shows the AI-refined information sent to Telegram at regular intervals, and the right image shows the Feishu multi-dimensional table for sending records.

Workflow Usage Notes

Ensure that the credentials used by the Feishu node have been configured during the processing of the RSS link subscription processing workflow and that permissions are correct;
The TG notification node uses a bot, which can be applied for and created by https://t.me/BotFather in Telegram. Sending messages in channels or groups requires corresponding permissions.

Orchestration File Sharing

Here we directly provide the n8n json format workflow, which you can directly copy and paste into n8n's orchestration panel for orchestration and debugging:

{
  "name": "飞书多维表 & RSS 智能总结",
  "nodes": [
    {
      "parameters": {
        "resource": "bitable",
        "operation": "bitable:table:record:search",
        "app_toke": "EEqtbliicaf3qRsgGPFcAxUtn1c",
        "table_id": "tbldTrKw4NsMY7Ix",
        "body": "={\n  \"field_names\": [\n    \"feed_url\",\n    \"feed_desc\"\n  ],\n  \"filter\": {\n    \"conjunction\": \"and\",\n    \"conditions\": []\n  }\n}"
      },
      "type": "n8n-nodes-feishu-lite.feishuNode",
      "typeVersion": 1,
      "position": [
        260,
        770
      ],
      "id": "dca798dd-51ec-41c5-8691-20f7868ea9d0",
      "name": "读取多维表记录，获取 RSS 订阅列表",
      "credentials": {
        "feishuCredentialsApi": {
          "id": "9zcGg2DbgzaOg0HP",
          "name": "Feishu Credentials n8n"
        }
      }
    },
    {
      "parameters": {
        "batchSize": "={{ 1 }}",
        "options": {}
      },
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3,
      "position": [
        700,
        770
      ],
      "id": "d7cf0429-fb00-4a18-b2c6-3733a32b24f6",
      "name": "Loop Over Items1",
      "alwaysOutputData": true,
      "retryOnFail": false,
      "waitBetweenTries": 5000,
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "model": {
          "__rl": true,
          "value": "qwen3-235b-a22b",
          "mode": "list",
          "cachedResultName": "qwen3-235b-a22b"
        },
        "options": {}
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.2,
      "position": [
        2020,
        740
      ],
      "id": "5f53e2c8-29d5-4a46-8e30-3bcec7c0563a",
      "name": "OpenAI Chat Model",
      "credentials": {
        "openAiApi": {
          "id": "7Eg9oNn5wpKXU7FP",
          "name": "Alibaba Qwen"
        }
      }
    },
    {
      "parameters": {
        "jsCode": "return $input.first().json.data.items;"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        480,
        770
      ],
      "id": "77cb1f74-a1fb-4f6c-97f9-c2dd04da8379",
      "name": "提取所有订阅链接"
    },
    {
      "parameters": {
        "url": "={{ $json.fields.feed_url.link }}",
        "options": {}
      },
      "type": "n8n-nodes-base.rssFeedRead",
      "typeVersion": 1.2,
      "position": [
        920,
        520
      ],
      "id": "959e31f1-7d9d-4018-9b9d-a27154c69aac",
      "name": "获取 RSS 订阅发布的文章",
      "notesInFlow": true,
      "retryOnFail": true,
      "waitBetweenTries": 5000,
      "onError": "continueRegularOutput",
      "notes": "如何判断是否有最新的 RSS Feed"
    },
    {
      "parameters": {
        "resource": "bitable",
        "operation": "bitable:table:record:search",
        "app_toke": "EEqtbliicaf3qRsgGPFcAxUtn1c",
        "table_id": "tbln3Bh6A6CTtuzv",
        "body": "={\n  \"filter\": {\n    \"conjunction\": \"and\",\n    \"conditions\": []\n  }\n}"
      },
      "type": "n8n-nodes-feishu-lite.feishuNode",
      "typeVersion": 1,
      "position": [
        1360,
        520
      ],
      "id": "7667ee26-4686-4854-9489-924668af2e14",
      "name": "查询已经整理过的 RSS 文章",
      "credentials": {
        "feishuCredentialsApi": {
          "id": "9zcGg2DbgzaOg0HP",
          "name": "Feishu Credentials n8n"
        }
      }
    },
    {
      "parameters": {
        "jsCode": "\n// 默认认为第一篇即最新的一篇文章\nreturn {\n  \"feed_link\": $input.first().json.link,\n  \"title\": $input.first().json.title,\n  \"pub_date\": new Date($input.first().json.pubDate).getTime()\n};"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1140,
        520
      ],
      "id": "deed99e9-0a50-4a90-8013-12856c546116",
      "name": "获取最新发布的文章"
    },
    {
      "parameters": {
        "jsCode": "let urls = $input.first().json.data.items.map(item => item.fields.url.link)\n\nreturn [\n  {\n    json: {\n      sent_urs: urls,\n      send_url: $('获取最新发布的文章').first().json.feed_link,\n      title: $('获取最新发布的文章').first().json.title,\n      pub_date: $('获取最新发布的文章').first().json.pub_date\n    }\n  }\n];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1580,
        520
      ],
      "id": "2b6078c2-95b9-491e-87c6-b79da64c657d",
      "name": "聚合代发送信息和已发送信息"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "c931be49-c9c9-42e8-a97a-2758e06cb519",
              "leftValue": "={{ $json.pub_date }}",
              "rightValue": "={{ Date.now() - 3 * 24 * 60 * 60 * 1000 }}",
              "operator": {
                "type": "number",
                "operation": "gt"
              }
            },
            {
              "id": "2e58720d-c671-4eda-b1b4-968556db1bc2",
              "leftValue": "={{ $json.sent_urs }}",
              "rightValue": "={{ $json.send_url }}",
              "operator": {
                "type": "array",
                "operation": "notContains",
                "rightType": "any"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1800,
        520
      ],
      "id": "7957932e-bc1a-4d2a-8c10-888452d45371",
      "name": "过滤最近 3 天发布 & 并且没有整理过的文章"
    },
    {
      "parameters": {
        "chatId": "-1002056221907",
        "text": "=<strong>{{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.title }}</strong>\n\n{{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.send_url }}\n\nSummary:\n\n{{ $json.output }}",
        "additionalFields": {
          "parse_mode": "HTML"
        }
      },
      "type": "n8n-nodes-base.telegram",
      "typeVersion": 1.2,
      "position": [
        2460,
        520
      ],
      "id": "196939c8-5d46-4a03-9a86-95f755ff34ea",
      "name": "发送最新文章到 TG 频道",
      "webhookId": "ea5f5231-946a-4847-ab40-73caeba82e38",
      "credentials": {
        "telegramApi": {
          "id": "ryEUflPWvRynMmig",
          "name": "Telegram account"
        }
      }
    },
    {
      "parameters": {
        "sseEndpoint": "https://mcp.api-inference.modelscope.net/521f5eb00f1d4d/sse"
      },
      "type": "@n8n/n8n-nodes-langchain.mcpClientTool",
      "typeVersion": 1,
      "position": [
        2260,
        740
      ],
      "id": "3ed34103-cb9f-4edf-9ab8-0fb96535ba5b",
      "name": "fetch tool"
    },
    {
      "parameters": {
        "resource": "bitable",
        "operation": "bitable:table:record:add",
        "app_toke": "EEqtbliicaf3qRsgGPFcAxUtn1c",
        "table_id": "tbln3Bh6A6CTtuzv",
        "body": "={\n  \"fields\": {\n    \"title\": \"{{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.title }}\",\n    \"url\": {\n      \"link\": \"{{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.send_url }}\",\n      \"text\": \"{{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.send_url }}\"\n    },\n    \"pubDate\": {{ $('过滤最近 3 天发布 & 并且没有整理过的文章').item.json.pub_date }}\n  }\n}"
      },
      "type": "n8n-nodes-feishu-lite.feishuNode",
      "typeVersion": 1,
      "position": [
        2680,
        640
      ],
      "id": "42d2aca4-5570-4c3e-96d8-79b4d731f5eb",
      "name": "记录文章已经被整理",
      "credentials": {
        "feishuCredentialsApi": {
          "id": "9zcGg2DbgzaOg0HP",
          "name": "Feishu Credentials n8n"
        }
      }
    },
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours"
            }
          ]
        }
      },
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        40,
        780
      ],
      "id": "1533c646-66e2-4db5-a33b-20e0a25f5969",
      "name": "Schedule Trigger"
    },
    {
      "parameters": {
        "promptType": "define",
        "text": "=The URL to be refined is as follows:\n\n{{ $json.send_url }}\n",
        "options": {
          "systemMessage": "You are a professional content summary assistant. You can use the fetch tool to obtain the web page content of the URL I provide, and then extract the key points and essence, ensuring the content is complete and no article information is lost. The language must be Chinese. The final output text format should be HTML format supported by Telegram, without unsupported HTML tags.\n\nRequirements: The web page content obtained using the fetch tool must be complete. The final summary output format must not contain HTML tags not supported by Telegram.\n\nWhen summarizing articles, please follow these guidelines:\n1. Read the entire article to understand the main idea and core points.\n2. Identify key information in the article, such as major events, important data, core arguments, etc.\n3. Organize the key information using concise and clear language to form a coherent summary.\n4. Avoid including details and examples from the article unless they are crucial to understanding the core points.\n5. Ensure the summary covers all important aspects of the article without missing key information.\n\nTelegram-supported HTML tags are as follows:\n<b>bold</b>, <strong>bold</strong>\n<i>italic</i>, <em>italic</em>\n<u>underline</u>, <ins>underline</ins>\n<s>strikethrough</s>, <strike>strikethrough</strike>, <del>strikethrough</del>\n<span class=\"tg-spoiler\">spoiler</span>, <tg-spoiler>spoiler</tg-spoiler>\n<b>bold <i>italic bold <s>italic bold strikethrough <span class=\"tg-spoiler\">italic bold strikethrough spoiler</span></s> <u>underline italic bold</u></i> bold</b>\n<a href=\"http://www.example.com/\">inline URL</a>\n<a href=\"tg://user?id=123456789\">inline mention of a user</a>\n<tg-emoji emoji-id=\"5368324170671202286\">👍</tg-emoji>\n<code>inline fixed-width code</code>\n<pre>pre-formatted fixed-width code block</pre>\n<pre><code class=\"language-python\">pre-formatted fixed-width code block written in the Python programming language</code></pre>\n<blockquote>Block quotation started\\nBlock quotation continued\\nThe last line of the block quotation</blockquote>\n<blockquote expandable>Expandable block quotation started\\nExpandable block quotation continued\\nExpandable block quotation continued\\nHidden by default part of the block quotation started\\nExpandable block quotation continued\\nThe last line of the block quotation</blockquote>\n\nStrictly prohibited HTML tags: <ul>, <li>, <br>, <p>"
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 2,
      "position": [
        2060,
        520
      ],
      "id": "99c120dd-baec-469d-8315-709488188464",
      "name": "Summary AI Agent",
      "onError": "continueRegularOutput"
    }
  ],
  "pinData": {
    "Schedule Trigger": [
      {
        "json": {
          "timestamp": "2025-07-06T11:00:58.007-04:00",
          "Readable date": "July 6th 2025, 11:00:58 am",
          "Readable time": "11:00:58 am",
          "Day of week": "Sunday",
          "Year": "2025",
          "Month": "July",
          "Day of month": "06",
          "Hour": "11",
          "Minute": "00",
          "Second": "58",
          "Timezone": "America/New_York (UTC-04:00)"
        }
      }
    ]
  },
  "connections": {
    "Loop Over Items1": {
      "main": [
        [],
        [
          {
            "node": "获取 RSS 订阅发布的文章",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "OpenAI Chat Model": {
      "ai_languageModel": [
        [
          {
            "node": "Summary AI Agent",
            "type": "ai_languageModel",
            "index": 0
          }
        ]
      ]
    },
    "读取多维表记录，获取 RSS 订阅列表": {
      "main": [
        [
          {
            "node": "提取所有订阅链接",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "提取所有订阅链接": {
      "main": [
        [
          {
            "node": "Loop Over Items1",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "获取 RSS 订阅发布的文章": {
      "main": [
        [
          {
            "node": "获取最新发布的文章",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "查询已经整理过的 RSS 文章": {
      "main": [
        [
          {
            "node": "聚合代发送信息和已发送信息",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "获取最新发布的文章": {
      "main": [
        [
          {
            "node": "查询已经整理过的 RSS 文章",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "聚合代发送信息和已发送信息": {
      "main": [
        [
          {
            "node": "过滤最近 3 天发布 & 并且没有整理过的文章",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "过滤最近 3 天发布 & 并且没有整理过的文章": {
      "main": [
        [
          {
            "node": "Summary AI Agent",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Loop Over Items1",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "发送最新文章到 TG 频道": {
      "main": [
        [
          {
            "node": "记录文章已经被整理",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "fetch tool": {
      "ai_tool": [
        [
          {
            "node": "Summary AI Agent",
            "type": "ai_tool",
            "index": 0
          }
        ]
      ]
    },
    "记录文章已经被整理": {
      "main": [
        [
          {
            "node": "Loop Over Items1",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "读取多维表记录，获取 RSS 订阅列表",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Summary AI Agent": {
      "main": [
        [
          {
            "node": "发送最新文章到 TG 频道",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  },
  "versionId": "bcb9ad0a-6964-473c-9b5e-c1d03e2fb850",
  "meta": {
    "templateId": "self-building-ai-agent",
    "templateCredsSetupCompleted": true,
    "instanceId": "1c9ed367917141e075921fdbc6cbe734bce9dde165b1e3a672c9dd236366be6c"
  },
  "id": "Sz06Yz8CTSIkC0ji",
  "tags": []
}

Conclusion

Alright~, this sharing session ends here ღ( ´･ᴗ･` ). I hope friends who see this can have more fun with it. Comfortable~, for scenarios that are not performance-sensitive, using n8n is not bad.

(Amazing!) How to manage and install multiple versions of Erlang/OTP and Elixir via vfox in Windows

yeshan333 — Sat, 22 Jun 2024 08:18:15 +0000

About a month ago, I wrote an article on how to use the cross-platform version management tool vfox to install and manage multiple Erlang/OTP and Elixir version under Linux system -> Install mutiple Erlang and Elixir with vfox. the demonstration operation system used in the article is Ubuntu 20.04 Linux operation system.

Recently, the latest version of the vfox-erlang and vfox-elixir plugins has supported the installation and management of multiple version of Erlang/OTP and Elixir under Windows platforms. and has passed the End to End test -> Testing.

This article will use the Windows 10 operation system as an example to teach you how to install and manage multiple Erlang/OTP and Elixir version on Windows platforms.

> Get-ComputerInfo
WindowsBuildLabEx                                       : 22621.1.amd64fre.ni_release.220506-1250
WindowsCurrentVersion                                   : 6.3
WindowsInstallationType                                 : Client
WindowsProductName                                      : Windows 10 Pro
......

1、Install vfox

vfox (version-fox) is a popular cross-platform universal version management tool recently. it is written in Go language and the plug-in mechanism uses Lua to realize scalability. currently vfox already supports the management of versions of most mainstream programming languages, and the ecosystem is relatively strong. here you can see the programming language versions and tools currently supported and managed by vfox-> vfox-Available Plugins.

Please be sure to install vfox of version 0.5.3+ and above, otherwise vfox-erlang and vfox-elixir will not work normally. Here we install vfox through winget:

> winget install vfox
.......

❯ vfox -version
vfox version 0.5.3

In order for vfox to find the installed versions of Elixir and Erlang, vfox needs to be mounted to the powershell by default:

if (-not (Test-Path -Path $PROFILE)) { New-Item -Type File -Path $PROFILE -Force }; Add-Content -Path $PROFILE -Value 'Invoke-Expression "$(vfox activate pwsh)"'

If PowerShell prompts: cannot be loaded because the execution of scripts is disabled on this system.Open PowerShell with Run as Administrator.Then, run this command in PowerShell

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
# After that type Y and press Enter.
y

You can also refer to the official document to install vfox -> https://vfox.lhan.me/guides/quick-start.html. after installing vfox, we will install the following version management plugins:

# add vfox-erlang plugin for managine mutiple erlang versions
vfox add erlang
# add vfox-elixir plugin for managine mutiple elixir versions
vfox add elixir

After the installation is complete, you can use the two vfox plugins vfox-erlang and vfox-elixir in the Windows platform to install and manage multiple Erlang and Elixir versions.

Let's continue.

2、Install Erlang/OTP through vfox-erlang plugin

Since Elixir relies on Erlang/OTP, we need to install Erlang/OTP before installing Elixir. If you have already installed Erlang/OTP through other methods, please ensure that the version of Elixir installed through vfox-elixir is compatible with it. You can check the official documentation of Elixir to confirm this between-elixir-and-erlang-otp.

# get avaliable version
❯ vfox search erlang
Please select a version of erlang [type to search]: 
->  v25.0.4
   v24.3.4.16
   v24.1.3
   v24.0
   v24.3
   v24.3.2
   v25.2
   v27.0-rc2
   v24.3.4.1
Press ↑/↓ to select and press ←/→ to page, and press Enter to confirm

# you can also specify a version to install, such as
vfox install erlang@26.2.2

you can install any distribution that appears in the https://github.com/erlang/otp/releases containing the windows executable(exe) file. When you see the following message, the installation is complete.

compile info.......
...
Install erlang@26.2.2 success! 
Please use vfox use erlang@26.2.2 to use it.

We use vfox to switch to the Erlang/OTP version just installed to verify whether the next installation is successful:

❯ vfox use -g erlang@26.2.2
Now using erlang@26.2.2.
❯ erl
Erlang/OTP 26 [erts-14.2.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]

Eshell V14.2.2 (press Ctrl+G to abort, type help(). for help)
1>

If you can correctly wake up the REPL (Read-Eval-Print Loop) interactive command line, then the installation is fine. Next, start installing Elixir

3、Install Elixir via vfox-elixir plugin

Before installing the specified Elixir version, make sure that the currently installed shell can find the toolchain related to the installed Erlang/OTP version.

# Before the installation starts, switch to the Erlang version that Elixir depends on:
vfox use -g erlang@26.2.2

# Install an Erlang/OTP compatible version of Elixir
> vfox search elixir
Please select a version of elixir to install [type to search]:
->  v1.16.2-elixir-otp-26
   v1.16.2-elixir-otp-25
   v1.16.2-elixir-otp-24
   v1.16.1-elixir-otp-26
   v1.16.1-elixir-otp-25
   v1.16.1-elixir-otp-24
   v1.16.0-rc.1-elixir-otp-26
   v1.16.0-rc.1-elixir-otp-25
   v1.16.0-rc.1-elixir-otp-24
   v1.16.0-rc.0-elixir-otp-26
   v1.16.0-rc.0-elixir-otp-25
   v1.16.0-rc.0-elixir-otp-24
   v1.16.0-elixir-otp-26
   v1.16.0-elixir-otp-25
   v1.16.0-elixir-otp-24
   v1.15.7-elixir-otp-26
   v1.15.7-elixir-otp-25
   v1.15.7-elixir-otp-24
   v1.15.6-elixir-otp-26
   v1.15.6-elixir-otp-25
Press ↑/↓ to select and press ←/→ to page, and press Enter to confirm

# such as:
vfox install elixir@v1.16.1-elixir-otp-26
.....
.....
Install elixir@1.16.1-elixir-otp-26 success!
Please use vfox use elixir@1.16.1-elixir-otp-26 to use it.

When you see the relevant information such as Install elixir@1.16.1-elixir-otp-26 success! Please use vfox use elixir@1.16.1-elixir-otp-26 to use it., it means that the installation has been completed. Next, verify the availability:

❯ vfox use -g elixir@1.16.1-elixir-otp-26
Now using elixir@1.15.2.
> iex.bat
Erlang/OTP 26 [erts-14.2.5] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]                                                                                                                                              Interactive Elixir (1.16.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

If Elixir's REPL (Read-Eval-Print Loop) interactive command line can be opened normally, then the installation is successful and available.

In the end

vfox's two plug-ins for installing and managing Erlang/OTP and Elixir versions also support managing multiple versions under Uinx-like (Linux & Darwin MacOS) system. You can check this document for more information:https://github.com/version-fox/vfox-elixir. Full platform operating system support ~

Happy & funny!

Validate your Jenkinsfile with the vscode plugin vscode-jenkins-pipeline-linter-connector and the LLMs large model

yeshan333 — Sat, 25 May 2024 14:39:40 +0000

Jenkins is a popular automation tool for CI/CD, if you have used GitHub Action, similar to it, most automation tools now provide DSL (Domain Specific Language) to describe & orchestrate automation workflows, Jenkins' Pipeline Syntax is the orchestration language provided by Jenkins, the corresponding orchestration file is generally called Jenkinsfile, syntax rules and Groovy is similar.

I usually use Declarative Pipeline Syntax a lot, and I usually use a Git repository for Jenkinsfile management. After the local editing is completed, the headache is the syntax verification, and it is often necessary to actually run the pipeline after the code is committed to confirm whether there are any syntax problems.

In fact, this syntax check is configured on the Jenkins UI, but it can't be copied every time after editing in the code editor, and the official Jenkins documentation also suggests what toolchain pipeline-development-tools can be used for the use of local development pipelines. You can use command-line tools, Jenkins Open API, IDE plug-ins, etc.

I use Visual Studio Code a lot on a daily basis, so I finally chose the vscode plugin vscode-jenkins-pipeline-linter-connector, which is implemented by submitting the content of the Jenkinsfile to Jenkins through the API to verify.

However, the vscode plug-in has fallen into disrepair for a long time, and the code has been in use for a long time, and there are many problems encountered in actual use, such as:

Jenkinsfile with Chinese verification results are easy to garbled characters, such as this Jenkinsfile:



pipeline {
    agent any

    stages {
        stage('Hello中文>>>>>') {
            steps {
                echo 'Hello Worl中文
            }
        }
    }
}

The verification result will return garbled characters, as follows:



Errors encountered validating Jenkinsfile:
WorkflowScript: 6: unexpected char: 0xB8 @ line 6, column 36.
                   echo 'Hello World'ä¸æ��

The basic library that the plugin implementation depends on is also relatively old, so I forked the original plugin and did the following code refactoring and some problem fixes & optimizations, mainly as follows:

Fixing the Chinese (or other charset) garbled text issue in Jenkinsfile.
It can be verified without saving the Jenkinsfile.
The validation can be automatically triggered immediately when the file is saved.
Support to control what kind of file name can be verified, which is equivalent to a whitelist mechanism, and some people may write the workflow definition under another file name, such as: workflows.jenkins , etc., so there is this feature.
langchain.js and Cloudflare's free Workers AI REST API to configure large models for Jenkinsfile review.
...

The plugin is now available in the Visual Studio Code Store and Open VSX Registry, and you can theoretically use it in Microsoft Visual Studio Code, code-server, VSCodium, and other vscode series IDEs, linked below:

Microsoft Visual Studio Marketplace: https://marketplace.visualstudio.com/items?itemName=yeshan333.jenkins-pipeline-linter-connector-fork
Open VSX Registry: https://marketplace.visualstudio.com/items?itemName=yeshan333.jenkins-pipeline-linter-connector-fork

Now you should be able to search for it in the plugin search, use yeshan333.jenkins-pipeline-linter-connector-fork to search for installations:

Configure the plugin

There are a few example configurations already given in the plugin documentation, just fill in your vscode user configuration json file:



{
    "jenkins.pipeline.linter.connector.url": "https://jenkins.shan333.cn/pipeline-model-converter/validate",
    "jenkins.pipeline.linter.connector.user": "jenkins_username",
    "jenkins.pipeline.linter.connector.pass": "jenkins_password"
}

Replace the url and user password with your own Jenkins. Of course, you can also configure it directly in the plugin configuration:

Once configured, you can use Validate Jenkins in the Command Pallette to enable the Jenkinsfile validation:

Let's take a look at how to use LLM to review Jenkinsfiles for you.

Review your Jenkinsfile with the LLM large model

This function is disabled by default, and needs to be enabled by configuring jenkins.pipeline.linter.connector.llm.enable.

After the function is enabled, we still need to fill in a few key configurations, as follows:



{
    "jenkins.pipeline.linter.connector.llm.enable": true,
    "jenkins.pipeline.linter.connector.llm.baseUrl": "https://api.cloudflare.com/client/v4/accounts/<CF_ACCOUNT_ID>/ai/v1",
    "jenkins.pipeline.linter.connector.llm.modelName": "@cf/meta/llama-2-7b-chat-fp16",
    "jenkins.pipeline.linter.connector.llm.apiKey": "<CF_API_TOKEN>",
}

baseUrl and apiKey need to be applied to the Cloudflare User Dashboard.

By default, the plugin uses the text generation model provided by the Cloudflare Workers AI REST API to review our Jenkinsfile, which currently offers a free quota that is basically enough for daily use.

Step 1: You need to follow the documentation provided by Cloudflare to obtain the API access key -> Get started with the Workers AI REST API, and fill in the obtained API Token in the configuration "jenkins.pipeline.linter.connector.llm.apiKey".

Step 2: In the previous step, you will also get an Account ID when applying, this ACCOUNT ID is used to assemble the configuration "jenkins.pipeline.linter.connector.llm.baseUrl" , replace the <CF_ACCOUNT_ID> of "https://api.cloudflare.com/client/v4/accounts/<CF_ACCOUNT_ID>/ai/v1" with your Account ID.

Configuring jenkins.pipeline.linter.connector.llm.modelName is optional, and you can use any of the text generation models mentioned in https://developers.cloudflare.com/workers-ai/models/#text-generation for review.

After the above configuration is completed, the Jenkinsfile verification will be trigger with Validate Jenkins in the vscode Command Pallette, and the review opinions will be asked to the large model at the same time, which will have the following effect:

Chaos (fault) testing method for etcd and MongoDB

yeshan333 — Sun, 19 May 2024 07:19:27 +0000

Recently, I have been doing chaos (fault) tests on the robustness of some self-built database driver/client base libraries to verify and understand the fault handling mechanism and recovery time of the business. It mainly involves the two basic components MongoDB and etcd. This article will introduce the relevant test methods.

Fault test in MongoDB

MongoDB is a popular document database in the world, supporting ACID transactions, distributed and other features.

Most of the articles on chaos (fault) testing of MongoDB in the community are simulated by processing monogd or mongos. For example, if you want MongoDB to trigger copy set switching, you can use a shell script like this:



# suspended the primary node
kill -s STOP <mongodb-primary-pid>

# After the service is damaged, MongoDB should stepDown ReplicaSet in a few seconds to ten seconds.
# After the stepDown is complete, the service can automatically switch the connection to the new working primary node, without manual intervention, the service will return to normal.
# The reliability of the Mongo Client Driver is generally verified here.

The above-mentioned means are generally system-level, if we just want to simulate a MongoDB command command encountered network problems, how to do further want to conduct more fine-grained testing. In fact, MongoDB in 4.x version above has implemented a set of controllable fault point simulation mechanism -> failCommand.

When deploying a MongoDB replica set in a test environment, you can generally enable this feature in the following ways:



mongod --setParameter enableTestCommands=1

Then we can open the fault point for a specific command through the mongo shell, for example, for a find operation to make it return error code 2:



db.adminCommand({
    configureFailPoint: "failCommand",
    mode: {
      "times": 1,
    },
    data: {errorCode: 2, failCommands: ["find"]}
});

These fault point simulations are controllable, and the cost is relatively low compared to the direct destruction on the machine, and it is also suitable for integrating into continuous integration automation processes. The MongoDB built-in fault point mechanism also supports many features, such as allowing a certain fault probability to occur, returning any MongoDB supported error code type, etc. Through this mechanism, we can easily verify the reliability of our own implementation of the MongoDB Client Driver in unit tests and integration tests.

If you want to know which fault points the MongoDB supports, you can check the specification provided by the MongoDB in detail, which mentions which fault points the driver can use for testing for each feature of the MongoDB.

MongoDB, there are many examples in the dirver code repository of the official go implementation that can be: https://github.com/mongodb/mongo-go-driver/blob/345ea9574e28732ca4f9d7d3bb9c103c897a65b8/mongo/with_transactions_test.go#L122.

Fault test in etcd

etcd is an open source and highly available distributed key-value storage system, which is mainly used for shared configuration and service discovery.

We mentioned earlier that MongoDB has a built-in controllable fault point injection mechanism to facilitate us to do fault point testing, so does etcd also provide it?

Yes, etcd officials also provide a built-in controllable fault injection method to facilitate us to do fault simulation tests around etcd. However, the official binary distribution available for deployment does not use the fault injection feature by default, which is different from the switch provided by MongoDB. etcd requires us to manually compile the binary containing the fault injection feature from the source code for deployment.

etcd has officially implemented a Go package gofail to do "controllable" fault point testing, which can control the probability and number of specific faults. gofail can be used in any Go implementation program.

In principle, comments are used in the source code to bury some fault injection points in places where problems may occur through comments (// gofail:), which is biased towards testing and verification, for example:



    if t.backend.hooks != nil {
        // gofail: var commitBeforePreCommitHook struct{}
        t.backend.hooks.OnPreCommitUnsafe(t)
        // gofail: var commitAfterPreCommitHook struct{}
    }

Before using go build to build the binary, use the command line tool gofail enable provided by gofail to cancel the comments of these fault injection related codes and generate the code related to the fault point, so that the compiled binary can be used for fine-grained testing of fault scenarios. Use gofail disable to remove the generated fault point related codes, the binary compiled with go build can be used in the production environment.

When executing final binary, you can wake up the fault point through the environment variable GOFAIL_FAILPOINTS. if your binary program is a service that never stops, you can start an HTTP endpoint to wake up the buried fault point to the external test tool by GOFAIL_HTTP the environment variable at the same time as the program starts.

The specific principle implementation can be seen in the design document of gofail-> design.

It is worth mentioning that pingcap have rebuilt a wheel based on gofail and made many optimizations:
failpoint related code should not have any additional overhead;
Can not affect the normal function logic, can not have any intrusion on the function code;
failpoint code must be easy to read, easy to write and can introduce compiler detection;
In the generated code, the line number of the functional logic code cannot be changed (easy to debug);

If you want to understand how it is implemented, you can check out this official article: Design and Implementation of Golang Failpoints

Next, let's look at how to enable these fault burial points in etcd.

Compile etcd for fault testing

corresponding commands have been built into the Makefile of the official etcd github repository to help us quickly compile the binary etcd server containing fault points. the compilation steps are roughly as follows:



git clone git@github.com:etcd-io/etcd.git
cd etcd

# generate failpoint relative code
make gofail-enable
# compile etcd bin file
make build
# Restore code
make gofail-disable

After the above steps, the compiled binary files can be directly seen in the bin directory. Let's start etcd to have a look:



# enable http endpoint to control the failpoint
GOFAIL_HTTP="127.0.0.1:22381" ./bin/etcd

Use curl to see which failure points can be used:



curl http://127.0.0.1:22381

afterCommit=
afterStartDBTxn=
afterWritebackBuf=
applyBeforeOpenSnapshot=
beforeApplyOneConfChange=
beforeApplyOneEntryNormal=
beforeCommit=
beforeLookupWhenForwardLeaseTimeToLive=
beforeLookupWhenLeaseTimeToLive=
beforeSendWatchResponse=
beforeStartDBTxn=
beforeWritebackBuf=
commitAfterPreCommitHook=
commitBeforePreCommitHook=
compactAfterCommitBatch=
compactAfterCommitScheduledCompact=
compactAfterSetFinishedCompact=
compactBeforeCommitBatch=
compactBeforeCommitScheduledCompact=
compactBeforeSetFinishedCompact=
defragBeforeCopy=
defragBeforeRename=
raftAfterApplySnap=
raftAfterSave=
raftAfterSaveSnap=
raftAfterWALRelease=
raftBeforeAdvance=
raftBeforeApplySnap=
raftBeforeFollowerSend=
raftBeforeLeaderSend=
raftBeforeSave=
raftBeforeSaveSnap=
walAfterSync=
walBeforeSync=

Knowing these fault points, you can set the fault type for the specified fault, as follows:



# In beforeLookupWhenForwardLeaseTimeToLive failoint sleep 10 seconds
curl http://127.0.0.1:22381/beforeLookupWhenForwardLeaseTimeToLive -XPUT -d'sleep(10000)'
# peek failpoint status
curl http://127.0.0.1:22381/beforeLookupWhenForwardLeaseTimeToLive
sleep(1000)

For the description syntax of the failure point, see: https://github.com/etcd-io/gofail/blob/master/doc/design.md#syntax

so far, we have been able to do some fault simulation tests by using the fault points built in etcd. how to use these fault points can refer to the official integration test implementation of etcd-> etcd Robustness Testing. you can search for relevant codes by the name of the fault point.

In addition to the above-mentioned built-in failure points of etcd, the official warehouse of etcd also provides a system-level integration test example-> etcd local-tester, which simulates the node downtime test in etcd cluster mode.

Well, the sharing of this article is over for the time being ღ( ´･ᴗ･` )~

Commercial break: I recently maintenance can maintain multiple etcd server, etcdctl etcductl version of the tools vfox-etcd), You can also use it to install multiple versions of etcd containing failpoint on the machine for chaos (failure simulation) tests!

Install mutiple Erlang and Elixir with vfox

yeshan333 — Sat, 27 Apr 2024 09:50:29 +0000

vfox (version-fox) is a popular general version management tool write in Go, and the plug-in mechanism uses Lua to achieve extensibility. At present, vfox has supported the management of most mainstream programming language versions, and the ecosystem is quite strong. Here you can see the programming language versions and tools that vfox currently supports and manages -> vfox-Available Plugins.

The Elixir and Erlang communities have long been popular for installing and managing multi-version environments through asdf. asdf is also a general-purpose version management tool, and the ecosystem is so rich.

Vfox is very similar to asdf-vm in that it uses .tool-versions file to manage project-level and global version information. This means that if you've used asdf before, it won't be difficult to switch to vfox. Because the core implementations of vfox and vfox are a bit different, vfox executes nearly 5 times faster than ASDF~, and the official documentation also gives benchmark results: version-fox Comparison with asdf-vm

If you've been using asdf to manage and maintain multiple versions of Erlang and Elixir, then vfox is also a good choice for you.

This article will show you how to install and manage multiple versions of Erlang and Elixir via vfox.

Install vfox

vfox (version-fox) is cross OS system friendly, which means it can be used on both Windows and Unix-like systems. The core of this article is to install and manage multiple versions of Erlang and Elixir through vfox. Because the two plug-in implementations of vfox to manage Erlang and Elixir versions do not yet support management under the Windows operating system, the sample environment in this article is mainly the Ubuntu 20.04 Linux environment. Let's get started~

Install vfox (version fox) first:

echo "deb [trusted=yes] https://apt.fury.io/versionfox/ /" | sudo tee /etc/apt/sources.list.d/versionfox.list
sudo apt-get update
sudo apt-get install vfox

In order for vfox to find the installed versions of Elixir and Erlang, vfox needs to be mounted to the shell by default. Next, modify the shell configuration (take Bash as an example):

# Hook your shell
echo 'eval "$(vfox activate bash)"' >> ~/.bashrc

You can also refer to this official documentation to install vfox -> https://vfox.lhan.me/guides/quick-start.html. After installing VFOX, let's install the following plugins:

# add vfox-erlang plugin
vfox add erlang
# add vfox-elixir plugin
vfox add elixir

Next, we can install and manage multiple versions of Erlang and Elixir through the two vfox plugins vfox-erlang and vfox-elixir installed above.

Install Erlang/OTP via the vfox-erlang plugin

Because Elixir depends on Erlang, we need to install Erlang before installing Elixir. Erlang is installed through the source code of the corresponding version, so we need to have the corresponding compilation toolchain, here take Ubuntu 20.04 as an example:

sudo apt-get -y install build-essential autoconf m4 libncurses5-dev libwxgtk3.0-gtk3-dev libwxgtk-webview3.0-gtk3-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev openjdk-11-jdk

Now it's time to install Erlang.

# use vfox search get an avaliable version
❯ vfox search erlang
Please select a version of erlang [type to search]: 
->  v25.0.4
   v24.3.4.16
   v24.1.3
   v24.0
   v24.3
   v24.3.2
   v25.2
   v27.0-rc2
   v24.3.4.1
Press ↑/↓ to select and press ←/→ to page, and press Enter to confirm

# you can also specific a version, eg:
vfox install erlang@26.2.2

Theoretically, you could install any version that appears in https://github.com/erlang/otp/releases. Since it is compiled and installed from source, the installation process will take some time. When you see the following message, the installation is complete.

compile info.......
...
Install erlang@26.2.2 success! 
Please use vfox use erlang@26.2.2 to use it.

Let's use vfox to switch to the Erlang/OTP version we just installed to verify that the installation is successful:

❯ vfox use erlang@26.2.2
Now using erlang@26.2.2.
❯ erl
Erlang/OTP 26 [erts-14.2.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]

Eshell V14.2.2 (press Ctrl+G to abort, type help(). for help)
1>

If the REPL wakes up correctly, then install it. Let's start installing Elixir.

Install Elixir

Because the installation of Elixir is also compiled and installed from the source code of the corresponding version, the compilation of Elixir needs to depend on Erlang, so we first let the current shell can find the Erlang just installed.

# switch shell to a Erlang version
❯ vfox use erlang@26.2.2
Now using erlang@26.2.2.
# install Elixir
> vfox install elixir@1.15.2
.........
.........
Generated ex_unit app
==> logger (compile)
Generated logger app
Generated eex app
==> iex (compile)
Generated iex app
Install elixir@1.15.2 success! 
Please use vfox use elixir@1.15.2 to use it.

When you see Install elixir@1.15.2 success!, it means that the installation has been successful. The installation can be confirmed by IEX as a complete success:

❯ vfox use elixir@1.15.2
Now using elixir@1.15.2.
❯ iex
Erlang/OTP 26 [erts-14.2.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit:ns]

Interactive Elixir (1.15.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

If you want to install a different version of Elixir, please make sure that the current version of Erlang/OTP is compatible with the version of Elixir, check this document to confirm compatibility: 《compatibility-and-deprecations.html#between-elixir-and-erlang-otp》。

Set the global usage version

We can use vfox use -g xxx to set the version of Erlang and Elixir that we use by default.

> vfox use -g erlang@26.2.2
> vfox use -g elixir@1.15.2

# make sure setting succ
> cat ~/.version-fox/.tool-versions 
erlang 26.2.2
elixir 1.15.2

The End

The two plugins for vfox to install and manage the Erlang/OTP and Elixir versions also support managing multiple versions under MacOS Darwin System. You can check out this document for more information: https://github.com/version-fox/vfox-elixir?tab=readme-ov-file#install-in-darwin-macos-13.

Happy & funny!

Installing Erlang With vfox

yeshan333 — Fri, 26 Apr 2024 15:56:20 +0000

vfox (version fox) is a cross-platform, extensible version manager. It supports native Windows, and of course Unix-like! With it, you can quickly install and switch different environment.

Recently, I have wrote some plugins for vfox. The vfox-erlang plugin is one of them. I really like the plugin management mechanism of vfox (Based on Lua). You can use the vfox-erlang plugin to quickly manage mutiple Erlang/OTP version on your machine.

I have used a similar tool asdf before, but the previous experience of using asdf was not very good (I don’t mean to step on it~, the ASDF ecosystem is very strong), vfox now supports a lot of plugins, and can already manage the versions of most common mainstream languages.

vfox's version management workflow is generally similar to asdf, but with a bit better performance (about 5x), since asdf is written in shell at its core. The official documentation also gives a benchmark, see 《Comparison with asdf-vm》：

vfox, like asdf, can be configured globally and project level tool version via the .tool-version configuration file, which means that if you switch from asdf to vfox, it's quite convenient.

Using vfox-erlang

This article mainly describes how to use the vfox-erlang plugin to manage multiple Erlang/OTP versions on the same machine. It is also common to have multiple versions of Erlang/OTP for testing and comparison in the same development environment.

At present, the actual installation process of the vfox-erlang plug-in implementation is to compile and install Erlang/OTP from the GitHub source code, so for the time being, it only supports the installation and management of Erlang/OTP versions on Unix-like systems (such as ubuntu, macos darwin, etc.) (the windows exe installer is actually provided by the official site, but recently I haven't had enough time to perfect the plug-in implementation, and the scenarios of using Erlang in windows are generally relatively few).

Erlang is a programming language used to build massively scalable soft real-time systems with requirements on high availability. Some of its uses are in telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance.
OTP is set of Erlang libraries and design principles providing middle-ware to develop these systems. It includes its own distributed database, applications to interface towards other languages, debugging and release handling tools.
from site: https://www.erlang.org/

Install the vfox and vfox-erlang plugin

Before using vfox-erlang to manage Erlang/OTP versions, please make sure that you have installed vfox on your machine, you can refer to the official Quick Start documentation, this article takes Ubuntu 20.04 as an example.

# install vfox via apt
echo "deb [trusted=yes] https://apt.fury.io/versionfox/ /" | sudo tee /etc/apt/sources.list.d/versionfox.list
sudo apt-get update -y
sudo apt-get install vfox -y

# Hook vfox to your Shell, let vfox found the Erlang/OTP version
echo 'eval "$(vfox activate bash)"' >> ~/.bashrc

# add vfox-erlang plugin, plugin is generally installed in the ~/.version-fox/plugin/erlang directory
vfox add erlang

Install the specified version of Erlang/OTP via plugin

Since Erlang/OTP is compiled and installed from source, we need to have the corresponding build toolchain and dependent software, here is an example of Ubuntu 20.04:

# install require utils
sudo apt-get -y install build-essential autoconf m4 libncurses5-dev libwxgtk3.0-gtk3-dev libwxgtk-webview3.0-gtk3-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev openjdk-11-jdk

and then we can then manage the installation of multiple Erlang/OTP versions via vfox.

# search a avaliable Erlang/OTP version to install
❯ vfox search erlang
Please select a version of erlang [type to search]: 
->  v25.3.2.5
   v24.0-rc3
   v24.3
   v23.3.4.18
   v24.0.6
   v24.3.2
   v25.3
   v24.1.4
   v26.0.2

# or you can also specific version
> vfox install erlang@26.2.2
...
Install erlang@26.2.2 success! 
Please use vfox use erlang@26.2.2 to use it.

When you see something like Install erlang@xxx success! information. It mean the the installation is complete. Next, you can use the vfox use command to switch Erlang/OTP version, so that the current shell session can use the corresponding Erlang/OTP version.

# use the specific Erlang/OTP version
vfox use erlang@26.2.2

vfox provides three perspectives of version management: current shell session level, project level, global level, through a .tool-versions can flexibly assign different Erlang/OTP versions to different project directories, More information can be found in the official documentation: vfox-Switch runtime..

The usage examples in this article are mainly based on Linux systems, but the user documentation of vfox-erlang also gives the user guide install-in-darwin-macos-13 under MacOS Darwin, and provides continuous integration testing under Linux and MacOS for reference: vfox-erlang E2E testing. vfox-erlang E2E testing.

Happy and funny~

The solution of Elixir continuous runtime system code coverage collection

yeshan333 — Sat, 13 Aug 2022 10:02:48 +0000

zh_hans

Code coverage is an effective means to assist software engineers in verifying code quality. The runtime environment's ability to collect code coverage fully combines black and white box testing capabilities and greatly increases engineers' confidence in software quality. This article introduces a solution for code coverage collection in the Elixir runtime environment, and provides an in-depth insight into its internal principles.

1. Brief talk on code coverage

As a SDET or a SWE, we often need to write unit tests or integration test cases to verify the correctness of the system/application, but at the same time we often question whether our tests are adequate. At this time, test coverage is a means of measuring the adequacy of our testing, enhancing the success rate and confidence of the software release, and giving us more reflective perspectives. The note of the value is that high code coverage does not indicate high code quality, but conversely, code coverage is low, and code quality will not be high.

Most programming languages come with the ability to collect unit test coverage, and the same is true for Elixir, the official mix build tool comes with the ability to collect coverage, but it is currently only suitable for offline system, not for runtime system. This article will be based on Erlang's cover module to give a solution for the Elixir runtime system. Since cover is Erlang's built-in module, but why it works equally well with Elixir, we'll unveil its mystery in a follow-up. Before we get started, let's take a look at the two mainstream ways in which the open source community collects code coverage at runtime (here we look at the bytecode stubbing method of Java, which has a huge ecosystem of the language community):

Next let's focus on the core of elixir runtime coverage collection in this article - the cover module.

2. Delve into the Erlang Cover coverage collection implementation mechanism

2.1. Introduction Erlang Cover

cover is part of Erlang's built-in tools set, providing a powerful ability to collect code coverage.

2.2. Erlang code coverage collection implementation analysis

As you can see from Erlang's official manual of the cover module, cover counts the number of times every executable line in the Erlang program is executed.

From the introduction of the official documentation, cover can be used for code coverage collection of the runtime system. When the code is instrumented, it does not modify the code source files of any modules or the beam files generated after compilation (that is the industry calls the On-The-Fly mode). Every time the executable row is called, the runtime system updates the number of calls to cover in an in-memory database (erlang ets) for storing data for subsequent coverage analysis.

Next, we'll explore the details of the On-The-Fly mode under cover.

2.3. Learn about BEAM File Format

Before we can further understand the details of the cover implementation, it is necessary to understand the format of the BEAM file after the elixir source code is compiled. The compiled product of the Elixir (.ex file), like the Erlang (.erl file), is a binary chunked file, which is divided into several sections to store information used when the program runs (such as virtual machine operation instructions). In Erlang/Elixir, each module will have a corresponding BEAM file. The approximate structure of the BEAM file is as follows:

Let's take a look at the approximate content of the beam file through an Elixir mini demo project:

Step 1. Clone the project yeshan333/explore_ast_app to the local:

git clone https://github.com/yeshan333/explore_ast_app.git
cd explore_ast_app

Step 2. Build this project in OTP release format. (note: Elixir and Erlang need to be installed locally):

MIX_ENV=prod mix distillery.release

It can be noted that each Elixir module is compiled into a BEAM file (can be seen in the directory _build/prod/rel/explore_ast_app/lib/explore_ast_app-0.1.0/ebin).

Step 3. Next, let's view the chunks in the Beam file through Erlang's standard library beam_lib:

# open the iex console
iex -S mix

View all chunks of the compiled BEAM file (Elixir.ExploreAstApp.beam):

$ iex -S mix
Erlang/OTP 24 [erts-12.1] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:1] [jit] [dtrace]

Interactive Elixir (1.12.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> beam_file_path = "_build/prod/rel/explore_ast_app/lib/explore_ast_app-0.1.0/ebin/Elixir.ExploreAstApp.beam"
"_build/prod/rel/explore_ast_app/lib/explore_ast_app-0.1.0/ebin/Elixir.ExploreAstApp.beam"
iex(2)> all_chunks = :beam_lib.all_chunks(String.to_charlist(beam_file_path))
{:ok, ExploreAstApp,
 [
   {'AtU8',
    <<0, 0, 0, 15, 20, 69, 108, 105, 120, 105, 114, 46, 69, 120, 112, 108, 111,
      114, 101, 65, 115, 116, 65, 112, 112, 8, 95, 95, 105, 110, 102, 111, 95,
      95, 10, 97, 116, 116, 114, 105, 98, 117, 116, 101, ...>>},
   {'Code',
    <<0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 169, 0, 0, 0, 14, 0, 0, 0, 4, 1, 16,
      153, 0, 2, 18, 34, 16, 1, 32, 59, 3, 21, 23, 8, 16, 50, 117, 66, 117, 82,
      101, 98, ...>>},
   {'StrT', ""},
   {'ImpT',
    <<0, 0, 0, 2, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 2, 0, 0, 0, 11, 0, 0, 0,
      12, 0, 0, 0, 1>>},
   {'ExpT',
    <<0, 0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 15, 0, 0, 0, 0,
      0, 0, 0, 11, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 9, ...>>},
   {'LitT',
    <<0, 0, 0, 52, 120, 156, 99, 96, 96, 96, 98, 96, 96, 16, 106, 206, 1, 146,
      140, 25, 76, 229, 172, 25, 169, 57, 57, 249, 137, 12, 89, 64, 190, 88,
      115, 46, 144, 20, 248, ...>>},
   {'LocT', <<0, 0, 0, 0>>},
   {'Attr',
    <<131, 108, 0, 0, 0, 1, 104, 2, 100, 0, 3, 118, 115, 110, 108, 0, 0, 0, 1,
      110, 16, 0, 165, 236, 94, 47, 119, 160, 184, 33, 240, 28, 89, 11, 22, 130,
      207, ...>>},
   {'CInf',
    <<131, 108, 0, 0, 0, 3, 104, 2, 100, 0, 7, 118, 101, 114, 115, 105, 111,
      110, 107, 0, 5, 56, 46, 48, 46, 51, 104, 2, 100, 0, 7, 111, 112, 116, 105,
      111, ...>>},
   {'Dbgi',
    <<131, 80, 0, 0, 1, 143, 120, 156, 117, 80, 203, 78, 3, 49, 12, 76, 233, 67,
      162, 5, 113, 65, 124, 70, 87, 253, 2, 212, 67, 63, 129, 115, 148, 221,
      120, ...>>},
   {'Docs',
    <<131, 80, 0, 0, 0, 241, 120, 156, 93, 142, 205, 10, 194, 48, 16, 132, 215,
      74, 91, 9, 248, 14, 129, 94, 244, 82, 241, 234, 65, 40, 88, 241, 45, 108,
      ...>>},
   {'ExCk',
    <<131, 104, 2, 100, 0, 17, 101, 108, 105, 120, 105, 114, 95, 99, 104, 101,
      99, 107, 101, 114, 95, 118, 49, 116, 0, 0, 0, 1, 100, 0, 7, 101, 120,
      ...>>},
   {'Line',
    <<0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 18, 241, 0,
      22, 108, 105, 98, 47, 101, 120, 112, 108, ...>>}
 ]}

As you can see, the obtained chunks correspond to the previous diagram. We can also obtain the Erlang AST (abstract syntax tree) corresponding to the module (ExploreAstApp) through the beam_lib standard library:

iex(3)> result = :beam_lib.chunks(String.to_charlist(beam_file_path), [:abstract_code])
{:ok,
 {ExploreAstApp,
  [
    abstract_code: {:raw_abstract_v1,
     [
       {:attribute, 1, :file, {'lib/explore_ast_app.ex', 1}},
       {:attribute, 1, :module, ExploreAstApp},
       {:attribute, 1, :compile, [:no_auto_import]},
       {:attribute, 1, :export, [__info__: 1, hello: 0]},
       {:attribute, 1, :spec,
        {{:__info__, 1},
         [
           {:type, 1, :fun,
            [
              {:type, 1, :product,
               [
                 {:type, 1, :union,
                  [
                    {:atom, 1, :attributes},
                    {:atom, 1, :compile},
                    {:atom, 1, :functions},
                    {:atom, 1, :macros},
                    {:atom, 1, :md5},
                    {:atom, 1, :exports_md5},
                    {:atom, 1, :module},
                    {:atom, 1, :deprecated}
                  ]}
               ]},
              {:type, 1, :any, []}
            ]}
         ]}},
       {:function, 0, :__info__, 1,
        [
          {:clause, 0, [{:atom, 0, :module}], [], [{:atom, 0, ExploreAstApp}]},
          {:clause, 0, [{:atom, 0, :functions}], [],
           [
             {:cons, 0, {:tuple, 0, [{:atom, 0, :hello}, {:integer, 0, 0}]},
              {nil, 0}}
           ]},
          {:clause, 0, [{:atom, 0, :macros}], [], [nil: 0]},
          {:clause, 0, [{:atom, 0, :exports_md5}], [],
           [
             {:bin, 0,
              [
                {:bin_element, 0,
                 {:string, 0,
                  [240, 105, 247, 119, 22, 50, 219, 207, 90, 95, 127, 92, ...]},
                 :default, :default}
              ]}
           ]},
          {:clause, 0, [{:match, 0, {:var, 0, :Key}, {:atom, 0, :attributes}}],
           [],
           [
             {:call, 0,
              {:remote, 0, {:atom, 0, :erlang}, {:atom, 0, :get_module_info}},
              [{:atom, 0, ExploreAstApp}, {:var, 0, :Key}]}
           ]},
          {:clause, 0, [{:match, 0, {:var, 0, :Key}, {:atom, 0, :compile}}], [],
           [
             {:call, 0,
              {:remote, 0, {:atom, 0, :erlang}, {:atom, 0, :get_module_info}},
              [{:atom, 0, ExploreAstApp}, {:var, 0, :Key}]}
           ]},
          {:clause, 0, [{:match, 0, {:var, 0, :Key}, {:atom, 0, :md5}}], [],
           [
             {:call, 0,
              {:remote, 0, {:atom, 0, :erlang}, {:atom, 0, :get_module_info}},
              [{:atom, 0, ExploreAstApp}, {:var, 0, :Key}]}
           ]},
          {:clause, 0, [{:atom, 0, :deprecated}], [], [nil: 0]}
        ]},
       {:function, 15, :hello, 0, [{:clause, 15, [], [], [{:atom, 0, :world}]}]}
     ]}
  ]}}

It can be seen that AST is expressed in the form of Erlang Terms (called Abstract Code), which is easy to read. The Abstract Code is very useful in the on-the-fly instrumentation process of cover.

The above AST structure is simple and easy to read, and we can easily match it with the source code (lib/explore_ast_app.ex) before the module is compiled, although the AST structure is the final Erlang AST, and some extras information are added by the Erlang compiler, but does not affect reading:

The second element in the tuple generally represents the number of source code lines. You can learn more about Erlang's Abstract Format through the official documentation. By observing the Erlang AST structure of several BEAM files, you will be familiar with it. It is worth noting that the Abstract Code was stored in the Abstract Chunk of the BEAM file before OTP 20.

If you want to learn more about BEAM files in detail, you can check out the following two documents:

2.4. Elixir source code compilation process

After understanding BEAM File Format, we also need to understand the compilation process of Elixir code, which will help us better understand cover. The process of compiling Elixir source code into BEAM file may not be as you imagined In the same way, instead of directly from Elixir's AST, it becomes executable BEAM Code after being processed by the compiler backend. There is also a process in the middle, as shown in the following figure:

The above process can be described as:

Step 1、The Elixir source code will be parsed by a custom lexical analyzer (elixir_tokenizer) and yacc to generate the initial version of Elixir AST, which is expressed in the form of Elixir Terms; if you are interested in Elixir's AST, you can follow this Project arjan/ast_ninja;
Step 2、In the Elixir AST stage, some custom and built-in Macros have not been expanded, and these Macros are expanded into the final Elixir AST in the Expanded Elixir AST stage;
Step 3、Final Elixir AST will be converted into Erlang standard AST form (Erlang Abstract Format) after being processed by Elixir Compiler;
Step 4、Finally, Elixir will use the Erlang Compiler to process the Erlang AST, converting it into BEAM bytecode executable by the BEAM Virtual Machine (VM). For details on the compiler, see: elixir_compiler.erl and elixir_erl.erl source code For more details on the Erlang Compiler, see theBeamBook/#CH-Compiler.

2.5. Cover On-The-Fly Instrumentation Implementation

Now it's time for dinner. Let's see how cover performs instrumentation and coverage collection. To use cover to complete code coverage collection, we must know three dragon-slaying swords:

cover:start: Used to create the cover coverage collection process, it will complete the creation of the relevant ets table to store the coverage data, cover.erl#L159 & cover.erl#L632, and we can also start the cover process of the remote Erlang node.
cover:compile_beam: For instrumentation, cover will read the content of the abstract_code of the BEAM file, namely Erlang AST. The key code is in cover.erl#L1541, and then transform and munge the Erlang AST From, it will call bump_call, after each executable line will insert the following abstract_code:

    {call,A,{remote,A,{atom,A,ets},{atom,A,update_counter}},
     [{atom,A,?COVER_TABLE},
      {tuple,A,[{atom,A,?BUMP_REC_NAME},
                {atom,A,Vars#vars.module},
                {atom,A,Vars#vars.function},
                {integer,A,Vars#vars.arity},
                {integer,A,Vars#vars.clause},
                {integer,A,Line}]},
      {integer,A,1}]}.

From the previous understanding of Erlang AST, we know that this is equivalent to inserting the following line of code:

ets:update_counter(?COVER_TABLE, #bump{module=Module, function=Function, arity=Arity, clause=Clause, line=Line}, 1).

Then for the mungeed Erlang AST Form, cover uses the Erlang Compiler to obtain the Erlang Beam Code (also known as object code. i.e. bytecode, VM execution instructions) from the mungeed AST expression form. cover.erl#L1580. And then use the Erlang code server to replace the old object code with the new object code obtained, load_binary cover.erl#L1581 into ERTS (Erlang Run Time System). cover completes the Erlang AST instrumentation process, so that whenever the executable line is Executed, the corresponding ets storage table will update the number of times the code line was called.

cover:analyze: Analyze the data stored in the ets table to obtain the number of times the executable line was executed (called), which can be used for statistical coverage data.

munge: Used to make a series of potentially destructive or irreversible changes to data or files.

3. Elixir Application runtime coverage collection example

Through the above, after understanding the implementation details of the Erlang Cover module. Let us take a deployed and running Elixir Application (we will use the previous yesan333/explore_ast_app) as an example to perform large-scale tests (system & integration tests) of the Elixir application runtime of code line-level coverage collection.

Here we will use a tool library: ex_integration_coveralls for coverage analysis, which is an Elixir Wrapper for the Erlang module cover to collection Elixir runtime system coverage. Let's start:

Step 1、Add ex_integration_coveralls dependency to mix.exs file:

  defp deps do
    [
      ...,
      {:ex_integration_coveralls, "~> 0.3.0"}
    ]
  end

Pull the dependencies and rebuild the project:

mix deps.get
MIX_ENV=prod mix distillery.release

Step 2、Start the project:

_build/prod/rel/explore_ast_app/bin/explore_ast_app foreground

Step 3、Connect to the remote_console of the Elixir runtime application node:

_build/prod/rel/explore_ast_app/bin/explore_ast_app remote_console

Step 4、Use ex_integration_coveralls (ExIntegrationCoveralls.execute) to start cover and perform code coverage collection:

iex(explore_ast_app@127.0.0.1)1> compiled_beam_dir_path = "/Users/yeshan/oss_github/explore_ast_app/_build/prod/rel/explore_ast_app/lib/explore_ast_app-0.1.0/ebin"
"/Users/yeshan/oss_github/explore_ast_app/_build/prod/rel/explore_ast_app/lib/explore_ast_app-0.1.0/ebin"
iex(explore_ast_app@127.0.0.1)2> ExIntegrationCoveralls.execute(compiled_beam_dir_path)
[
  ok: ExploreAstApp.Router,
  ok: ExploreAstApp.Plug.VerifyRequest.IncompleteRequestError,
  ok: ExploreAstApp.Plug.VerifyRequest,
  ok: ExploreAstApp.Application,
  ok: ExploreAstApp
]
iex(explore_ast_app@127.0.0.1)3> compile_time_source_lib_abs_path = "/Users/yeshan/oss_github/explore_ast_app"
"/Users/yeshan/oss_github/explore_ast_app"
iex(explore_ast_app@127.0.0.1)4> source_code_abs_path = "/Users/yeshan/oss_github/explore_ast_app"
"/Users/yeshan/oss_github/explore_ast_app"
iex(explore_ast_app@127.0.0.1)5> ExIntegrationCoveralls.get_total_coverage(compile_time_source_lib_abs_path, source_code_abs_path)
0

As you can see, the initial coverage is 0, because no code has been called yet.

Step 5、Let's execute the following cURL. Let code be called:

$ curl --location --request GET 'http://localhost:8080/hello'
hello %

Check out the code coverage data again in iex console:

iex(explore_ast_app@127.0.0.1)6> ExIntegrationCoveralls.get_total_coverage(compile_time_source_lib_abs_path, source_code_abs_path)
17.1

As you can see, the cURL (test case) coverage for this project is 17.1%.

We can also use the following methods to view more detailed code coverage, such as viewing the code coverage of lib/explore_ast_app/router.ex (nil means the line is not an executable line):

iex(explore_ast_app@127.0.0.1)7> result = ExIntegrationCoveralls.get_coverage_report(compile_time_source_lib_abs_path, source_code_abs_path)
.......
iex(explore_ast_app@127.0.0.1)8> Enum.at(Map.get(result, :files), 3)
%ExIntegrationCoveralls.Stats.Source{
  coverage: 18.2,
  filename: "lib/explore_ast_app/router.ex",
  hits: 4,
  misses: 18,
  sloc: 22,
  source: [
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 1,
      source: "defmodule ExploreAstApp.Router do"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: 1, source: "  use Plug.Router"},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  use Plug.ErrorHandler"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  import Plug.Conn"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  alias ExploreAstApp.Plug.VerifyRequest"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  plug Plug.Parsers, parsers: [:urlencoded, :multipart]"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  plug VerifyRequest, fields: [\"content\", \"mimetype\"], paths: [\"/upload\"]"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  plug :match"},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  plug Plug.Parsers, parsers: [:json], pass: [\"application/json\"], json_decoder: Jason"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "  plug :dispatch"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "  get \"/welcome\" do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "    send_resp(conn, 200, \"Welcome\")"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  end"},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "  get \"/upload\" do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "    send_resp(conn, 201, \"Uploaded\")"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  end"},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 1,
      source: "  get \"/hello\" do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "    # query parameter is user like this:"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "    # http://localhost:4001/hello?name=John"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "    # which will create %{\"name\" => \"John\"}"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 1,
      source: "      send_resp(conn, 200, \"hello \#{Map.get(conn.query_params, \"name\")}\")"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  end"},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "  get \"/hello/:name\" do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "    send_resp(conn, 200, \"hello \#{name}\")"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "  end"},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "  post \"/hello\" do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "    # json body of POST request {\"name\": \"John\"} is parsed to %{\"name\" => \"John\"}"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "    # so it can be accesable with e.g. Map.get(conn.body_params, \"name\") or with pattern matching"
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: 0, source: "    name ="},
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "      case conn.body_params do"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: 0,
      source: "        %{\"name\" => a_name } -> a_name"
    },
    %ExIntegrationCoveralls.Stats.Line{
      coverage: nil,
      source: "        _ -> \"\""
    },
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: "      end"},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, source: ""},
    %ExIntegrationCoveralls.Stats.Line{coverage: nil, ...},
    %ExIntegrationCoveralls.Stats.Line{...},
    ...
  ]
}

Based on the post_cov_stats_to_ud_ci interface, it is possible to further interface with internal or external Codecov-like coverage systems.

Based on this, we can realize the collection of code coverage with large-scale (integration & system) testing capabilities without stopping the Elixir Application.

4. Continuous runtime coverage collection solution for large-scale Elixir/Erlang Microservice clusters

With the continuous expansion of the Elixir/Erlang microservice system, the coverage collection method shown in the previous section needs further evolution. Referring to the design of Prometheus Pull-Base, the overall design (combination of Pull & Push mode) is as follows:

We expand based on ex_integration_coveralls. After the Elixir Application is started, a http worker is started up to expose the code coverage data in real time, which is convenient for communication with heterogeneous systems. The Coverage Push Gateway is responsible for regularly pulling the coverage data (Gateway can be a OTP Application, which allows ex_integration_coveralls to directly start up the custom GenServer Worker for interactive integration test system in the distributed OTP system), after the integration/system test system informs the end of the test, the Gateway pushes the coverage data to the Cover Center for code coverage rate display.

End (long way to go).

DEV Community: yeshan333

Generate Slideshow-Style Documentation Sites for GitHub Repositories with iFLOW-CLI GitHub Action and Qwen3-Coder

Using iFLOW CLI GitHub Action

Generating Slideshow-Style Documentation Sites with iFLOW CLI GitHub Action

Conclusion

Generate Slideshow-Style Documentation Sites for GitHub Repositories with iFLOW-CLI GitHub Action and Qwen3-Coder

Using iFLOW CLI GitHub Action

Generating Slideshow-Style Documentation Sites with iFLOW CLI GitHub Action

Conclusion

Building Your Own RSS Feed Subscription Management & AI Large Model Reading Workflow with n8n

Deploying n8n with Docker

Workflow Design

RSS Link Subscription Processing Workflow

Workflow Orchestration File Sharing

Workflow Usage Notes

AI Large Model-Based RSS Article Information Acquisition, Organization, and Push Workflow

Workflow Usage Notes

Orchestration File Sharing

Conclusion

(Amazing!) How to manage and install multiple versions of Erlang/OTP and Elixir via vfox in Windows

1、Install vfox

2、Install Erlang/OTP through vfox-erlang plugin

3、Install Elixir via vfox-elixir plugin

In the end

Validate your Jenkinsfile with the vscode plugin vscode-jenkins-pipeline-linter-connector and the LLMs large model

Configure the plugin

Review your Jenkinsfile with the LLM large model

Chaos (fault) testing method for etcd and MongoDB

Fault test in MongoDB

Fault test in etcd

Compile etcd for fault testing

Install mutiple Erlang and Elixir with vfox

Install vfox

Install Erlang/OTP via the vfox-erlang plugin

Install Elixir

Set the global usage version

The End

Installing Erlang With vfox

Using vfox-erlang

Install the vfox and vfox-erlang plugin

Install the specified version of Erlang/OTP via plugin

The solution of Elixir continuous runtime system code coverage collection

1. Brief talk on code coverage

2. Delve into the Erlang Cover coverage collection implementation mechanism

2.1. Introduction Erlang Cover

2.2. Erlang code coverage collection implementation analysis

2.3. Learn about BEAM File Format

2.4. Elixir source code compilation process

2.5. Cover On-The-Fly Instrumentation Implementation

3. Elixir Application runtime coverage collection example

4. Continuous runtime coverage collection solution for large-scale Elixir/Erlang Microservice clusters

References