aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/client/context.rs7
-rw-r--r--src/client/dispatch.rs470
-rw-r--r--src/client/mod.rs20
-rw-r--r--src/framework/mod.rs3
-rw-r--r--src/framework/standard/mod.rs41
-rw-r--r--src/lib.rs4
6 files changed, 154 insertions, 391 deletions
diff --git a/src/client/context.rs b/src/client/context.rs
index 614f79a..31eeca5 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -4,7 +4,6 @@ use typemap::ShareMap;
use gateway::Shard;
use model::*;
use parking_lot::Mutex;
-use tokio_core::reactor::Handle;
#[cfg(all(feature = "builder", feature = "cache"))]
use super::CACHE;
@@ -42,20 +41,16 @@ pub struct Context {
/// Note that if you are sharding, in relevant terms, this is the shard
/// which received the event being dispatched.
pub shard: Arc<Mutex<Shard>>,
- /// A tokio handle for spawning efficient tasks inside commands and events.
- pub handle: Handle,
}
impl Context {
/// Create a new Context to be passed to an event handler.
pub(crate) fn new(shard: Arc<Mutex<Shard>>,
- data: Arc<Mutex<ShareMap>>,
- handle: Handle)
+ data: Arc<Mutex<ShareMap>>)
-> Context {
Context {
data,
shard,
- handle,
}
}
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index c07f240..6c2cfc4 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -6,7 +6,6 @@ use typemap::ShareMap;
use gateway::Shard;
use model::event::Event;
use model::{Channel, Message};
-use tokio_core::reactor::Handle;
#[cfg(feature = "cache")]
use chrono::{Timelike, Utc};
@@ -38,34 +37,30 @@ macro_rules! now {
() => (Utc::now().time().second() * 1000)
}
-fn context(conn: &Arc<Mutex<Shard>>, data: &Arc<Mutex<ShareMap>>, handle: &Handle) -> Context {
- Context::new(conn.clone(), data.clone(), handle.clone())
+fn context(conn: &Arc<Mutex<Shard>>, data: &Arc<Mutex<ShareMap>>) -> Context {
+ Context::new(conn.clone(), data.clone())
}
#[cfg(feature = "framework")]
pub fn dispatch<H: EventHandler + 'static>(event: Event,
conn: &Arc<Mutex<Shard>>,
- framework: &Arc<
- sync::Mutex<Option<Box<Framework + Send>>>,
->,
+ framework: &Arc<sync::Mutex<Option<Box<Framework + Send>>>>,
data: &Arc<Mutex<ShareMap>>,
- event_handler: &Arc<H>,
- tokio_handle: &Handle) {
+ event_handler: &Arc<H>) {
match event {
Event::MessageCreate(event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
dispatch_message(
context.clone(),
event.message.clone(),
event_handler,
- tokio_handle,
);
if let Some(ref mut framework) = *framework.lock().unwrap() {
- framework.dispatch(context, event.message, tokio_handle);
+ framework.dispatch(context, event.message);
}
},
- other => handle_event(other, conn, data, event_handler, tokio_handle),
+ other => handle_event(other, conn, data, event_handler),
}
}
@@ -73,41 +68,34 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
pub fn dispatch<H: EventHandler + 'static>(event: Event,
conn: &Arc<Mutex<Shard>>,
data: &Arc<Mutex<ShareMap>>,
- event_handler: &Arc<H>,
- tokio_handle: &Handle) {
+ event_handler: &Arc<H>) {
match event {
Event::MessageCreate(event) => {
- let context = context(conn, data, tokio_handle);
- dispatch_message(context, event.message, event_handler, tokio_handle);
+ let context = context(conn, data);
+ dispatch_message(context, event.message, event_handler);
},
- other => handle_event(other, conn, data, event_handler, tokio_handle),
+ other => handle_event(other, conn, data, event_handler),
}
}
#[allow(unused_mut)]
fn dispatch_message<H: EventHandler + 'static>(context: Context,
mut message: Message,
- event_handler: &Arc<H>,
- tokio_handle: &Handle) {
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- #[cfg(feature = "model")]
- {
- message.transform_content();
- }
+ event_handler: &Arc<H>) {
- h.on_message(context, message);
+ #[cfg(feature = "model")]
+ {
+ message.transform_content();
+ }
- Ok(())
- });
+ event_handler.on_message(context, message);
}
#[allow(cyclomatic_complexity, unused_assignments, unused_mut)]
fn handle_event<H: EventHandler + 'static>(event: Event,
conn: &Arc<Mutex<Shard>>,
data: &Arc<Mutex<ShareMap>>,
- event_handler: &Arc<H>,
- tokio_handle: &Handle) {
+ event_handler: &Arc<H>) {
#[cfg(feature = "cache")]
let mut last_guild_create_time = now!();
@@ -126,124 +114,79 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
Event::ChannelCreate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
// This different channel_create dispatching is only due to the fact that
// each time the bot receives a dm, this event is also fired.
// So in short, only exists to reduce unnecessary clutter.
- let h = event_handler.clone();
match event.channel {
Channel::Private(channel) => {
- tokio_handle.spawn_fn(move || {
- h.on_private_channel_create(context, channel);
- Ok(())
- });
+ event_handler.on_private_channel_create(context, channel);
},
Channel::Group(_) => {},
Channel::Guild(channel) => {
- tokio_handle.spawn_fn(move || {
- h.on_channel_create(context, channel);
- Ok(())
- });
+ event_handler.on_channel_create(context, channel);
},
Channel::Category(channel) => {
- tokio_handle.spawn_fn(move || {
- h.on_category_create(context, channel);
- Ok(())
- });
+ event_handler.on_category_create(context, channel);
},
}
},
Event::ChannelDelete(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
match event.channel {
Channel::Private(_) | Channel::Group(_) => {},
Channel::Guild(channel) => {
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_channel_delete(context, channel);
- Ok(())
- });
+ event_handler.on_channel_delete(context, channel);
},
Channel::Category(channel) => {
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_category_delete(context, channel);
- Ok(())
- });
+ event_handler.on_category_delete(context, channel);
},
}
},
Event::ChannelPinsUpdate(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_channel_pins_update(context, event);
- Ok(())
- });
+ event_handler.on_channel_pins_update(context, event);
},
Event::ChannelRecipientAdd(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_channel_recipient_addition(context, event.channel_id, event.user);
- Ok(())
- });
+ event_handler.on_channel_recipient_addition(context, event.channel_id, event.user);
},
Event::ChannelRecipientRemove(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_channel_recipient_removal(context, event.channel_id, event.user);
- Ok(())
- });
+ event_handler.on_channel_recipient_removal(context, event.channel_id, event.user);
},
Event::ChannelUpdate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
let before = CACHE.read().unwrap().channel(event.channel.id());
- tokio_handle.spawn_fn(move || {
- h.on_channel_update(context, before, event.channel);
- Ok(())
- });
+ event_handler.on_channel_update(context, before, event.channel);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_channel_update(context, event.channel);
- Ok(())
- });
+ event_handler.on_channel_update(context, event.channel);
}}
},
Event::GuildBanAdd(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_ban_addition(context, event.guild_id, event.user);
- Ok(())
- });
+ event_handler.on_guild_ban_addition(context, event.guild_id, event.user);
},
Event::GuildBanRemove(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_ban_removal(context, event.guild_id, event.user);
- Ok(())
- });
+ event_handler.on_guild_ban_removal(context, event.guild_id, event.user);
},
Event::GuildCreate(mut event) => {
#[cfg(feature = "cache")]
@@ -262,9 +205,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
let cache = CACHE.read().unwrap();
if cache.unavailable_guilds.is_empty() {
- let h = event_handler.clone();
-
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
let guild_amount = cache
.guilds
@@ -272,289 +213,179 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
.map(|(&id, _)| id)
.collect::<Vec<GuildId>>();
- tokio_handle.spawn_fn(move || {
- h.on_cached(context, guild_amount);
- Ok(())
- });
+ event_handler.on_cached(context, guild_amount);
}
}
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_guild_create(context, event.guild, _is_new);
- Ok(())
- });
+ event_handler.on_guild_create(context, event.guild, _is_new);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_create(context, event.guild);
- Ok(())
- });
+ event_handler.on_guild_create(context, event.guild);
}}
},
Event::GuildDelete(mut event) => {
let _full = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_guild_delete(context, event.guild, _full);
- Ok(())
- });
+ event_handler.on_guild_delete(context, event.guild, _full);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_delete(context, event.guild);
- Ok(())
- });
+ event_handler.on_guild_delete(context, event.guild);
}}
},
Event::GuildEmojisUpdate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_emojis_update(context, event.guild_id, event.emojis);
- Ok(())
- });
+ event_handler.on_guild_emojis_update(context, event.guild_id, event.emojis);
},
Event::GuildIntegrationsUpdate(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_integrations_update(context, event.guild_id);
- Ok(())
- });
+ event_handler.on_guild_integrations_update(context, event.guild_id);
},
Event::GuildMemberAdd(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_member_addition(context, event.guild_id, event.member);
- Ok(())
- });
+ event_handler.on_guild_member_addition(context, event.guild_id, event.member);
},
Event::GuildMemberRemove(mut event) => {
let _member = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_guild_member_removal(context, event.guild_id, event.user, _member);
- Ok(())
- });
+ event_handler.on_guild_member_removal(context, event.guild_id, event.user, _member);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_member_removal(context, event.guild_id, event.user);
- Ok(())
- });
+ event_handler.on_guild_member_removal(context, event.guild_id, event.user);
}}
},
Event::GuildMemberUpdate(mut event) => {
let _before = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- feature_cache! {
- {
- // This is safe to unwrap, as the update would have created
- // the member if it did not exist. So, there is be _no_ way
- // that this could fail under any circumstance.
- let after = CACHE.read()
- .unwrap()
- .member(event.guild_id, event.user.id)
- .unwrap()
- .clone();
-
- tokio_handle.spawn_fn(move || {
- h.on_guild_member_update(context, _before, after);
- Ok(())
- });
- } else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_member_update(context, event);
- Ok(())
- });
- }
- }
+ feature_cache! {{
+ // This is safe to unwrap, as the update would have created
+ // the member if it did not exist. So, there is be _no_ way
+ // that this could fail under any circumstance.
+ let after = CACHE.read()
+ .unwrap()
+ .member(event.guild_id, event.user.id)
+ .unwrap()
+ .clone();
+
+ event_handler.on_guild_member_update(context, _before, after);
+ } else {
+ event_handler.on_guild_member_update(context, event);
+ }}
},
Event::GuildMembersChunk(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_members_chunk(context, event.guild_id, event.members);
- Ok(())
- });
+ event_handler.on_guild_members_chunk(context, event.guild_id, event.members);
},
Event::GuildRoleCreate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_role_create(context, event.guild_id, event.role);
- Ok(())
- });
+ event_handler.on_guild_role_create(context, event.guild_id, event.role);
},
Event::GuildRoleDelete(mut event) => {
let _role = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_guild_role_delete(context, event.guild_id, event.role_id, _role);
- Ok(())
- });
+ event_handler.on_guild_role_delete(context, event.guild_id, event.role_id, _role);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_role_delete(context, event.guild_id, event.role_id);
- Ok(())
- });
+ event_handler.on_guild_role_delete(context, event.guild_id, event.role_id);
}}
},
Event::GuildRoleUpdate(mut event) => {
let _before = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_guild_role_update(context, event.guild_id, _before, event.role);
- Ok(())
- });
+ event_handler.on_guild_role_update(context, event.guild_id, _before, event.role);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_role_update(context, event.guild_id, event.role);
- Ok(())
- });
+ event_handler.on_guild_role_update(context, event.guild_id, event.role);
}}
},
Event::GuildUnavailable(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_guild_unavailable(context, event.guild_id);
- Ok(())
- });
+ event_handler.on_guild_unavailable(context, event.guild_id);
},
Event::GuildUpdate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- feature_cache! {
- {
- let before = CACHE.read()
- .unwrap()
- .guilds
- .get(&event.guild.id)
- .cloned();
+ feature_cache! {{
+ let before = CACHE.read()
+ .unwrap()
+ .guilds
+ .get(&event.guild.id)
+ .cloned();
- tokio_handle.spawn_fn(move || {
- h.on_guild_update(context, before, event.guild);
- Ok(())
- });
- } else {
- tokio_handle.spawn_fn(move || {
- h.on_guild_update(context, event.guild);
- Ok(())
- });
- }
- }
+ event_handler.on_guild_update(context, before, event.guild);
+ } else {
+ event_handler.on_guild_update(context, event.guild);
+ }}
},
// Already handled by the framework check macro
Event::MessageCreate(_) => {},
Event::MessageDeleteBulk(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_message_delete_bulk(context, event.channel_id, event.ids);
- Ok(())
- });
+ event_handler.on_message_delete_bulk(context, event.channel_id, event.ids);
},
Event::MessageDelete(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_message_delete(context, event.channel_id, event.message_id);
- Ok(())
- });
+ event_handler.on_message_delete(context, event.channel_id, event.message_id);
},
Event::MessageUpdate(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_message_update(context, event);
- Ok(())
- });
+ event_handler.on_message_update(context, event);
},
Event::PresencesReplace(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_presence_replace(context, event.presences);
- Ok(())
- });
+ event_handler.on_presence_replace(context, event.presences);
},
Event::PresenceUpdate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_presence_update(context, event);
- Ok(())
- });
+ event_handler.on_presence_update(context, event);
},
Event::ReactionAdd(mut event) => {
- let h = event_handler.clone();
- let context = context(conn, data, tokio_handle);
- tokio_handle.spawn_fn(move || {
- h.on_reaction_add(context, event.reaction);
- Ok(())
- });
+ let context = context(conn, data);
+
+ event_handler.on_reaction_add(context, event.reaction);
},
Event::ReactionRemove(mut event) => {
- let h = event_handler.clone();
- let context = context(conn, data, tokio_handle);
- tokio_handle.spawn_fn(move || {
- h.on_reaction_remove(context, event.reaction);
- Ok(())
- });
+ let context = context(conn, data);
+
+ event_handler.on_reaction_remove(context, event.reaction);
},
Event::ReactionRemoveAll(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_reaction_remove_all(context, event.channel_id, event.message_id);
- Ok(())
- });
+ event_handler.on_reaction_remove_all(context, event.channel_id, event.message_id);
},
Event::Ready(mut event) => {
update!(event);
@@ -564,98 +395,59 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
last_guild_create_time = now!();
let _ = wait_for_guilds()
- .map(|_| {
- let context = context(conn, data, tokio_handle);
+ .map(move |_| {
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_ready(context, event.ready);
- Ok(())
+ event_handler.on_ready(context, event.ready);
});
- });
} else {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_ready(context, event.ready);
- Ok(())
- });
+ event_handler.on_ready(context, event.ready);
}
}
},
Event::Resumed(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_resume(context, event);
- Ok(())
- });
+ event_handler.on_resume(context, event);
},
Event::TypingStart(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_typing_start(context, event);
- Ok(())
- });
+ event_handler.on_typing_start(context, event);
},
Event::Unknown(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_unknown(context, event.kind, event.value);
- Ok(())
- });
+ event_handler.on_unknown(context, event.kind, event.value);
},
Event::UserUpdate(mut event) => {
let _before = update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
feature_cache! {{
- tokio_handle.spawn_fn(move || {
- h.on_user_update(context, _before.unwrap(), event.current_user);
- Ok(())
- });
+ event_handler.on_user_update(context, _before.unwrap(), event.current_user);
} else {
- tokio_handle.spawn_fn(move || {
- h.on_user_update(context, event.current_user);
- Ok(())
- });
+ event_handler.on_user_update(context, event.current_user);
}}
},
Event::VoiceServerUpdate(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_voice_server_update(context, event);
- Ok(())
- });
+ event_handler.on_voice_server_update(context, event);
},
Event::VoiceStateUpdate(mut event) => {
update!(event);
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_voice_state_update(context, event.guild_id, event.voice_state);
- Ok(())
- });
+ event_handler.on_voice_state_update(context, event.guild_id, event.voice_state);
},
Event::WebhookUpdate(mut event) => {
- let context = context(conn, data, tokio_handle);
+ let context = context(conn, data);
- let h = event_handler.clone();
- tokio_handle.spawn_fn(move || {
- h.on_webhook_update(context, event.guild_id, event.channel_id);
- Ok(())
- });
+ event_handler.on_webhook_update(context, event.guild_id, event.channel_id);
},
}
}
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 5eec673..20c2bd6 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -39,8 +39,6 @@ use self::dispatch::dispatch;
use std::sync::{self, Arc};
use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
use parking_lot::Mutex;
-use tokio_core::reactor::Core;
-use futures;
use std::collections::HashMap;
use std::time::Duration;
use std::{mem, thread};
@@ -798,13 +796,7 @@ impl<H: EventHandler + Send + Sync + 'static> Client<H> {
}};
threads.push(thread::spawn(move || {
- let mut core = Core::new().unwrap();
-
- core.run(futures::future::lazy(move || {
- monitor_shard(monitor_info);
-
- futures::future::ok::<(), ()>(())
- })).unwrap();
+ monitor_shard(monitor_info);
}));
},
Err(why) => warn!("Error starting shard {:?}: {:?}", shard_info, why),
@@ -954,8 +946,6 @@ fn monitor_shard<H: EventHandler + Send + Sync + 'static>(mut info: MonitorInfo<
}
fn handle_shard<H: EventHandler + Send + Sync + 'static>(info: &mut MonitorInfo<H>) {
- let mut core = Core::new().unwrap();
- let handle = core.handle();
// This is currently all ducktape. Redo this.
while HANDLE_STILL.load(Ordering::Relaxed) {
@@ -1029,17 +1019,13 @@ fn handle_shard<H: EventHandler + Send + Sync + 'static>(info: &mut MonitorInfo<
&info.shard,
&info.framework,
&info.data,
- &info.event_handler,
- &handle);
+ &info.event_handler);
} else {
dispatch(event,
&info.shard,
&info.data,
- &info.event_handler,
- &handle);
+ &info.event_handler);
}}
-
- core.turn(None);
}
}
diff --git a/src/framework/mod.rs b/src/framework/mod.rs
index 678b5dc..0641ab6 100644
--- a/src/framework/mod.rs
+++ b/src/framework/mod.rs
@@ -62,7 +62,6 @@ pub use self::standard::StandardFramework;
use client::Context;
use model::Message;
-use tokio_core::reactor::Handle;
#[cfg(feature = "standard_framework")]
use model::UserId;
@@ -75,7 +74,7 @@ use model::UserId;
/// Note that you may see some other methods in here as well, but they're meant to be internal only
/// for the builtin framework.
pub trait Framework {
- fn dispatch(&mut self, Context, Message, &Handle);
+ fn dispatch(&mut self, Context, Message);
#[cfg(feature = "standard_framework")]
fn update_current_user(&mut self, UserId, bool) {}
diff --git a/src/framework/standard/mod.rs b/src/framework/standard/mod.rs
index 913a1c5..17e2fdd 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -24,7 +24,6 @@ use client::Context;
use super::Framework;
use model::{ChannelId, GuildId, Message, UserId};
use model::permissions::Permissions;
-use tokio_core::reactor::Handle;
use internal::RwLockExt;
#[cfg(feature = "cache")]
@@ -831,7 +830,7 @@ impl StandardFramework {
}
impl Framework for StandardFramework {
- fn dispatch(&mut self, mut context: Context, message: Message, tokio_handle: &Handle) {
+ fn dispatch(&mut self, mut context: Context, message: Message) {
let res = command::positions(&mut context, &message, &self.configuration);
let positions = match res {
@@ -927,31 +926,27 @@ impl Framework for StandardFramework {
return;
}
- tokio_handle.spawn_fn(move || {
- if let Some(before) = before {
- if !(before)(&mut context, &message, &built) {
- return Ok(());
- }
+ if let Some(before) = before {
+ if !(before)(&mut context, &message, &built) {
+ return;
}
+ }
- let result = match command.exec {
- CommandType::StringResponse(ref x) => {
- let _ = message.channel_id.say(x);
-
- Ok(())
- },
- CommandType::Basic(ref x) => (x)(&mut context, &message, args),
- CommandType::WithCommands(ref x) => {
- (x)(&mut context, &message, groups, args)
- },
- };
+ let result = match command.exec {
+ CommandType::StringResponse(ref x) => {
+ let _ = message.channel_id.say(x);
- if let Some(after) = after {
- (after)(&mut context, &message, &built, result);
- }
+ Ok(())
+ },
+ CommandType::Basic(ref x) => (x)(&mut context, &message, args),
+ CommandType::WithCommands(ref x) => {
+ (x)(&mut context, &message, groups, args)
+ },
+ };
- Ok(())
- });
+ if let Some(after) = after {
+ (after)(&mut context, &message, &built, result);
+ }
return;
}
diff --git a/src/lib.rs b/src/lib.rs
index be55059..cc6cab3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,8 +114,6 @@ extern crate base64;
extern crate byteorder;
#[cfg(feature = "gateway")]
extern crate flate2;
-#[cfg(feature = "futures")]
-extern crate futures;
#[cfg(feature = "hyper")]
extern crate hyper;
#[cfg(feature = "hyper-native-tls")]
@@ -130,8 +128,6 @@ extern crate opus;
extern crate parking_lot;
#[cfg(feature = "voice")]
extern crate sodiumoxide;
-#[cfg(feature = "tokio-core")]
-extern crate tokio_core;
#[cfg(feature = "client")]
extern crate typemap;
#[cfg(feature = "standard_framework")]
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-19 10:27:35 +0000