TypeScript utils.intervalUtils类代码示例

    public startEmittingNetworkConnectionAndUserBalanceState() {
        if (!_.isUndefined(this._watchNetworkAndBalanceIntervalId)) {
            return; // we are already emitting the state
        }

        let prevNodeVersion: string;
        this._prevUserEtherBalanceInWei = new BigNumber(0);
        this._dispatcher.updateNetworkId(this._prevNetworkId);
        this._watchNetworkAndBalanceIntervalId = intervalUtils.setAsyncExcludingInterval(
            async () => {
                // Check for network state changes
                let currentNetworkId;
                try {
                    currentNetworkId = await this._web3Wrapper.getNetworkIdAsync();
                } catch (err) {
                    // Noop
                }
                if (currentNetworkId !== this._prevNetworkId) {
                    this._prevNetworkId = currentNetworkId;
                    this._dispatcher.updateNetworkId(currentNetworkId);
                }

                // Check for node version changes
                const currentNodeVersion = await this._web3Wrapper.getNodeVersionAsync();
                if (currentNodeVersion !== prevNodeVersion) {
                    prevNodeVersion = currentNodeVersion;
                    this._dispatcher.updateNodeVersion(currentNodeVersion);
                }

                if (this._shouldPollUserAddress) {
                    const addresses = await this._web3Wrapper.getAvailableAddressesAsync();
                    const userAddressIfExists = addresses[0];
                    // Update makerAddress on network change
                    if (this._prevUserAddressIfExists !== userAddressIfExists) {
                        this._prevUserAddressIfExists = userAddressIfExists;
                        this._dispatcher.updateUserAddress(userAddressIfExists);
                    }

                    // Check for user ether balance changes
                    if (!_.isUndefined(userAddressIfExists)) {
                        await this._updateUserWeiBalanceAsync(userAddressIfExists);
                    }
                } else {
                    // This logic is primarily for the Ledger, since we don't regularly poll for the address
                    // we simply update the balance for the last fetched address.
                    if (!_.isUndefined(this._prevUserAddressIfExists)) {
                        await this._updateUserWeiBalanceAsync(this._prevUserAddressIfExists);
                    }
                }
            },
            5000,
            (err: Error) => {
                logUtils.log(`Watching network and balances failed: ${err.stack}`);
                this._stopEmittingNetworkConnectionAndUserBalanceStateAsync();
            },
        );
    }

 private _stopBlockAndLogStream(): void {
     if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
         throw new Error(ZeroExError.SubscriptionNotFound);
     }
     this._blockAndLogStreamerIfExists.unsubscribeFromOnLogAdded(this._onLogAddedSubscriptionToken as string);
     this._blockAndLogStreamerIfExists.unsubscribeFromOnLogRemoved(this._onLogRemovedSubscriptionToken as string);
     intervalUtils.clearAsyncExcludingInterval(this._blockAndLogStreamIntervalIfExists as NodeJS.Timer);
     delete this._blockAndLogStreamerIfExists;
 }

 async () => {
     const [balance] = await this.getTokenBalanceAndAllowanceAsync(
         this._userAddressIfExists,
         token.address,
     );
     if (!balance.eq(currBalance)) {
         intervalUtils.clearAsyncExcludingInterval(tokenPollInterval);
         resolve(balance);
     }
 },

 private _start() {
     this._queueIntervalIdIfExists = intervalUtils.setAsyncExcludingInterval(
         async () => {
             const taskAsync = this._queue.shift();
             if (_.isUndefined(taskAsync)) {
                 return Promise.resolve();
             }
             await taskAsync();
         },
         this._queueIntervalMs,
         (err: Error) => {
             logUtils.log(`Unexpected err: ${err} - ${JSON.stringify(err)}`);
             // tslint:disable-next-line:no-floating-promises
             errorReporter.reportAsync(err);
         },
     );
 }

 const newTokenBalancePromise = new Promise((resolve: (balance: BigNumber) => void, reject) => {
     const tokenPollInterval = intervalUtils.setAsyncExcludingInterval(
         async () => {
             const [balance] = await this.getTokenBalanceAndAllowanceAsync(
                 this._userAddressIfExists,
                 token.address,
             );
             if (!balance.eq(currBalance)) {
                 intervalUtils.clearAsyncExcludingInterval(tokenPollInterval);
                 resolve(balance);
             }
         },
         5000,
         (err: Error) => {
             logUtils.log(`Polling tokenBalance failed: ${err}`);
             intervalUtils.clearAsyncExcludingInterval(tokenPollInterval);
             reject(err);
         },
     );
 });

 private _startBlockAndLogStream(): void {
     if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
         throw new Error(ZeroExError.SubscriptionAlreadyPresent);
     }
     this._blockAndLogStreamerIfExists = new BlockAndLogStreamer(
         this._web3Wrapper.getBlockAsync.bind(this._web3Wrapper),
         this._web3Wrapper.getLogsAsync.bind(this._web3Wrapper),
     );
     const catchAllLogFilter = {};
     this._blockAndLogStreamerIfExists.addLogFilter(catchAllLogFilter);
     this._blockAndLogStreamIntervalIfExists = intervalUtils.setAsyncExcludingInterval(
         this._reconcileBlockAsync.bind(this),
         constants.DEFAULT_BLOCK_POLLING_INTERVAL,
         this._onReconcileBlockError.bind(this),
     );
     let isRemoved = false;
     this._onLogAddedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogAdded(
         this._onLogStateChanged.bind(this, isRemoved),
     );
     isRemoved = true;
     this._onLogRemovedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogRemoved(
         this._onLogStateChanged.bind(this, isRemoved),
     );
 }

 (err: Error) => {
     logUtils.log(`Polling tokenBalance failed: ${err}`);
     intervalUtils.clearAsyncExcludingInterval(tokenPollInterval);
     reject(err);
 },

 private _stopEmittingNetworkConnectionAndUserBalanceStateAsync() {
     if (!_.isUndefined(this._watchNetworkAndBalanceIntervalId)) {
         intervalUtils.clearAsyncExcludingInterval(this._watchNetworkAndBalanceIntervalId);
     }
 }

 public stop() {
     if (!_.isUndefined(this._queueIntervalIdIfExists)) {
         intervalUtils.clearAsyncExcludingInterval(this._queueIntervalIdIfExists);
     }
 }