zelo72
/
flodgatt
mirror of https://github.com/mastodon/flodgatt
1
0
Fork 0
Code Issues Releases Wiki Activity

s/pg_conn/pg_pool to match reality

This commit is contained in:
Daniel Sockwell 2020-01-10 15:27:26 -05:00
parent cf86fded95
commit 9306f52976
5 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/main.rs
View File

@ -30,13 +30,13 @@ fn main() {
let client_agent_sse = ClientAgent::blank(redis_cfg);
let client_agent_ws = client_agent_sse.clone_with_shared_receiver();
let pg_conn = user::PostgresPool::new(postgres_cfg);
let pg_pool = user::PostgresPool::new(postgres_cfg);
warn!("Streaming server initialized and ready to accept connections");
// Server Sent Events
let sse_update_interval = *cfg.ws_interval;
let sse_routes = sse::extract_user_or_reject(pg_conn.clone())
let sse_routes = sse::extract_user_or_reject(pg_pool.clone())
.and(warp::sse())
.map(
move |user: user::User, sse_connection_to_client: warp::sse::Sse| {
@ -57,7 +57,7 @@ fn main() {
// WebSocket
let ws_update_interval = *cfg.ws_interval;
let websocket_routes = ws::extract_user_or_reject(pg_conn.clone())
let websocket_routes = ws::extract_user_or_reject(pg_pool.clone())
.and(warp::ws::ws2())
.map(move |user: user::User, ws: Ws2| {
warn!("Incoming request");

30
src/parse_client_request/sse.rs
View File

@ -39,7 +39,7 @@ macro_rules! parse_query {
.boxed()
};
}
pub fn extract_user_or_reject(pg_conn: PostgresPool) -> BoxedFilter<(User,)> {
pub fn extract_user_or_reject(pg_pool: PostgresPool) -> BoxedFilter<(User,)> {
any_of!(
parse_query!(
path => "api" / "v1" / "streaming" / "user" / "notification"
@ -67,7 +67,7 @@ pub fn extract_user_or_reject(pg_conn: PostgresPool) -> BoxedFilter<(User,)> {
// parameter, we need to update our Query if the header has a token
.and(query::OptionalAccessToken::from_sse_header())
.and_then(Query::update_access_token)
.and_then(move |q| User::from_query(q, pg_conn.clone()))
.and_then(move |q| User::from_query(q, pg_pool.clone()))
.boxed()
}
@ -83,10 +83,10 @@ mod test {
}) => {
#[test]
fn $name() {
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
let user = warp::test::request()
.path($path)
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
assert_eq!(user, $user);
}
@ -101,17 +101,17 @@ mod test {
#[test]
fn $name() {
let path = format!("{}?access_token=TEST_USER", $path);
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
$(let path = format!("{}&{}", path, $query);)*
let user = warp::test::request()
.path(&path)
.filter(&extract_user_or_reject(pg_conn.clone()))
.filter(&extract_user_or_reject(mock_pg_pool.clone()))
.expect("in test");
assert_eq!(user, $user);
let user = warp::test::request()
.path(&path)
.header("Authorization", "Bearer: TEST_USER")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
assert_eq!(user, $user);
}
@ -127,10 +127,10 @@ mod test {
fn $name() {
let path = format!("{}?access_token=INVALID", $path);
$(let path = format!("{}&{}", path, $query);)*
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path(&path)
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
};
@ -146,11 +146,11 @@ mod test {
let path = $path;
$(let path = format!("{}?{}", path, $query);)*
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path(&path)
.header("Authorization", "Bearer: INVALID")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
};
@ -165,10 +165,10 @@ mod test {
fn $name() {
let path = $path;
$(let path = format!("{}?{}", path, $query);)*
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path(&path)
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
};
@ -437,10 +437,10 @@ mod test {
#[test]
#[should_panic(expected = "NotFound")]
fn nonexistant_endpoint() {
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path("/api/v1/streaming/DOES_NOT_EXIST")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
}

2
src/parse_client_request/user/mock_postgres.rs
View File

@ -28,7 +28,7 @@ pub fn query_for_user_data(
(user_id, lang, scopes)
}
pub fn query_list_owner(list_id: i64, _pg_conn: PostgresPool) -> Option<i64> {
pub fn query_list_owner(list_id: i64, _pg_pool: PostgresPool) -> Option<i64> {
match list_id {
1 => Some(1),
_ => None,

14
src/parse_client_request/user/mod.rs
View File

@ -58,7 +58,7 @@ impl From<Vec<String>> for OauthScope {
}
impl User {
pub fn from_query(q: Query, pg_conn: PostgresPool) -> Result<Self, Rejection> {
pub fn from_query(q: Query, pg_pool: PostgresPool) -> Result<Self, Rejection> {
let (id, access_token, scopes, langs, logged_in) = match q.access_token.clone() {
None => (
-1,
@ -69,7 +69,7 @@ impl User {
),
Some(token) => {
let (id, langs, scope_list) =
postgres::query_for_user_data(&token, pg_conn.clone());
postgres::query_for_user_data(&token, pg_pool.clone());
if id == -1 {
return Err(warp::reject::custom("Error: Invalid access token"));
}
@ -87,7 +87,7 @@ impl User {
filter: Filter::Language,
};
user = user.update_timeline_and_filter(q, pg_conn.clone())?;
user = user.update_timeline_and_filter(q, pg_pool.clone())?;
Ok(user)
}
@ -95,7 +95,7 @@ impl User {
fn update_timeline_and_filter(
mut self,
q: Query,
pg_conn: PostgresPool,
pg_pool: PostgresPool,
) -> Result<Self, Rejection> {
let read_scope = self.scopes.clone();
@ -116,7 +116,7 @@ impl User {
format!("{}", self.id)
}
// List endpoint:
"list" if self.owns_list(q.list, pg_conn) && (read_scope.all || read_scope.lists) => {
"list" if self.owns_list(q.list, pg_pool) && (read_scope.all || read_scope.lists) => {
self.filter = Filter::NoFilter;
format!("list:{}", q.list)
}
@ -139,8 +139,8 @@ impl User {
}
/// Determine whether the User is authorised for a specified list
pub fn owns_list(&self, list: i64, pg_conn: PostgresPool) -> bool {
match postgres::query_list_owner(list, pg_conn) {
pub fn owns_list(&self, list: i64, pg_pool: PostgresPool) -> bool {
match postgres::query_list_owner(list, pg_pool) {
Some(i) if i == self.id => true,
_ => false,
}

24
src/parse_client_request/ws.rs
View File

@ -32,11 +32,11 @@ fn parse_query() -> BoxedFilter<(Query,)> {
.boxed()
}
pub fn extract_user_or_reject(pg_conn: PostgresPool) -> BoxedFilter<(User,)> {
pub fn extract_user_or_reject(pg_pool: PostgresPool) -> BoxedFilter<(User,)> {
parse_query()
.and(query::OptionalAccessToken::from_ws_header())
.and_then(Query::update_access_token)
.and_then(move |q| User::from_query(q, pg_conn.clone()))
.and_then(move |q| User::from_query(q, pg_pool.clone()))
.boxed()
}
@ -52,14 +52,14 @@ mod test {
}) => {
#[test]
fn $name() {
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
let user = warp::test::request()
.path($path)
.header("connection", "upgrade")
.header("upgrade", "websocket")
.header("sec-websocket-version", "13")
.header("sec-websocket-key", "dGhlIHNhbXBsZSBub25jZQ==")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
assert_eq!(user, $user);
}
@ -72,7 +72,7 @@ mod test {
}) => {
#[test]
fn $name() {
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
let path = format!("{}&access_token=TEST_USER", $path);
let user = warp::test::request()
.path(&path)
@ -80,7 +80,7 @@ mod test {
.header("upgrade", "websocket")
.header("sec-websocket-version", "13")
.header("sec-websocket-key", "dGhlIHNhbXBsZSBub25jZQ==")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
assert_eq!(user, $user);
}
@ -96,10 +96,10 @@ mod test {
fn $name() {
let path = format!("{}&access_token=INVALID", $path);
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path(&path)
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
};
@ -112,10 +112,10 @@ mod test {
#[should_panic(expected = "Error: Missing access token")]
fn $name() {
let path = $path;
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path(&path)
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
};
@ -316,14 +316,14 @@ mod test {
#[test]
#[should_panic(expected = "NotFound")]
fn nonexistant_endpoint() {
let pg_conn = PostgresPool::new();
let mock_pg_pool = PostgresPool::new();
warp::test::request()
.path("/api/v1/streaming/DOES_NOT_EXIST")
.header("connection", "upgrade")
.header("upgrade", "websocket")
.header("sec-websocket-version", "13")
.header("sec-websocket-key", "dGhlIHNhbXBsZSBub25jZQ==")
.filter(&extract_user_or_reject(pg_conn))
.filter(&extract_user_or_reject(mock_pg_pool))
.expect("in test");
}
}