1st commit: minimal working version

Author: felipepenha

.dockerignore

@@ -0,0 +1,15 @@
+# Rust
+target
+
+# Docker
+Dockerfile
+.dockerignore
+
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Images
+images
+.png

.gitattributes

@@ -0,0 +1,3 @@
+notebooks/* linguist-documentation
+notebooks/**/* linguist-documentation
+images/* linguist-documentation

.gitignore

@@ -0,0 +1,17 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# Jupyter notebook checkpoints
+.ipynb_checkpoints
+
+# Ignore Bash
+.sh

Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "greenhouse"
+version = "0.1.0"
+authors = ["Felipe Penha <[email protected]>"]
+description = "A Rust containerized framework for a better Data X development workflow."
+repository = "https://github.com/felipepenha/rust-greenhouse"
+license = "Apache-2.0"
+include = [
+    "src/**/*.rs",
+    "Cargo.toml",
+]
+edition= "2018"
+
+[workspace]
+members = ["src/*"]
+
+[lib]
+name = "foo"
+path = "src/lib.rs"
+crate-type = ["lib"]
+test = true
+
+[[bin]]
+name = "script"
+path = "src/main.rs"
+
+[dependencies]
+datafusion = "2.0.0"
+arrow = "2.0.0"

Dockerfile

@@ -0,0 +1,31 @@
+FROM rust:latest AS base
+
+USER root
+
+ARG APP_DIR=/usr/app
+
+RUN mkdir $APP_DIR
+WORKDIR $APP_DIR
+
+# Install Jupyter and evcxr
+
+RUN apt update && apt install -y \
+    jupyter-notebook \
+    cmake
+   
+RUN cargo install evcxr_repl
+RUN cargo install evcxr_jupyter
+
+RUN evcxr_jupyter --install
+
+# Configure Rust Channel
+
+RUN rustup install nightly-2021-01-21
+RUN rustup override set nightly-2021-01-21
+RUN rustup default nightly-2021-01-21
+RUN echo $(rustup show)
+
+# Copy project directories
+
+COPY src $APP_DIR/src
+COPY Cargo.toml $APP_DIR/Cargo.toml

LICENSE

@@ -0,0 +1,38 @@
+BUILD = docker-compose build
+RUN = docker-compose run
+
+
+help:
+	@echo "USAGE"
+	@echo
+	@echo "    make <command>"
+	@echo "    Include 'sudo' when necessary."
+	@echo
+	@echo
+	@echo "COMMANDS"
+	@echo
+	@echo "    build:           build image using cache"
+	@echo "    build-no-cache:  build image from scratch, and not from cache"
+	@echo "    bash:            bash REPL (Read-Eval-Print loop), suitable for debugging"
+	@echo "    rust:            access rust through the Evcxr REPL (Read-Eval-Print loop)"
+	@echo "    rust-jupyter:    access rust through the Evcxr Jupyter Notebook"
+
+#################
+# User Commands #
+#################
+
+build:
+	$(BUILD)
+
+build-no-cache:
+	$(BUILD) --no-cache
+
+bash:
+	$(RUN) bash
+
+rust:
+	$(RUN) rust
+
+rust-jupyter:
+	$(RUN) --service-ports rust-jupyter
+

Makefile

@@ -1,2 +1,184 @@
-# rust-greenhouse
-A Rust containerized framework for a better Data X development workflow. Where X = Science, Engineering, Analytics, etc.
+![](/images/Greenhouse_github_card.png)
+
+# Greenhouse
+
+A containerized Rust framework for a better Data X development workflow. Where X = Science, Engineering, Analytics, etc.
+
+The name "Greenhouse" is a metaphor. A greenhouse is a structure made of glass to grow plants despite of external conditions such as a cold winter. Likewise, the Greenhouse framework builds a standalone container which is fully transparent to the user.
+
+
+# Quick Start
+
+This is a template repository. [Follow this link for instructions to create a repository from a template](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-from-a-template#creating-a-repository-from-a-template).
+
+
+The greenhouse work is initiated with `make` commands.
+
+
+To see the most up to date list of available commands run
+
+```bash
+$ make help
+
+USAGE
+
+    make <command>
+    Include 'sudo' when necessary.
+
+
+COMMANDS
+
+    build:           build image using cache
+    build-no-cache:  build image from scratch, and not from cache
+    bash:            bash REPL (Read-Eval-Print loop), suitable for debugging
+    rust:            access rust through the Evcxr REPL (Read-Eval-Print loop)
+    rust-jupyter:    access rust through the Evcxr Jupyter Notebook
+```
+
+
+To build your greenhouse (as it is), you first need to run:
+
+```bash
+$ make build-no-cache
+```
+
+
+To access Jupyter in your local browser:
+
+```bash
+$ make rust-jupyter
+
+Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
+    
+    To access the notebook, open this file in a browser:
+        file:///root/.local/share/jupyter/runtime/nbserver-1-open.html
+    Or copy and paste one of these URLs:
+        http://(xxxxxxxxxxxx or 127.0.0.1):8888/?token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+Next, you simply need to follow the instructions printed out on your own terminal.
+
+In the generic example above, I would paste the following on my browser:
+
+```bash
+http://127.0.0.1:8888/?token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+Any changes made in the files within the Jupyter interface, for example saved changes in `.rs`, `.ipynb`, and `.py` files, will be reflected in the original files you store locally, and vice-versa. This is ensured by the fact that the whole greenhouse directory is set as a `volume` in the `docker-compose.yml` configuration file.
+
+You may also choose to run code using the REPL (Read-Eval-Print loop) in the terminal by running:
+
+```bash
+$ make rust
+```
+
+
+Now, you are ready to start developing Rust code by creating new `.rs` files in the `/src` directory.
+
+
+During development phase, you can normally test out new code in a Jupyter Notebook, as you would do with Python.
+
+
+For example, in the file `src/messages.rs` we have a public function defined as
+
+```rust
+pub fn hello_world() {
+    println!("Hello, world! From `src/message.rs`");
+}
+```
+
+
+In the Jupyter Notebook you will be able to access it through
+
+```rust
+>> #[path = "/usr/app/src/messages.rs"] mod messages;
+>> use messages::hello_world;
+```
+
+Next, to actually use the function:
+
+```rust
+>> messages::hello_world();
+
+Hello, world! From `src/message.rs`
+```
+
+Check out additional examples in the `/notebooks` directory (`.ipynb` files with preffix `example_`).
+
+
+# Greenhouse Structure
+
+
+```bash
+.
+├── Cargo.lock
+├── Cargo.toml
+├── docker-compose.yml
+├── Dockerfile
+├── LICENSE
+├── Makefile
+├── notebooks
+│   ├── example_datafusion.ipynb
+│   └── example_messages.ipynb
+├── README.md
+├── rust-toolchain.toml
+├── src
+│   ├── lib.rs
+│   ├── main.rs
+│   └── messages.rs
+└── target
+```
+
+* `Cargo.toml`: manifest of the package. Dependencies are defined here.
+* `src/`: source directory for your Rust package
+* `src/lib.rs`: defines your package (ex: which crates are included)
+* `src/main.rs`: a script for dev purposes with `$cargo run`
+* `messages.rs`: example of crate that yields a "Hello World" message
+
+# Adding External Dependencies
+
+You need to include any external dependencies to the `Cargo.toml` file in addition to the default list:
+
+```yaml
+[dependencies]
+datafusion = "2.0.0"
+arrow = "2.0.0"
+```
+
+You may also want to change a few lines in the `Dockerfile` to ensure that the correct version of Rust, consistent with your dependencies, is being used. We keep it fixed in the original Greenhouse template at `nightly-2021-01-01`:
+
+```yaml
+RUN rustup install nightly-2021-01-01
+RUN rustup override set nightly-2021-01-01
+RUN rustup run nightly rustc --version
+```
+
+`$ make build` will print out on your screen the version that is being used, in your own greenhouse. You may want to double-check it by running:
+
+```bash
+$ make bash
+$ rustup run nightly rustc --version
+
+Default host: x86_64-unknown-linux-gnu
+rustup home:  /usr/local/rustup
+
+installed toolchains
+--------------------
+
+nightly-2021-01-01-x86_64-unknown-linux-gnu
+1.49.0-x86_64-unknown-linux-gnu (default)
+
+active toolchain
+----------------
+
+nightly-2021-01-01-x86_64-unknown-linux-gnu (directory override for '/usr/app')
+rustc 1.51.0-nightly (44e3daf5e 2020-12-31)
+```
+
+The above output means that, in fact, `nightly-2021-01-01` is being used for `/usr/app`.
+
+
+
+
+
+

README.md

@@ -0,0 +1,37 @@
+version: "3"
+
+services:
+  
+  base:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: base_image
+      
+  bash:
+    image: base_image
+    user: root
+    volumes:
+      - .:/usr/app/
+    working_dir: /usr/app/
+    entrypoint: /bin/sh
+
+  rust:
+    image: base_image
+    user: root
+    volumes:
+      - .:/usr/app/
+    working_dir: /usr/app/
+
+    command: "evcxr"
+
+
+  rust-jupyter:
+    image: base_image
+    user: root
+    volumes:
+      - .:/usr/app/
+    working_dir: /usr/app/
+    command: "jupyter notebook --ip=0.0.0.0 --port=8888 --allow-root --no-browser"
+    ports:
+      - 8888:8888

docker-compose.yml

@@ -0,0 +1,31 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "extern crate arrow;\n",
+    "extern crate datafusion;"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Rust",
+   "language": "rust",
+   "name": "rust"
+  },
+  "language_info": {
+   "codemirror_mode": "rust",
+   "file_extension": ".rs",
+   "mimetype": "text/rust",
+   "name": "Rust",
+   "pygment_lexer": "rust",
+   "version": ""
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}