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

19 lines
334 B
Rust
Raw Normal View History

Implement basic Server Sent Events with Warp This commit rolls up several days of work that took place in a side repo which was originally intended to be a test/proof-of-concept repo but that grew into a full implementation. This implementation switches to Warp as the framework for the primary web server (in large part because Warp offers built-in support for SSE and several other advantages). This implementation relies on a custom Redis interface built on Tokio (because the current Redis Rust crate does not support asnyc PubSub). Using a custom interface should also be faster, since it does not contain logic for anything other than pubsub—which is all we need. Finally, I note that the SSE support is currently as feature-complete as it is possible to be without having yet added the Postgress interface this means that all of the endpoints are present and are accessible on localhost. However, none of the endpoints have authentication yet, and the endpoints that should provide user-specific data (e.g., `/api/v1/streaming/user`) are currently hard-coded to provide data for user 1 (the admin). Other than those limitations, however, the SSE implementation is feature complete.
2019-04-15 20:22:44 +02:00
use serde_derive::Deserialize;
Allow seperate SSE responses to share Redis pubsub This commit implements a shared stream of data from Redis, which allows all SSE connections that send the same data to the client to share a single connection to Redis. (Previously, each client got their own connection, which would significantly increase the number of open Redis connections—especially since nearly all clients will subscribe to `/public`.)
2019-04-27 02:00:11 +02:00
#[derive(Deserialize, Debug)]
Implement basic Server Sent Events with Warp This commit rolls up several days of work that took place in a side repo which was originally intended to be a test/proof-of-concept repo but that grew into a full implementation. This implementation switches to Warp as the framework for the primary web server (in large part because Warp offers built-in support for SSE and several other advantages). This implementation relies on a custom Redis interface built on Tokio (because the current Redis Rust crate does not support asnyc PubSub). Using a custom interface should also be faster, since it does not contain logic for anything other than pubsub—which is all we need. Finally, I note that the SSE support is currently as feature-complete as it is possible to be without having yet added the Postgress interface this means that all of the endpoints are present and are accessible on localhost. However, none of the endpoints have authentication yet, and the endpoints that should provide user-specific data (e.g., `/api/v1/streaming/user`) are currently hard-coded to provide data for user 1 (the admin). Other than those limitations, however, the SSE implementation is feature complete.
2019-04-15 20:22:44 +02:00
pub struct Media {
pub only_media: String,
}
Allow seperate SSE responses to share Redis pubsub This commit implements a shared stream of data from Redis, which allows all SSE connections that send the same data to the client to share a single connection to Redis. (Previously, each client got their own connection, which would significantly increase the number of open Redis connections—especially since nearly all clients will subscribe to `/public`.)
2019-04-27 02:00:11 +02:00
#[derive(Deserialize, Debug)]
Implement basic Server Sent Events with Warp This commit rolls up several days of work that took place in a side repo which was originally intended to be a test/proof-of-concept repo but that grew into a full implementation. This implementation switches to Warp as the framework for the primary web server (in large part because Warp offers built-in support for SSE and several other advantages). This implementation relies on a custom Redis interface built on Tokio (because the current Redis Rust crate does not support asnyc PubSub). Using a custom interface should also be faster, since it does not contain logic for anything other than pubsub—which is all we need. Finally, I note that the SSE support is currently as feature-complete as it is possible to be without having yet added the Postgress interface this means that all of the endpoints are present and are accessible on localhost. However, none of the endpoints have authentication yet, and the endpoints that should provide user-specific data (e.g., `/api/v1/streaming/user`) are currently hard-coded to provide data for user 1 (the admin). Other than those limitations, however, the SSE implementation is feature complete.
2019-04-15 20:22:44 +02:00
pub struct Hashtag {
pub tag: String,
}
Allow seperate SSE responses to share Redis pubsub This commit implements a shared stream of data from Redis, which allows all SSE connections that send the same data to the client to share a single connection to Redis. (Previously, each client got their own connection, which would significantly increase the number of open Redis connections—especially since nearly all clients will subscribe to `/public`.)
2019-04-27 02:00:11 +02:00
#[derive(Deserialize, Debug)]
Implement basic Server Sent Events with Warp This commit rolls up several days of work that took place in a side repo which was originally intended to be a test/proof-of-concept repo but that grew into a full implementation. This implementation switches to Warp as the framework for the primary web server (in large part because Warp offers built-in support for SSE and several other advantages). This implementation relies on a custom Redis interface built on Tokio (because the current Redis Rust crate does not support asnyc PubSub). Using a custom interface should also be faster, since it does not contain logic for anything other than pubsub—which is all we need. Finally, I note that the SSE support is currently as feature-complete as it is possible to be without having yet added the Postgress interface this means that all of the endpoints are present and are accessible on localhost. However, none of the endpoints have authentication yet, and the endpoints that should provide user-specific data (e.g., `/api/v1/streaming/user`) are currently hard-coded to provide data for user 1 (the admin). Other than those limitations, however, the SSE implementation is feature complete.
2019-04-15 20:22:44 +02:00
pub struct List {
Close Redis connections when SSE stream ends This commit tracks the existence of the SSE stream and closes the connection to the redis pub/sub channel when the stream is closed. This prevents the number of redis connections from growing over time. Note, however, that the current code still subscribes to one redis channel per SSE connection rather than reusing existing subscriptions. This will need to be fixed in a later PR.
2019-04-21 15:21:44 +02:00
pub list: i64,
Implement basic Server Sent Events with Warp This commit rolls up several days of work that took place in a side repo which was originally intended to be a test/proof-of-concept repo but that grew into a full implementation. This implementation switches to Warp as the framework for the primary web server (in large part because Warp offers built-in support for SSE and several other advantages). This implementation relies on a custom Redis interface built on Tokio (because the current Redis Rust crate does not support asnyc PubSub). Using a custom interface should also be faster, since it does not contain logic for anything other than pubsub—which is all we need. Finally, I note that the SSE support is currently as feature-complete as it is possible to be without having yet added the Postgress interface this means that all of the endpoints are present and are accessible on localhost. However, none of the endpoints have authentication yet, and the endpoints that should provide user-specific data (e.g., `/api/v1/streaming/user`) are currently hard-coded to provide data for user 1 (the admin). Other than those limitations, however, the SSE implementation is feature complete.
2019-04-15 20:22:44 +02:00
}
Allow seperate SSE responses to share Redis pubsub This commit implements a shared stream of data from Redis, which allows all SSE connections that send the same data to the client to share a single connection to Redis. (Previously, each client got their own connection, which would significantly increase the number of open Redis connections—especially since nearly all clients will subscribe to `/public`.)
2019-04-27 02:00:11 +02:00
#[derive(Deserialize, Debug)]
Finish building out postgres auth
2019-04-19 01:02:29 +02:00
pub struct Auth {
pub access_token: String,
}