feat: Dockerise the code and create Github CI (#2)

Dockerises the code for the drand-rs
Adds a CI for github for easy deployments

Author: Prabhat1308

Diff for: .dockerignore

@@ -0,0 +1 @@
+.env

Diff for: .gitattributes

@@ -0,0 +1 @@
+src/protobuf/* linguist-generated=true

Diff for: .github/workflows/prod.yml

@@ -0,0 +1,57 @@
+name: Drand
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+env:
+    CARGO_TERM_COLOR: always
+
+jobs:
+    build-arkworks:
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v2
+          - name: Install protobuf-compiler
+            run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
+          - name: Install Rust
+            uses: actions-rs/toolchain@v1
+            with:
+              profile: minimal
+              toolchain: stable
+              override: true
+              components: rustfmt, clippy
+          - name: Build with arkworks
+            run: cargo build --release --verbose --features arkworks
+          - name: Test with arkworks
+            run: cargo test --release --verbose --features arkworks
+          - name: Lint with arkworks
+            run: cargo clippy --release --features arkworks 
+          - name: Build Docker image with arkworks
+            run: docker build --build-arg FEATURES=arkworks -t drand:arkworks .
+
+    build-blstrs:
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v2
+          - name: Install protobuf-compiler
+            run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
+          - name: Install Rust
+            uses: actions-rs/toolchain@v1
+            with:
+              profile: minimal
+              toolchain: stable
+              override: true
+              components: rustfmt, clippy
+          - name: Build with blstrs
+            run: cargo build --release --verbose --features blstrs
+          - name: Test with blstrs
+            run: cargo test --release --verbose --features blstrs
+          - name: Lint with blstrs
+            run: cargo clippy --release --features blstrs 
+          - name: Build Docker image with blstrs
+            run: docker build --build-arg FEATURES=blstrs -t drand:blstrs .

Diff for: Dockerfile

@@ -0,0 +1,55 @@
+# Use the official Rust image as the base image
+FROM rust:latest AS builder
+
+# Set the working directory
+WORKDIR /app
+
+# Install protobuf compiler
+RUN apt-get update && apt-get install -y protobuf-compiler
+
+# Copy the current directory contents into the container at /app
+COPY . .
+
+#default build is arkworks if not specified otherwise
+ARG FEATURES=arkworks
+
+# Build the application
+RUN cargo build --release --features ${FEATURES}
+
+# Use the official Golang image to download the binary
+FROM golang:latest AS golang_builder
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Download the golang binary (needed when we run from latest releases)
+# RUN wget https://github.com/drand/drand/releases/download/v1.5.8/drand_1.5.8_linux_amd64.tar.gz && \
+#    tar -xzf drand_1.5.8_linux_amd64.tar.gz && \
+#    mkdir -p /app/make_demo && \
+#    mv drand /app/make_demo/drand_go
+
+# Use Ubuntu as the final base image
+FROM ubuntu:22.04 
+
+# Set the working directory
+WORKDIR /app/make_demo
+
+# Copy the compiled Rust binary from the builder stage
+COPY --from=builder /app/target/release/drand /app/make_demo/drand_rs
+
+# Copy the Golang binary from the golang_builder stage
+# COPY --from=golang_builder /app/make_demo/drand_go /app/make_demo/drand_go
+
+# Copy only the necessary files from make_demo
+COPY make_demo/drand_go .
+COPY make_demo/stop .
+COPY make_demo/run .
+
+# Install any necessary runtime dependencies
+RUN apt-get update && apt-get install -y libssl-dev ca-certificates && rm -rf /var/lib/apt/lists/*
+
+# Make the run script executable
+RUN chmod +x run
+
+# Set the entrypoint to the run script
+ENTRYPOINT ["./run"]

Diff for: README.md

@@ -1,3 +1,7 @@
+# Notice
+
+Main branch currently support the drand-go 1.5.8 binary . To check for versions greater than this , look into the other branches
+
 # drand-rs
 
 **This project is currently at the prototype stage and does not contain full functionality. Codebase uploaded only for demonstration purpose and does not reflect the final quiality. For production usage, please visit [Drand Golang implementation](https://github.com/drand/drand)**
@@ -55,3 +59,25 @@ Number of nodes can be modified for various scenaries, for example:
 ```
    [video: 4-7-10 nodes group](https://drive.google.com/file/d/191rzucL5gX529J6PMfG5YfpZej6GoWQV/view?usp=drive_link)
 
+## How to run Docker image 
+
+Build the image 
+
+```
+docker build -t drand-rs .
+```
+
+Check if the image is created
+
+```
+docker images
+```
+
+Run the docker image 
+
+```
+docker run --rm -it drand-rs 
+#or
+docker compose up
+```
+

Diff for: docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.8'
+
+services:
+  drand:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    volumes:
+      - ./make_demo:/app/make_demo
+    working_dir: /app/make_demo
+    entrypoint: ["./run"]

Diff for: rustfmt.toml

@@ -0,0 +1,2 @@
+use_small_heuristics = "Max"
+

Diff for: src/cli.rs

@@ -146,47 +146,28 @@ impl Cli {
     pub async fn run(self) -> anyhow::Result<()> {
         init_log(self.verbose)?;
         match self.commands {
-            Commands::GenerateKeypair {
-                folder,
-                id,
-                scheme,
-                address,
-                tls_disable,
-            } => {
+            Commands::GenerateKeypair { folder, id, scheme, address, tls_disable } => {
                 //  - Default boolean value is true, omitting '--tls_disable' leads to tls_disable:true
                 //  - We want to keep CLI in sync with golang implementation
                 //  - From here tls:true means tls enabled, this can probably be done more elegantly
                 let tls = !tls_disable;
                 crate::core::schemes::gen_keypair(scheme, &folder, tls, id, address)?
             }
-            Commands::Start {
-                folder,
-                id,
-                private_listen,
-                control,
-            } => control::start(&folder, id, &control, private_listen).await?,
+            Commands::Start { folder, id, private_listen, control } => {
+                control::start(&folder, id, &control, private_listen).await?
+            }
 
             Commands::Stop { control, id } => control::stop(&control, id.as_ref()).await?,
 
             Commands::Show(show) => match show {
                 Show::Public { control, id } => control::public_key_request(&control, id).await?,
             },
             Commands::Util(util) => match util {
-                Util::Check {
-                    tls_disable,
-                    id,
-                    addresses,
-                } => todo!(),
+                Util::Check { tls_disable, id, addresses } => todo!(),
                 Util::ListSchemes { control } => control::list_schemes(&control).await?,
                 Util::PoolInfo { control } => control::pool_info(&control).await?,
             },
-            Commands::Share {
-                control,
-                leader,
-                id,
-                tls_disable,
-                connect,
-            } => {
+            Commands::Share { control, leader, id, tls_disable, connect } => {
                 //  - Default boolean value is true, omitting '--tls_disable' leads to tls_disable:true
                 //  - We want to keep CLI in sync with golang implementation
                 //  - From here tls:true means tls enabled, this can probably be done more elegantly

Diff for: src/core/beacon.rs

@@ -125,13 +125,7 @@ impl<S: Scheme> Beacon<S> {
     ) -> Self {
         let span = info_span!("", id = format!("{private_listen}.{id}"));
 
-        Self(Arc::new(InnerNode {
-            beacon_id: id.clone(),
-            fs,
-            keypair,
-            pool,
-            span,
-        }))
+        Self(Arc::new(InnerNode { beacon_id: id.clone(), fs, keypair, pool, span }))
     }
 
     pub fn start(self, mut rx: Receiver<BeaconCmd>) {
@@ -299,18 +293,11 @@ impl<S: Scheme> Beacon<S> {
         secret: &[u8],
     ) -> Result<DkgConfig<S>> {
         if secret != p.secret_proof {
-            bail!(
-                "secret_proof is not valid, beacon_id: {}",
-                self.beacon_id.as_str()
-            );
+            bail!("secret_proof is not valid, beacon_id: {}", self.beacon_id.as_str());
         }
 
         if p.new_group.scheme_id != S::ID {
-            bail!(
-                "invalid scheme, expected: {}, received: {}",
-                S::ID,
-                p.new_group.scheme_id,
-            );
+            bail!("invalid scheme, expected: {}, received: {}", S::ID, p.new_group.scheme_id,);
         }
         let leader_key = Affine::deserialize(leader_key)?;
 
@@ -321,10 +308,7 @@ impl<S: Scheme> Beacon<S> {
         }
         let group: Group<S> = p.new_group.try_into()?;
         let Some(dkg_index) = group.find_index(self.keypair.public()) else {
-            bail!(
-                "local node {} is not found in group_file",
-                self.keypair.public().address()
-            )
+            bail!("local node {} is not found in group_file", self.keypair.public().address())
         };
 
         Ok(DkgConfig::new(leader_key, group, p.dkg_timeout, dkg_index))
@@ -333,9 +317,7 @@ impl<S: Scheme> Beacon<S> {
 
 impl From<String> for BeaconID {
     fn from(value: String) -> Self {
-        Self {
-            inner: value.into(),
-        }
+        Self { inner: value.into() }
     }
 }
 

Diff for: src/core/chain.rs

@@ -118,11 +118,7 @@ impl<S: Scheme> ChainHandler<S> {
 
     async fn add_partial(&mut self, p: PartialBeaconPacket) -> Result<()> {
         let sig_sh = SigShare::deserialize(&p.partial_sig)?;
-        if self
-            .sigs_buf
-            .iter()
-            .any(|stored| stored.index() == sig_sh.index())
-        {
+        if self.sigs_buf.iter().any(|stored| stored.index() == sig_sh.index()) {
             debug!(parent: self.node.span(), "ignoring dublicated partial, index: {}, round: {}", sig_sh.index(), p.round);
             return Ok(());
         }
@@ -135,11 +131,7 @@ impl<S: Scheme> ChainHandler<S> {
         let msg = S::Beacon::digest(&p.previous_signature, p.round);
         let key = &self.share.public().eval(sig_sh.index()).v;
         if S::bls_verify(key, sig_sh.value(), &msg).is_err() {
-            bail!(
-                "invalid bls signarure, index: {}, round: {}",
-                sig_sh.index(),
-                p.round
-            );
+            bail!("invalid bls signarure, index: {}, round: {}", sig_sh.index(), p.round);
         }
 
         debug!(parent: self.node.span(), "Added valid partial, index: {}, round: {}, last_stored.round: {}", sig_sh.index(), p.round, self.last_stored.round);
@@ -183,11 +175,7 @@ impl<S: Scheme> ChainHandler<S> {
                 metadata: From::from(&self.node.beacon_id),
             };
 
-            if !self
-                .sigs_buf
-                .iter()
-                .any(|stored| stored.index() == our_partial.index())
-            {
+            if !self.sigs_buf.iter().any(|stored| stored.index() == our_partial.index()) {
                 self.try_recover(our_partial, &msg);
             }
             let _ = self.node.pool.send(PoolCmd::Partial(packet)).await;

Diff for: src/core/daemon.rs

@@ -54,13 +54,7 @@ impl Daemon {
         let pool = Pool::start(false, logger.register_pool());
         let beacons = MultiBeacon::new(beacon_id, base_folder, &private_listen, pool.clone())?;
         let (stop_daemon, _) = tokio::sync::broadcast::channel::<()>(1);
-        let daemon = Self {
-            beacons,
-            stop_daemon,
-            logger,
-            private_listen,
-            pool,
-        };
+        let daemon = Self { beacons, stop_daemon, logger, private_listen, pool };
 
         Ok(Arc::new(daemon))
     }
@@ -127,9 +121,7 @@ impl Daemon {
             .await
             .map_err(|e| Status::invalid_argument(e.to_string()))?;
 
-        callback
-            .await
-            .map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
+        callback.await.map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
     }
 
     pub async fn broadcast_dkg_bundle(&self, bundle: Bundle, id: &str) -> Result<(), Status> {
@@ -166,14 +158,9 @@ impl Daemon {
 
     pub async fn pool_status(&self) -> Result<String, Status> {
         let (sender, callback) = oneshot::channel();
-        self.pool
-            .send(PoolCmd::Status(sender))
-            .await
-            .map_err(|e| Status::from_error(e.into()))?;
+        self.pool.send(PoolCmd::Status(sender)).await.map_err(|e| Status::from_error(e.into()))?;
 
-        callback
-            .await
-            .map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
+        callback.await.map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
     }
 }