yusdacra/icy_matrix - Change VO4UOVTJKRL5LOOMKGMQ5DGN5SAZGCEUAUZTKGRE6N3KSCCXHWFAC

Fix many crashes

Created by Yusuf Bera Ertan on November 17, 2020

VO4UOVTJKRL5LOOMKGMQ5DGN5SAZGCEUAUZTKGRE6N3KSCCXHWFAC

Dependencies

In channels

main

Change contents

Replacement in Cargo.lock at line 269 [3.164758]
B:BD[3.171939] → [3.171939:171958]
```
version = "0.1.44"
```
[3.171939]
[3.171958]
```
version = "0.1.45"
```

Replacement in Cargo.lock at line 271 [3.164758]

B:BD[3.172023] → [3.172023:172101]

checksum = "0e56268c17a6248366d66d4a47a3381369d068cce8409bb1716ed77ea32163bb"

[3.172023]

[3.172101]

checksum = "eb6210b637171dfba4cda12e579ac6dc73f5165ad56133e5d72ef3131f320855"

Replacement in Cargo.lock at line 1026 [3.164758]
B:BD[3.190086] → [4.1371:1390]
```
version = "0.10.0"
```
[3.190086]
[3.190104]
```
version = "0.10.2"
```

Replacement in Cargo.lock at line 1028 [3.164758]

B:BD[3.190169] → [4.1391:1469]

checksum = "668e725370f2b2243a5f43c6e4be6be3d501fb2441b81f7ee604ef766b5ab91b"

[3.190169]

[4.1469]

checksum = "579160312273c954cc51bd440f059dde741029ac8daf8c84fece76cb77f62c15"

Replacement in Cargo.lock at line 1947 [3.164758]
B:BD[3.210705] → [3.210705:210726]
```
 "ttf-parser 0.8.2",
```
[3.210705]
[3.210987]
```
 "ttf-parser 0.8.3",
```
Replacement in Cargo.lock at line 2645 [3.164758]
B:BD[3.228257] → [3.228257:228276]
```
version = "0.22.0"
```
[3.228257]
[3.228276]
```
version = "0.22.1"
```

Replacement in Cargo.lock at line 2647 [3.164758]

B:BD[3.228341] → [3.228341:228419]

checksum = "d8221f4aebf53a4447aebd4fe29ebff2c66dd2c2821e63675e09e85bd21c8633"

[3.228341]

[3.228419]

checksum = "ea964c42ce40326fe96111918abe71fa45076da1ea85769f3f1ab1cda9a1d496"

Replacement in Cargo.lock at line 2930 [3.164758]
B:BD[3.235132] → [3.235132:235150]
```
version = "0.8.2"
```
[3.235132]
[3.235150]
```
version = "0.8.3"
```

Replacement in Cargo.lock at line 2932 [3.164758]

B:BD[3.235215] → [3.235215:235293]

checksum = "d973cfa0e6124166b50a1105a67c85de40bbc625082f35c0f56f84cb1fb0a827"

[3.235215]

[3.235293]

checksum = "7622061403fd00f0820df288e5a580e87d3ce15a1c4313c59fd1ffb77129903f"

Replacement in src/client/media.rs at line 9 [3.124864]

B:BD[3.125024] → [3.125024:125159]

pub fn make_content_path(content_url: &Uri) -> PathBuf {
    make_content_folder(content_url).join(make_content_filename(content_url))

[3.125024]

[3.125159]

pub fn make_content_path(content_url: &Uri) -> Option<PathBuf> {
    make_content_folder(content_url)
        .map(|f| make_content_filename(content_url).map(|ff| f.join(ff)))
        .flatten()

Replacement in src/client/media.rs at line 15 [3.124864]

B:BD[3.125162] → [3.125162:125307]

pub fn make_content_filename(content_url: &Uri) -> PathBuf {
    let filename = content_url.path()[1..].to_string();
    PathBuf::from(filename)

[3.125162]

[3.125307]

pub fn make_content_filename(content_url: &Uri) -> Option<PathBuf> {
    if !content_url.path().is_empty() {
        let filename = content_url.path()[1..].to_string();
        Some(PathBuf::from(filename))
    } else {
        None
    }

Replacement in src/client/media.rs at line 24 [3.124864]

B:BD[3.125310] → [3.125310:125369]

pub fn make_content_folder(content_url: &Uri) -> PathBuf {

[3.125310]

[3.125369]

pub fn make_content_folder(content_url: &Uri) -> Option<PathBuf> {

Replacement in src/client/media.rs at line 28 [3.124864]

B:BD[3.125457] → [3.125457:125525]

        content_url.authority().unwrap().as_str().replace('.', "_")

[3.125457]

[3.125525]

        content_url
            .authority()
            .map(|a| a.as_str().replace('.', "_"))?

Replacement in src/client/media.rs at line 32 [3.124864]

B:BD[3.125532] → [3.125532:125568]

    PathBuf::from(server_media_dir)

[3.125532]

[4.4523]

    Some(PathBuf::from(server_media_dir))
}
pub fn content_exists(content_url: &Uri) -> bool {
    make_content_path(content_url)
        .map(|p| p.exists())
        .unwrap_or(false)

Replacement in src/client/mod.rs at line 298 [3.104841]

B:BD[3.113541] → [3.113541:113919]

        Ok(inner
            .request(get_content::Request::new(
                content_url.path().trim_matches('/'),
                content_url
                    .authority()
                    .unwrap()
                    .as_str()
                    .try_into()
                    .unwrap(),
            ))
            .await?)
        .map(|response| response.file)

[3.113541]

[5.1889]

        if let (Some(server_address), Some(content_id)) = (
            content_url
                .authority()
                .map(|a| a.as_str().try_into().map_or(None, Some))
                .flatten(),
            if content_url.path().is_empty() {
                None
            } else {
                Some(content_url.path().trim_matches('/'))
            },
        ) {
            inner
                .request(get_content::Request::new(content_id, server_address))
                .await
                .map_or_else(|err| Err(err.into()), |response| Ok(response.file))
        } else {
            Err(ClientError::Custom(String::from(
                "Could not make server address or content ID",
            )))
        }

Replacement in src/client/timeline_event.rs at line 1 [3.75034]

B:BD[3.75034] → [2.3589:3660]

use super::{media::make_content_path, media::ContentType, room::Room};

[3.75034]

[3.75080]

use super::{media::content_exists, media::ContentType, room::Room};

Replacement in src/client/timeline_event.rs at line 126 [3.75034]

B:BD[3.80836] → [3.80836:80924]

                                            "changed their display name from {} to {}",

[3.80836]

[3.80924]

                                            "changed their display name from \"{}\" to \"{}\"",

Replacement in src/client/timeline_event.rs at line 280 [3.75034]

B:BD[2.3810] → [2.3810:3874]

                if make_content_path(&thumbnail_url).exists() {

[2.3810]

[2.3874]

                if content_exists(&thumbnail_url) {

Replacement in src/client/timeline_event.rs at line 290 [3.75034]

B:BD[2.4190] → [2.4190:4248]

            if make_content_path(&content_url).exists() {

[2.4190]

[2.4248]

            if content_exists(&content_url) {

Insertion in src/main.rs at line 29 [3.73994]

[3.74800]

        use std::os::unix::fs::PermissionsExt;
        if let Err(err) = std::fs::set_permissions(
            client::SESSION_ID_PATH,
            std::fs::Permissions::from_mode(0o600),
        ) {
            log::error!("Could not set permissions of session file: {}", err);
        }

Replacement in src/ui/component/event_history.rs at line 4 [3.64751]
B:BD[3.64807] → [3.64807:64859]
```
        media::{make_content_path, ThumbnailStore},
```
[3.64807]
[3.64859]
```
        media::{content_exists, ThumbnailStore},
```
Replacement in src/ui/component/event_history.rs at line 18 [3.64751]
B:BD[3.65191] → [3.65191:65216]
```
use std::time::Duration;
```
[3.65191]
[3.65216]
```
use std::time::{Duration, Instant};
```

Replacement in src/ui/component/event_history.rs at line 54 [3.64751]

B:BD[3.66404] → [3.66404:66521]

    // This unwrap should be safe enough
    let mut last_minute = last_timestamp.elapsed().unwrap().as_secs() / 60;

[3.66404]

[3.66521]

    let mut last_minute = last_timestamp
        .elapsed()
        .unwrap_or_else(|_| Instant::now().elapsed())
        .as_secs()
        / 60;

Replacement in src/ui/component/event_history.rs at line 65 [3.64751]

B:BD[3.66698] → [3.66698:66787]

        let cur_timestamp = timeline_event.origin_server_timestamp().elapsed().unwrap();

[3.66698]

[3.66787]

        let cur_timestamp = timeline_event
            .origin_server_timestamp()
            .elapsed()
            .unwrap_or_else(|_| Instant::now().elapsed());

Replacement in src/ui/component/event_history.rs at line 100 [3.64751]

B:BD[3.67973] → [3.67973:68082]

            // These unwraps should be safe enough
            let time = last_timestamp.elapsed().unwrap();

[3.67973]

[3.68082]

            let time = last_timestamp
                .elapsed()
                .unwrap_or_else(|_| Instant::now().elapsed());

Replacement in src/ui/component/event_history.rs at line 163 [3.64751]

B:BD[3.70762] → [3.70762:70841]

            let does_content_exist = make_content_path(&content_url).exists();

[3.70762]

[3.70841]

            let does_content_exist = content_exists(&content_url);

Replacement in src/ui/screen/main.rs at line 415 [3.22734]

B:BD[2.5366] → [2.5366:5563]

                                            tokio::fs::read(media::make_content_path(
                                                &thumbnail_url,
                                            ))

[2.5366]

[2.5563]

                                            tokio::fs::read(
                                                media::make_content_path(&thumbnail_url)
                                                    .map_or_else(
                                                        || {
                                                            Err(ClientError::Custom(String::from(
                                                                "Could not make content path",
                                                            )))
                                                        },
                                                        |p| Ok(p),
                                                    )?,
                                            )

Replacement in src/ui/screen/main.rs at line 453 [3.22734]

B:BD[2.6823] → [2.6823:7441]

                                        let path = media::make_content_path(&thumbnail_url);
                                        let server_media_dir =
                                            media::make_content_folder(&thumbnail_url);
                                        tokio::fs::create_dir_all(server_media_dir).await?;
                                        tokio::fs::write(path, raw_data.as_slice())
                                            .await
                                            .map(|_| (thumbnail_url, raw_data))
                                            .map_err(|e| e.into())

[2.6823]

[2.7441]

                                        if let (Some(content_path), Some(server_media_dir)) = (
                                            media::make_content_path(&thumbnail_url),
                                            media::make_content_folder(&thumbnail_url),
                                        ) {
                                            tokio::fs::create_dir_all(server_media_dir).await?;
                                            tokio::fs::write(content_path, raw_data.as_slice())
                                                .await
                                                .map(|_| (thumbnail_url, raw_data))
                                                .map_err(|e| e.into())
                                        } else {
                                            Err(ClientError::Custom(String::from(
                                                "Could not make content path or server media path",
                                            )))
                                        }

Replacement in src/ui/screen/main.rs at line 612 [3.22734]

B:BD[3.46942] → [4.10332:10548]

∅:D[4.10548] → [3.47127:47280]

B:BD[3.47127] → [3.47127:47280]

B:BD[3.47280] → [4.10549:10644]

∅:D[4.10644] → [3.47475:47525]

B:BD[3.47475] → [3.47475:47525]

B:BD[3.47525] → [4.10645:10746]

∅:D[4.10746] → [3.47699:47787]

B:BD[3.47699] → [3.47699:47787]

B:BD[3.47787] → [4.10747:11071]

                let content_path = media::make_content_path(&content_url);
                return if content_path.exists() {
                    Command::perform(async move { Ok(content_path) }, process_path_result)
                } else {
                    let inner = self.client.inner();
                    Command::perform(
                        async move {
                            match Client::download_content(inner, content_url.clone()).await {
                                Ok(raw_data) => {
                                    let server_media_dir = media::make_content_folder(&content_url);
                                    tokio::fs::create_dir_all(server_media_dir).await?;
                                    tokio::fs::write(&content_path, raw_data.as_slice()).await?;
                                    Ok((
                                        content_path,
                                        if is_thumbnail {
                                            Some((content_url, raw_data))

[3.46942]

[4.11071]

                if let Some(content_path) = media::make_content_path(&content_url) {
                    return if content_path.exists() {
                        Command::perform(async move { Ok(content_path) }, process_path_result)
                    } else {
                        let inner = self.client.inner();
                        Command::perform(
                            async move {
                                match Client::download_content(inner, content_url.clone()).await {
                                    Ok(raw_data) => {
                                        if let Some(server_media_dir) =
                                            media::make_content_folder(&content_url)
                                        {
                                            tokio::fs::create_dir_all(server_media_dir).await?;
                                            tokio::fs::write(&content_path, raw_data.as_slice())
                                                .await?;
                                            Ok((
                                                content_path,
                                                if is_thumbnail {
                                                    Some((content_url, raw_data))
                                                } else {
                                                    None
                                                },
                                            ))

Replacement in src/ui/screen/main.rs at line 636 [3.22734]

B:BD[4.11120] → [4.11120:11251]

                                            None
                                        },
                                    ))

[4.11120]

[3.48138]

                                            Err(ClientError::Custom(String::from("Could not make media path: media doesnt come from any server")))
                                        }
                                    }
                                    Err(err) => Err(err),

Replacement in src/ui/screen/main.rs at line 641 [3.22734]

B:BD[3.48172] → [3.48172:48331]

B:BD[3.48331] → [4.11252:11470]

∅:D[4.11470] → [3.48525:48914]

B:BD[3.48525] → [3.48525:48914]

                                Err(err) => Err(err),
                            }
                        },
                        |result| match result {
                            Ok((content_path, thumbnail)) => {
                                open::that_in_background(content_path);
                                if let Some((content_url, raw_data)) = thumbnail {
                                    super::Message::MainScreen(Message::DownloadedThumbnail {
                                        thumbnail_url: content_url,
                                        thumbnail: ImageHandle::from_memory(raw_data),
                                    })
                                } else {
                                    super::Message::Nothing

[3.48172]

[3.48914]

                            },
                            |result| match result {
                                Ok((content_path, thumbnail)) => {
                                    open::that_in_background(content_path);
                                    if let Some((content_url, raw_data)) = thumbnail {
                                        super::Message::MainScreen(Message::DownloadedThumbnail {
                                            thumbnail_url: content_url,
                                            thumbnail: ImageHandle::from_memory(raw_data),
                                        })
                                    } else {
                                        super::Message::Nothing
                                    }

Replacement in src/ui/screen/main.rs at line 654 [3.22734]

B:BD[3.48948] → [3.48948:49130]

                            }
                            Err(err) => super::Message::MatrixError(Box::new(err)),
                        },
                    )
                };

[3.48948]

[3.49130]

                                Err(err) => super::Message::MatrixError(Box::new(err)),
                            },
                        )
                    };
                }

Replacement in src/ui/screen/main.rs at line 773 [3.22734]

B:BD[4.17587] → [4.17587:17863]

                                            if let Err(err) = tokio::fs::create_dir_all(
                                                media::make_content_folder(&content_url),
                                            )
                                            .await

[4.17587]

[4.17863]

                                            if let Some(server_media_dir) =
                                                media::make_content_folder(&content_url)

Replacement in src/ui/screen/main.rs at line 776 [3.22734]

B:BD[4.17909] → [4.17909:18073]

                                                log::warn!("An IO error occured while trying to create a folder to hard link a file you tried to upload: {}", err);

[4.17909]

[4.18073]

                                                if let Err(err) =
                                                    tokio::fs::create_dir_all(server_media_dir)
                                                        .await
                                                {
                                                    log::warn!("An IO error occured while trying to create a folder to hard link a file you tried to upload: {}", err);
                                                }

Replacement in src/ui/screen/main.rs at line 783 [3.22734]

B:BD[4.18119] → [4.18119:18443]

                                            if let Err(err) = tokio::fs::hard_link(
                                                &path,
                                                media::make_content_path(&content_url),
                                            )
                                            .await

[4.18119]

[4.18443]

                                            if let Some(content_path) =
                                                media::make_content_path(&content_url)

Replacement in src/ui/screen/main.rs at line 786 [3.22734]

B:BD[4.18489] → [4.18489:18674]

                                                log::warn!("An IO error occured while hard linking a file you tried to upload (this may result in a duplication of the file): {}", err);

[4.18489]

[4.18674]

                                                if let Err(err) =
                                                    tokio::fs::hard_link(&path, content_path).await
                                                {
                                                    log::warn!("An IO error occured while hard linking a file you tried to upload (this may result in a duplication of the file): {}", err);
                                                }

Deletion in src/ui/screen/main.rs at line 848 [3.22734]

B:BD[4.21888] → [4.21888:21981]

                                            println!("thumbnail_url: {:?}", thumbnail_url);

Insertion in src/ui/screen/main.rs at line 1086 [3.22734]
[3.56552]
[3.56552]
```
        println!("subbing");
```