refactor image builds

[zhangzujian]

• Make sure you have followed Kube-OVN Code Style.

What type of this PR

Examples of user facing changes:

• Features
• Bug fixes
• Docs
• Tests

Which issue(s) this PR fixes:

With this patch, a new image with the tag <VERSION>-debug will be built. We can use the image to debug OVS/OVN.

WHAT

🤖 Generated by Copilot at ecbe803

This pull request adds a new feature to build and push debug images of kube-ovn for both x86 and arm platforms. It updates the Makefile and several GitHub workflows to support the new debug tag and image. It also deletes an unused workflow file.

🤖 Generated by Copilot at ecbe803

Sing, O Muse, of the mighty deeds of the kube-ovn team,
Who built and pushed the debug images with skill and care,
To aid the troubleshooters of the network overlay,
And make the OVN work on platforms diverse and fair.

HOW

🤖 Generated by Copilot at ecbe803

• Add support for debug images for both x86 and arm platforms (link, link, link, link, link, link, link, link, link, link, link, link, link, link)
• Use the debug tag instead of the no-avx512 tag for the debug image in the build-x86-image.yaml workflow (link)
• Tag the debug image with the x86 suffix in the build-x86-image.yaml workflow (link)
• Push the debug image with the x86 suffix in the build-x86-image.yaml workflow (link)
• Tag the debug image with the debug suffix for the arm platform in the build-arm64-image.yaml workflow (link)
• Push the debug images for both platforms in the build-kube-ovn-base.yaml workflow (link)
• Pull and create a manifest for the debug images for both platforms in the publish.yaml workflow (link)
• Add a variable for the debug tag in the Makefile (link)
• Use the debug tag and the base tag arguments for the docker build commands in the build-kube-ovn target in the Makefile (link)
• Use the debug argument and the debug tag for the docker buildx commands in the base-amd64 and base-arm64 targets in the Makefile (link, link)
• Use the debug tag for the docker save commands in the tar-kube-ovn, base-tar-amd64, and base-tar-arm64 targets in the Makefile (link, link, link)
• Add a kind-install-debug target in the Makefile to test the debug image in a kind cluster (link)
• Delete the build-kube-ovn-debug.yaml workflow as it is no longer needed (link)

[github-actions]

• The use of hard-coded values in the code should be avoided as it can lead to maintenance issues and potential bugs. Instead, constants or configuration files should be used.
• The code should follow a consistent formatting style throughout the project. Inconsistent formatting can make the code difficult to read and maintain.
• The patch introduces a new feature that may impact the performance of the system. It is important to conduct thorough testing to ensure that the performance is not negatively affected.
• The code should have proper error handling mechanisms in place to handle unexpected scenarios. This will help prevent crashes and improve the overall stability of the system.
• The patch introduces changes to existing functionality. It is important to ensure that these changes do not introduce any regressions or break existing functionality. Thorough testing and code reviews should be conducted to catch any potential issues.

[github-actions]

• Inconsistent formatting: There are several instances where the indentation and spacing of the code is inconsistent. This can make it difficult to read and understand the code. It is important to maintain consistent formatting throughout the codebase to improve readability and maintainability.

• Potential performance issues: There are some areas of the code that may cause performance issues, such as nested loops or excessive use of memory. It is important to review these areas and optimize the code where possible to improve performance.

• Lack of comments/documentation: Some parts of the code lack sufficient comments or documentation, making it difficult for other developers to understand the purpose and functionality of the code. It is important to add comments and documentation to improve the overall quality of the codebase.

• Error handling: There are some areas of the code where error handling is not implemented or could be improved. It is important to ensure that all potential errors are handled properly to prevent crashes or unexpected behavior.

• Security vulnerabilities: There may be potential security vulnerabilities in the code, such as SQL injection or cross-site scripting (XSS) attacks. It is important to review the code for these vulnerabilities and implement appropriate security measures to protect against them.

[github-actions]

• Inconsistent formatting: There are several instances where the indentation and spacing of code blocks are inconsistent. This can make the code harder to read and maintain. It would be helpful to establish a consistent formatting style throughout the codebase.
• Potential performance issues: There are some areas of the code that may cause performance issues, such as nested loops or excessive use of database queries. It would be beneficial to review these sections and optimize them if possible.
• Lack of error handling: There are some functions that do not have proper error handling, which could lead to unexpected behavior or crashes. It would be important to add appropriate error handling to ensure the stability of the application.
• Unclear variable names: Some variable names are unclear or too generic, making it difficult to understand their purpose. It would be helpful to use more descriptive variable names to improve code readability.
• Redundant code: There are some sections of code that appear to be redundant or unnecessary. Removing this code could simplify the codebase and improve performance. It would be worth reviewing these sections to determine if they can be removed.

[github-actions]

• Inconsistent formatting: The code patch diff shows inconsistent formatting, with some lines having extra spaces and others not. This can make the code difficult to read and maintain. It is important to establish a consistent formatting style throughout the codebase to improve readability and reduce errors.

• Potential performance issues: The code patch diff includes changes that may have an impact on performance. It is important to thoroughly test these changes to ensure they do not cause any performance degradation. Additionally, it may be worth considering alternative approaches to achieve the same functionality if performance is a concern.

• Lack of documentation: The code patch diff does not include sufficient documentation for the changes made. It is important to provide clear and concise documentation for all code changes to help other developers understand the purpose and implementation of the changes.

• Potential bugs: The code patch diff includes changes that may introduce new bugs or regressions. It is important to thoroughly test these changes and perform code reviews to identify and address any potential issues before merging the changes into the main codebase.

• Code complexity: The code patch diff includes changes that increase the overall complexity of the code. It is important to keep the code as simple and straightforward as possible to improve readability and maintainability. Consider refactoring the code to simplify it and reduce its overall complexity.

[github-actions]

• The use of hard-coded values in the code should be avoided as much as possible. Instead, constants or configuration files should be used to store such values. This will make it easier to modify these values in the future if needed.
• The patch includes changes to multiple files, which makes it difficult to review and understand the changes. It would be better if the changes were split into smaller, more focused patches that can be reviewed and tested independently.
• The patch introduces a new feature, but there are no unit tests or integration tests included to ensure that the feature works correctly and does not break existing functionality. Tests should be added to cover all new and existing functionality.
• The patch includes changes to the formatting of the code, but the changes are inconsistent and do not follow the project's style guide. All code should be formatted consistently to improve readability and maintainability.
• The patch includes changes to the Kubernetes API objects used by kube-ovn, but there is no documentation explaining how these objects are used or what their purpose is. Documentation should be added to help other developers understand the code and use the API objects correctly.

[github-actions]

• Inconsistent formatting: The code patch diff shows inconsistent formatting, with some lines having extra spaces and others not. This can make the code difficult to read and maintain. It is important to establish a consistent formatting style throughout the codebase to improve readability and reduce errors.

• Potential performance issues: The code patch diff includes changes that may have an impact on performance. For example, adding new features or functionality without considering the impact on system resources can lead to slower response times or even crashes. It is important to thoroughly test any changes that could affect performance before merging them into the codebase.

• Lack of comments/documentation: The code patch diff does not include sufficient comments or documentation to explain the purpose and function of the code. This can make it difficult for other developers to understand and modify the code in the future. Adding clear and concise comments and documentation can improve the overall quality of the codebase.

• Incomplete error handling: The code patch diff does not include complete error handling for all possible scenarios. This can lead to unexpected behavior or crashes when errors occur. It is important to anticipate and handle errors in a comprehensive manner to ensure the stability and reliability of the code.

• Security vulnerabilities: The code patch diff may introduce security vulnerabilities into the codebase. For example, adding new functionality without considering potential security risks can leave the system open to attacks. It is important to conduct thorough security testing and implement appropriate security measures to protect the system from potential threats.