Split repo into tulsa and example-app (#7)

* Initial commit for repo split

* Update rust.yml

.github/dependabot.yml

@@ -6,6 +6,10 @@
 version: 2
 updates:
   - package-ecosystem: "cargo" # See documentation for possible values
-    directory: "/" # Location of package manifests
+    directory: "/example-app" # Location of package manifests
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "cargo" # See documentation for possible values
+    directory: "/tulsa" # Location of package manifests
     schedule:
       interval: "weekly"

.github/workflows/rust.yml

@@ -18,7 +18,11 @@ jobs:
     - uses: actions/checkout@v3
     - name: Setup protoc
       uses: arduino/[email protected]
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
+    - name: Build tulsa
+      run: cd tulsa && cargo build --verbose
+    - name: Test tulsa
+      run: cd tulsa && cargo test --verbose
+    - name: Build example-app
+      run: cd example-app && cargo build --verbose
+    - name: Test example-app
+      run: cd example-app && cargo test --verbose

README.md

@@ -1,21 +1,3 @@
-# gtfs-realtime-rust
+# tulsa
 
-This is a Rust learning exercise to build a REST server that dynamically launches and manages a set of async tasks. These tasks fetch a GTFS-Realtime feed from an endpoint supplied during a POST call.
-
-## Running Locally
-```
-cargo test
-cargo run
-```
-
-## Sample Feed
-```
-{
-    "name": "MTA A Division",
-    "frequency": 30,
-    "url": "https://api-endint.mta.info/Dataservice/mtagtfsfeeds/nyct%2Fgtfs",
-    "headers": {
-        "x-api-key": "<key_goes_here>"
-    }
-}
-```
+Learning Rust by building a scheduler for both async and sync tasks.

Cargo.toml → example-app/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+tulsa = { path = "../tulsa" }
 axum = "0.6.18"
 axum-macros = "0.3.7"
 hyper = { version = "0.14.27", features = ["client"] }

example-app/README.md

@@ -0,0 +1,21 @@
+# gtfs-realtime-rust
+
+This is a Rust learning exercise to build a REST server that dynamically launches and manages a set of async tasks. These tasks fetch a GTFS-Realtime feed from an endpoint supplied during a POST call.
+
+## Running Locally
+```
+cargo test
+cargo run
+```
+
+## Sample Feed
+```
+{
+    "name": "MTA A Division",
+    "frequency": 30,
+    "url": "https://api-endint.mta.info/Dataservice/mtagtfsfeeds/nyct%2Fgtfs",
+    "headers": {
+        "x-api-key": "<key_goes_here>"
+    }
+}
+```

build.rs → example-app/build.rs

@@ -1,6 +1,5 @@
 extern crate prost_build;
 
-// Helpful example from: https://github.com/danburkert/snazzy
 fn main() {
     prost_build::compile_protos(&["src/gtfs-realtime.proto"], &["src/"]).unwrap();
 }

src/api.rs → example-app/src/api.rs

@@ -8,9 +8,9 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use std::sync::{Arc, Mutex, RwLock};
 use std::{collections::HashMap, sync::mpsc::{Sender, SendError}};
+use tulsa::model::{SyncTask, AsyncTask};
 
 use crate::fetcher::{fetch_sync, Feed, recurring_fetch};
-use crate::model::{SyncTask, AsyncTask};
 
 pub trait TaskSender<T> {
     fn send(&self, task: T) -> Result<(), SendError<T>>;

src/lib.rs → example-app/src/lib.rs

@@ -1,7 +1,5 @@
 pub mod api;
 pub mod fetcher;
-pub mod model;
-pub mod scheduler;
 
 // The deps module is an effort to re-implement my third-party dependencies as
 // a learning exercise. I do not plan to make this code public and my

src/main.rs → example-app/src/main.rs

@@ -1,9 +1,9 @@
 use std::net::SocketAddr;
 use std::sync::{Arc, mpsc, Mutex};
 use tokio::runtime::Builder;
+use tulsa::scheduler;
 
 use gtfs_realtime_rust::api;
-use gtfs_realtime_rust::scheduler;
 
 fn main() {
     let (sender, receiver) = mpsc::channel();

tests/integration_test.rs → example-app/tests/integration_test.rs

@@ -1,7 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use gtfs_realtime_rust::api;
-    use gtfs_realtime_rust::scheduler;
+    use tulsa::scheduler;
     use reqwest::blocking::Client;
     use serde_json::json;
     use std::sync::mpsc;
@@ -11,6 +10,8 @@ mod tests {
     use std::sync::Arc;
     use std::sync::Mutex;
 
+    use gtfs_realtime_rust::api;
+
     #[test]
     fn integration() {
         let (sender, receiver) = mpsc::channel();

tulsa/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "tulsa"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tokio = { version = "1.29.1", features = ["macros", "time", "rt-multi-thread"] }

tulsa/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod model;
+pub mod scheduler;

src/scheduler.rs → tulsa/src/scheduler.rs

@@ -18,8 +18,7 @@ impl AsyncScheduler {
 
         let num_threads = 1;
         let runtime = Builder::new_multi_thread()
-            .enable_time()
-            .enable_io()
+            .enable_all()
             .worker_threads(num_threads)
             .thread_name("scheduler-runtime")
             .build()

tests/scheduler_test.rs → tulsa/tests/scheduler_test.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod tests {
-    use gtfs_realtime_rust::model::AsyncTask;
-    use gtfs_realtime_rust::scheduler;
+    use tulsa::model::AsyncTask;
+    use tulsa::scheduler;
     use std::fs::File;
     use std::fs::OpenOptions;
     use std::io::prelude::*;