Remove code for fetching collector auth tokens (#1801)

Author: divergentdave

app/src/ApiClient.ts

@@ -305,11 +305,6 @@ export class ApiClient {
     return res.data as Task;
   }
 
-  async taskCollectorAuthTokens(taskId: string): Promise<CollectorAuthToken[]> {
-    const res = await this.get(`/api/tasks/${taskId}/collector_auth_tokens`);
-    return res.data as CollectorAuthToken[];
-  }
-
   async deleteMembership(membershipId: string): Promise<null> {
     await this.delete(`/api/memberships/${membershipId}`);
     return null;

app/src/tasks/TaskDetail/CollectorAuthTokens.tsx

@@ -7,7 +7,6 @@ import { Task } from "../../ApiClient";
 import "@github/relative-time-element";
 import { AccountBreadcrumbs } from "../../util";
 import Placeholder from "react-bootstrap/Placeholder";
-import CollectorAuthTokens from "./CollectorAuthTokens";
 import Metrics from "./Metrics";
 import ClientConfig from "./ClientConfig";
 import TaskPropertyTable from "./TaskPropertyTable";
@@ -63,7 +62,6 @@ export default function TaskDetail() {
         <TaskPropertyTable />
         <ClientConfig />
         <Metrics />
-        <CollectorAuthTokens />
       </Row>
     </>
   );

app/src/tasks/TaskDetail/index.tsx

@@ -64,18 +64,6 @@ export default function tasks(apiClient: ApiClient): RouteObject {
               throw new Error(`unexpected method ${request.method}`);
           }
         },
-        children: [
-          {
-            path: "collector_auth_tokens",
-            loader({ params }) {
-              return defer({
-                collectorAuthTokens: apiClient.taskCollectorAuthTokens(
-                  params.taskId as string,
-                ),
-              });
-            },
-          },
-        ],
       },
       {
         path: "new",

app/src/tasks/index.tsx

@@ -88,9 +88,6 @@ pub enum TaskAction {
         #[arg(long, action, conflicts_with = "expiration")]
         now: bool,
     },
-
-    /// retrieve the collector auth tokens for a task
-    CollectorAuthTokens { task_id: String },
 }
 
 impl TaskAction {
@@ -274,9 +271,6 @@ impl TaskAction {
                 output.display(client.rename_task(&task_id, &name).await?)
             }
 
-            TaskAction::CollectorAuthTokens { task_id } => {
-                output.display(client.task_collector_auth_tokens(&task_id).await?)
-            }
             TaskAction::Delete { task_id, force } => {
                 if force {
                     client.force_delete_task(&task_id).await?

cli/src/tasks.rs

@@ -278,14 +278,6 @@ impl DivviupClient {
             .await
     }
 
-    pub async fn task_collector_auth_tokens(
-        &self,
-        task_id: &str,
-    ) -> ClientResult<Vec<CollectorAuthenticationToken>> {
-        self.get(&format!("api/tasks/{task_id}/collector_auth_tokens"))
-            .await
-    }
-
     pub async fn rename_task(&self, task_id: &str, new_name: &str) -> ClientResult<Task> {
         self.patch(&format!("api/tasks/{task_id}"), &json!({"name": new_name}))
             .await

client/src/lib.rs

@@ -157,33 +157,3 @@ async fn force_delete_task(
     assert!(response_tasks.is_empty());
     Ok(())
 }
-
-#[test(harness = with_configured_client)]
-async fn collector_auth_tokens_no_token_hash(
-    app: Arc<DivviupApi>,
-    account: Account,
-    client: DivviupClient,
-) -> TestResult {
-    let task = fixtures::task(&app, &account).await;
-
-    let mut leader = task.leader_aggregator(app.db()).await?.into_active_model();
-    leader.features = ActiveValue::Set(Features::default().into());
-    leader.update(app.db()).await?;
-
-    let tokens = client.task_collector_auth_tokens(&task.id).await?;
-    assert!(!tokens.is_empty()); // we don't have aggregator-api client logs here
-    Ok(())
-}
-
-#[test(harness = with_configured_client)]
-async fn collector_auth_tokens_token_hash(
-    app: Arc<DivviupApi>,
-    account: Account,
-    client: DivviupClient,
-) -> TestResult {
-    let task = fixtures::task(&app, &account).await;
-    let leader = task.leader_aggregator(app.db()).await?;
-    assert!(leader.features.token_hash_enabled());
-    assert!(client.task_collector_auth_tokens(&task.id).await.is_err());
-    Ok(())
-}

client/tests/integration/tasks.rs

@@ -235,37 +235,6 @@ paths:
         "404":
           description: Not Found
 
-  /tasks/{task_id}/collector_auth_tokens:
-    get:
-      parameters:
-        - in: path
-          name: task_id
-          schema:
-            type: string
-          required: true
-          description: UUID of the task
-      tags: ["tasks"]
-      summary: retrieve the collector auth tokens for the task specified by `task_id`
-      description: retrieve the collector auth tokens for the task specified by `task_id`
-      operationId: showTaskCollectorAuthTokens
-      responses:
-        "200":
-          description: success
-          content:
-            application/vnd.divviup+json;version=0.1:
-              schema:
-                type: array
-                items:
-                  type: object
-                  properties:
-                    type:
-                      type: string
-                      enum: [bearer]
-                    token:
-                      type: string
-        "404":
-          $ref: "#/components/responses/NotFound"
-
   /accounts/{account_id}/tasks:
     parameters:
       - $ref: "#/components/parameters/AccountId"

documentation/openapi.yml

@@ -65,10 +65,6 @@ fn api_routes() -> impl Handler {
             .post("/accounts", api(accounts::create))
             .delete("/memberships/:membership_id", api(memberships::delete))
             .get("/tasks/:task_id", api(tasks::show))
-            .get(
-                "/tasks/:task_id/collector_auth_tokens",
-                api(tasks::collector_auth_tokens::index),
-            )
             .patch("/tasks/:task_id", api(tasks::update))
             .delete("/tasks/:task_id", api(tasks::delete))
             .patch("/aggregators/:aggregator_id", api(aggregators::update))

src/routes.rs

@@ -177,21 +177,3 @@ pub async fn delete(
     am.update(&db).await?;
     Ok(Status::NoContent)
 }
-
-pub mod collector_auth_tokens {
-    use super::*;
-    pub async fn index(
-        conn: &mut Conn,
-        (task, db, State(client)): (Task, Db, State<Client>),
-    ) -> Result<impl Handler, Error> {
-        let leader = task.leader_aggregator(&db).await?;
-        if leader.features.token_hash_enabled() {
-            Err(Error::NotFound)
-        } else {
-            let crypter = conn.state().unwrap();
-            let client = leader.client(client, crypter)?;
-            let task_response = client.get_task(&task.id).await?;
-            Ok(Json([task_response.collector_auth_token]))
-        }
-    }
-}