public void onReceivePushSolution(RepairSolution solution) {
        logger_.info("Solution for path {} received.", solution.failedPath);

        // Update routing table.
        for (PeerReference ref : solution.failedHosts) {
            Host failedHost = Deserializer.deserializeHost(ref);
            logger_.debug("Removing failed host {}:{}", failedHost, failedHost.getPort());
            routingTable_.removeReference(failedHost);
            registry_.removeIssue(failedHost.getUUID());
        }

        for (PeerReference ref : solution.updatedHosts) {
            Host updatedHost = Deserializer.deserializeHost(ref);
            logger_.debug("Updating host {}:{}", updatedHost, updatedHost.getPort());
            routingTable_.removeReference(updatedHost);
            routingTable_.addReference(0, updatedHost);
            //routingTable_.updateReference(updatedHost);
        }

        routingTable_.refresh(maxRef_);
        logger_.debug("Routing table updated.");

        if (solution.levelPrefix.compareTo(routingTable_.getLocalhost().getHostPath().toString()) == 0) {
            // sanity included...
            logger_.debug("Broadcasting cannot proceed. {} is the final point.", solution.levelPrefix);
            return;
        }

        // Continue solution broadcasting.
        PGridPath levelPrefix = new PGridPath(solution.levelPrefix);
        PGridPath localPath = routingTable_.getLocalhost().getHostPath();
        logger_.debug("Common with level prefix '{}': {}", levelPrefix, localPath.commonPrefix(levelPrefix));
        int startLevel = localPath.commonPrefix(levelPrefix).length();
        logger_.debug("Starting from level {}", startLevel);
        for (int i = startLevel; i < localPath.length(); i++) {
            logger_.debug("Informing level {} ({})", i, localPath.subPath(0, i));
            Random r = new Random(System.currentTimeMillis());
            Host[] level = routingTable_.getLevelArray(i);
            int nextInt = r.nextInt(level.length + 1);
            nextInt = nextInt <= 0 ? 0 : nextInt - 1;
            Host host = level[nextInt];
            PGridPath responsibility = new PGridPath(localPath.subPath(0, i));
            responsibility.revertAndAppend(localPath.value(i));
            solution.levelPrefix = responsibility.toString();

            try {
                logger_.info("{}:{} is responsible for subtree {}",
                        new Object[]{host, host.getPort(), responsibility});
                RepairHandle repairHandle = getRemoteHandle(host);
                repairHandle.pushSolution(solution);
            } catch (CommunicationException e) {
                // Ignore the failure. The broadcasting becomes really
                // complicated if a new repair session will start. What
                // will happen with all the host that already got the
                // solution?
                logger_.debug("{}:{} is not reachable.", host, host.getPort());
            }
            if (i >= localPath.length()) {
                logger_.error("From {} to {} ({})", new Object[]{startLevel, localPath.length(), i});
                System.exit(i);
            }
        }
    }