1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
use anyhow::{anyhow, Context};
use redis::{self, AsyncCommands};
use kittybox::database::Storage;
use kittybox::database::FileStorage;
use std::collections::HashMap;
/// Convert from a Redis storage to a new storage new_storage.
async fn convert_from_redis<S: Storage>(from: String, new_storage: S) -> anyhow::Result<()> {
let db = redis::Client::open(from).context("Failed to open the Redis connection")?;
let mut conn = db.get_async_std_connection().await.context("Failed to connect to Redis")?;
// Rebinding to convince the borrow checker we're not smuggling stuff outta scope
let storage = &new_storage;
let mut stream = conn.hscan::<_, String>("posts").await?;
while let Some(key) = stream.next_item().await {
let value = serde_json::from_str::<serde_json::Value>(
&stream.next_item().await
.ok_or(anyhow!("Failed to find a corresponding value for the key"))?
)?;
println!("{}, {:?}", key, value);
if value["see_other"].is_string() {
continue
}
let user = &(
url::Url::parse(
value["properties"]["uid"][0]
.as_str().unwrap()
).unwrap().origin().ascii_serialization().clone()
+ "/"
);
if let Err(err) = storage.clone().put_post(&value, user).await {
eprintln!("Error saving post: {}", err);
}
}
let mut stream: redis::AsyncIter<String> = conn.scan_match("settings_*").await?;
while let Some(key) = stream.next_item().await {
let mut conn = db.get_async_std_connection().await.context("Failed to connect to Redis")?;
let user = key.strip_prefix("settings_").unwrap();
match conn.hgetall::<&str, HashMap<String, String>>(&key).await.context(format!("Failed getting settings from key {}", key)) {
Ok(settings) => {
for (k, v) in settings.iter() {
if let Err(e) = storage.set_setting(k, &user, v).await.with_context(|| format!("Failed setting {} for {}", k, user)) {
eprintln!("{}", e);
}
}
},
Err(e) => {
eprintln!("{}", e);
}
}
}
return Ok(());
}
#[async_std::main]
async fn main() -> anyhow::Result<()> {
let mut args = std::env::args();
args.next(); // skip argv[0]
let old_uri = args.next().ok_or_else(|| anyhow!("No import source is provided."))?;
let new_uri = args.next().ok_or_else(|| anyhow!("No import destination is provided."))?;
let storage = if new_uri.starts_with("file:") {
let folder = new_uri.strip_prefix("file://").unwrap();
let path = std::path::PathBuf::from(folder);
Box::new(FileStorage::new(path).await.context("Failed to construct the file storage")?)
} else {
anyhow::bail!("Cannot construct the storage abstraction for destination storage. Check the storage type?");
};
if old_uri.starts_with("redis") {
convert_from_redis(old_uri, *storage).await?
}
Ok(())
}
|
