1837 lines · 70.2 KB · Rust
RawDownload
use std::collections::{HashMap, HashSet};use std::sync::mpsc::SyncSender; use chrono::{DateTime, Duration, Utc};use itertools::Itertools;use rand::Rng;use warp_core::features::FeatureFlag;use warp_errors::report_error;use warp_graphql::scalars::time::ServerTimestamp;use warpui::{AppContext, Entity, ModelContext, SingletonEntity}; use super::generic_string_model::GenericStringObjectId;use crate::ai::execution_profiles::CloudAIExecutionProfile;use crate::auth::AuthStateProvider;use crate::cloud_object::{    CloudModelType, CloudObject, CloudObjectLocation, CloudObjectPermissions, GenericCloudObject,    GenericServerObject, GenericStringObjectFormat, JsonObjectType, ObjectIdType, ObjectType,    ObjectsToUpdate, Owner, Revision, RevisionAndLastEditor, ServerCloudObject, ServerCreationInfo,    ServerFolder, ServerMetadata, ServerNotebook, ServerPermissions, ServerWorkflow, Space,};use crate::drive::folders::{CloudFolder, CloudFolderModel};use crate::drive::{    CloudObjectTypeAndId, DriveIndexVariant, should_auto_open_welcome_folder,    write_has_auto_opened_welcome_folder_to_user_defaults,};use crate::env_vars::{CloudEnvVarCollection, CloudEnvVarCollectionModel, EnvVarCollection};use crate::notebooks::CloudNotebook;use crate::persistence::ModelEvent;use crate::server::ids::{ClientId, HashableId, ObjectUid, ServerId, SyncId, ToServerId};use crate::settings::cloud_preferences::{CloudPreference, CloudPreferenceModel};use crate::workflows::workflow::Workflow;use crate::workflows::workflow_enum::{CloudWorkflowEnum, CloudWorkflowEnumModel, WorkflowEnum};use crate::workflows::{CloudWorkflow, CloudWorkflowModel};use crate::workspaces::user_workspaces::UserWorkspaces; // Equivalent to 24 hoursconst MIN_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 1440; // Equivalent to 36 hoursconst MAX_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 2160; #[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum UpdateSource {    /// This cloud model change came from the server (i.e. an RTC message).    Server,    /// This cloud model change originated locally (i.e. from a user edit).    Local,} #[derive(Debug, Clone, PartialEq, Eq)]pub enum CloudModelEvent {    ObjectMoved {        type_and_id: CloudObjectTypeAndId,        source: UpdateSource,        from_folder: Option<SyncId>,        to_folder: Option<SyncId>,    },    ObjectUpdated {        type_and_id: CloudObjectTypeAndId,        source: UpdateSource,    },    ObjectTrashed {        type_and_id: CloudObjectTypeAndId,        source: UpdateSource,    },    ObjectUntrashed {        type_and_id: CloudObjectTypeAndId,        source: UpdateSource,    },    NotebookEditorChangedFromServer {        notebook_id: SyncId,    },    ObjectCreated {        type_and_id: CloudObjectTypeAndId,    },    /// An object was permanently deleted.    ObjectDeleted {        type_and_id: CloudObjectTypeAndId,        /// The parent folder of this object, since it's no longer in the model.        folder_id: Option<SyncId>,    },    /// An object's permissioned were changed.    ObjectPermissionsUpdated {        type_and_id: CloudObjectTypeAndId,        source: UpdateSource,    },    /// An object identified by `id` was force expanded.    ObjectForceExpanded {        id: String,    },    /// A SyncId was converted from ClientId to ServerId after successful object creation on the server.    ObjectSynced {        type_and_id: CloudObjectTypeAndId,        client_id: ClientId,        server_id: ServerId,    },    /// The initial bulk load of cloud objects from the server has completed.    InitialLoadCompleted,    /// Environment last-task timestamps fetched outside the generic cloud-object sync were merged.    EnvironmentLastTaskRunTimestampsUpdated,} enum FolderOpenState {    Open,    Closed,    Reversed,} /// Persistence model for [CloudObject] information. In an ideal world, this singleton model/// is a 1:1 mapping for what we persisting in sqlite, and on the server. Any logic beyond a basic update/// or query to data in [CloudModel] should instead be stored in [CloudViewModel] and tested in/// model_test.rs.pub struct CloudModel {    objects_by_id: HashMap<ObjectUid, Box<dyn CloudObject>>,    model_event_sender: Option<SyncSender<ModelEvent>>,     time_of_next_force_refresh: Option<DateTime<Utc>>,} impl CloudModel {    pub fn new(        model_event_sender: Option<SyncSender<ModelEvent>>,        cached_objects: Vec<Box<dyn CloudObject>>,        time_of_next_force_refresh: Option<DateTime<Utc>>,    ) -> Self {        let objects_by_id = cached_objects            .into_iter()            .map(|object| (object.uid().to_owned(), object))            .collect::<HashMap<ObjectUid, Box<dyn CloudObject>>>();         Self {            objects_by_id,            model_event_sender,            time_of_next_force_refresh,        }    }     /// This method updates the in-memory object after the CreateObject() endpoint returns successfully.    /// It uses the existing client_id to locate the object and then it:    /// (1) Sets the object's server_id    /// (2) Sets the object's creation statistics (creator_uid)    pub fn update_object_after_server_creation(        &mut self,        client_id: ClientId,        server_creation_info: ServerCreationInfo,        ctx: &mut ModelContext<Self>,    ) {        let creator_uid = server_creation_info.creator_uid;        let server_id = server_creation_info.server_id_and_type.id;        let server_permissions = server_creation_info.permissions;         // Use server id for the object going forward.        if let Some((_, mut object)) = self.objects_by_id.remove_entry(&client_id.to_string()) {            object.set_server_id(server_id);            object.metadata_mut().creator_uid = creator_uid;             // Update permissions from server response            let new_permissions = CloudObjectPermissions::new_from_server(server_permissions);            *object.permissions_mut() = new_permissions;             let type_and_id = object.cloud_object_type_and_id();            self.objects_by_id.insert(object.uid(), object);             // Emit CloudModelEvent for SyncId conversion            ctx.emit(CloudModelEvent::ObjectSynced {                type_and_id,                client_id,                server_id,            });             ctx.notify();        }    }     /// Determines whether or not the given object_id can be moved to the given location, based on    /// what we currently support from an API perspective.    ///    /// We do NOT support    /// - Moving folders across spaces    /// - Transferring from team space to personal space    /// - Moving directly into a folder across spaces    pub fn can_move_object_to_location(        &self,        hashed_id: &str,        new_location: CloudObjectLocation,        app: &AppContext,    ) -> bool {        // TODO(ben): Update as sharing+moving is supported in more cases.         if let Some(object) = self.objects_by_id.get(hashed_id) {            let object_space = object.space(app);            if let CloudObjectLocation::Space(space) = new_location {                if matches!(object_space, Space::Team { .. }) && space == Space::Personal {                    return false;                }                 if !object.can_move_to_space(space, app) {                    return false;                }            }             if let CloudObjectLocation::Folder(target_folder_id) = new_location {                let folder_to_move: Option<&CloudFolder> = object.into();                if let Some(folder_to_move) = folder_to_move {                    // We do not want to move a folder into itself.                    if folder_to_move.id == target_folder_id {                        return false;                    }                     // Since we are trying to move a folder into a folder, we want to ensure that the                    // target folder is not a child of the folder we are trying to move.                    let mut target_folder_parent_folder_id = self                        .get_folder(&target_folder_id)                        .and_then(|folder| folder.metadata().folder_id);                    while let Some(parent_id) = target_folder_parent_folder_id {                        if parent_id == folder_to_move.id {                            return false;                        }                        target_folder_parent_folder_id = self                            .get_folder(&parent_id)                            .and_then(|folder| folder.metadata().folder_id);                    }                }                if let Some(target_folder) = self.get_folder(&target_folder_id) {                    // TODO: @ianhodge We do not yet support moving directly into a folder from another space                    if target_folder.permissions.owner != object.permissions().owner {                        return false;                    }                }            }             return true;        }        false    }     /// Given a hashed object-id, returns the object's CloudObjectLocation    /// (either a folder or top level space)    pub fn object_location(        &self,        hashed_id: &str,        app: &AppContext,    ) -> Option<CloudObjectLocation> {        self.objects_by_id            .get(hashed_id)            .map(|object| object.location(self, app))    }     pub fn set_latest_revision_and_editor(        &mut self,        uid: &str,        revision_and_editor: RevisionAndLastEditor,        ctx: &mut ModelContext<Self>,    ) {        if let Some(object) = self.objects_by_id.get_mut(uid) {            object.metadata_mut().revision = Some(revision_and_editor.revision);            object.metadata_mut().last_editor_uid = revision_and_editor.last_editor_uid;        }        ctx.notify();    }     /// Checks if the current object has a conflict and clears the conflict if that conflicts revision    /// is behind the current revision of the object. We need this because occasionally echo'd back updates    /// from RTC will result in a conflict, and we want to clear it once the server response is successful.    ///    /// This must only be called after the server *accepts* an update.    pub fn check_and_maybe_clear_current_conflict(        &mut self,        uid: &str,        ctx: &mut ModelContext<Self>,    ) {        if let Some(object) = self.objects_by_id.get_mut(uid)            && let Some(conflicting_revision) = object.conflicting_object_revision()            && let Some(current_revision) = object.metadata().revision        {            // If the pending conflict is out of date compared to the current revision, clear it.            // If we received the RTC update for an edit before the server response, the            // conflict's revision may be the same as the current revision.            if conflicting_revision <= current_revision {                object.clear_conflict_status();            }        }        ctx.notify();    }     pub fn get_by_uid(&self, uid: &ObjectUid) -> Option<&dyn CloudObject> {        self.objects_by_id.get(uid).map(|o| o.as_ref())    }     pub fn get_mut_by_uid(&mut self, uid: &ObjectUid) -> Option<&mut Box<dyn CloudObject>> {        self.objects_by_id.get_mut(uid)    }     pub fn cloud_objects(&self) -> impl Iterator<Item = &Box<dyn CloudObject>> {        self.objects_by_id.values()    }     pub fn cloud_objects_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn CloudObject>> {        self.objects_by_id.values_mut()    }     pub fn create_object(        &mut self,        id: SyncId,        object: impl CloudObject + 'static,        ctx: &mut ModelContext<CloudModel>,    ) {        ctx.emit(CloudModelEvent::ObjectCreated {            type_and_id: object.cloud_object_type_and_id(),        });        self.create_object_internal(id, object);        ctx.notify();    }     // Does not emit events or notify — used during initial load where    // InitialLoadCompleted is emitted once afterward instead.    fn create_object_internal(&mut self, id: SyncId, object: impl CloudObject + 'static) {        self.objects_by_id.insert(id.uid(), Box::new(object));    }     pub fn delete_objects_by_id(        &mut self,        uids: Vec<ObjectUid>,        ctx: &mut ModelContext<Self>,    ) -> (Vec<(SyncId, ObjectIdType)>, i32) {        let mut count = 0;        let mut sync_ids_and_types: Vec<(SyncId, ObjectIdType)> = Vec::new();        for uid in uids {            if let Some(object) = self.objects_by_id.remove(&uid) {                let cloud_object_type_and_id = object.cloud_object_type_and_id();                sync_ids_and_types.push((                    cloud_object_type_and_id.sync_id(),                    cloud_object_type_and_id.object_id_type(),                ));                 ctx.emit(CloudModelEvent::ObjectDeleted {                    type_and_id: object.cloud_object_type_and_id(),                    folder_id: object.metadata().folder_id,                });                count += 1;            }        }        ctx.notify();        (sync_ids_and_types, count)    }     /// Remove an object and all its descendants from `CloudModel` recursively.    pub fn delete_object_and_descendants(        &mut self,        uid: ObjectUid,        ctx: &mut ModelContext<Self>,    ) -> Vec<(SyncId, ObjectIdType)> {        let mut accumulator = Vec::new();        self.delete_object_and_descendants_internal(uid, &mut accumulator, ctx);        accumulator    }     fn delete_object_and_descendants_internal(        &mut self,        uid: ObjectUid,        accumulator: &mut Vec<(SyncId, ObjectIdType)>,        ctx: &mut ModelContext<Self>,    ) {        if let Some(object) = self.objects_by_id.remove(&uid) {            accumulator.push((                object.sync_id(),                object.cloud_object_type_and_id().object_id_type(),            ));            ctx.emit(CloudModelEvent::ObjectDeleted {                type_and_id: object.cloud_object_type_and_id(),                folder_id: object.metadata().folder_id,            });            if object.object_type() == ObjectType::Folder {                let contents = self                    .objects_by_id                    .iter()                    .filter_map(|(child_uid, child)| {                        if child                            .metadata()                            .folder_id                            .is_some_and(|parent| parent.uid() == uid)                        {                            Some(child_uid.clone())                        } else {                            None                        }                    })                    // Collect into a temporary Vec so that we can can call this mutable method                    // recursively.                    .collect_vec();                for child in contents {                    self.delete_object_and_descendants_internal(child, accumulator, ctx);                }            }        }    }     pub fn check_if_object_is_in_cloudmodel(&mut self, uid: ObjectUid) -> bool {        self.objects_by_id.contains_key(&uid)    }     /// Updates an existing object from a server response. Returns `None` if the object    /// was found and updated, or `Some(id)` if it doesn't exist yet.    /// Does not emit events or notify — callers are responsible for that.    fn update_cloud_object_if_exists<K, M>(        &mut self,        server_object: GenericServerObject<K, M>,    ) -> Option<SyncId>    where        K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static,        M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,    {        let id = server_object.id;        let boxed_option = self.get_mut_by_uid(&id.uid());        if let Some(boxed) = boxed_option {            let object: Option<&mut GenericCloudObject<K, M>> = boxed.into();            if let Some(object) = object {                object.update_from_server_object(server_object);            } else {                log::warn!(                    "Unable to update server object.  Expected object to implement GenericCloudObject"                );                debug_assert!(false, "Unable to update server object.  Failed downcast");            }            None        } else {            Some(id)        }    }     /// Update the in-memory object with an update from the server. If the object has not been    /// seen before a new object is created. Emits events and notifies.    pub fn upsert_from_server_object<K, M>(        &mut self,        server_object: GenericServerObject<K, M>,        ctx: &mut ModelContext<Self>,    ) where        K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static,        M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,    {        let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone());        if let Some(id) = id_if_doesnt_exist {            // If we haven't seen the object before--attempt to insert.            self.create_object(                id,                GenericCloudObject::<K, M>::new_from_server(server_object),                ctx,            );        } else {            // Object existed and was updated — emit ObjectUpdated if no conflict.            let uid = server_object.id.uid();            if let Some(object) = self.get_by_uid(&uid)                && !object.has_conflicting_changes()            {                ctx.emit(CloudModelEvent::ObjectUpdated {                    type_and_id: object.cloud_object_type_and_id(),                    source: UpdateSource::Server,                });            }        }        ctx.notify();    }     // Does not emit events or notify — used during initial load where    // InitialLoadCompleted is emitted once afterward instead.    fn upsert_from_server_object_internal<K, M>(&mut self, server_object: GenericServerObject<K, M>)    where        K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static,        M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,    {        let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone());        if let Some(id) = id_if_doesnt_exist {            self.create_object_internal(                id,                GenericCloudObject::<K, M>::new_from_server(server_object),            );        }    }     /// Update the in-memory notebook with an update from the server. If the object has not been    /// seen before--a new object is created.    pub fn upsert_from_server_notebook(        &mut self,        server_notebook: ServerNotebook,        ctx: &mut ModelContext<Self>,    ) {        self.upsert_from_server_object(server_notebook, ctx);    }     /// Upsert either inserts a new cloud object or updates an existing one. When updating an object,    /// this overwrites all fields that are protected by the revision. For fields protected by the metadata ts,    /// see update_object_metadata().    pub fn upsert_from_server_cloud_object(        &mut self,        server_cloud_object: ServerCloudObject,        ctx: &mut ModelContext<Self>,    ) {        match server_cloud_object {            ServerCloudObject::Notebook(notebook) => {                self.upsert_from_server_notebook(notebook, ctx);

Lines 1–500 of 1837.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t