callWithoutBalancer(actionName, params, opts = {}) {
		if (params === undefined) params = {}; // Backward compatibility

		let nodeID = null;
		let endpoint = null;
		if (typeof actionName !== "string") {
			endpoint = actionName;
			actionName = endpoint.action.name;
			nodeID = endpoint.id;
		} else {
			if (opts.nodeID) {
				nodeID = opts.nodeID;
				endpoint = this.registry.getActionEndpointByNodeId(actionName, nodeID);
				if (!endpoint) {
					this.logger.warn(`Service '${actionName}' is not found on '${nodeID}' node.`);
					return this.Promise.reject(
						new E.ServiceNotFoundError({ action: actionName, nodeID })
					).catch(err => this.errorHandler(err, { nodeID, actionName, params, opts }));
				}
			} else {
				// Get endpoint list by action name
				const epList = this.registry.getActionEndpoints(actionName);
				if (epList == null) {
					this.logger.warn(`Service '${actionName}' is not registered.`);
					return this.Promise.reject(
						new E.ServiceNotFoundError({ action: actionName })
					).catch(err => this.errorHandler(err, { actionName, params, opts }));
				}

				endpoint = epList.getFirst();
				if (endpoint == null) {
					const errMsg = `Service '${actionName}' is not available.`;
					this.logger.warn(errMsg);
					return this.Promise.reject(
						new E.ServiceNotAvailableError({ action: actionName })
					).catch(err => this.errorHandler(err, { actionName, params, opts }));
				}
			}
		}

		// Create context
		let ctx;
		if (opts.ctx != null) {
			// Reused context
			ctx = opts.ctx;
			if (endpoint) {
				ctx.endpoint = endpoint;
				ctx.action = endpoint.action;
			}
		} else {
			// New root context
			ctx = this.ContextFactory.create(this, endpoint, params, opts);
		}
		ctx.nodeID = nodeID;

		this.logger.debug("Call action on a node.", {
			action: ctx.action.name,
			nodeID: ctx.nodeID,
			requestID: ctx.requestID
		});

		let p = endpoint.action.remoteHandler(ctx);

		// Pointer to Context
		p.ctx = ctx;

		return p;
	}
Call an action without built-in balancer.
You don't call it directly. Broker will replace the
original 'call' method to this if you disable the
built-in balancer with the "disableBalancer" option.

@param {String} actionName	name of action
@param {Object?} params		params of action
@param {Object?} opts 		options of call (optional)
@returns {Promise}

@private
@memberof ServiceBroker