DOCSEARCHbyAlgolia
Submit Docs

Remiz Documentation

website·Indexed 29 days ago

https://remiz-org.github.io/remiz/

A simple and extensible command line tool designed to build and deploy packages using the .pack format. Documentation covers installation on Windows, Mac, and Linux, global and package configuration specifications, the build and deployment process, and instructions for writing custom packagers.

Tokens
5.1K
Snippets
33
Records
47
Agent score
72%

What's inside Remiz

  1. Overview of Remiz project deployment tool

    Remiz is an open-source (MIT license), multi-platform (Windows, Mac, Linux) command-line tool used to create and deploy reproducible copies of projects. It serializes all project data into a single compressed binary file with a .pack extension (which is customizable). The tool is designed for integration into CI/CD pipelines (such as GitLab or Jenkins) and is configured using TOML files.

  2. Overview of Remiz project packaging

    Remiz is an open-source (MIT licensed), cross-platform command-line tool used to create and deploy reproducible copies of projects. It serializes project data into a single compressed binary file, typically with a .pack extension. It is designed for use both on local machines and within CI/CD pipelines (such as GitLab or Jenkins) to define packaging and deployment processes. Configuration is handled via TOML files.

  3. Overview of Remiz features and architecture

    Remiz is an open-source (MIT licensed) tool written in Rust, designed for fast, reliable, and secure building and deployment of packages. It features an extensible architecture where configurations are defined in TOML, allowing developers to use any programming language to build or deploy project components.

  4. Remiz Project Overview

    Remiz is an open-source (MIT licensed) tool written in Rust, designed for the fast installation, building, and deployment of packages. It emphasizes reliability, security, and performance.

  5. Understand the Remiz build process and packager execution

    Remiz builds packages by sequentially calling packager entrypoints defined in the global configuration for every packager declared in the package configuration.

    Key behaviors:

    • Remiz gathers files from the 'magic folder' for each packager.
    • A packager can register zero, one, or multiple files; however, a warning is triggered if no files are found.
    • If any packager exits with a non-zero exit code, the entire build process stops immediately.
    • The final package is produced after all packagers complete, combining all packager files and metadata.

  6. Understand the Remiz package build process

    Remiz builds packages by sequentially calling the entry points of each packager declared in the package configuration. For each packager, Remiz retrieves files from designated 'magic folders'. A packager may produce zero, one, or multiple files; however, if no files are found, a warning is displayed. If any packager exits with a non-zero return code, the entire package build process is halted. Once all packagers are processed, Remiz aggregates all retrieved files and adds metadata to produce the final package.

  7. Create a custom Remiz packager

    A packager in Remiz allows you to organize a project by components, handling how assets are saved during the build process and how they are deployed. A packager can be written in any executable language. It must implement two primary logic paths: build and deploy. Remiz passes the necessary information to the packager via command-line arguments.
    #!/usr/bin/python3

import argparse

def get_args():
    parser = argparse.ArgumentParser(description='copy_files packager.')

    subparser = parser.add_subparsers(dest="subcommand", required=True)
    build_parser = subparser.add_parser("build")
    build_parser.add_argument('--path', required=True)

    deploy_parser = subparser.add_parser("deploy")
    deploy_parser.add_argument('--path', required=True)
    deploy_parser.add_argument('--env', required=True)

    return parser.parse_known_args()

# Implement your build and deploy functions
def build(path, unknown_args):
    pass

def deploy(path, unknown_args, env):
    pass

if __name__ == "__main__":
    args, unknown_args = get_args()

    if args.subcommand == "build":
        build(args.path, unknown_args)

    if args.subcommand == "deploy":
        deploy(args.path, unknown_args, args.env)

  10. Install Remiz binary on Linux

    Remiz is distributed as a binary available for Windows, Mac, and Linux via the GitHub Release page. For Linux users, download the .tar.gz archive, extract it, and move the binary to a directory in your system $PATH (such as /usr/local/bin) or create a symbolic link to make the remiz command available globally.
    # Download and extract the binary
wget https://github.com/remiz-org/remiz/releases/download/v0.0.23/remiz_v0.0.23_x86_64-unknown-linux-musl.tar.gz
tar -xf remiz_v0.0.23_x86_64-unknown-linux-musl.tar.gz

# Create a symbolic link to make the command available everywhere
ln -s ~/remiz/remiz /usr/local/bin/remiz

  12. Implement a custom Remiz packager

    A packager in Remiz is an executable script (written in any language) responsible for building and deploying project assets. To implement a packager, you must create a script that handles two primary subcommands: build and deploy. Remiz passes the necessary context (such as paths and environment variables) as arguments to these commands.
    #!/usr/bin/python3
import argparse

def get_args():
    parser = argparse.ArgumentParser(description='copy_files packager.')
    subparser = parser.add_subparsers(dest="subcommand", required=True)
    
    # Build command: requires the path to the package
    build_parser = subparser.add_parser("build")
    build_parser.add_argument('--path', required=True)

    # Deploy command: requires the path and the target environment
    deploy_parser = subparser.add_parser("deploy")
    deploy_parser.add_argument('--path', required=True)
    deploy_parser.add_argument('--env', required=True)

    return parser.parse_known_args()

if __name__ == "__main__":
    args, unknown_args = get_args()
    if args.subcommand == "build":
        # Implement build logic here
        build(args.path, unknown_args)
    if args.subcommand == "deploy":
        # Implement deploy logic here
        deploy(args.path, unknown_args, args.env)