TypeScript async-file.readFile函数代码示例

    suiteSetup(async () => {
        let port = await getPort();
        server = new ServerMock(null,
            {
                host: "localhost",
                port: port,
                key: await fs.readFile("test/unitTests/testAssets/private.pem"),
                cert: await fs.readFile("test/unitTests/testAssets/public.pem")
            });

        httpsServerUrl = `https://127.0.0.1:${port}`;
    });

 public static async CreateMockHttpsServer(): Promise<MockHttpsServer> {
     let port = await getPort();
     let server = new ServerMock(null,
         {
             host: "localhost",
             port: port,
             key: await fs.readFile("test/unitTests/testAssets/private.pem"),
             cert: await fs.readFile("test/unitTests/testAssets/public.pem")
         });
 
     return new MockHttpsServer(server, `https://localhost:${port}`);
 }

 test('File is downloaded', async () => {
     await DownloadFile(tmpFile.fd, fileDescription, eventStream, networkSettingsProvider, getURL(elem.urlPath), getURL(elem.fallBackUrlPath));
     const stats = await fs.stat(tmpFile.name);
     expect(stats.size).to.not.equal(0);
     let text = await fs.readFile(tmpFile.name, 'utf8');
     expect(text).to.be.equal("Test content");
 });

 async (err: Error|null, output?: string) => {
     if (err) {
         throw err;
     }
     const generatedHeader = await fs.readFile(`${__dirname}/templates/generated-sources.js.tmpl`);
     await fs.writeFile(`${__dirname}/../project/schema.d.ts`, generatedHeader + output);
     resolve();
 },

export async function loadSchema() {

    const projectDefinition = JSON.parse(await fs.readFile(`${PROJECT_CWD}/package.json`));
    const protoDir = projectDefinition["apiSchema"];

    shelljs.mkdir("-p", `${__dirname}/../project`);

    await generateSchemaJS(protoDir);
    await gtenerateDefinition();
}

async function doWork(): Promise<void> {
    const balancesFileContents = await fs.readFile(argv.balances, 'utf8');
    const allowanceOwnersFileContents = await fs.readFile(argv.allowanceOwners, 'utf8');
    const allowanceSpendersFileContents = await fs.readFile(argv.allowanceSpenders, 'utf8');

    const balances = balancesFileContents.split('\n');
    const allowanceOwners = allowanceOwnersFileContents.split('\n');
    const allowanceSpenders = allowanceSpendersFileContents.split('\n');

    const legacyRepData = {
        balances,
        allowanceOwners,
        allowanceSpenders,
    }

    const repContractAddress = argv.repAddress;
    const chunkSize = argv.chunkSize;

    const legacyRepMigrator: LegacyRepMigrator = await LegacyRepMigrator.create(legacyRepData, repContractAddress, chunkSize);
    await legacyRepMigrator.migrateLegacyRep();
}

    public async compileContracts(): Promise<CompilerOutput> {
        // Check if all contracts are cached (and thus do not need to be compiled)
        try {
            const stats = await fs.stat(this.configuration.contractOutputPath);
            const lastCompiledTimestamp = stats.mtime;
            const ignoreCachedFile = function(file: string, stats: fs.Stats): boolean {
                return (stats.isFile() && path.extname(file) !== ".sol") || (stats.isFile() && path.extname(file) === ".sol" && stats.mtime < lastCompiledTimestamp);
            }
            const uncachedFiles = await recursiveReadDir(this.configuration.contractSourceRoot, [ignoreCachedFile]);
            if (uncachedFiles.length === 0) {
                return JSON.parse(await fs.readFile(this.configuration.contractOutputPath, "utf8"));
            }
        } catch {
            // Unable to read compiled contracts output file (likely because it has not been generated)
        }

        console.log('Compiling contracts, this may take a minute...');

        // Compile all contracts in the specified input directory
        const compilerInputJson = await this.generateCompilerInput();
        const compilerOutputJson = compileStandardWrapper(JSON.stringify(compilerInputJson));
        const compilerOutput: CompilerOutput = JSON.parse(compilerOutputJson);
        if (compilerOutput.errors) {
            let errors = "";

            for (let error of compilerOutput.errors) {
                // FIXME: https://github.com/ethereum/solidity/issues/3273
                if (error.message.includes("instruction is only available after the Metropolis hard fork")) continue;
                errors += error.formattedMessage + "\n";
            }

            if (errors.length > 0) {
                throw new Error("The following errors/warnings were returned by solc:\n\n" + errors);
            }
        }

        // Create output directory (if it doesn't exist)
        await asyncMkdirp(path.dirname(this.configuration.contractOutputPath));

        // Output contract data to single file
        const filteredCompilerOutput = this.filterCompilerOutput(compilerOutput);
        await fs.writeFile(this.configuration.contractOutputPath, JSON.stringify(filteredCompilerOutput, null, '\t'));

        // Output abi data to a single file
        const abiOutput = this.generateAbiOutput(filteredCompilerOutput);
        await fs.writeFile(this.configuration.abiOutputPath, JSON.stringify(abiOutput, null, '\t'));

        return filteredCompilerOutput;
    }

export async function generateServices() {
    const projectDefinition = JSON.parse(await fs.readFile(`${PROJECT_CWD}/package.json`));
    const apiSourceDir = projectDefinition["apiSource"] || "src/api";

    const files = await fs.readdir(`${PROJECT_CWD}/${apiSourceDir}`);

    const moduleList: Module[] = [];

    for (const filename of files) {
        if (filename.indexOf(".js") < 0 && filename.indexOf(".ts") < 0) {
            console.warn(`File ${filename} is not a JavaScript / TypeScript file.`);
        }
        const isTypeScript = filename.indexOf(".ts") >= 0;
        const moduleName = filename.substring(0, filename.lastIndexOf("."));

        const apiList: ApiEndpoint[] = [];

        let fileContent = await fs.readTextFile(`${PROJECT_CWD}/${apiSourceDir}/${filename}`, "utf8");
        if (isTypeScript) {
            fileContent = ts.transpile(fileContent, {
                removeComments: false
            });
        }

        const ast = esprima.parse(fileContent, {
            tolerant: true,
            comment: true
        });
        const comments = ast.comments;
        const blockComments = comments.filter((c: any) => c.type == "Block").map((c: any) => c.value);

        let packageName: string;

        blockComments.forEach((comment: string) => {
            let endpointName: string;
            let requestType: string;
            let responseType: string;
            comment.split("\n").forEach(line => {
                if (line.indexOf(PACKAGE_NAME_NOTE) >= 0) {
                    packageName = extractAttribute(line, PACKAGE_NAME_NOTE);
                    console.log(`[PWA] Generated service ${packageName}.`);
                } else if (line.indexOf(ENDPOINT_NAME_NOTE) >= 0) {
                    endpointName = extractAttribute(line, ENDPOINT_NAME_NOTE);
                } else if (line.indexOf(REQUEST_NOTE) >= 0) {
                    requestType = extractAttribute(line, REQUEST_NOTE);
                } else if (line.indexOf(RESPONSE_NOTE) >= 0) {
                    responseType = extractAttribute(line, RESPONSE_NOTE);
                }
            });
            if (endpointName && requestType && responseType) {
                const requestTypeInterface = getInterfaceNameFromType(requestType);
                const responseTypeInterface = getInterfaceNameFromType(responseType);
                const endpoint = {moduleName, endpointName, requestType, responseType, requestTypeInterface, responseTypeInterface};
                apiList.push(endpoint);

            }
        });

        moduleList.push({
            sourceFileName: filename,
            packageName,
            moduleName,
            apiList,
        });
    }

    for (const module of moduleList) {
        const {sourceFileName, packageName, moduleName, apiList} = module;
        const proto = await generateProto(sourceFileName, packageName, moduleName, apiList);

        const projectDefinition = JSON.parse(await fs.readFile(`${PROJECT_CWD}/package.json`));
        const protoDir = projectDefinition["apiSchema"];
        shelljs.mkdir("-p", `${protoDir}/services`);
        await fs.writeFile(`${protoDir}/services/${moduleName}.proto`, proto);
    }

}