Merge fa2a41ef27 into e4a16e91fa

cli/tools/installer.rs

@@ -115,16 +115,10 @@ exec deno {} "$@"
   Ok(())
 }
 
-fn get_installer_root() -> Result<PathBuf, AnyError> {
-  if let Some(env_dir) = env::var_os("DENO_INSTALL_ROOT") {
+fn get_installer_root() -> Result<PathBuf, io::Error> {
+  if let Ok(env_dir) = env::var("DENO_INSTALL_ROOT") {
     if !env_dir.is_empty() {
-      let env_dir = PathBuf::from(env_dir);
-      return canonicalize_path_maybe_not_exists(&env_dir).with_context(|| {
-        format!(
-          "Canonicalizing DENO_INSTALL_ROOT ('{}').",
-          env_dir.display()
-        )
-      });
+      return canonicalize_path_maybe_not_exists(&PathBuf::from(env_dir));
     }
   }
   // Note: on Windows, the $HOME environment variable may be set by users or by
@@ -593,22 +587,11 @@ async fn resolve_shim_data(
     let copy_path = get_hidden_file_with_ext(&file_path, "deno.json");
     executable_args.push("--config".to_string());
     executable_args.push(copy_path.to_str().unwrap().to_string());
-    let mut config_text = fs::read_to_string(config_path)
-      .with_context(|| format!("error reading {config_path}"))?;
-    // always remove the import map field because when someone specifies `--import-map` we
-    // don't want that file to be attempted to be loaded and when they don't specify that
-    // (which is just something we haven't implemented yet)
-    if let Some(new_text) = remove_import_map_field_from_text(&config_text) {
-      if flags.import_map_path.is_none() {
-        log::warn!(
-          "{} \"importMap\" field in the specified config file we be ignored. Use the --import-map flag instead.",
-          crate::colors::yellow("Warning"),
-        );
-      }
-      config_text = new_text;
-    }
-
-    extra_files.push((copy_path, config_text));
+    extra_files.push((
+      copy_path,
+      fs::read_to_string(config_path)
+        .with_context(|| format!("error reading {config_path}"))?,
+    ));
   } else {
     executable_args.push("--no-config".to_string());
   }
@@ -648,16 +631,6 @@ async fn resolve_shim_data(
   })
 }
 
-fn remove_import_map_field_from_text(config_text: &str) -> Option<String> {
-  let value =
-    jsonc_parser::cst::CstRootNode::parse(config_text, &Default::default())
-      .ok()?;
-  let root_value = value.object_value()?;
-  let import_map_value = root_value.get("importMap")?;
-  import_map_value.remove();
-  Some(value.to_string())
-}
-
 fn get_hidden_file_with_ext(file_path: &Path, ext: &str) -> PathBuf {
   // use a dot file to prevent the file from showing up in some
   // users shell auto-complete since this directory is on the PATH
@@ -1612,17 +1585,4 @@ mod tests {
       assert!(!file_path.exists());
     }
   }
-
-  #[test]
-  fn test_remove_import_map_field_from_text() {
-    assert_eq!(
-      remove_import_map_field_from_text(
-        r#"{
-    "importMap": "./value.json"
-}"#,
-      )
-      .unwrap(),
-      "{}"
-    );
-  }
 }

ext/node/lib.rs

@@ -226,6 +226,7 @@ deno_core::extension!(deno_node,
     ops::crypto::op_node_decipheriv_decrypt,
     ops::crypto::op_node_decipheriv_final,
     ops::crypto::op_node_decipheriv_set_aad,
+    ops::crypto::op_node_decipheriv_take,
     ops::crypto::op_node_dh_compute_secret,
     ops::crypto::op_node_diffie_hellman,
     ops::crypto::op_node_ecdh_compute_public_key,

ext/node/ops/crypto/cipher.rs

@@ -500,11 +500,6 @@ impl Decipher {
     auth_tag: &[u8],
   ) -> Result<(), DecipherError> {
     use Decipher::*;
-
-    if input.is_empty() && !matches!(self, Aes128Gcm(_) | Aes256Gcm(_)) {
-      return Ok(());
-    }
-
     match (self, auto_pad) {
       (Aes128Cbc(decryptor), true) => {
         assert!(input.len() == 16);

ext/node/ops/crypto/mod.rs

@@ -332,6 +332,17 @@ pub fn op_node_decipheriv_decrypt(
   true
 }
 
+#[op2(fast)]
+pub fn op_node_decipheriv_take(
+  state: &mut OpState,
+  #[smi] rid: u32,
+) -> Result<(), cipher::DecipherContextError> {
+  let context = state.resource_table.take::<cipher::DecipherContext>(rid)?;
+  Rc::try_unwrap(context)
+    .map_err(|_| cipher::DecipherContextError::ContextInUse)?;
+  Ok(())
+}
+
 #[op2]
 pub fn op_node_decipheriv_final(
   state: &mut OpState,

ext/node/polyfills/internal/crypto/cipher.ts

@@ -18,6 +18,7 @@ import {
   op_node_decipheriv_decrypt,
   op_node_decipheriv_final,
   op_node_decipheriv_set_aad,
+  op_node_decipheriv_take,
   op_node_private_decrypt,
   op_node_private_encrypt,
   op_node_public_encrypt,
@@ -351,6 +352,14 @@ export class Decipheriv extends Transform implements Cipher {
   }
 
   final(encoding: string = getDefaultEncoding()): Buffer | string {
+    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
+      op_node_decipheriv_take(this.#context);
+      return encoding === "buffer" ? Buffer.from([]) : "";
+    }
+    if (this.#cache.cache.byteLength != 16) {
+      throw new Error("Invalid final block size");
+    }
+
     let buf = new Buffer(16);
     op_node_decipheriv_final(
       this.#context,
@@ -360,13 +369,6 @@ export class Decipheriv extends Transform implements Cipher {
       this.#authTag || NO_TAG,
     );
 
-    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
-      return encoding === "buffer" ? Buffer.from([]) : "";
-    }
-    if (this.#cache.cache.byteLength != 16) {
-      throw new Error("Invalid final block size");
-    }
-
     buf = buf.subarray(0, 16 - buf.at(-1)); // Padded in Pkcs7 mode
     return encoding === "buffer" ? buf : buf.toString(encoding);
   }

ext/os/lib.rs

@@ -116,12 +116,6 @@ deno_core::extension!(
     "op_exit" | "op_set_exit_code" | "op_get_exit_code" =>
       op.with_implementation_from(&deno_core::op_void_sync()),
     _ => op,
-  },
-  state = |state| {
-    #[cfg(unix)]
-    {
-      state.put(ops::signal::SignalState::default());
-    }
   }
 );
 

ext/telemetry/lib.rs

@@ -42,7 +42,6 @@ use opentelemetry::metrics::InstrumentBuilder;
 use opentelemetry::metrics::MeterProvider as _;
 use opentelemetry::otel_debug;
 use opentelemetry::otel_error;
-use opentelemetry::trace::Link;
 use opentelemetry::trace::SpanContext;
 use opentelemetry::trace::SpanId;
 use opentelemetry::trace::SpanKind;
@@ -95,7 +94,6 @@ deno_core::extension!(
     op_otel_span_attribute1,
     op_otel_span_attribute2,
     op_otel_span_attribute3,
-    op_otel_span_add_link,
     op_otel_span_update_name,
     op_otel_metric_attribute3,
     op_otel_metric_record0,
@@ -1326,6 +1324,17 @@ impl OtelSpan {
     }
   }
 
+  #[fast]
+  fn drop_link(&self) {
+    let mut state = self.0.borrow_mut();
+    match &mut **state {
+      OtelSpanState::Recording(span) => {
+        span.links.dropped_count += 1;
+      }
+      OtelSpanState::Done(_) => {}
+    }
+  }
+
   #[fast]
   fn end(&self, end_time: f64) {
     let end_time = if end_time.is_nan() {
@@ -1439,48 +1448,6 @@ fn op_otel_span_update_name<'s>(
   }
 }
 
-#[op2(fast)]
-fn op_otel_span_add_link<'s>(
-  scope: &mut v8::HandleScope<'s>,
-  span: v8::Local<'s, v8::Value>,
-  trace_id: v8::Local<'s, v8::Value>,
-  span_id: v8::Local<'s, v8::Value>,
-  #[smi] trace_flags: u8,
-  is_remote: bool,
-  #[smi] dropped_attributes_count: u32,
-) -> bool {
-  let trace_id = parse_trace_id(scope, trace_id);
-  if trace_id == TraceId::INVALID {
-    return false;
-  };
-  let span_id = parse_span_id(scope, span_id);
-  if span_id == SpanId::INVALID {
-    return false;
-  };
-  let span_context = SpanContext::new(
-    trace_id,
-    span_id,
-    TraceFlags::new(trace_flags),
-    is_remote,
-    TraceState::NONE,
-  );
-
-  let Some(span) =
-    deno_core::_ops::try_unwrap_cppgc_object::<OtelSpan>(scope, span)
-  else {
-    return true;
-  };
-  let mut state = span.0.borrow_mut();
-  if let OtelSpanState::Recording(span) = &mut **state {
-    span.links.links.push(Link::new(
-      span_context,
-      vec![],
-      dropped_attributes_count,
-    ));
-  }
-  true
-}
-
 struct OtelMeter(opentelemetry::metrics::Meter);
 
 impl deno_core::GarbageCollected for OtelMeter {}

ext/telemetry/telemetry.ts

@@ -15,7 +15,6 @@ import {
   op_otel_metric_record2,
   op_otel_metric_record3,
   op_otel_metric_wait_to_observe,
-  op_otel_span_add_link,
   op_otel_span_attribute1,
   op_otel_span_attribute2,
   op_otel_span_attribute3,
@@ -187,6 +186,7 @@ interface OtelSpan {
   spanContext(): SpanContext;
   setStatus(status: SpanStatusCode, errorDescription: string): void;
   dropEvent(): void;
+  dropLink(): void;
   end(endTime: number): void;
 }
 
@@ -359,24 +359,14 @@ class Span {
     return this;
   }
 
-  addLink(link: Link): Span {
-    const droppedAttributeCount = (link.droppedAttributesCount ?? 0) +
-      (link.attributes ? ObjectKeys(link.attributes).length : 0);
-    const valid = op_otel_span_add_link(
-      this.#otelSpan,
-      link.context.traceId,
-      link.context.spanId,
-      link.context.traceFlags,
-      link.context.isRemote ?? false,
-      droppedAttributeCount,
-    );
-    if (!valid) return this;
+  addLink(_link: Link): Span {
+    this.#otelSpan?.dropLink();
     return this;
   }
 
   addLinks(links: Link[]): Span {
     for (let i = 0; i < links.length; i++) {
-      this.addLink(links[i]);
+      this.#otelSpan?.dropLink();
     }
     return this;
   }

tests/specs/cli/otel_basic/__test__.jsonc

@@ -22,10 +22,6 @@
       },
       "args": "run -A main.ts metric.ts",
       "output": "metric.out"
-    },
-    "links": {
-      "args": "run -A main.ts links.ts",
-      "output": "links.out"
     }
   }
 }

tests/specs/cli/otel_basic/links.out

@@ -1,96 +0,0 @@
-{
-  "spans": [
-    {
-      "traceId": "00000000000000000000000000000001",
-      "spanId": "0000000000000001",
-      "traceState": "",
-      "parentSpanId": "",
-      "flags": 1,
-      "name": "example span",
-      "kind": 1,
-      "startTimeUnixNano": "[WILDCARD]",
-      "endTimeUnixNano": "[WILDCARD]",
-      "attributes": [],
-      "droppedAttributesCount": 0,
-      "events": [],
-      "droppedEventsCount": 0,
-      "links": [
-        {
-          "traceId": "1234567890abcdef1234567890abcdef",
-          "spanId": "1234567890abcdef",
-          "traceState": "",
-          "attributes": [],
-          "droppedAttributesCount": 0,
-          "flags": 1
-        }
-      ],
-      "droppedLinksCount": 0,
-      "status": {
-        "message": "",
-        "code": 0
-      }
-    },
-    {
-      "traceId": "00000000000000000000000000000002",
-      "spanId": "0000000000000002",
-      "traceState": "",
-      "parentSpanId": "",
-      "flags": 1,
-      "name": "example span",
-      "kind": 1,
-      "startTimeUnixNano": "[WILDCARD]",
-      "endTimeUnixNano": "[WILDCARD]",
-      "attributes": [],
-      "droppedAttributesCount": 0,
-      "events": [],
-      "droppedEventsCount": 0,
-      "links": [
-        {
-          "traceId": "1234567890abcdef1234567890abcdef",
-          "spanId": "1234567890abcdef",
-          "traceState": "",
-          "attributes": [],
-          "droppedAttributesCount": 0,
-          "flags": 1
-        }
-      ],
-      "droppedLinksCount": 0,
-      "status": {
-        "message": "",
-        "code": 0
-      }
-    },
-    {
-      "traceId": "00000000000000000000000000000003",
-      "spanId": "0000000000000003",
-      "traceState": "",
-      "parentSpanId": "",
-      "flags": 1,
-      "name": "example span",
-      "kind": 1,
-      "startTimeUnixNano": "[WILDCARD]",
-      "endTimeUnixNano": "[WILDCARD]",
-      "attributes": [],
-      "droppedAttributesCount": 0,
-      "events": [],
-      "droppedEventsCount": 0,
-      "links": [
-        {
-          "traceId": "1234567890abcdef1234567890abcdef",
-          "spanId": "1234567890abcdef",
-          "traceState": "",
-          "attributes": [],
-          "droppedAttributesCount": 2,
-          "flags": 1
-        }
-      ],
-      "droppedLinksCount": 0,
-      "status": {
-        "message": "",
-        "code": 0
-      }
-    }
-  ],
-  "logs": [],
-  "metrics": []
-}

tests/specs/cli/otel_basic/links.ts

@@ -1,40 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-import { trace } from "npm:@opentelemetry/api@1.9.0";
-
-const tracer = trace.getTracer("example-tracer");
-
-const span1 = tracer.startSpan("example span", {
-  links: [{
-    context: {
-      traceId: "1234567890abcdef1234567890abcdef",
-      spanId: "1234567890abcdef",
-      traceFlags: 1,
-    },
-  }],
-});
-span1.end();
-
-const span2 = tracer.startSpan("example span");
-span2.addLink({
-  context: {
-    traceId: "1234567890abcdef1234567890abcdef",
-    spanId: "1234567890abcdef",
-    traceFlags: 1,
-  },
-});
-span2.end();
-
-const span3 = tracer.startSpan("example span");
-span3.addLink({
-  context: {
-    traceId: "1234567890abcdef1234567890abcdef",
-    spanId: "1234567890abcdef",
-    traceFlags: 1,
-  },
-  attributes: {
-    key: "value",
-  },
-  droppedAttributesCount: 1,
-});
-span3.end();

tests/specs/install/global/config_file_import_map/__test__.jsonc

@@ -1,5 +0,0 @@
-{
-  "tempDir": true,
-  "args": "install -g --root ./folder --config deno.json main.ts --name my-cli",
-  "output": "install.out"
-}

tests/specs/install/global/config_file_import_map/deno.json

@@ -1,3 +0,0 @@
-{
-  "importMap": "./import_map.json"
-}

tests/specs/install/global/config_file_import_map/import_map.json

@@ -1,2 +0,0 @@
-{
-}

tests/specs/install/global/config_file_import_map/install.out

@@ -1,3 +0,0 @@
-Warning "importMap" field in the specified config file we be ignored. Use the --import-map flag instead.
-✅ Successfully installed my-cli
-[WILDCARD]

tests/specs/install/global/config_file_import_map/main.ts

@@ -1 +0,0 @@
-console.log(1);

tests/unit_node/crypto/crypto_cipher_gcm_test.ts

@@ -4,7 +4,7 @@ import crypto from "node:crypto";
 import { Buffer } from "node:buffer";
 import testVectors128 from "./gcmEncryptExtIV128.json" with { type: "json" };
 import testVectors256 from "./gcmEncryptExtIV256.json" with { type: "json" };
-import { assertEquals, assertThrows } from "@std/assert";
+import { assertEquals } from "@std/assert";
 
 const aesGcm = (bits: string, key: Uint8Array) => {
   const ALGO = bits == "128" ? `aes-128-gcm` : `aes-256-gcm`;
@@ -123,7 +123,7 @@ Deno.test({
 // Issue #27441
 // https://github.com/denoland/deno/issues/27441
 Deno.test({
-  name: "aes-256-gcm supports IV of non standard length and auth tag check",
+  name: "aes-256-gcm supports IV of non standard length",
   fn() {
     const decipher = crypto.createDecipheriv(
       "aes-256-gcm",
@@ -136,10 +136,6 @@ Deno.test({
       "utf-8",
     );
     assertEquals(decrypted, "this is a secret");
-    assertThrows(
-      () => decipher.final(),
-      TypeError,
-      "Failed to authenticate data",
-    );
+    decipher.final();
   },
 });