refactor: rewrite ops to use ResourceTable2 (#8512)

This commit migrates all ops to use new resource table
and "AsyncRefCell".

Old implementation of resource table was completely 
removed and all code referencing it was updated to use
new system.

1 files changed, 119 insertions, 134 deletions

diff --git a/core/resources.rs b/core/resources.rs
index 753fa9713..da3b634fc 100644
--- a/core/resources.rs
+++ b/core/resources.rs
@@ -1,20 +1,63 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 
-// Think of Resources as File Descriptors. They are integers that are allocated by
-// the privileged side of Deno to refer to various rust objects that need to be
-// referenced between multiple ops. For example, network sockets are resources.
-// Resources may or may not correspond to a real operating system file
-// descriptor (hence the different name).
+// Think of Resources as File Descriptors. They are integers that are allocated
+// by the privileged side of Deno which refer to various rust objects that need
+// to be persisted between various ops. For example, network sockets are
+// resources. Resources may or may not correspond to a real operating system
+// file descriptor (hence the different name).
 
-use crate::resources2::ResourceId;
+use std::any::type_name;
 use std::any::Any;
+use std::any::TypeId;
+use std::borrow::Cow;
 use std::collections::HashMap;
+use std::iter::Iterator;
+use std::rc::Rc;
+
+/// All objects that can be store in the resource table should implement the
+/// `Resource` trait.
+pub trait Resource: Any + 'static {
+  /// Returns a string representation of the resource which is made available
+  /// to JavaScript code through `op_resources`. The default implementation
+  /// returns the Rust type name, but specific resource types may override this
+  /// trait method.
+  fn name(&self) -> Cow<str> {
+    type_name::<Self>().into()
+  }
+
+  /// Resources may implement the `close()` trait method if they need to do
+  /// resource specific clean-ups, such as cancelling pending futures, after a
+  /// resource has been removed from the resource table.
+  fn close(self: Rc<Self>) {}
+}
+
+impl dyn Resource {
+  #[inline(always)]
+  fn is<T: Resource>(&self) -> bool {
+    self.type_id() == TypeId::of::<T>()
+  }
 
-/// These store Deno's file descriptors. These are not necessarily the operating
-/// system ones.
-type ResourceMap = HashMap<ResourceId, (String, Box<dyn Any>)>;
+  #[inline(always)]
+  #[allow(clippy::needless_lifetimes)]
+  pub fn downcast_rc<'a, T: Resource>(self: &'a Rc<Self>) -> Option<&'a Rc<T>> {
+    if self.is::<T>() {
+      let ptr = self as *const Rc<_> as *const Rc<T>;
+      Some(unsafe { &*ptr })
+    } else {
+      None
+    }
+  }
+}
 
-/// Map-like data structure storing Deno's resources (equivalent to file descriptors).
+/// A `ResourceId` is an integer value referencing a resource. It could be
+/// considered to be the Deno equivalent of a `file descriptor` in POSIX like
+/// operating systems. Elsewhere in the code base it is commonly abbreviated
+/// to `rid`.
+// TODO: use `u64` instead?
+pub type ResourceId = u32;
+
+/// Map-like data structure storing Deno's resources (equivalent to file
+/// descriptors).
 ///
 /// Provides basic methods for element access. A resource can be of any type.
 /// Different types of resources can be stored in the same map, and provided
@@ -24,156 +67,98 @@ type ResourceMap = HashMap<ResourceId, (String, Box<dyn Any>)>;
 /// the key in the map.
 #[derive(Default)]
 pub struct ResourceTable {
-  map: ResourceMap,
-  next_id: u32,
+  index: HashMap<ResourceId, Rc<dyn Resource>>,
+  next_rid: ResourceId,
 }
 
 impl ResourceTable {
-  /// Checks if the given resource ID is contained.
-  pub fn has(&self, rid: ResourceId) -> bool {
-    self.map.contains_key(&rid)
-  }
-
-  /// Returns a shared reference to a resource.
+  /// Inserts resource into the resource table, which takes ownership of it.
   ///
-  /// Returns `None`, if `rid` is not stored or has a type different from `T`.
-  pub fn get<T: Any>(&self, rid: ResourceId) -> Option<&T> {
-    let (_, resource) = self.map.get(&rid)?;
-    resource.downcast_ref::<T>()
-  }
-
-  /// Returns a mutable reference to a resource.
+  /// The resource type is erased at runtime and must be statically known
+  /// when retrieving it through `get()`.
   ///
-  /// Returns `None`, if `rid` is not stored or has a type different from `T`.
-  pub fn get_mut<T: Any>(&mut self, rid: ResourceId) -> Option<&mut T> {
-    let (_, resource) = self.map.get_mut(&rid)?;
-    resource.downcast_mut::<T>()
-  }
-
-  // TODO: resource id allocation should probably be randomized for security.
-  fn next_rid(&mut self) -> ResourceId {
-    let next_rid = self.next_id;
-    self.next_id += 1;
-    next_rid as ResourceId
+  /// Returns a unique resource ID, which acts as a key for this resource.
+  pub fn add<T: Resource>(&mut self, resource: T) -> ResourceId {
+    self.add_rc(Rc::new(resource))
   }
 
-  /// Inserts a resource, taking ownership of it.
+  /// Inserts a `Rc`-wrapped resource into the resource table.
   ///
   /// The resource type is erased at runtime and must be statically known
   /// when retrieving it through `get()`.
   ///
   /// Returns a unique resource ID, which acts as a key for this resource.
-  pub fn add(&mut self, name: &str, resource: Box<dyn Any>) -> ResourceId {
-    let rid = self.next_rid();
-    let r = self.map.insert(rid, (name.to_string(), resource));
-    assert!(r.is_none());
+  pub fn add_rc<T: Resource>(&mut self, resource: Rc<T>) -> ResourceId {
+    let resource = resource as Rc<dyn Resource>;
+    let rid = self.next_rid;
+    let removed_resource = self.index.insert(rid, resource);
+    assert!(removed_resource.is_none());
+    self.next_rid += 1;
     rid
   }
 
-  /// Returns a map of resource IDs to names.
-  ///
-  /// The name is the one specified during `add()`. To access resources themselves,
-  /// use the `get()` or `get_mut()` functions.
-  pub fn entries(&self) -> HashMap<ResourceId, String> {
-    self
-      .map
-      .iter()
-      .map(|(key, (name, _resource))| (*key, name.clone()))
-      .collect()
-  }
-
-  // close(2) is done by dropping the value. Therefore we just need to remove
-  // the resource from the resource table.
-  pub fn close(&mut self, rid: ResourceId) -> Option<()> {
-    self.map.remove(&rid).map(|(_name, _resource)| ())
-  }
-
-  /// Removes the resource identified by `rid` and returns it.
-  ///
-  /// When the provided `rid` is stored, the associated resource will be removed.
-  /// Otherwise, nothing happens and `None` is returned.
-  ///
-  /// If the type `T` matches the resource's type, the resource will be returned.
-  /// If the type mismatches, `None` is returned, but the resource is still removed.
-  pub fn remove<T: Any>(&mut self, rid: ResourceId) -> Option<Box<T>> {
-    if let Some((_name, resource)) = self.map.remove(&rid) {
-      let res = match resource.downcast::<T>() {
-        Ok(res) => Some(res),
-        Err(_e) => None,
-      };
-      return res;
-    }
-    None
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  struct FakeResource {
-    not_empty: u128,
-  }
-
-  impl FakeResource {
-    fn new(value: u128) -> FakeResource {
-      FakeResource { not_empty: value }
-    }
+  /// Returns true if any resource with the given `rid` exists.
+  pub fn has(&self, rid: ResourceId) -> bool {
+    self.index.contains_key(&rid)
   }
 
-  #[test]
-  fn test_create_resource_table_default() {
-    let table = ResourceTable::default();
-    assert_eq!(table.map.len(), 0);
+  /// Returns a reference counted pointer to the resource of type `T` with the
+  /// given `rid`. If `rid` is not present or has a type different than `T`,
+  /// this function returns `None`.
+  pub fn get<T: Resource>(&self, rid: ResourceId) -> Option<Rc<T>> {
+    self
+      .index
+      .get(&rid)
+      .and_then(|rc| rc.downcast_rc::<T>())
+      .map(Clone::clone)
   }
 
-  #[test]
-  fn test_add_to_resource_table_not_empty() {
-    let mut table = ResourceTable::default();
-    table.add("fake1", Box::new(FakeResource::new(1)));
-    table.add("fake2", Box::new(FakeResource::new(2)));
-    assert_eq!(table.map.len(), 2);
+  pub fn get_any(&self, rid: ResourceId) -> Option<Rc<dyn Resource>> {
+    self.index.get(&rid).map(Clone::clone)
   }
 
-  #[test]
-  fn test_add_to_resource_table_are_contiguous() {
-    let mut table = ResourceTable::default();
-    let rid1 = table.add("fake1", Box::new(FakeResource::new(1)));
-    let rid2 = table.add("fake2", Box::new(FakeResource::new(2)));
-    assert_eq!(rid1 + 1, rid2);
+  /// Removes a resource of type `T` from the resource table and returns it.
+  /// If a resource with the given `rid` exists but its type does not match `T`,
+  /// it is not removed from the resource table. Note that the resource's
+  /// `close()` method is *not* called.
+  pub fn take<T: Resource>(&mut self, rid: ResourceId) -> Option<Rc<T>> {
+    let resource = self.get::<T>(rid)?;
+    self.index.remove(&rid);
+    Some(resource)
   }
 
-  #[test]
-  fn test_get_from_resource_table_is_what_was_given() {
-    let mut table = ResourceTable::default();
-    let rid = table.add("fake", Box::new(FakeResource::new(7)));
-    let resource = table.get::<FakeResource>(rid);
-    assert_eq!(resource.unwrap().not_empty, 7);
+  /// Removes a resource from the resource table and returns it. Note that the
+  /// resource's `close()` method is *not* called.
+  pub fn take_any(&mut self, rid: ResourceId) -> Option<Rc<dyn Resource>> {
+    self.index.remove(&rid)
   }
 
-  #[test]
-  fn test_remove_from_resource_table() {
-    let mut table = ResourceTable::default();
-    let rid1 = table.add("fake1", Box::new(FakeResource::new(1)));
-    let rid2 = table.add("fake2", Box::new(FakeResource::new(2)));
-    assert_eq!(table.map.len(), 2);
-    table.close(rid1);
-    assert_eq!(table.map.len(), 1);
-    table.close(rid2);
-    assert_eq!(table.map.len(), 0);
+  /// Removes the resource with the given `rid` from the resource table. If the
+  /// only reference to this resource existed in the resource table, this will
+  /// cause the resource to be dropped. However, since resources are reference
+  /// counted, therefore pending ops are not automatically cancelled. A resource
+  /// may implement the `close()` method to perform clean-ups such as canceling
+  /// ops.
+  pub fn close(&mut self, rid: ResourceId) -> Option<()> {
+    self.index.remove(&rid).map(|resource| resource.close())
   }
 
-  #[test]
-  fn test_take_from_resource_table() {
-    let mut table = ResourceTable::default();
-    let rid1 = table.add("fake1", Box::new(FakeResource::new(1)));
-    let rid2 = table.add("fake2", Box::new(FakeResource::new(2)));
-    assert_eq!(table.map.len(), 2);
-    let res1 = table.remove::<FakeResource>(rid1);
-    assert_eq!(table.map.len(), 1);
-    assert!(res1.is_some());
-    let res2 = table.remove::<FakeResource>(rid2);
-    assert_eq!(table.map.len(), 0);
-    assert!(res2.is_some());
+  /// Returns an iterator that yields a `(id, name)` pair for every resource
+  /// that's currently in the resource table. This can be used for debugging
+  /// purposes or to implement the `op_resources` op. Note that the order in
+  /// which items appear is not specified.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// # use deno_core::ResourceTable;
+  /// # let resource_table = ResourceTable::default();
+  /// let resource_names = resource_table.names().collect::<Vec<_>>();
+  /// ```
+  pub fn names(&self) -> impl Iterator<Item = (ResourceId, Cow<str>)> {
+    self
+      .index
+      .iter()
+      .map(|(&id, resource)| (id, resource.name()))
   }
 }