Blazing fast, memory safe & modern Linux package manager written in Rust.

Overview

paket

Blazing fast, memory safe & modern Linux package manager written in Rust.

Roadmap

Version: 0.1

  • Paket.toml file parsing. (#1, #2)
  • CLI handling (paket <...>) (#3)
  • libpaket to install and manage pakets for usage in paket-cli and paket-server and other developers.
  • Creating .paket files with paket build (#6, #7, #8)
  • Install a .paket file with paket install <filename> (#9)
  • Upgrade, Downgrade an existing paket
  • Remove a paket

Version: 0.2

  • paket-server serves as a repository file server
  • QUIC + HTTP/3 implementation for both client(paket-cli) and server(paket-server)
  • Download and install .paket files from repository
  • Search pakets with paket search [keywords]

Version 0.3:

  • Development of paket-maker-gui, making the creating .paket process easy for package maintainers.

How does it work?

Basically: Alt text

Package Types

type Description
application an Application in binary compiled form (e.g. vlc)
script an Application in script form (e.g.: pardus-image-writer, Python or Javascript script applications)
library a Shared Library to applications depend on it. (e.g. libgtk-4-1)
development_library Development files of a library which programs depend on. Used in application development. (e.g. libgtk-4-dev)
application_source_code Source code of an application. It can be used to compile the application from source code embedded in the package. (e.g. gzip-src)
library_source_code Source code of a library. It can be used to compile the library from source code embedded in the package. (e.g. libXYZ-1-src)
configuration Files to be directly copied to the system. (e.g. font-abc, icon-xyz, dotfiles-xyz)
Comments
  • [Task] Create a Configuration paket with `paket build`

    [Task] Create a Configuration paket with `paket build`

    Depends-On: #6

    Description: Create a paket regarding to the paket type of PackageType::Configuration

    Configuration type means "just copy the files inside the paket to their regarding paths in the system":

    • {PaketRoot}/etc/X11/xorg.conf -> /etc/X11/xorg.conf
    • {PaketRoot}/$USER_HOME/.config/monitors.xml -> /home/my-user/.config/monitors.xml (accessing the home folder of the current user by creating a "$USER_HOME" folder)
    • {PaketRoot}/$ALL_USERS_HOMES/.config/monitors.xml -> ["/home/my-user/.config/monitors.xml", "/home/user2/.config/monitors.xml", ...] (accessing the home folders of all users by creating a "$ALL_USERS_HOMES")

    Acceptance Criteria:

    • [x] Local paket can be created successfully.
    • [x] Tests are passing.
    • [x] Documentations on every struct, property and function is written with ///. There should be a description and a small example usage.

    Implementation Details:

    // Some example code about how it will work
    
    Task paket-cli 
    opened by eminfedar 0
  • [Task] Create a common paket building for using on every type

    [Task] Create a common paket building for using on every type

    Description: This is the first task of Creating a Paket milestone.

    Every different building type have common things like creating a tar.gz package, calculating SHA256SUM etc.

    Acceptance Criteria:

    • [x] Common functions implemented
    • [x] Tests are passing.
    • [x] Documentations on every struct, property and function is written with ///. There should be a description and a small example usage.

    Implementation Details:

    // Some example code about how it will work
    
    Task 
    opened by eminfedar 0
  • [Task] Move common

    [Task] Move common "paket" code to a crate `libpaket`

    Description: paket-cli and paket-server can depend on libpaket which consists common structures and functions to work with paket's.

    Acceptance Criteria:

    • [x] paket-cli and paket-server depends on libpaket.
    • [x] libpaket consists common paket structures and functions. Prevents code duplication on paket-cli and paket-server with common code.
    • [x] Tests are passing.
    • [x] Documentations on every struct, property and function is written with ///. There should be a description and a small example usage.

    Implementation Details:

    enhancement Task 
    opened by eminfedar 0
  • [Task] CLI Handling

    [Task] CLI Handling

    Acceptance Criteria:

    • [x] Separate cli module for cli handling paket-cli can handle these CLI inputs:
    • [x] paket build
    • [x] paket install <packages>...
    • [x] paket remove <packages>...
    • [x] paket search <keywords>...

    Implementation Details: Use clap crate. Define build, install etc. as commands.

    Task paket-cli 
    opened by eminfedar 0
  • [Task] Paket.toml - Add `dependencies` field

    [Task] Paket.toml - Add `dependencies` field

    Acceptance Criteria:

    • [ ] Dependencies struct implemented and added in Config
    • [ ] Basic tests are working. (tests/toml_parse.rs)
    • [ ] Full tests are working. (tests/toml_parse.rs)
    • [ ] Documentations on every struct, property and function is written with /// three slashes.

    Implementation Details: Config Struct:

    #[derive(Deserialize, Serialize)]
    struct Config {
        package: Package,
        dependencies: Option<Dependencies>,
    }
    

    Dependencies Struct:

    #[derive(Deserialize, Serialize)]
    struct Dependencies {
        application: Option<Vec<String>>,
        library: Option<Vec<String>>,
        development: Option<Vec<String>>,
    }
    

    These fields may be updated, names may change or new fields may be added.

    Example Paket.toml:

    [package]
    name = "paket-ornek"
    version = "0.1.0"
    maintainers = ["Emin Fedar <[email protected]>"]
    
    description = "A paket package example."
    license = "MIT"
    
    architectures = ["amd64"]
    
    [dependencies]
    application = ["python3.11", "python3-gi"]
    library = ["libgtk-3-0", "libglib2.0.0", "libpango-1.0-0"]
    # development = ["libgtk-3-0-dev"] # This field is only needed if the paket type is Source Code
    
    Task paket-cli 
    opened by eminfedar 0
  • [Task] Paket.toml - Add `struct Config`

    [Task] Paket.toml - Add `struct Config`

    Acceptance Criteria:

    • [x] Package and Config structs implemented
    • [x] Reading & Parsing Paket.toml is working.
    • [x] Basic, Full, and wrong content contained Paket.toml files and corresponding tests are working.(tests/toml_parse.rs)

    Implementation Details: Config struct:

    #[derive(Debug, Deserialize)]
    struct Config {
        package: Package,
    }
    

    Package struct corresponding to the [package] title in the .toml file:

    #[derive(Debug, Deserialize)]
    struct Package {
        // ------------- Must Fields -------------
        name: String,
        version: String,
        maintainers: Vec<String>,
        description: String,
        license: String,
        architectures: Vec<String>,
    
        // ------------- Optional Fields -------------
        homepage: Option<String>,
        keywords: Option<Vec<String>>,
        categories: Option<Vec<String>>,
    }
    

    These fields may be updated, names may change or new fields may be added.

    Example "Basic" Paket.toml:

    [package]
    name = "paket-ornek"
    version = "0.1.0"
    maintainers = ["Emin Fedar <[email protected]>"]
    
    description = "A paket package example."
    license = "MIT"
    
    architectures = ["amd64"]
    

    Example "Full" Paket.toml:

    [package]
    name = "hello-world"
    version = "0.1.0"
    maintainers = ["Emin Fedar <[email protected]>"]
    
    homepage = "pardus.org.tr"
    keywords = ["package", "tags", "here"]
    categories = ["Game", "Education"]
    
    license = "MIT"
    architectures = ["amd64"]
    
    description = """
    Multiline description of what this package is about.
    """
    
    Task paket-cli 
    opened by eminfedar 0
  • [Task] Install a `Configuration` package type with `paket install`

    [Task] Install a `Configuration` package type with `paket install`

    Description: a local .paket file builded with Configuration type should be installable with this usage:

    paket install paket-name_1.0.0.paket
    

    Configuration type means "just copy the files inside the paket to their regarding paths in the system":

    • {PaketRoot}/etc/X11/xorg.conf -> /etc/X11/xorg.conf
    • {PaketRoot}/$USER_HOME/.config/monitors.xml -> /home/my-user/.config/monitors.xml (accessing the home folder of the current user by creating a "$USER_HOME" folder)
    • {PaketRoot}/$ALL_USERS_HOMES/.config/monitors.xml -> [ "/home/my-user/.config/monitors.xml", "/home/user2/.config/monitors.xml", "/home/another-user/.config/monitors.xml", ] (accessing the home folders of all users by creating a "$ALL_USERS_HOMES")

    Acceptance Criteria:

    • [ ] Local paket can be installed successfully.
    • [ ] Installed pakets are stored in /var folder.
    • [ ] Upgrading or Downgrading for same package.
    • [ ] SHA256SUM check before installation
    • [ ] Files in $USER_HOME must be owned by the installer user, not root.
    • [ ] Files in $ALL_USERS_HOMES must owned by each different user, not root or installer user.
    • [ ] Tests are passing.
    • [ ] Documentations on every struct, property and function is written with ///. There should be a description and a small example usage.

    Implementation Details:

    // Some example code about how it will work
    
    Task paket-cli 
    opened by eminfedar 0
  • [Task] Add build support for `Application`, `Script`, `Library`, `Development Library` package types with `paket build`

    [Task] Add build support for `Application`, `Script`, `Library`, `Development Library` package types with `paket build`

    Description: Create a paket regarding to the paket type of these:

    • PackageType::Application
    • PackageType::Script
    • PackageType::Library
    • PackageType::DevelopmentLibrary

    UPDATED: These fields not in their final form, constantly updated. Custom Fields for Types:

    • PackageType::Application =>
    [application]
    executable = "myapp"
    icon = "myapp.svg"
    
    assets_folder = "assets" # stores the assets(image,video,sound,binary,text data etc.) in paket folder. like: assets/img/logo.png, assets/sound/intro.ogg, assets/3d_objects/My3DModel.obj
    desktop_file = "assets/export/myapp.desktop" # optional, automatically generated if not provided
    
    • PackageType::Script =>
    [script]
    executable = "main.py" # To create link `/usr/bin/myapp` -> `/usr/share/paketname/src/main.py`
    icon = "myapp.svg"
    
    sources_folder = "src" # stores the scripts in paket folder. like: src/main.py, src/MainWindow.py, src/Utils.py
    assets_folder = "assets" # stores the assets(image,video,sound,binary,text data etc.) in paket folder. like: assets/img/logo.png, assets/sound/intro.ogg, assets/3d_objects/My3DModel.obj
    desktop_file = "assets/export/myapp.desktop"  # optional, automatically generated if not provided
    

    TODO: These package types have custom fields. Application & Script types have executable stores the binary which makes paket manage application and script pakets more powerful. (will work on these fields, program files which stored on /usr/share for scripting files? etc.) Libraries also should be powerful to work on. paket should know if it is an archive .a or .so file only etc. Also Application or Script packages automatically create .desktop files with paket information while installing.

    Acceptance Criteria:

    • [ ] Local paket can be builded and created successfully.
    • [ ] Different build tactics for different PackageTypes. (maybe?)
    • [ ] Tests are passing.
    • [ ] Documentations on every struct, property and function is written with ///. There should be a description and a small example usage.

    Implementation Details:

    // Some example code about how it will work
    
    Task paket-cli 
    opened by eminfedar 0
Owner
null
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert.

Linked Atomic Random Insert Vector Lariv is a thread-safe, self-memory-managed vector with no guaranteed sequential insert. It internally uses a linke

Guillem Jara 8 Feb 1, 2023
PE Parsing, but blazing fast

PE Parser A blazing fast ?? PE Parser written in Rust Motivation The main goals of pe-parser is to write something suitable for a PE Loader. Is editin

Isaac Marovitz 8 Apr 21, 2023
A fast lean and clean modern constraint programming solver implementation (in rust)

MaxiCP-rs This project aims at implementing a fast, and clean constraint programming solver with a focus on correctness, simplicity, maintainability a

Xavier Gillard 5 Dec 10, 2022
A traditional web forum built in Rust with modern technology to be fast, secure, scalable, and stable.

Volksforo A traditional web forum built in Rust with modern technology to be fast, secure, scalable, and stable. Stack Rust actix-web askama ScyllaDB

Josh 5 Mar 21, 2023
DWARF packaging utility, written in Rust, supporting GNU extension and DWARF 5 package formats.

thorin thorin is an DWARF packaging utility for creating DWARF packages (*.dwp files) out of input DWARF objects (*.dwo files; or *.o files with .dwo

The Rust Programming Language 19 Nov 16, 2022
Thread-safe clone-on-write container for fast concurrent writing and reading.

sync_cow Thread-safe clone-on-write container for fast concurrent writing and reading. SyncCow is a container for concurrent writing and reading of da

null 40 Jan 16, 2023
RcLite: small, fast, and memory-friendly reference counting for Rust

RcLite: small, fast, and memory-friendly reference counting RcLite is a lightweight reference-counting solution for Rust that serves as an alternative

Khashayar Fereidani 147 Apr 14, 2023
Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash

Lorust - API Documentation Lorust is the Rust version of Lodash, which is a modern Javascript utilty library delivering modularity, performance & extr

Imamuzzaki Abu Salam 2 Jul 9, 2023
Small programs written in Rust. Warm up for the upcoming Selenium Manager

Rust Examples This repository contains several example programs written in Rust. Selenium Manager These examples are used as warm up for the upcoming

Boni GarcĂ­a 5 Dec 30, 2022
A gitweb/cgit-like interface for the modern age

rgit See it in action! A gitweb/cgit-like interface for the modern age. Written in Rust using Axum, git2, Askama and Sled. Sled is used to store all m

jordan 14 Apr 8, 2023
Safe, comp time generated queries in rust

query_builder For each struct field following methods will be generated. All fields where_FIELDNAME_eq Numeric fields where_FIELDNAME_le where_FIELDNA

Amirreza Askarpour 2 Oct 31, 2021
Safe Rust bindings to the DynamoRIO dynamic binary instrumentation framework.

Introduction The dynamorio-rs crate provides safe Rust bindings to the DynamoRIO dynamic binary instrumentation framework, essentially allowing you to

S.J.R. van Schaik 17 Nov 21, 2022
Build database expression type checker and vectorized runtime executor in type-safe Rust

Typed Type Exercise in Rust Build database expression type checker and vectorized runtime executor in type-safe Rust. This project is highly inspired

Andy Lok 89 Dec 27, 2022
Safe, idiomatic bindings to cFE and OSAL APIs for Rust

n2o4 The n2o4 crate provides safe, idiomatic Rust bindings to the APIs of cFE and OSAL, the libraries of the Core Flight System (cFS). IMPORTANT NOTE

null 3 Aug 29, 2022
Safe MMDeploy Rust wrapper.

Introduction Safe MMDeploy Rust wrapper. News (2022.9.29) This repo has been added into the OpenMMLab ecosystem. (2022.9.27) This repo has been added

Mengyang Liu 14 Dec 15, 2022
Safe, efficient, and ergonomic bindings to Wolfram LibraryLink and the Wolfram Language

wolfram-library-link Bindings to the Wolfram LibraryLink interface, making it possible to call Rust code from the Wolfram Language. This library is us

Wolfram Research, Inc. 28 Dec 6, 2022
A type-safe, high speed programming language for scalable systems

A type-safe, high speed programming language for scalable systems! (featuring a cheesy logo!) note: the compiler is unfinished and probably buggy. if

Hail 0 Sep 14, 2022
Simple, safe way to store and distribute tensors

safetensors Safetensors This repository implements a new simple format for storing tensors safely (as opposed to pickle) and that is still fast (zero-

Hugging Face 402 Dec 29, 2022
A small in-memory key value database for rust

SmollDB Small in-memory key value database for rust This is a small in-memory key-value database, which can be easly backed up in a file or stream and

null 13 Dec 15, 2022