all: Remove ws routes and related settings

Author: lutter

docs/environment-variables.md

@@ -112,11 +112,7 @@ those.
   result is checked while the response is being constructed, so that
   execution does not take more memory than what is configured. The default
   value for both is unlimited.
-- `GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION`: maximum number of GraphQL
-  operations per WebSocket connection. Any operation created after the limit
-  will return an error to the client. Default: 1000.
 - `GRAPH_GRAPHQL_HTTP_PORT` : Port for the GraphQL HTTP server
-- `GRAPH_GRAPHQL_WS_PORT` : Port for the GraphQL WebSocket server
 - `GRAPH_SQL_STATEMENT_TIMEOUT`: the maximum number of seconds an
   individual SQL query is allowed to take during GraphQL
   execution. Default: unlimited
@@ -181,11 +177,10 @@ those.
   query, and the `query_id` of the GraphQL query that caused the SQL
   query. These SQL queries are marked with `component: GraphQlRunner` There
   are additional SQL queries that get logged when `sql` is given. These are
-  queries caused by mappings when processing blocks for a subgraph, and
-  queries caused by subscriptions. If `cache` is present in addition to
-  `gql`, also logs information for each toplevel GraphQL query field
-  whether that could be retrieved from cache or not. Defaults to no
-  logging.
+  queries caused by mappings when processing blocks for a subgraph. If
+  `cache` is present in addition to `gql`, also logs information for each
+  toplevel GraphQL query field whether that could be retrieved from cache
+  or not. Defaults to no logging.
 - `GRAPH_LOG_TIME_FORMAT`: Custom log time format.Default value is `%b %d %H:%M:%S%.3f`. More information [here](https://docs.rs/chrono/latest/chrono/#formatting-and-parsing).
 - `STORE_CONNECTION_POOL_SIZE`: How many simultaneous connections to allow to the store.
   Due to implementation details, this value may not be strictly adhered to. Defaults to 10.

graph/src/env/graphql.rs

@@ -86,9 +86,6 @@ pub struct EnvVarsGraphQl {
     /// Set by the environment variable `GRAPH_GRAPHQL_ERROR_RESULT_SIZE`. The
     /// default value is [`usize::MAX`].
     pub error_result_size: usize,
-    /// Set by the flag `GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION`.
-    /// Defaults to 1000.
-    pub max_operations_per_connection: usize,
     /// Set by the flag `GRAPH_GRAPHQL_DISABLE_BOOL_FILTERS`. Off by default.
     /// Disables AND/OR filters
     pub disable_bool_filters: bool,
@@ -144,7 +141,6 @@ impl From<InnerGraphQl> for EnvVarsGraphQl {
             allow_deployment_change: x.allow_deployment_change.0,
             warn_result_size: x.warn_result_size.0 .0,
             error_result_size: x.error_result_size.0 .0,
-            max_operations_per_connection: x.max_operations_per_connection,
             disable_bool_filters: x.disable_bool_filters.0,
             disable_child_sorting: x.disable_child_sorting.0,
             query_trace_token: x.query_trace_token,
@@ -192,8 +188,6 @@ pub struct InnerGraphQl {
     warn_result_size: WithDefaultUsize<NoUnderscores<usize>, { usize::MAX }>,
     #[envconfig(from = "GRAPH_GRAPHQL_ERROR_RESULT_SIZE", default = "")]
     error_result_size: WithDefaultUsize<NoUnderscores<usize>, { usize::MAX }>,
-    #[envconfig(from = "GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION", default = "1000")]
-    max_operations_per_connection: usize,
     #[envconfig(from = "GRAPH_GRAPHQL_DISABLE_BOOL_FILTERS", default = "false")]
     pub disable_bool_filters: EnvVarBoolean,
     #[envconfig(from = "GRAPH_GRAPHQL_DISABLE_CHILD_SORTING", default = "false")]

node/src/main.rs

@@ -141,7 +141,6 @@ async fn main() {
 
     // Obtain ports to use for the GraphQL server(s)
     let http_port = opt.http_port;
-    let ws_port = opt.ws_port;
 
     // Obtain JSON-RPC server port
     let json_rpc_port = opt.admin_port;
@@ -442,7 +441,6 @@ async fn main() {
         let json_rpc_server = JsonRpcServer::serve(
             json_rpc_port,
             http_port,
-            ws_port,
             subgraph_registrar.clone(),
             node_id.clone(),
             logger.clone(),
@@ -504,7 +502,7 @@ async fn main() {
         }
 
         // Serve GraphQL queries over HTTP
-        graph::spawn(async move { graphql_server.start(http_port, ws_port).await });
+        graph::spawn(async move { graphql_server.start(http_port).await });
 
         // Run the index node server
         graph::spawn(async move { index_node_server.start(index_node_port).await });

node/src/opt.rs

@@ -132,14 +132,6 @@ pub struct Opt {
         help = "Port for the index node server"
     )]
     pub index_node_port: u16,
-    #[clap(
-        long,
-        default_value = "8001",
-        value_name = "PORT",
-        help = "Port for the GraphQL WebSocket server",
-        env = "GRAPH_GRAPHQL_WS_PORT"
-    )]
-    pub ws_port: u16,
     #[clap(
         long,
         default_value = "8020",

server/http/src/server.rs

@@ -32,7 +32,7 @@ impl<Q: GraphQlRunner> GraphQLServer<Q> {
         }
     }
 
-    pub async fn start(&self, port: u16, ws_port: u16) -> Result<ServerHandle, anyhow::Error> {
+    pub async fn start(&self, port: u16) -> Result<ServerHandle, anyhow::Error> {
         let logger = self.logger.clone();
 
         info!(
@@ -42,7 +42,7 @@ impl<Q: GraphQlRunner> GraphQLServer<Q> {
 
         let graphql_runner = self.graphql_runner.clone();
 
-        let service = Arc::new(GraphQLService::new(logger.clone(), graphql_runner, ws_port));
+        let service = Arc::new(GraphQLService::new(logger.clone(), graphql_runner));
 
         start(logger, port, move |req| {
             let service = service.cheap_clone();

server/http/src/service.rs

@@ -48,25 +48,22 @@ fn client_error(msg: impl Into<String>) -> ServerResponse {
 pub struct GraphQLService<Q> {
     logger: Logger,
     graphql_runner: Arc<Q>,
-    ws_port: u16,
 }
 
 impl<Q> GraphQLService<Q>
 where
     Q: GraphQlRunner,
 {
     /// Creates a new GraphQL service.
-    pub fn new(logger: Logger, graphql_runner: Arc<Q>, ws_port: u16) -> Self {
+    pub fn new(logger: Logger, graphql_runner: Arc<Q>) -> Self {
         GraphQLService {
             logger,
             graphql_runner,
-            ws_port,
         }
     }
 
     fn graphiql_html(&self) -> String {
-        include_str!("../assets/index.html")
-            .replace("__WS_PORT__", format!("{}", self.ws_port).as_str())
+        include_str!("../assets/index.html").to_string()
     }
 
     async fn index(&self) -> ServerResult {
@@ -459,7 +456,7 @@ mod tests {
         let logger = Logger::root(slog::Discard, o!());
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let service = GraphQLService::new(logger, graphql_runner, 8001);
+        let service = GraphQLService::new(logger, graphql_runner);
 
         let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::GET)
@@ -491,7 +488,7 @@ mod tests {
         let subgraph_id = USERS.clone();
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let service = GraphQLService::new(logger, graphql_runner, 8001);
+        let service = GraphQLService::new(logger, graphql_runner);
 
         let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::POST)
@@ -523,7 +520,7 @@ mod tests {
         let subgraph_id = USERS.clone();
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let service = GraphQLService::new(logger, graphql_runner, 8001);
+        let service = GraphQLService::new(logger, graphql_runner);
 
         let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::POST)

server/http/tests/server.rs

@@ -165,7 +165,7 @@ mod test {
         let query_runner = Arc::new(TestGraphQlRunner);
         let server = HyperGraphQLServer::new(&logger_factory, query_runner);
         let server_handle = server
-            .start(8007, 8008)
+            .start(8007)
             .await
             .expect("Failed to start GraphQL server");
         while !server_handle.accepting.load(Ordering::SeqCst) {
@@ -197,7 +197,7 @@ mod test {
         let query_runner = Arc::new(TestGraphQlRunner);
         let server = HyperGraphQLServer::new(&logger_factory, query_runner);
         let server_handle = server
-            .start(8002, 8003)
+            .start(8002)
             .await
             .expect("Failed to start GraphQL server");
         while !server_handle.accepting.load(Ordering::SeqCst) {
@@ -269,7 +269,7 @@ mod test {
         let query_runner = Arc::new(TestGraphQlRunner);
         let server = HyperGraphQLServer::new(&logger_factory, query_runner);
         let server_handle = server
-            .start(8003, 8004)
+            .start(8003)
             .await
             .expect("Failed to start GraphQL server");
         while !server_handle.accepting.load(Ordering::SeqCst) {
@@ -306,7 +306,7 @@ mod test {
         let query_runner = Arc::new(TestGraphQlRunner);
         let server = HyperGraphQLServer::new(&logger_factory, query_runner);
         let server_handle = server
-            .start(8005, 8006)
+            .start(8005)
             .await
             .expect("Failed to start GraphQL server");
         while !server_handle.accepting.load(Ordering::SeqCst) {

server/json-rpc/src/lib.rs

@@ -21,7 +21,6 @@ impl JsonRpcServer {
     pub async fn serve<R>(
         port: u16,
         http_port: u16,
-        ws_port: u16,
         registrar: Arc<R>,
         node_id: NodeId,
         logger: Logger,
@@ -39,7 +38,6 @@ impl JsonRpcServer {
         let state = ServerState {
             registrar,
             http_port,
-            ws_port,
             node_id,
             logger,
         };
@@ -87,7 +85,6 @@ impl JsonRpcServer {
 struct ServerState<R> {
     registrar: Arc<R>,
     http_port: u16,
-    ws_port: u16,
     node_id: NodeId,
     logger: Logger,
 }
@@ -123,7 +120,7 @@ impl<R: SubgraphRegistrar> ServerState<R> {
         info!(&self.logger, "Received subgraph_deploy request"; "params" => format!("{:?}", params));
 
         let node_id = params.node_id.clone().unwrap_or(self.node_id.clone());
-        let routes = subgraph_routes(&params.name, self.http_port, self.ws_port);
+        let routes = subgraph_routes(&params.name, self.http_port);
         match self
             .registrar
             .create_subgraph_version(
@@ -243,15 +240,11 @@ fn json_rpc_error(
     )))
 }
 
-fn subgraph_routes(name: &SubgraphName, http_port: u16, ws_port: u16) -> JsonValue {
+fn subgraph_routes(name: &SubgraphName, http_port: u16) -> JsonValue {
     let http_base_url = ENV_VARS
         .external_http_base_url
         .clone()
         .unwrap_or_else(|| format!(":{}", http_port));
-    let ws_base_url = ENV_VARS
-        .external_ws_base_url
-        .clone()
-        .unwrap_or_else(|| format!(":{}", ws_port));
 
     let mut map = BTreeMap::new();
     map.insert(
@@ -262,10 +255,6 @@ fn subgraph_routes(name: &SubgraphName, http_port: u16, ws_port: u16) -> JsonVal
         "queries",
         format!("{}/subgraphs/name/{}", http_base_url, name),
     );
-    map.insert(
-        "subscriptions",
-        format!("{}/subgraphs/name/{}", ws_base_url, name),
-    );
 
     serde_json::to_value(map).expect("invalid subgraph routes")
 }