@yume-chan/adb 0.0.18 → 0.0.20

package/src/commands/sync/push.ts

@@ -1,52 +1,171 @@
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
 import {
-    ChunkStream,
-    WritableStream,
-    pipeFrom,
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
+    AbortController,
+    ConsumableWritableStream,
+    DistributionStream,
 } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import Struct, { placeholder } from "@yume-chan/struct";
+
+import { NOOP } from "../../utils/index.js";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import type { AdbSyncSocket, AdbSyncSocketLocked } from "./socket.js";
 import { LinuxFileType } from "./stat.js";
 
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+
+export interface AdbSyncPushV1Options {
+    socket: AdbSyncSocket;
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    type?: LinuxFileType;
+    permission?: number;
+    mtime?: number;
+    packetSize?: number;
+}
+
 export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
     "unused"
 );
 
-export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+async function pipeFileData(
+    locked: AdbSyncSocketLocked,
+    file: ReadableStream<Consumable<Uint8Array>>,
+    packetSize: number,
+    mtime: number
+) {
+    // Read and write in parallel,
+    // allow error response to abort the write.
+    const abortController = new AbortController();
+    file.pipeThrough(new DistributionStream(packetSize, true))
+        .pipeTo(
+            new ConsumableWritableStream({
+                write: async (chunk) => {
+                    await adbSyncWriteRequest(
+                        locked,
+                        AdbSyncRequestId.Data,
+                        chunk
+                    );
+                },
+            }),
+            { signal: abortController.signal }
+        )
+        .then(async () => {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
+            await locked.flush();
+        }, NOOP);
+
+    await adbSyncReadResponse(
+        locked,
+        AdbSyncResponseId.Ok,
+        AdbSyncOkResponse
+    ).catch((e) => {
+        abortController.abort();
+        throw e;
+    });
+}
+
+export async function adbSyncPushV1({
+    socket,
+    filename,
+    file,
+    type = LinuxFileType.File,
+    permission = 0o666,
+    mtime = (Date.now() / 1000) | 0,
+    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
+}: AdbSyncPushV1Options) {
+    const locked = await socket.lock();
+    try {
+        const mode = (type << 12) | permission;
+        const pathAndMode = `${filename},${mode.toString()}`;
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Send, pathAndMode);
+        await pipeFileData(locked, file, packetSize, mtime);
+    } finally {
+        locked.release();
+    }
+}
+
+export enum AdbSyncSendV2Flags {
+    None = 0,
+    Brotli = 1,
+    /**
+     * 2
+     */
+    Lz4 = 1 << 1,
+    /**
+     * 4
+     */
+    Zstd = 1 << 2,
+    /**
+     * 0x80000000
+     */
+    DryRun = (1 << 31) >>> 0,
+}
+
+export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
+    /**
+     * Don't write the file to disk. Requires the `sendrecv_v2` feature.
+     *
+     * It was used during ADB development to benchmark the performance of
+     * compression algorithms.
+     */
+    dryRun?: boolean;
+}
+
+export const AdbSyncSendV2Request = new Struct({ littleEndian: true })
+    .uint32("id", placeholder<AdbSyncRequestId>())
+    .uint32("mode")
+    .uint32("flags", placeholder<AdbSyncSendV2Flags>());
+
+export async function adbSyncPushV2({
+    socket,
+    filename,
+    file,
+    type = LinuxFileType.File,
+    permission = 0o666,
+    mtime = (Date.now() / 1000) | 0,
+    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
+    dryRun = false,
+}: AdbSyncPushV2Options) {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.SendV2, filename);
+
+        const mode = (type << 12) | permission;
+        let flags: AdbSyncSendV2Flags = AdbSyncSendV2Flags.None;
+        if (dryRun) {
+            flags |= AdbSyncSendV2Flags.DryRun;
+        }
+        await locked.write(
+            AdbSyncSendV2Request.serialize({
+                id: AdbSyncRequestId.SendV2,
+                mode,
+                flags,
+            })
+        );
+
+        await pipeFileData(locked, file, packetSize, mtime);
+    } finally {
+        locked.release();
+    }
+}
+
+export interface AdbSyncPushOptions extends AdbSyncPushV2Options {
+    /**
+     * Whether to use the v2 protocol. Requires the `sendrecv_v2` feature.
+     */
+    v2: boolean;
+}
+
+export function adbSyncPush(options: AdbSyncPushOptions) {
+    if (options.v2) {
+        return adbSyncPushV2(options);
+    }
+
+    if (options.dryRun) {
+        throw new Error("dryRun is not supported in v1");
+    }
 
-export function adbSyncPush(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    filename: string,
-    mode: number = (LinuxFileType.File << 12) | 0o666,
-    mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE
-): WritableStream<Uint8Array> {
-    return pipeFrom(
-        new WritableStream<Uint8Array>({
-            async start() {
-                const pathAndMode = `${filename},${mode.toString()}`;
-                await adbSyncWriteRequest(
-                    writer,
-                    AdbSyncRequestId.Send,
-                    pathAndMode
-                );
-            },
-            async write(chunk) {
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
-            },
-            async close() {
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
-                await adbSyncReadResponse(
-                    stream,
-                    AdbSyncResponseId.Ok,
-                    AdbSyncOkResponse
-                );
-            },
-        }),
-        new ChunkStream(packetSize)
-    );
+    return adbSyncPushV1(options);
 }

package/src/commands/sync/request.ts

@@ -1,15 +1,15 @@
-import { type WritableStreamDefaultWriter } from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
     List = "LIST",
-    List2 = "LIS2",
+    ListV2 = "LIS2",
     Send = "SEND",
+    SendV2 = "SND2",
     Lstat = "STAT",
     Stat = "STA2",
-    Lstat2 = "LST2",
+    LstatV2 = "LST2",
     Data = "DATA",
     Done = "DONE",
     Receive = "RECV",
@@ -20,30 +20,35 @@ export const AdbSyncNumberRequest = new Struct({ littleEndian: true })
     .uint32("arg");
 
 export const AdbSyncDataRequest = new Struct({ littleEndian: true })
-    .fields(AdbSyncNumberRequest)
+    .concat(AdbSyncNumberRequest)
     .uint8Array("data", { lengthField: "arg" });
 
+export interface AdbSyncWritable {
+    write(buffer: Uint8Array): Promise<void>;
+}
+
 export async function adbSyncWriteRequest(
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    writable: AdbSyncWritable,
     id: AdbSyncRequestId | string,
     value: number | string | Uint8Array
 ): Promise<void> {
-    let buffer: Uint8Array;
     if (typeof value === "number") {
-        buffer = AdbSyncNumberRequest.serialize({
+        const buffer = AdbSyncNumberRequest.serialize({
             id,
             arg: value,
         });
+        await writable.write(buffer);
     } else if (typeof value === "string") {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: encodeUtf8(value),
-        });
+        // Let `writable` buffer writes
+        const buffer = encodeUtf8(value);
+        await writable.write(
+            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength })
+        );
+        await writable.write(buffer);
     } else {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: value,
-        });
+        await writable.write(
+            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength })
+        );
+        await writable.write(value);
     }
-    await writer.write(buffer);
 }

package/src/commands/sync/response.ts

@@ -1,8 +1,9 @@
-import { type BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct, {
-    type StructLike,
-    type StructValueType,
+import type {
+    AsyncExactReadable,
+    StructLike,
+    StructValueType,
 } from "@yume-chan/struct";
+import Struct from "@yume-chan/struct";
 
 import { decodeUtf8 } from "../../utils/index.js";
 
@@ -26,11 +27,11 @@ export const AdbSyncFailResponse = new Struct({ littleEndian: true })
     });
 
 export async function adbSyncReadResponse<T>(
-    stream: BufferedReadableStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
     type: StructLike<T>
 ): Promise<T> {
-    const actualId = decodeUtf8(await stream.read(4));
+    const actualId = decodeUtf8(await stream.readExactly(4));
     switch (actualId) {
         case AdbSyncResponseId.Fail:
             await AdbSyncFailResponse.deserialize(stream);
@@ -45,12 +46,12 @@ export async function adbSyncReadResponse<T>(
 export async function* adbSyncReadResponses<
     T extends Struct<object, PropertyKey, object, any>
 >(
-    stream: BufferedReadableStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
     type: T
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
-        const actualId = decodeUtf8(await stream.read(4));
+        const actualId = decodeUtf8(await stream.readExactly(4));
         switch (actualId) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
@@ -60,7 +61,7 @@ export async function* adbSyncReadResponses<
                 //
                 // For example, `DONE` responses for `LIST` requests are 16 bytes (same as `DENT` responses),
                 // but `DONE` responses for `STAT` requests are 12 bytes (same as `STAT` responses).
-                await stream.read(type.size);
+                await stream.readExactly(type.size);
                 return;
             case id:
                 yield await type.deserialize(stream);

package/src/commands/sync/socket.ts

@@ -0,0 +1,99 @@
+import type {
+    Consumable,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    BufferCombiner,
+    BufferedReadableStream,
+    ConsumableWritableStream,
+} from "@yume-chan/stream-extra";
+import type { AsyncExactReadable } from "@yume-chan/struct";
+
+import type { AdbSocket } from "../../adb.js";
+import { AutoResetEvent } from "../../utils/index.js";
+
+export class AdbSyncSocketLocked implements AsyncExactReadable {
+    readonly #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    readonly #readable: BufferedReadableStream;
+    readonly #socketLock: AutoResetEvent;
+    readonly #writeLock = new AutoResetEvent();
+    readonly #combiner: BufferCombiner;
+
+    public get position() {
+        return this.#readable.position;
+    }
+
+    public constructor(
+        writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
+        readable: BufferedReadableStream,
+        bufferSize: number,
+        lock: AutoResetEvent
+    ) {
+        this.#writer = writer;
+        this.#readable = readable;
+        this.#socketLock = lock;
+        this.#combiner = new BufferCombiner(bufferSize);
+    }
+
+    private async writeInnerStream(buffer: Uint8Array) {
+        await ConsumableWritableStream.write(this.#writer, buffer);
+    }
+
+    public async flush() {
+        try {
+            await this.#writeLock.wait();
+            const buffer = this.#combiner.flush();
+            if (buffer) {
+                await this.writeInnerStream(buffer);
+            }
+        } finally {
+            this.#writeLock.notifyOne();
+        }
+    }
+
+    public async write(data: Uint8Array) {
+        try {
+            await this.#writeLock.wait();
+            for (const buffer of this.#combiner.push(data)) {
+                await this.writeInnerStream(buffer);
+            }
+        } finally {
+            this.#writeLock.notifyOne();
+        }
+    }
+
+    public async readExactly(length: number) {
+        await this.flush();
+        return await this.#readable.readExactly(length);
+    }
+
+    public release(): void {
+        this.#combiner.flush();
+        this.#socketLock.notifyOne();
+    }
+}
+
+export class AdbSyncSocket {
+    readonly #lock = new AutoResetEvent();
+    readonly #socket: AdbSocket;
+    readonly #locked: AdbSyncSocketLocked;
+
+    public constructor(socket: AdbSocket, bufferSize: number) {
+        this.#socket = socket;
+        this.#locked = new AdbSyncSocketLocked(
+            socket.writable.getWriter(),
+            new BufferedReadableStream(socket.readable),
+            bufferSize,
+            this.#lock
+        );
+    }
+
+    public async lock() {
+        await this.#lock.wait();
+        return this.#locked;
+    }
+
+    public async close() {
+        await this.#socket.close();
+    }
+}

package/src/commands/sync/stat.ts

@@ -1,11 +1,8 @@
-import {
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
 import Struct, { placeholder } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import type { AdbSyncSocket } from "./socket.js";
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -47,7 +44,7 @@ export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
     });
 
 export type AdbSyncLstatResponse =
-    typeof AdbSyncLstatResponse["TDeserializeResult"];
+    (typeof AdbSyncLstatResponse)["TDeserializeResult"];
 
 export enum AdbSyncStatErrorCode {
     SUCCESS = 0,
@@ -101,52 +98,60 @@ export const AdbSyncStatResponse = new Struct({ littleEndian: true })
     });
 
 export type AdbSyncStatResponse =
-    typeof AdbSyncStatResponse["TDeserializeResult"];
+    (typeof AdbSyncStatResponse)["TDeserializeResult"];
 
 export async function adbSyncLstat(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string,
     v2: boolean
 ): Promise<AdbSyncStat> {
-    if (v2) {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat2, path);
-        return await adbSyncReadResponse(
-            stream,
-            AdbSyncResponseId.Lstat2,
-            AdbSyncStatResponse
-        );
-    } else {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat, path);
-        const response = await adbSyncReadResponse(
-            stream,
-            AdbSyncResponseId.Lstat,
-            AdbSyncLstatResponse
-        );
-        return {
-            mode: response.mode,
-            // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
-            size: BigInt(response.size),
-            mtime: BigInt(response.mtime),
-            get type() {
-                return response.type;
-            },
-            get permission() {
-                return response.permission;
-            },
-        };
+    const locked = await socket.lock();
+    try {
+        if (v2) {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.LstatV2, path);
+            return await adbSyncReadResponse(
+                locked,
+                AdbSyncResponseId.Lstat2,
+                AdbSyncStatResponse
+            );
+        } else {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.Lstat, path);
+            const response = await adbSyncReadResponse(
+                locked,
+                AdbSyncResponseId.Lstat,
+                AdbSyncLstatResponse
+            );
+            return {
+                mode: response.mode,
+                // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
+                size: BigInt(response.size),
+                mtime: BigInt(response.mtime),
+                get type() {
+                    return response.type;
+                },
+                get permission() {
+                    return response.permission;
+                },
+            };
+        }
+    } finally {
+        locked.release();
     }
 }
 
 export async function adbSyncStat(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string
 ): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(
-        stream,
-        AdbSyncResponseId.Stat,
-        AdbSyncStatResponse
-    );
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Stat, path);
+        return await adbSyncReadResponse(
+            locked,
+            AdbSyncResponseId.Stat,
+            AdbSyncStatResponse
+        );
+    } finally {
+        locked.release();
+    }
 }