messageHandler(cmd, packet) {
		try {
			const payload = packet.payload;

			// Check payload
			if (!payload) {
				/* istanbul ignore next */
				throw new E.MoleculerServerError(
					"Missing response payload.",
					500,
					"MISSING_PAYLOAD"
				);
			}

			// Check protocol version
			if (payload.ver !== this.broker.PROTOCOL_VERSION && !this.opts.disableVersionCheck) {
				throw new E.ProtocolVersionMismatchError({
					nodeID: payload.sender,
					actual: this.broker.PROTOCOL_VERSION,
					received: payload.ver
				});
			}

			if (payload.sender === this.nodeID) {
				// Detect nodeID conflict
				if (cmd === P.PACKET_INFO && payload.instanceID !== this.instanceID) {
					this.broker.fatal(
						"ServiceBroker has detected a nodeID conflict, use unique nodeIDs. ServiceBroker stopped."
					);
					return this.Promise.resolve(false);
				}

				// Skip own packets (if only built-in balancer disabled)
				if (cmd !== P.PACKET_EVENT && cmd !== P.PACKET_REQUEST && cmd !== P.PACKET_RESPONSE)
					return this.Promise.resolve(false);
			}

			// Request
			if (cmd === P.PACKET_REQUEST) {
				return this.requestHandler(payload).then(() => true);
			}

			// Response
			else if (cmd === P.PACKET_RESPONSE) {
				this.responseHandler(payload);
			}

			// Event
			else if (cmd === P.PACKET_EVENT) {
				return this.eventHandler(payload);
			}

			// Discover
			else if (cmd === P.PACKET_DISCOVER) {
				this.discoverer.sendLocalNodeInfo(payload.sender);
			}

			// Node info
			else if (cmd === P.PACKET_INFO) {
				this.discoverer.processRemoteNodeInfo(payload.sender, payload);
			}

			// Disconnect
			else if (cmd === P.PACKET_DISCONNECT) {
				this.discoverer.remoteNodeDisconnected(payload.sender, false);
			}

			// Heartbeat
			else if (cmd === P.PACKET_HEARTBEAT) {
				this.discoverer.heartbeatReceived(payload.sender, payload);
			}

			// Ping
			else if (cmd === P.PACKET_PING) {
				this.sendPong(payload);
			}

			// Pong
			else if (cmd === P.PACKET_PONG) {
				this.processPong(payload);
			}

			return this.Promise.resolve(true);
		} catch (err) {
			this.logger.error(err, cmd, packet);

			this.broker.broadcastLocal("$transit.error", {
				error: err,
				module: "transit",
				type: C.FAILED_PROCESSING_PACKET
			});
		}
		return this.Promise.resolve(false);
	}
Message handler for incoming packets

@param {Array} topic
@param {String} msg
@returns {Promise<boolean>} If packet is processed resolve with `true` else `false`

@memberof Transit