@yume-chan/adb 0.0.17 → 0.0.19

package/src/commands/sync/push.ts

@@ -1,38 +1,159 @@
-import { BufferedReadableStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+import {
+    AbortController,
+    ConsumableWritableStream,
+    DistributionStream,
+} from "@yume-chan/stream-extra";
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { LinuxFileType } from './stat.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 AdbSyncOkResponse =
-    new Struct({ littleEndian: true })
-        .uint32('unused');
+const NOOP = () => {
+    // no-op
+};
 
 export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
-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)
-    );
+export interface AdbSyncPushV1Options {
+    socket: AdbSyncSocket;
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    mode?: number;
+    mtime?: number;
+    packetSize?: number;
+}
+
+export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
+    "unused"
+);
+
+async function pipeFile(
+    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,
+    mode = (LinuxFileType.File << 12) | 0o666,
+    mtime = (Date.now() / 1000) | 0,
+    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
+}: AdbSyncPushV1Options) {
+    const locked = await socket.lock();
+    try {
+        const pathAndMode = `${filename},${mode.toString()}`;
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Send, pathAndMode);
+        await pipeFile(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 {
+    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,
+    mode = (LinuxFileType.File << 12) | 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);
+
+        let flags: AdbSyncSendV2Flags = AdbSyncSendV2Flags.None;
+        if (dryRun) {
+            flags |= AdbSyncSendV2Flags.DryRun;
+        }
+        await locked.write(
+            AdbSyncSendV2Request.serialize({
+                id: AdbSyncRequestId.SendV2,
+                mode,
+                flags,
+            })
+        );
+
+        await pipeFile(locked, file, packetSize, mtime);
+    } finally {
+        locked.release();
+    }
+}
+
+export interface AdbSyncPushOptions extends AdbSyncPushV2Options {
+    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");
+    }
+
+    return adbSyncPushV1(options);
 }

package/src/commands/sync/request.ts

@@ -1,51 +1,54 @@
-import type { WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import Struct from "@yume-chan/struct";
 
-import { encodeUtf8 } from '../../utils/index.js';
+import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
-    List = 'LIST',
-    List2 = 'LIS2',
-    Send = 'SEND',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Data = 'DATA',
-    Done = 'DONE',
-    Receive = 'RECV',
+    List = "LIST",
+    ListV2 = "LIS2",
+    Send = "SEND",
+    SendV2 = "SND2",
+    Lstat = "STAT",
+    Stat = "STA2",
+    LstatV2 = "LST2",
+    Data = "DATA",
+    Done = "DONE",
+    Receive = "RECV",
 }
 
-export const AdbSyncNumberRequest =
-    new Struct({ littleEndian: true })
-        .string('id', { length: 4 })
-        .uint32('arg');
+export const AdbSyncNumberRequest = new Struct({ littleEndian: true })
+    .string("id", { length: 4 })
+    .uint32("arg");
 
-export const AdbSyncDataRequest =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncNumberRequest)
-        .uint8Array('data', { lengthField: 'arg' });
+export const AdbSyncDataRequest = new Struct({ littleEndian: true })
+    .fields(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({
+    if (typeof value === "number") {
+        const buffer = AdbSyncNumberRequest.serialize({
             id,
             arg: value,
         });
-    } else if (typeof value === 'string') {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: encodeUtf8(value),
-        });
+        await writable.write(buffer);
+    } else if (typeof value === "string") {
+        // 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,38 +1,41 @@
-import type { BufferedReadableStream } from '@yume-chan/stream-extra';
-import Struct, { StructValueType, type StructLike } from '@yume-chan/struct';
+import type {
+    StructAsyncDeserializeStream,
+    StructLike,
+    StructValueType,
+} from "@yume-chan/struct";
+import Struct from "@yume-chan/struct";
 
-import { decodeUtf8 } from '../../utils/index.js';
+import { decodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncResponseId {
-    Entry = 'DENT',
-    Entry2 = 'DNT2',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Done = 'DONE',
-    Data = 'DATA',
-    Ok = 'OKAY',
-    Fail = 'FAIL',
+    Entry = "DENT",
+    Entry2 = "DNT2",
+    Lstat = "STAT",
+    Stat = "STA2",
+    Lstat2 = "LST2",
+    Done = "DONE",
+    Data = "DATA",
+    Ok = "OKAY",
+    Fail = "FAIL",
 }
 
-export const AdbSyncFailResponse =
-    new Struct({ littleEndian: true })
-        .uint32('messageLength')
-        .string('message', { lengthField: 'messageLength' })
-        .postDeserialize(object => {
-            throw new Error(object.message);
-        });
+export const AdbSyncFailResponse = new Struct({ littleEndian: true })
+    .uint32("messageLength")
+    .string("message", { lengthField: "messageLength" })
+    .postDeserialize((object) => {
+        throw new Error(object.message);
+    });
 
 export async function adbSyncReadResponse<T>(
-    stream: BufferedReadableStream,
+    stream: StructAsyncDeserializeStream,
     id: AdbSyncResponseId,
-    type: StructLike<T>,
+    type: StructLike<T>
 ): Promise<T> {
     const actualId = decodeUtf8(await stream.read(4));
     switch (actualId) {
         case AdbSyncResponseId.Fail:
             await AdbSyncFailResponse.deserialize(stream);
-            throw new Error('Unreachable');
+            throw new Error("Unreachable");
         case id:
             return await type.deserialize(stream);
         default:
@@ -40,17 +43,19 @@ export async function adbSyncReadResponse<T>(
     }
 }
 
-export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>>(
-    stream: BufferedReadableStream,
+export async function* adbSyncReadResponses<
+    T extends Struct<object, PropertyKey, object, any>
+>(
+    stream: StructAsyncDeserializeStream,
     id: AdbSyncResponseId,
-    type: T,
+    type: T
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
         const actualId = decodeUtf8(await stream.read(4));
         switch (actualId) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
-                throw new Error('Unreachable');
+                throw new Error("Unreachable");
             case AdbSyncResponseId.Done:
                 // `DONE` responses' size are always same as the request's normal response.
                 //
@@ -62,7 +67,9 @@ export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>
                 yield await type.deserialize(stream);
                 break;
             default:
-                throw new Error(`Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`);
+                throw new Error(
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`
+                );
         }
     }
 }

package/src/commands/sync/socket.ts

@@ -0,0 +1,97 @@
+import type {
+    Consumable,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    BufferCombiner,
+    BufferedReadableStream,
+    ConsumableWritableStream,
+} from "@yume-chan/stream-extra";
+import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+
+import type { AdbSocket } from "../../index.js";
+import { AutoResetEvent } from "../../index.js";
+
+export class AdbSyncSocketLocked implements StructAsyncDeserializeStream {
+    private readonly _writer: WritableStreamDefaultWriter<
+        Consumable<Uint8Array>
+    >;
+    private readonly _readable: BufferedReadableStream;
+    private readonly _socketLock: AutoResetEvent;
+    private readonly _writeLock = new AutoResetEvent();
+    private readonly _combiner: BufferCombiner;
+
+    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 read(length: number) {
+        await this.flush();
+        return await this._readable.read(length);
+    }
+
+    public release(): void {
+        this._combiner.flush();
+        this._socketLock.notifyOne();
+    }
+}
+
+export class AdbSyncSocket {
+    private _lock = new AutoResetEvent();
+    private _socket: AdbSocket;
+    private _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,8 +1,8 @@
-import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct, { placeholder } from '@yume-chan/struct';
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+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 {
@@ -24,27 +24,27 @@ export interface AdbSyncStat {
     ctime?: bigint;
 }
 
-export const AdbSyncLstatResponse =
-    new Struct({ littleEndian: true })
-        .int32('mode')
-        .int32('size')
-        .int32('mtime')
-        .extra({
-            id: AdbSyncResponseId.Lstat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (
-                object.mode === 0 &&
-                object.size === 0 &&
-                object.mtime === 0
-            ) {
-                throw new Error('lstat failed');
-            }
-        });
+export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
+    .int32("mode")
+    .int32("size")
+    .int32("mtime")
+    .extra({
+        id: AdbSyncResponseId.Lstat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.mode === 0 && object.size === 0 && object.mtime === 0) {
+            throw new Error("lstat error");
+        }
+    });
 
-export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
+export type AdbSyncLstatResponse =
+    (typeof AdbSyncLstatResponse)["TDeserializeResult"];
 
 export enum AdbSyncStatErrorCode {
     SUCCESS = 0,
@@ -70,60 +70,88 @@ export enum AdbSyncStatErrorCode {
     ETXTBSY = 26,
 }
 
-export const AdbSyncStatResponse =
-    new Struct({ littleEndian: true })
-        .uint32('error', placeholder<AdbSyncStatErrorCode>())
-        .uint64('dev')
-        .uint64('ino')
-        .uint32('mode')
-        .uint32('nlink')
-        .uint32('uid')
-        .uint32('gid')
-        .uint64('size')
-        .uint64('atime')
-        .uint64('mtime')
-        .uint64('ctime')
-        .extra({
-            id: AdbSyncResponseId.Stat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (object.error) {
-                throw new Error(AdbSyncStatErrorCode[object.error]);
-            }
-        });
+export const AdbSyncStatResponse = new Struct({ littleEndian: true })
+    .uint32("error", placeholder<AdbSyncStatErrorCode>())
+    .uint64("dev")
+    .uint64("ino")
+    .uint32("mode")
+    .uint32("nlink")
+    .uint32("uid")
+    .uint32("gid")
+    .uint64("size")
+    .uint64("atime")
+    .uint64("mtime")
+    .uint64("ctime")
+    .extra({
+        id: AdbSyncResponseId.Stat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.error) {
+            throw new Error(AdbSyncStatErrorCode[object.error]);
+        }
+    });
 
-export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
+export type AdbSyncStatResponse =
+    (typeof AdbSyncStatResponse)["TDeserializeResult"];
 
 export async function adbSyncLstat(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string,
-    v2: boolean,
+    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>,
-    path: string,
+    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();
+    }
 }