tools/ubot-plugins/ubot-plugin-janitor/src/main.rs
changeset 15815 a803bfa3f56c
equal deleted inserted replaced
15814:d9db7b763bd1 15815:a803bfa3f56c
       
     1 use anyhow::Result as AHResult;
       
     2 
       
     3 use futures::prelude::*;
       
     4 use lapin::{options::*, types::FieldTable, BasicProperties, Connection, ConnectionProperties};
       
     5 
       
     6 use tokio_amqp::*;
       
     7 
       
     8 #[tokio::main]
       
     9 async fn main() -> AHResult<()> {
       
    10     let amqp_url = std::env::var("AMQP_URL").expect("expected AMQP_URL env variabe");
       
    11     let conn = Connection::connect(&amqp_url, ConnectionProperties::default().with_tokio()).await?;
       
    12 
       
    13     let pub_channel = conn.create_channel().await?;
       
    14     let sub_channel = conn.create_channel().await?;
       
    15 
       
    16     let queue = sub_channel
       
    17         .queue_declare(
       
    18             &"",
       
    19             QueueDeclareOptions {
       
    20                 exclusive: true,
       
    21                 auto_delete: true,
       
    22                 ..QueueDeclareOptions::default()
       
    23             },
       
    24             FieldTable::default(),
       
    25         )
       
    26         .await?;
       
    27 
       
    28     sub_channel
       
    29         .queue_bind(
       
    30             queue.name().as_str(),
       
    31             "irc",
       
    32             "*.hedgewars",
       
    33             QueueBindOptions::default(),
       
    34             FieldTable::default(),
       
    35         )
       
    36         .await?;
       
    37 
       
    38     let mut subscriber = sub_channel
       
    39         .basic_consume(
       
    40             queue.name().as_str(),
       
    41             &"",
       
    42             BasicConsumeOptions::default(),
       
    43             FieldTable::default(),
       
    44         )
       
    45         .await?;
       
    46 
       
    47     let mut last_joined = None;
       
    48     let mut talking_to = None;
       
    49 
       
    50     while let Some(amqp_message) = subscriber.next().await {
       
    51         let (_, delivery) = amqp_message.expect("error in consumer");
       
    52         delivery.ack(BasicAckOptions::default()).await?;
       
    53 
       
    54         match delivery.routing_key.as_str() {
       
    55             "msg.hedgewars" => {
       
    56                 let chat_message = String::from_utf8_lossy(&delivery.data);
       
    57                 if let Some((who, _)) = chat_message.split_once('\n') {
       
    58                     let who = Some(who.to_owned());
       
    59                     if talking_to == who || last_joined == who {
       
    60                         talking_to = who;
       
    61                         pub_channel
       
    62                             .basic_publish(
       
    63                                 "irc",
       
    64                                 "cmd.say.hedgewars",
       
    65                                 BasicPublishOptions::default(),
       
    66                                 vec![],
       
    67                                 BasicProperties::default(),
       
    68                             )
       
    69                             .await?;
       
    70                     } else {
       
    71                         last_joined = None;
       
    72                         talking_to = None;
       
    73                     }
       
    74                 }
       
    75             }
       
    76             "join.hedgewars" => {
       
    77                 last_joined = Some(String::from_utf8_lossy(&delivery.data).to_string());
       
    78             }
       
    79             _ => (),
       
    80         }
       
    81     }
       
    82 
       
    83     Ok(())
       
    84 }