language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-09-26 12:19:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor: update deno_core for error refactor (#26867)

Browse source 
Closes #26171

---------

Co-authored-by: David Sherret <dsherret@gmail.com>
This commit is contained in:
Leo Kettmeir 2025-01-08 14:52:32 -08:00 • committed by GitHub
parent 814da49dff
commit ea30e188a8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
214 changed files with 3787 additions and 4210 deletions
Download patch file Download diff file Expand all files Collapse all files

52
ext/net/raw.rs
View file

@ -1,15 +1,15 @@
// Copyright 2018-2025 the Deno authors. MIT license.
use std::borrow::Cow;
use std::rc::Rc;
use deno_core::error::bad_resource_id;
use deno_core::error::custom_error;
use deno_core::error::AnyError;
use deno_core::error::ResourceError;
use deno_core::AsyncRefCell;
use deno_core::CancelHandle;
use deno_core::Resource;
use deno_core::ResourceId;
use deno_core::ResourceTable;
use deno_error::JsErrorBox;
use crate::io::TcpStreamResource;
use crate::ops_tls::TlsStreamResource;
@ -69,10 +69,10 @@ impl<T: NetworkStreamListenerTrait + 'static> NetworkListenerResource<T> {
fn take(
resource_table: &mut ResourceTable,
listener_rid: ResourceId,
) -> Result<Option<NetworkStreamListener>, AnyError> {
) -> Result<Option<NetworkStreamListener>, JsErrorBox> {
if let Ok(resource_rc) = resource_table.take::<Self>(listener_rid) {
let resource = Rc::try_unwrap(resource_rc)
.map_err(|_| custom_error("Busy", "Listener is currently in use"))?;
.map_err(|_| JsErrorBox::new("Busy", "Listener is currently in use"))?;
return Ok(Some(resource.listener.into_inner().into()));
}
Ok(None)
@ -243,13 +243,13 @@ macro_rules! network_stream {
/// Return a `NetworkStreamListener` if a resource exists for this `ResourceId` and it is currently
/// not locked.
pub fn take_resource(resource_table: &mut ResourceTable, listener_rid: ResourceId) -> Result<NetworkStreamListener, AnyError> {
pub fn take_resource(resource_table: &mut ResourceTable, listener_rid: ResourceId) -> Result<NetworkStreamListener, JsErrorBox> {
$(
if let Some(resource) = NetworkListenerResource::<$listener>::take(resource_table, listener_rid)? {
return Ok(resource)
}
)*
Err(bad_resource_id())
Err(JsErrorBox::from_err(ResourceError::BadResourceId))
}
}
};
@ -322,12 +322,36 @@ impl From<tokio::net::unix::SocketAddr> for NetworkStreamAddress {
}
}
#[derive(Debug, thiserror::Error, deno_error::JsError)]
pub enum TakeNetworkStreamError {
#[class("Busy")]
#[error("TCP stream is currently in use")]
TcpBusy,
#[class("Busy")]
#[error("TLS stream is currently in use")]
TlsBusy,
#[cfg(unix)]
#[class("Busy")]
#[error("Unix socket is currently in use")]
UnixBusy,
#[class(generic)]
#[error(transparent)]
ReuniteTcp(#[from] tokio::net::tcp::ReuniteError),
#[cfg(unix)]
#[class(generic)]
#[error(transparent)]
ReuniteUnix(#[from] tokio::net::unix::ReuniteError),
#[class(inherit)]
#[error(transparent)]
Resource(deno_core::error::ResourceError),
}
/// In some cases it may be more efficient to extract the resource from the resource table and use it directly (for example, an HTTP server).
/// This method will extract a stream from the resource table and return it, unwrapped.
pub fn take_network_stream_resource(
resource_table: &mut ResourceTable,
stream_rid: ResourceId,
) -> Result<NetworkStream, AnyError> {
) -> Result<NetworkStream, TakeNetworkStreamError> {
// The stream we're attempting to unwrap may be in use somewhere else. If that's the case, we cannot proceed
// with the process of unwrapping this connection, so we just return a bad resource error.
// See also: https://github.com/denoland/deno/pull/16242
@ -336,7 +360,7 @@ pub fn take_network_stream_resource(
{
// This TCP connection might be used somewhere else.
let resource = Rc::try_unwrap(resource_rc)
.map_err(|_| custom_error("Busy", "TCP stream is currently in use"))?;
.map_err(|_| TakeNetworkStreamError::TcpBusy)?;
let (read_half, write_half) = resource.into_inner();
let tcp_stream = read_half.reunite(write_half)?;
return Ok(NetworkStream::Tcp(tcp_stream));
@ -346,7 +370,7 @@ pub fn take_network_stream_resource(
{
// This TLS connection might be used somewhere else.
let resource = Rc::try_unwrap(resource_rc)
.map_err(|_| custom_error("Busy", "TLS stream is currently in use"))?;
.map_err(|_| TakeNetworkStreamError::TlsBusy)?;
let (read_half, write_half) = resource.into_inner();
let tls_stream = read_half.unsplit(write_half);
return Ok(NetworkStream::Tls(tls_stream));
@ -358,13 +382,15 @@ pub fn take_network_stream_resource(
{
// This UNIX socket might be used somewhere else.
let resource = Rc::try_unwrap(resource_rc)
.map_err(|_| custom_error("Busy", "Unix socket is currently in use"))?;
.map_err(|_| TakeNetworkStreamError::UnixBusy)?;
let (read_half, write_half) = resource.into_inner();
let unix_stream = read_half.reunite(write_half)?;
return Ok(NetworkStream::Unix(unix_stream));
}
Err(bad_resource_id())
Err(TakeNetworkStreamError::Resource(
ResourceError::BadResourceId,
))
}
/// In some cases it may be more efficient to extract the resource from the resource table and use it directly (for example, an HTTP server).
@ -372,6 +398,6 @@ pub fn take_network_stream_resource(
pub fn take_network_stream_listener_resource(
resource_table: &mut ResourceTable,
listener_rid: ResourceId,
) -> Result<NetworkStreamListener, AnyError> {
) -> Result<NetworkStreamListener, JsErrorBox> {
NetworkStreamListener::take_resource(resource_table, listener_rid)
}