can.java

High performance DB query

            curCoord++;

            if (curCoord == DIM) {
                curCoord = 0;
            }
        }

        for (int i = 0; i < DIM; i++) {
            coordinates[i] = (((double) curVal[i]) / ((double) maxVal[i] + 1));
        }

        return coordinates;
    }

    /**
     * Find the node responsible for a locationID value, asynchronous call
     * @param locationID the identifier of interest
     * @param applicationID
     * @param requestor the object that should receive the callback when the lookup is complete
     * @param requestID an identifier used by the requestor to determine which request this is an answer to
     */
    public void lookup(BitID locationID, long applicationID,
                       LocationServiceClient requestor, Object requestID) {
        double[] lookupCoord = getCoordinates(locationID);

        if (requestID == null) {
            return;
        }

        Integer lookupID = new Integer(messageID);
        InetSocketAddress nextHop = neighborhood.nextHop(lookupCoord);

        if (zone.contains(lookupCoord)) {
            nextHop = mySocketAddress;
        }

        lookupResponseClient.put(lookupID, requestor);
        lookupResponseIdentifier.put(lookupID, requestID);

        Lookup lookup = Lookup.allocate(messageID, mySocketAddress,
                                        applicationID);
        Route route = Route.allocate(messageID, mySocketAddress, lookupCoord,
                                     lookup, false);

        messageID++;

        if (TIMEOUT > 0) {
            timeoutManager.addTimeout(route, lookupID, TIMEOUT, this);
        }

        StatCollector.addSample(StatVars.NETWORK_OUT,
                                StatVars.LOCATION_SERVICE, StatVars.CAN_LOOKUP,
                                SerializationManager.getPayloadSize(lookup));
        StatCollector.addSample(StatVars.NETWORK_OUT,
                                StatVars.LOCATION_SERVICE, StatVars.CAN_ROUTE,
                                SerializationManager.getPayloadSize(route)
                                - SerializationManager.getPayloadSize(lookup));
        LocalNode.myUDPMessenger.send(mySocketAddress, nextHop, route);

        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[]{"Sending LOOKUP: ",
                                                     String.valueOf(requestID),
                                                     " to: ", nextHop,
                                                     " Neighborhood has: ",
                                                     String.valueOf(
                                                         neighborhood.getNumNeighbors())}));
        }

        return;
    }

    /**
     * Send a message to a node responsible for a locationID value
     * @param locationID the identifier of interest
     * @param applicationID the application intended to supply answer
     * @param message the message that will be hopped along the path to the destination
     * @param provideUpCalls true if upcalls should be attempted along path, false if just destination should get called
     */
    public void send(BitID locationID, long applicationID, Payload message,
                     boolean provideUpCalls) {
        double[] lookupCoord = getCoordinates(locationID);
        InetSocketAddress nextHop = neighborhood.nextHop(lookupCoord);

        if (zone.contains(lookupCoord)) {
            nextHop = mySocketAddress;
        }

        Message theMessage = Message.allocate(messageID, mySocketAddress,
                                              locationID, applicationID,
                                              message, provideUpCalls);
        Route route = Route.allocate(messageID, mySocketAddress, lookupCoord,
                                     theMessage, provideUpCalls);

        StatCollector.addSample(
            StatVars.NETWORK_OUT, StatVars.LOCATION_SERVICE,
            StatVars.CAN_MESSAGE,
            SerializationManager.getPayloadSize(theMessage));
        StatCollector.addSample(
            StatVars.NETWORK_OUT, StatVars.LOCATION_SERVICE,
            StatVars.CAN_ROUTE,
            SerializationManager.getPayloadSize(route)
            - SerializationManager.getPayloadSize(theMessage));
        LocalNode.myUDPMessenger.send(mySocketAddress, nextHop, route);

        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[]{"Sending MESSAGE: ",
                                                     String.valueOf(messageID),
                                                     " to: ", nextHop,
                                                     " Neighborhood has: ",
                                                     String.valueOf(
                                                         neighborhood.getNumNeighbors())}));
        }

        messageID++;
    }

    /**
     * Method handleTimeout
     *
     * @param item
     * @param currentTime
     */
    public void handleTimeout(Object item, double currentTime) {
        Route route = Route.allocate(((Route) item));

        route.incrementHopCount(-1);
        timeoutManager.addTimeout(route, new Integer(route.getID()), TIMEOUT,
                                  this);
        processRoute(LocalNode.myIPAddress, route);
        StatCollector.addSample(StatVars.MISC_A, StatVars.LOCATION_SERVICE,
                                StatVars.LOOKUP_TIMEOUTS, 1);
    }

    /**
     * Register a client for local location mapping changes and multicast processing
     *
     * @param client
     * @param applicationID
     * @param lookupReturnAddress
     */
    public void registerClient(LocationServiceClient client,
                               long applicationID,
                               InetSocketAddress lookupReturnAddress) {
        localClients.add(client);

        Long appID = new Long(applicationID);

        applications.put(appID, lookupReturnAddress);
        applicationsCallback.put(appID, client);
    }

    /**
     * Deliver a a newly-arrived payload to the client of a socket.
     *
     * @param source the transport address of the sender
     * @param payload the received payload.
     */
    public void handleUDPNetwork(InetSocketAddress source, Payload payload) {

        // Demultiplex the message type
        if (payload instanceof Route) {

            // Route statistics collected in processRoute
            processRoute(source.getAddress(), (Route) payload);
        } else if (payload instanceof Lookup) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_LOOKUP,
                SerializationManager.getPayloadSize(payload));
            processLookup(source.getAddress(), (Lookup) payload);
            Lookup.free((Lookup) payload);
        } else if (payload instanceof Introduce) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_INTRODUCE,
                SerializationManager.getPayloadSize(payload));
            processIntroduce(source.getAddress(), (Introduce) payload);
            Introduce.free((Introduce) payload);
        } else if (payload instanceof Welcome) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_WELCOME,
                SerializationManager.getPayloadSize(payload));
            processWelcome((Welcome) payload);
            Welcome.free((Welcome) payload);
        } else if (payload instanceof Accept) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_ACCEPT,
                SerializationManager.getPayloadSize(payload));
            processAccept(source.getAddress(), (Accept) payload);
            Accept.free((Accept) payload);
        } else if (payload instanceof Update) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_UPDATE,
                SerializationManager.getPayloadSize(payload));
            processUpdate((Update) payload);
            Update.free((Update) payload);
        } else if (payload instanceof Refuse) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_REFUSE,
                SerializationManager.getPayloadSize(payload));
            processRefuse((Refuse) payload);
            Refuse.free((Refuse) payload);
        } else if (payload instanceof LookupResponse) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_LOOKUPRESPONSE,
                SerializationManager.getPayloadSize(payload));
            processLookupResponse((LookupResponse) payload,
                                  source.equals(mySocketAddress));
            LookupResponse.free((LookupResponse) payload);
        } else if (payload instanceof Leave) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_LEAVE,
                SerializationManager.getPayloadSize(payload));
            processLeave((Leave) payload);
            Leave.free((Leave) payload);
        } else if (payload instanceof AcceptLeave) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_ACCEPTLEAVE,
                SerializationManager.getPayloadSize(payload));
            processAcceptLeave((AcceptLeave) payload);
            AcceptLeave.free((AcceptLeave) payload);
        } else if (payload instanceof LeaveComplete) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_LEAVECOMPLETE,
                SerializationManager.getPayloadSize(payload));
            processLeaveComplete((LeaveComplete) payload);
            LeaveComplete.free((LeaveComplete) payload);
        } else if (payload instanceof RefuseLeave) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_REFUSELEAVE,
                SerializationManager.getPayloadSize(payload));
            processRefuseLeave((RefuseLeave) payload);
            RefuseLeave.free((RefuseLeave) payload);
        } else if (payload instanceof LeaveUpdate) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_LEAVEUPDATE,
                SerializationManager.getPayloadSize(payload));
            processLeaveUpdate((LeaveUpdate) payload);
            LeaveUpdate.free((LeaveUpdate) payload);
        } else if (payload instanceof Message) {
            StatCollector.addSample(
                StatVars.NETWORK_IN, StatVars.LOCATION_SERVICE,
                StatVars.CAN_MESSAGE,
                SerializationManager.getPayloadSize(payload));
            handleMessageUpCall(null, (Message) payload,
                                source.equals(mySocketAddress));
        }
    }

    /**
     * Method handleClock
     *
     * @param data
     */
    public void handleClock(Object data) {
        Integer signal = (Integer) data;

        if (signal == CLEANUP_SIGNAL) {
            if (doRouteMaintenance) {
                neighborhood.cleanup(LocalNode.myTimer.getCurrentTime(),
                                     CLEANUP);
            }

            LocalNode.myTimer.schedule(CLEANUP, CLEANUP_SIGNAL, this);
        } else if (signal == UPDATE_SIGNAL) {
            if (doRouteMaintenance) {
                updateNeighbors(neighborhood);
            }

            LocalNode.myTimer.schedule(
                LocalNode.myRandom.nextDouble() * (MAX_UPDATE - MIN_UPDATE)
                + MIN_UPDATE, UPDATE_SIGNAL, this);
        } else if (signal == RETRY_SIGNAL) {
            sendIntroduce();
        } else if (signal == RETRY_SIGNAL_LEAVE) {
            leave();
        }
    }

    /**
     * Method toString
     * @return
     */
    public String toString() {
        return "<CAN: ZN: " + zone + " SZ: " + zone.getArea() + ">";
    }

    /** Removes all data and state */
    public void reset() {
        localClients = new ArrayList();
        lookupResponseClient = new HashMap();
        lookupResponseIdentifier = new HashMap();
        applications = new HashMap();
        applicationsCallback = new HashMap();
    }

    /**
     * Method setRouteMaintenance
     *
     * @param doRouteMaintenance
     */
    public void setRouteMaintenance(boolean doRouteMaintenance) {
        this.doRouteMaintenance = doRouteMaintenance;
    }
}