chore: purge scripting

Author: obaraelijah

src/lib.rs

@@ -20,7 +20,6 @@ pub mod hyperloglog;
 pub mod keys;
 pub mod lists;
 pub mod misc;
-pub mod scripting;
 pub mod server;
 pub mod sets;
 pub mod sorted_sets;

src/logger.rs

@@ -5,7 +5,7 @@
 use lazy_static::lazy_static;
 use slog::Logger;
 use sloggers::terminal::{Destination, TerminalLoggerBuilder};
-use sloggers::types::{Severity, SourceLocation};
+use sloggers::types::{Severity};
 use sloggers::Build;
 
 #[cfg(debug_assertions)]

src/main.rs

@@ -1,9 +1,8 @@
 use redis_proto::database::{get_dump_file, load_state, save_state_interval};
 use redis_proto::logger::LOGGER;
-use redis_proto::scripting::{handle_redis_cmd, ScriptingBridge, ScriptingEngine};
 use redis_proto::server::socket_listener;
 use redis_proto::startup::{startup_message, Config};
-use tokio::sync::mpsc::channel;
+
 
 use slog::{info, warn};
 use structopt::StructOpt;
@@ -31,26 +30,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "Database is in memory-only mode. STATE WILL NOT BE SAVED!"
         );
     }
-    // Create the channels for scripting
-    let (prog_string_sx, prog_string_rx) = channel(12);
-    let (cmd_result_sx, cmd_result_rx) = channel(12);
-
-    let scripting_engine =
-        ScriptingEngine::new(prog_string_rx, cmd_result_sx, state.clone(), &opt)?;
-
-    info!(LOGGER, "ScriptingEngine main loop started");
-    std::thread::spawn(|| scripting_engine.main_loop());
-
-    let scripting_bridge = ScriptingBridge::new(prog_string_sx);
-
-    tokio::spawn(handle_redis_cmd(
-        cmd_result_rx,
-        state.clone(),
-        dump_file.clone(),
-        scripting_bridge.clone(),
-    ));
 
     // Start the server! It will start listening for connections.
-    socket_listener(state.clone(), dump_file.clone(), opt, scripting_bridge).await;
+    socket_listener(state.clone(), dump_file.clone(), opt).await;
     Ok(())
 }

src/misc.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+
 
 /// use crate::scripting::{Program, ScriptingBridge};
 use crate::types::{Count, Index, Key, RedisValueRef, ReturnValue, StateRef, StateStoreRef, Value};

src/scripting.rs

@@ -1,8 +1,8 @@
+/// Server launch file. Starts the services to make redis-proto work.
+use crate::asyncresp::RespParser;
 use crate::database::save_state;
 use crate::misc::misc_interact;
 use crate::ops::{op_interact, Ops};
-/// Server launch file. Starts the services to make redis-proto work.
-use crate::asyncresp::RespParser;
 use crate::{logger::LOGGER, types::StateRef};
 use crate::{
     ops::translate,
@@ -13,7 +13,7 @@ use futures::StreamExt;
 use futures_util::sink::SinkExt;
 use slog::{debug, error, info};
 use std::sync::atomic::Ordering;
-use std::{net::SocketAddr, sync::Arc};
+use std::net::SocketAddr;
 use tokio::net::{TcpListener, TcpStream};
 use tokio_util::codec::Decoder;
 
@@ -45,9 +45,7 @@ pub async fn process_command(
             debug!(LOGGER, "running op {:?}", op.clone());
             // Step 1: Execute the operation the operation (from translate above)
             let res: ReturnValue = match op {
-                Ops::Misc(op) => {
-                    misc_interact(op, state, state_store.clone()),
-                }
+                Ops::Misc(op) => misc_interact(op, state, state_store.clone()).await,
                 _ => op_interact(op, state.clone()).await,
             };
             // Step 2: Update commands_ran_since_save counter, and save if necessary
@@ -66,11 +64,7 @@ pub async fn process_command(
 /// This will synchronously process requests / responses for this
 /// connection only. Other connections will be spread across the
 /// thread pool.
-async fn process(
-    socket: TcpStream,
-    state_store: StateStoreRef,
-    dump_file: Dumpfile,
-) {
+async fn process(socket: TcpStream, state_store: StateStoreRef, dump_file: Dumpfile) {
     tokio::spawn(async move {
         let mut state = state_store.get_default();
         let mut transport = RespParser.framed(socket);
@@ -83,7 +77,7 @@ async fn process(
                 &mut state,
                 state_store.clone(),
                 dump_file.clone(),
-            redis_value.unwrap(),
+                redis_value.unwrap(),
             )
             .await;
             // let res = match translate(redis_value.unwrap()) {
@@ -96,7 +90,7 @@ async fn process(
             //                     op,
             //                     &mut state,
             //                     state_store.clone(),
-            //             
+            //
             //                 )
             //                 .await
             //             }
@@ -119,11 +113,7 @@ async fn process(
 }
 
 /// The listener for redis-proto. Accepts connections and spawns handlers.
-pub async fn socket_listener(
-    state_store: StateStoreRef,
-    dump_file: Dumpfile,
-    config: Config,
-) {
+pub async fn socket_listener(state_store: StateStoreRef, dump_file: Dumpfile, config: Config) {
     // First, get the address determined and parsed.
     let addr_str = format!("{}:{}", "127.0.0.1", config.port);
     let addr = match addr_str.parse::<SocketAddr>() {
@@ -159,13 +149,7 @@ pub async fn socket_listener(
         match listener.accept().await {
             Ok((socket, _)) => {
                 debug!(LOGGER, "Accepted connection!");
-                process(
-                    socket,
-                    state_store.clone(),
-                    dump_file.clone(),
-         
-                )
-                .await;
+                process(socket, state_store.clone(), dump_file.clone()).await;
             }
             Err(e) => error!(LOGGER, "Failed to establish connectin: {:?}", e),
         };