Skip to content

Commit 90fddbf

Browse files
rakshith-ravirakshith-ravi
committed
Merged to arc-based-impl
1 parent 300bf98 commit 90fddbf

File tree

3 files changed

+48
-51
lines changed

3 files changed

+48
-51
lines changed

‎src/connection/inet_socket_connection.rs‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4,11 +4,7 @@ use crate::{
44
};
55
use std::time::Duration;
66

7-
use async_std::{
8-
io,
9-
net::{Shutdown, TcpStream},
10-
prelude::*,
11-
};
7+
use async_std::{io, net::Shutdown, net::TcpStream, prelude::*};
128
use async_trait::async_trait;
139

1410
pub struct InetSocketConnection {
@@ -37,7 +33,8 @@ impl BaseConnection for InetSocketConnection {
3733
if let Err(err) = result {
3834
return Err(Error::Internal(format!("{}", err)));
3935
}
40-
self.client = Some(result.unwrap());
36+
let client = result.unwrap();
37+
self.client = Some(client);
4138

4239
self.connection_setup = true;
4340
Ok(())

‎src/juno_module.rs‎

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,13 @@ impl JunoModule {
6464
pub fn new(protocol: BaseProtocol, connection: Box<dyn BaseConnection + Send + Sync>) -> Self {
6565
JunoModule {
6666
module_impl: Arc::new(JunoModuleImpl {
67-
protocol: Mutex::new(protocol),
67+
protocol: RwLock::new(protocol),
6868
connection: RwLock::new(connection),
69-
requests: Mutex::new(HashMap::new()),
70-
functions: Mutex::new(HashMap::new()),
71-
hook_listeners: Mutex::new(HashMap::new()),
69+
requests: RwLock::new(HashMap::new()),
70+
functions: RwLock::new(HashMap::new()),
71+
hook_listeners: RwLock::new(HashMap::new()),
7272
message_buffer: Mutex::new(vec![]),
73-
registered: Mutex::new(false),
73+
registered: RwLock::new(false),
7474
}),
7575
}
7676
}
@@ -83,7 +83,7 @@ impl JunoModule {
8383
) -> Result<()> {
8484
self.setup_connections().await?;
8585

86-
let request = self.module_impl.protocol.lock().await.initialize(
86+
let request = self.module_impl.protocol.write().await.initialize(
8787
String::from(module_id),
8888
String::from(version),
8989
dependencies,
@@ -100,14 +100,14 @@ impl JunoModule {
100100
let fn_name = fn_name.to_string();
101101
self.module_impl
102102
.functions
103-
.lock()
103+
.write()
104104
.await
105105
.insert(fn_name.clone(), function);
106106

107107
let request = self
108108
.module_impl
109109
.protocol
110-
.lock()
110+
.read()
111111
.await
112112
.declare_function(fn_name);
113113
self.send_request(request).await?;
@@ -123,23 +123,23 @@ impl JunoModule {
123123
let request = self
124124
.module_impl
125125
.protocol
126-
.lock()
126+
.read()
127127
.await
128128
.call_function(fn_name, args);
129129
self.send_request(request).await
130130
}
131131

132132
pub async fn register_hook(&mut self, hook: &str, callback: fn(Value)) -> Result<()> {
133133
let hook = hook.to_string();
134-
let mut hook_listeners = self.module_impl.hook_listeners.lock().await;
134+
let mut hook_listeners = self.module_impl.hook_listeners.write().await;
135135
if hook_listeners.contains_key(&hook) {
136136
hook_listeners.get_mut(&hook).unwrap().push(callback);
137137
} else {
138138
hook_listeners.insert(hook.clone(), vec![callback]);
139139
}
140140
drop(hook_listeners);
141141

142-
let request = self.module_impl.protocol.lock().await.register_hook(hook);
142+
let request = self.module_impl.protocol.read().await.register_hook(hook);
143143
self.send_request(request).await?;
144144
Ok(())
145145
}
@@ -149,7 +149,7 @@ impl JunoModule {
149149
let request = self
150150
.module_impl
151151
.protocol
152-
.lock()
152+
.read()
153153
.await
154154
.trigger_hook(hook, data);
155155
self.send_request(request).await?;
@@ -175,7 +175,7 @@ impl JunoModule {
175175
let mut connection = module.connection.write().await;
176176
if let Some(data) = connection.read_data().await {
177177
drop(connection);
178-
let mut protocol = module.protocol.lock().await;
178+
let mut protocol = module.protocol.write().await;
179179
protocol.append_buffer(data);
180180
while let Some(message) = protocol.get_next_message() {
181181
let request_id = message.get_request_id().clone();
@@ -189,29 +189,28 @@ impl JunoModule {
189189
let result =
190190
module.execute_function_call(function, arguments).await;
191191
let write_buffer = match result {
192-
Ok(value) => module.protocol.lock().await.encode(
193-
BaseMessage::FunctionCallResponse {
192+
Ok(value) => {
193+
protocol.encode(BaseMessage::FunctionCallResponse {
194194
request_id: request_id.clone(),
195195
data: value,
196-
},
197-
),
198-
Err(error) => {
199-
module.protocol.lock().await.encode(BaseMessage::Error {
200-
request_id: request_id.clone(),
201-
error: match error {
202-
Error::Internal(_) => 0,
203-
Error::FromJuno(error_code) => error_code,
204-
},
205196
})
206197
}
198+
Err(error) => protocol.encode(BaseMessage::Error {
199+
request_id: request_id.clone(),
200+
error: match error {
201+
Error::Internal(_) => 0,
202+
Error::FromJuno(error_code) => error_code,
203+
},
204+
}),
207205
};
208-
if let Err(err) =
209-
module.connection.write().await.send(write_buffer).await
210-
{
211-
Err(err)
212-
} else {
213-
Ok(Value::Null)
214-
}
206+
module
207+
.connection
208+
.write()
209+
.await
210+
.send(write_buffer)
211+
.await
212+
.unwrap();
213+
Ok(Value::Null)
215214
}
216215
BaseMessage::TriggerHookResponse { hook, data, .. } => {
217216
if let Err(err) = module.execute_hook_triggered(hook, data).await {
@@ -223,13 +222,14 @@ impl JunoModule {
223222
BaseMessage::Error { error, .. } => Err(Error::FromJuno(error)),
224223
_ => Ok(Value::Null),
225224
};
226-
let mut requests = module.requests.lock().await;
225+
let mut requests = module.requests.write().await;
227226
if !requests.contains_key(&request_id) {
228227
continue;
229228
}
230229
if requests.remove(&request_id).unwrap().send(value).is_err() {
231230
println!("Error sending response of requestId: {}", &request_id);
232231
}
232+
drop(requests);
233233
}
234234
drop(protocol);
235235
task::sleep(std::time::Duration::from_millis(10)).await;
@@ -244,15 +244,15 @@ impl JunoModule {
244244

245245
async fn send_request(&mut self, request: BaseMessage) -> Result<Value> {
246246
if let BaseMessage::RegisterModuleRequest { .. } = request {
247-
if *self.module_impl.registered.lock().await {
247+
if *self.module_impl.registered.read().await {
248248
return Err(Error::Internal(String::from("Module already registered")));
249249
}
250250
}
251251

252252
let request_type = request.get_type();
253253
let request_id = request.get_request_id().clone();
254-
let mut encoded = self.module_impl.protocol.lock().await.encode(request);
255-
if *self.module_impl.registered.lock().await || request_type == 1 {
254+
let mut encoded = self.module_impl.protocol.read().await.encode(request);
255+
if *self.module_impl.registered.read().await || request_type == 1 {
256256
self.module_impl
257257
.connection
258258
.write()
@@ -271,7 +271,7 @@ impl JunoModule {
271271

272272
self.module_impl
273273
.requests
274-
.lock()
274+
.write()
275275
.await
276276
.insert(request_id, sender);
277277

‎src/juno_module_impl.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -12,13 +12,13 @@ use std::collections::HashMap;
1212
// Create separate rwlocks for each individual element
1313
// Such that each one of them can be individually read or written independent of the other
1414
pub(crate) struct JunoModuleImpl {
15-
pub(crate) protocol: Mutex<BaseProtocol>,
15+
pub(crate) protocol: RwLock<BaseProtocol>,
1616
pub(crate) connection: RwLock<Box<dyn BaseConnection + Send + Sync>>,
17-
pub(crate) requests: Mutex<HashMap<String, Sender<Result<Value>>>>,
18-
pub(crate) functions: Mutex<HashMap<String, fn(HashMap<String, Value>) -> Value>>,
19-
pub(crate) hook_listeners: Mutex<HashMap<String, Vec<fn(Value)>>>,
17+
pub(crate) requests: RwLock<HashMap<String, Sender<Result<Value>>>>,
18+
pub(crate) functions: RwLock<HashMap<String, fn(HashMap<String, Value>) -> Value>>,
19+
pub(crate) hook_listeners: RwLock<HashMap<String, Vec<fn(Value)>>>,
2020
pub(crate) message_buffer: Mutex<Buffer>,
21-
pub(crate) registered: Mutex<bool>,
21+
pub(crate) registered: RwLock<bool>,
2222
}
2323

2424
impl JunoModuleImpl {
@@ -27,7 +27,7 @@ impl JunoModuleImpl {
2727
function: String,
2828
arguments: HashMap<String, Value>,
2929
) -> Result<Value> {
30-
let functions = self.functions.lock().await;
30+
let functions = self.functions.read().await;
3131
if !functions.contains_key(&function) {
3232
return Err(Error::FromJuno(utils::errors::UNKNOWN_FUNCTION));
3333
}
@@ -46,14 +46,14 @@ impl JunoModuleImpl {
4646

4747
let hook = hook.unwrap();
4848
if hook == "juno.activated" {
49-
*self.registered.lock().await = true;
49+
*self.registered.write().await = true;
5050
let mut buffer = self.message_buffer.lock().await;
5151
self.connection.write().await.send(buffer.clone()).await?;
5252
buffer.clear();
5353
} else if &hook == "juno.deactivated" {
54-
*self.registered.lock().await = true;
54+
*self.registered.write().await = true;
5555
} else {
56-
let hook_listeners = self.hook_listeners.lock().await;
56+
let hook_listeners = self.hook_listeners.read().await;
5757
if !hook_listeners.contains_key(&hook) {
5858
todo!("Wtf do I do now? Need to propogate errors. How do I do that?");
5959
}

0 commit comments

Comments
 (0)