Merge #124

124: Rename invocation request to invocation r=MikailBag a=MikailBag

bors r+

Co-authored-by: Mikail Bagishov <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -1,12 +1,12 @@
 -- indicies
 DROP INDEX runs_id_unique_index;
 -- tables
-DROP TABLE invocation_requests;
+DROP TABLE invocations;
 DROP TABLE runs;
 DROP TABLE users;
 -- sequences
 DROP SEQUENCE user_id_seq;
 DROP SEQUENCE run_id_seq;
-DROP SEQUENCE inv_req_id_seq;
+DROP SEQUENCE inv_id_seq;
 -- types
 DROP DOMAIN unsigned_integer;

src/db/migrations/2019-02-13-163254_initial/down.sql

@@ -41,13 +41,13 @@ CREATE TABLE runs
 
 CREATE UNIQUE INDEX runs_id_unique_index ON runs (id);
 
-CREATE SEQUENCE inv_req_id_seq START WITH 0 MINVALUE 0;
+CREATE SEQUENCE inv_id_seq START WITH 0 MINVALUE 0;
 
 -- Invocation requests
 
-CREATE table invocation_requests
+CREATE table invocations
 (
-    id          unsigned_integer DEFAULT nextval('inv_req_id_seq') UNIQUE PRIMARY KEY NOT NULL,
+    id          unsigned_integer DEFAULT nextval('inv_id_seq') UNIQUE PRIMARY KEY NOT NULL,
     -- This is serialized `InvokeTask`. See `invoker-api` for its definition
     invoke_task bytea                                                                 NOT NULL
 );

src/db/migrations/2019-02-13-163254_initial/up.sql

@@ -21,14 +21,14 @@ pub trait RunsRepo: std::fmt::Debug + Send + Sync {
     fn run_select(&self, with_run_id: Option<RunId>, limit: Option<u32>) -> Result<Vec<Run>>;
 }
 
-pub trait InvocationRequestsRepo: Send + Sync {
-    fn inv_req_new(&self, inv_req_data: NewInvocationRequest) -> Result<InvocationRequest>;
-    fn inv_req_pop(&self) -> Result<Option<InvocationRequest>>;
+pub trait InvocationsRepo: Send + Sync {
+    fn inv_new(&self, inv_req_data: NewInvocation) -> Result<Invocation>;
+    fn inv_pop(&self) -> Result<Option<Invocation>>;
 }
 
 pub trait UsersRepo: Send + Sync {
     fn user_new(&self, user_data: NewUser) -> Result<User>;
     fn user_try_load_by_login(&self, login: &str) -> Result<Option<User>>;
 }
 
-pub trait Repo: RunsRepo + InvocationRequestsRepo + UsersRepo {}
+pub trait Repo: RunsRepo + InvocationsRepo + UsersRepo {}

src/db/src/repo.rs

@@ -1,4 +1,4 @@
-use super::{InvocationRequestsRepo, Repo, RunsRepo, UsersRepo};
+use super::{InvocationsRepo, Repo, RunsRepo, UsersRepo};
 use crate::schema::*;
 use anyhow::{Context, Result};
 use diesel::{prelude::*, r2d2::ConnectionManager};
@@ -64,39 +64,37 @@ mod impl_users {
     }
 }
 
-mod impl_inv_reqs {
+mod impl_invs {
     use super::*;
-    use crate::schema::invocation_requests::dsl::*;
+    use crate::schema::invocations::dsl::*;
 
-    impl InvocationRequestsRepo for DieselRepo {
-        fn inv_req_new(&self, inv_req_data: NewInvocationRequest) -> Result<InvocationRequest> {
-            diesel::insert_into(invocation_requests)
-                .values(&inv_req_data.to_raw()?)
+    impl InvocationsRepo for DieselRepo {
+        fn inv_new(&self, inv_data: NewInvocation) -> Result<Invocation> {
+            diesel::insert_into(invocations)
+                .values(&inv_data.to_raw()?)
                 .get_result(&self.conn()?)
-                .context("failed to load invocation request")
-                .and_then(|raw| InvocationRequest::from_raw(&raw))
+                .context("failed to load invocation")
+                .and_then(|raw| Invocation::from_raw(&raw))
                 .map_err(Into::into)
         }
 
-        fn inv_req_pop(&self) -> Result<Option<InvocationRequest>> {
+        fn inv_pop(&self) -> Result<Option<Invocation>> {
             let conn = self.conn()?;
             conn.transaction::<_, anyhow::Error, _>(|| {
-                let waiting_submission = invocation_requests
-                    .limit(1)
-                    .load::<RawInvocationRequest>(&conn)?;
-                let waiting_submission = waiting_submission.into_iter().next();
-                match waiting_submission {
+                let invocation = invocations.limit(1).load::<RawInvocation>(&conn)?;
+                let invocation = invocation.into_iter().next();
+                match invocation {
                     Some(s) => {
-                        diesel::delete(invocation_requests)
+                        diesel::delete(invocations)
                             .filter(id.eq(s.id))
                             .execute(&conn)?;
 
-                        Ok(Some(InvocationRequest::from_raw(&s)?))
+                        Ok(Some(Invocation::from_raw(&s)?))
                     }
                     None => Ok(None),
                 }
             })
-            .context("failed to load invocation request")
+            .context("failed to extract invocation")
         }
     }
 }

src/db/src/repo/diesel_pg.rs

@@ -1,4 +1,4 @@
-use super::{InvocationRequestsRepo, Repo, RunsRepo, UsersRepo};
+use super::{InvocationsRepo, Repo, RunsRepo, UsersRepo};
 use crate::schema::*;
 use anyhow::{bail, Result};
 use std::{convert::TryFrom, sync::Mutex};
@@ -7,7 +7,7 @@ use std::{convert::TryFrom, sync::Mutex};
 struct Data {
     // None if run was deleted
     runs: Vec<Option<Run>>,
-    inv_reqs: Vec<InvocationRequest>,
+    invs: Vec<Invocation>,
     users: Vec<User>,
 }
 
@@ -118,21 +118,21 @@ impl RunsRepo for MemoryRepo {
     }
 }
 
-impl InvocationRequestsRepo for MemoryRepo {
-    fn inv_req_new(&self, inv_req_data: NewInvocationRequest) -> Result<InvocationRequest> {
+impl InvocationsRepo for MemoryRepo {
+    fn inv_new(&self, inv_data: NewInvocation) -> Result<Invocation> {
         let mut data = self.conn.lock().unwrap();
-        let inv_req_id = data.inv_reqs.len() as InvocationRequestId;
-        let inv_req = InvocationRequest {
-            id: inv_req_id,
-            invoke_task: inv_req_data.invoke_task,
+        let inv_id = data.invs.len() as InvocationId;
+        let inv = Invocation {
+            id: inv_id,
+            invoke_task: inv_data.invoke_task,
         };
-        data.inv_reqs.push(inv_req.clone());
-        Ok(inv_req)
+        data.invs.push(inv.clone());
+        Ok(inv)
     }
 
-    fn inv_req_pop(&self) -> Result<Option<InvocationRequest>> {
+    fn inv_pop(&self) -> Result<Option<Invocation>> {
         let mut data = self.conn.lock().unwrap();
-        Ok(data.inv_reqs.pop())
+        Ok(data.invs.pop())
     }
 }
 

src/db/src/repo/memory.rs

@@ -2,7 +2,7 @@ use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 
 pub type RunId = i32;
-pub type InvocationRequestId = i32;
+pub type InvocationId = i32;
 pub type UserId = uuid::Uuid;
 pub type ProblemId = String;
 
@@ -42,25 +42,25 @@ pub struct RunPatch {
 }
 
 #[derive(Queryable, Debug, Clone, Serialize, Deserialize)]
-pub(crate) struct RawInvocationRequest {
-    pub(crate) id: InvocationRequestId,
+pub(crate) struct RawInvocation {
+    pub(crate) id: InvocationId,
     pub(crate) invoke_task: Vec<u8>,
 }
 
 #[derive(Insertable)]
-#[table_name = "invocation_requests"]
-pub(crate) struct RawNewInvocationRequest {
+#[table_name = "invocations"]
+pub(crate) struct RawNewInvocation {
     pub(crate) invoke_task: Vec<u8>,
 }
 
 #[derive(Debug, Clone)]
-pub struct InvocationRequest {
-    pub id: InvocationRequestId,
+pub struct Invocation {
+    pub id: InvocationId,
     pub invoke_task: invoker_api::InvokeTask,
 }
 
-impl InvocationRequest {
-    pub(crate) fn from_raw(raw: &RawInvocationRequest) -> Result<Self> {
+impl Invocation {
+    pub(crate) fn from_raw(raw: &RawInvocation) -> Result<Self> {
         Ok(Self {
             id: raw.id,
             invoke_task: bincode::deserialize(&raw.invoke_task)
@@ -69,16 +69,16 @@ impl InvocationRequest {
     }
 }
 
-impl NewInvocationRequest {
-    pub(crate) fn to_raw(&self) -> Result<RawNewInvocationRequest> {
-        Ok(RawNewInvocationRequest {
+impl NewInvocation {
+    pub(crate) fn to_raw(&self) -> Result<RawNewInvocation> {
+        Ok(RawNewInvocation {
             invoke_task: bincode::serialize(&self.invoke_task)
                 .context("failed to serialize InvokeTask")?,
         })
     }
 }
 
-pub struct NewInvocationRequest {
+pub struct NewInvocation {
     pub invoke_task: invoker_api::InvokeTask,
 }
 

src/db/src/schema.rs

@@ -1,7 +1,7 @@
 table! {
     use super::*;
 
-    invocation_requests (id) {
+    invocations (id) {
         id -> Int4,
         invoke_task -> Bytea,
     }
@@ -36,7 +36,7 @@ table! {
 joinable!(runs -> users (user_id));
 
 allow_tables_to_appear_in_same_query!(
-    invocation_requests,
+    invocations,
     runs,
     users,
 );

src/db/src/schema_raw.rs

@@ -207,7 +207,7 @@ pub(super) fn submit_simple(
     problem: schema::ProblemId,
     contest: schema::ContestId,
 ) -> ApiResult<Run> {
-    use db::schema::NewInvocationRequest;
+    use db::schema::NewInvocation;
     let toolchain = ctx.cfg.toolchains.iter().find(|t| t.name == toolchain);
     let toolchain = match toolchain {
         Some(tc) => tc.clone(),
@@ -260,9 +260,9 @@ pub(super) fn submit_simple(
         status_update_callback: get_lsu_webhook_url(ctx, run.id as u32),
     };
 
-    let new_inv_req = NewInvocationRequest { invoke_task };
+    let new_inv = NewInvocation { invoke_task };
 
-    ctx.db.inv_req_new(new_inv_req).internal(ctx)?;
+    ctx.db.inv_new(new_inv).internal(ctx)?;
 
     Ok(describe_run(&run))
 }

src/frontend-engine/src/gql_server/runs.rs

@@ -12,7 +12,7 @@ mod valuer;
 use crate::{invoke_context::MainInvokeContext, invoke_env::InvokeEnv};
 use anyhow::{bail, Context};
 use cfg_if::cfg_if;
-use db::schema::InvocationRequest;
+use db::schema::Invocation;
 use invoker::Invoker;
 use invoker_api::InvokeTask;
 use slog_scope::{debug, error};
@@ -107,9 +107,9 @@ impl Server {
     }
 
     fn try_get_task(&self) -> Option<InvokeTask> {
-        let res: Option<InvocationRequest> = self
+        let res: Option<Invocation> = self
             .db_conn
-            .inv_req_pop() // TODO handle error
+            .inv_pop() // TODO handle error
             .ok()
             .flatten();