O01eg/sendxmppd-rs - Change 37OMJ4CKEJIHMGWDGILSULMALWUTXSIL2DK2SBEHLKECFZUG2P5QC

Send MUC message

Created by O01eg on February 18, 2019

37OMJ4CKEJIHMGWDGILSULMALWUTXSIL2DK2SBEHLKECFZUG2P5QC

Dependencies

In channels

main

Change contents

Deletion in src/xmpp/stanzas.rs at line 46 [3.13]

∅:D[2.52] → [2.52:181]

∅:D[2.181] → [4.309:361]

∅:D[4.309] → [4.309:361]

pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribed);
    presence.to = Some(jid);
    presence.into()
}

Insertion in src/xmpp/stanzas.rs at line 61 [3.13]

[4.931]


pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(to.into_bare_jid()));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()
}

Insertion in src/xmpp/mod.rs at line 30 [7.17]

[5.378]

[6.1786]

    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,

Deletion in src/xmpp/mod.rs at line 574 [7.17]

∅:D[2.204] → [2.204:762]

∅:D[2.762] → [5.2916:2938]

∅:D[5.2916] → [5.2916:2938]

                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }

Insertion in src/xmpp/mod.rs at line 604 [7.17]

[4.12358]

[6.23186]

            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }

Replacement in src/xmpp/mod.rs at line 630 [7.17]

∅:D[4.12737] → [4.12737:13233]

        stream::iter_ok(
            account
                .chatrooms
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, mut data }, muc_jid| {
            data.counter += 1;
            let id_muc_presence = format!("id_muc_presence{}", data.counter);
            let muc_presence =
                stanzas::make_muc_presence(&id_muc_presence, account2.jid.clone(), muc_jid);

[4.12737]

[4.13233]

        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );

Replacement in src/xmpp/mod.rs at line 640 [7.17]

∅:D[4.13234] → [4.13234:13299]

            info!("Sending muc presence... {:?}", muc_presence);

[4.13234]

[4.13299]

                info!("Sending muc presence... {:?}", muc_presence);

Replacement in src/xmpp/mod.rs at line 642 [7.17]

∅:D[4.13300] → [4.13300:13345]

            let account4 = account2.clone();

[4.13300]

[4.13345]

                let account4 = account2.clone();

Replacement in src/xmpp/mod.rs at line 644 [7.17]

∅:D[4.13346] → [4.13346:13784]

            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    account4
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|state| XmppConnection {
            account: account3,
            state,
        })

[4.13346]

[8.12130]

                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })

Insertion in src/xmpp/mod.rs at line 669 [7.17]

[5.4005]

[4.13871]

    Chatroom {
        muc_id: String,
        message: String,
    },

Insertion in src/main.rs at line 38 [9.17]

[4.13950]

fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .map_err(|e| e.into())
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
}

Replacement in src/main.rs at line 74 [9.17]

∅:D[4.14894] → [4.14894:14948]

        match xmpp_to_res {
            Err(err) => {

[4.14894]

[4.14948]

        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            .map(|h| h.to_str().map(|s| s.to_string()));
        match (xmpp_muc_opt, xmpp_to_res) {
            (None, Err(err)) => {

Replacement in src/main.rs at line 89 [9.17]
∅:D[4.15385] → [4.15385:15414]
```
            Ok(xmpp_to) => {
```
[4.15385]
[4.15414]
```
            (None, Ok(xmpp_to)) => {
```

Replacement in src/main.rs at line 92 [9.17]

∅:D[4.15523] → [4.15523:16148]

∅:D[4.16148] → [5.4006:4092]

∅:D[5.4092] → [4.16228:18122]

∅:D[4.16228] → [4.16228:18122]

                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand::Chat { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>

[4.15523]

[4.18122]

                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chat { xmpp_to, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(|e| e.into()),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(|e| e.into()),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>

Insertion in src/main.rs at line 128 [9.17]

[4.18136]

            (Some(Ok(muc_id)), _) => {
                info!("Got MUC request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chatroom { muc_id, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(|e| e.into()),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(|e| e.into()),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Err(err)), _) => {
                warn!("Unknown MUC destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown MUC destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }

Deletion in bitbucket-pipelines.yml at line 21 [10.26]

∅:D[10.703] → [11.32:155]

          - rustup component add rustfmt-preview
          - cargo fmt -- --version
          - cargo fmt --all -- --check

Insertion in bitbucket-pipelines.yml at line 29 [10.26]

[10.919]

[10.988]

          - rustup component add rustfmt-preview --toolchain nightly

Insertion in bitbucket-pipelines.yml at line 36 [10.26]

[12.62]

[10.1321]

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
          - cargo fmt -- --version
          - cargo fmt --all -- --check
================================
          - cargo fix --edition
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Insertion in README.md at line 0 [9.76]

[9.76]

### XMPP client daemon
#### Sending messages
```
curl http://localhost:8083/ -H "X-XMPP-To: some@domain.org" -d "Test"
```
#### Sending messages to MUC
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -d "Test"
```