Add demo of hyper

Signed-off-by: Aisuko <[email protected]>

Author: Aisuko

.gitignore

@@ -14,4 +14,6 @@ _book
 *.epub
 *.mobi
 *.pdf
-gRPC/rust/target/
+*target
+*.idea
+*.vscode

SUMMARY.md

@@ -17,10 +17,10 @@
     * [👨‍💻 Segfault](freesoftware/the-gnu-hurd/cgo/segmentation-fault.md)
   * [🛃 Rust FFI](freesoftware/the-gnu-hurd/rust-ffi.md)
 * [🧚🏻‍♂️ Programming](freesoftware/programming/README.md)
-  * [✏️ Introduction to programming](freesoftware/programming/introduction-to-6811-programming.md)
-  * [- Mutable Value Semantics](freesoftware/programming/mutable_value_semantics.md)
+  * [📖 Introduction to programming](freesoftware/programming/introduction-to-6811-programming.md)
+  * [📖 Mutable Value Semantics](freesoftware/programming/mutable_value_semantics.md)
   * [📖 Linked List](freesoftware/programming/linked-list.md)
-  * [Rust](freesoftware/programming/rust/README.md)
+  * [📖 Rust](freespftware/programming/rust/README.md)
     * [📖 Keyword dyn](freesoftware/programming/rust/keyword_dyn.md)
 * [🎹 Algorithm](freesoftware/algorithm/README.md)
   * [Two-pointer Technique](freesoftware/algorithm/two_pointer_technique.md)

freesoftware/programming/rust/codec.md

@@ -0,0 +1,3 @@
+# Trait Codec
+
+Trait that knows how to encode and decode gRPC messages

freesoftware/programming/rust/hyper.md

@@ -0,0 +1,16 @@
+# Crate hyper
+
+hyper is a fast and correct HTTP implementation written in and for Rust
+
+## Features Flags
+* HTTP/1 and HTTP/2
+* Asynchronous design
+* Leading in performance
+* Tested and correct
+* Extensive production use
+* Client and Server APIs
+
+
+## "Low-level"
+
+The `hyper` crate provides a low-level HTTP implementation, means to be a building block for libraries and applications.

freesoftware/programming/rust/prost.md

@@ -0,0 +1,12 @@
+# Crate prost
+
+`prost` is a Protocol Buffers implementation for the Rust language. `prost` generates simple, idiomatic Rust code from `proto2` and `proto3` files.
+
+The features of `prost`:
+* Generates simple, idiomatic, and readble Rust types by taking advantage of Rust `derive` attributes.
+* Retains comments from `.proto` files in generated Rust code.
+* Allows existing Rust types (not generated from a .proto) to be serialized and deseri8alized by adding attributes.
+* Uses the `bytes::{Buf, BufMut}` abstractions for seialization instead of `std::io::{Read, Write}`
+* Respects the Protobuf `package` specifier when organizing generated code into Rust modules.
+* Preserves unknown enum values during dserialization
+* Does not include support for runtime reflection or message descriptor

freesoftware/programming/rust/tokio.md

@@ -0,0 +1,28 @@
+# tokio
+
+In Rust, we call package  as `Crate`. Crate tokio is a runtime for wrtiting reliable netwrok applications without compromising speed. And it is a event-driven, non-blocking I/O platform for writing asynchronous applications with Rust. It provides a rich set of components for building servers and clients.
+
+
+## Working with Tasks
+
+Asynchronous program in Rust are based around lightweigh, non-blocking units of execution called tasks.
+
+
+The `tokio::task` module provides important tools for working with tasks:
+* The `spawn` function and `JoinHandle` type, for scheduling a new task on the Tokio runtime and awaiting the output of a spawned task, respectively.
+* Functions for running blocking operatiions in an asynchronous task context.
+
+The `tokio::task` module is present only when the "rt" feature flag is enabled.
+
+The crate Tokio provides a runtime for executing asynchronous tasks. Most applications can use the `#[tokio::main]` macro to run their code on the tokio runtime. However, this macro provides only basic configuration options. More advanced APIs for configuring and managing runtimes are provided by the `tokio::runtime` module.
+
+Using the runtime requires the "rt" or "rt-multi-thread" feature flags, to enable the current-thread single-threaded scheduler and the multi-thread scheduler, respectively.
+
+
+## CPU-bound tasks and blocking code
+
+Tokio is able to concurrently run many tasks on a few thread by repeatedly swapping the currently running task on each thread.  However, this kind of swapping can only happen at `.await` points, so code that spends a long time wihtout reaching an `.await` will prevent other tasks from running. To combat this, Tokio provides two kinds of threads: COre threads and blocking threads.
+
+The core threads are where all asynchronous code runs, and Tokio will by default spawn one for each CPU core. You can use the env variable `TOKIO_WORKER_THREADS` to override the default value.
+
+The blocking threads are spawned on demand, can be used to run blocking code that would otherwise block other tasks from running and are kept alive when not used for a certain amount of time which can be configured with `thread_keep_alive`. Since it is not possible for Tokio to swap out blocking tasks, like it can do with asynchronous code, the upper limit on the number of blocking threads is very large. These limits can be configured on the Builder.

freesoftware/programming/rust/tonic.md

@@ -0,0 +1,31 @@
+# Crate tonic
+
+A Rust implementation of gRPC, a high performance, open source, general RPC framework that puts mobile and HTTP/2 first. And it is a gRPC over HTTP/2 implementation focused on:
+
+* **high performance**
+* **interoperability**
+* **flexibility**
+
+And the library was created to have first class support of async/await and to act as a core building block for production systems wriiten in Rust.
+
+
+# Features Flags
+
+* `transport` Enable the fully featured, batteries included client and serber implementation based on the [`hyper`](./hyper.md), [`tower`](./tower.md) and [`tokio`](./tokio.md) crate. Enabled by default.
+* `channel` Enables just the full featured channel/client portion of the `transport` feature
+* `codegen` Enables all the required exports and optional dependencies required for `tonic-build`. Enabled by default.
+* `tls` Enables the `rustls` based TLS options for the `transport` feature. Not enabled by default.
+* `tls-roots` Adds system trust roots to `rustls` based gRPC client using the `rustls-native-certs` crate. Not enabled by default.
+* `tls-webpki-roots` Add the standard trust roots from the `webpki-roots` crate to `rustls` based gRPC clients. Not enabled by default.
+* [`prost`](./prost.md) Enables the prost based gRPC [Codec](./codec.md) implementation
+* `gzip` Enables compressing requests, responses, and streams. Depends on flate2. Not enabled by default. Replaces the `compression` flag from earlier versions of tonic(<=0.7>).
+
+# Usage
+
+Tower provides an abstraction layer, and generic implementation of various middleware. This menas that the `tower` crate on its own does not provide a working implementation of a network client ot server. Instead, Tower's Service trait provides an integration point between application code, libraries providing middleware implementations, and libraries that implement servers and/or clients for various network protocols.
+
+Depending on your particulat use case, you might use Tower in several ways:
+
+* Implementing application logic for a networked program
+* Implementing middleware to add custom behavior to network clients and servers in a reusable manner
+* Implementing a network protocol

freesoftware/programming/rust/tower.md

@@ -0,0 +1,9 @@
+# Crate tower
+
+Tower is a library of modular and reusable components for building robust networking clients and servers.
+
+Tower provides a simple core abstraction, the `Service` trait, which represents an asynchronous function taking a request and returning either a response or an error. This astraction can be used to model both client and servers.
+
+Generic components, like `timeouts`, `rate limiting`, and `load balancing`, can be modeled as `Service`s that wrap some inner service and apply additional behavior before or after the inner service is called. This allows implementing these components in a protocol-agnostic, composable way. Typically, such services are referred to as middleware.
+
+An additinal abstraction, the `Layer` trait, is used to compose middleware with `Service`s. If a `Service` can be thought of as an asynchronous function from a request type to a response type, a `Layer` is a functrion taking a `Service` of one typr and returning a `Service` of a different type. The `ServiceBuilder` type is used to add middleware to a service by composing it with multiple `Layer`s.

gRPC/hyper/.vscode/settings.json

@@ -0,0 +1,34 @@
+{
+    "editor.inlayHints.enabled": "on",
+    "editor.inlayHints.fontFamily": "Courier New",
+    "editor.inlayHints.fontSize": 11,
+
+    "editor.semanticHighlighting.enabled": "configuredByTheme",
+
+    "editor.semanticTokenColorCustomizations": {
+        "enabled": true,
+        "rules": {
+            "*.mutable":{
+                "fontStyle": "",
+            },
+            "genericType": {
+                "foreground": "#ff0000",
+                "fontStyle": "bold"
+            },
+            "parameter":{
+                "foreground": "#ff0000",
+                "fontStyle": "bold"
+            },
+            "type": {
+                "foreground": "#ab1844",
+                "fontStyle": "bold"
+            },
+            "operator.unsafe": "#ff6600",
+            "function.unsafe": "#ff6600",
+            "method.unsafe": "#ff6600"
+        }
+    },
+    "rust-analyzer.linkedProjects": [
+        "./base/Cargo.toml"
+    ],
+}