simplereplicamanager.java

中間件開發详细说明：清华大学J2EE教程讲义（ppt）-Tsinghua University J2EE tutorial lectures (ppt) [上载源码成为会员下载此源码] [成为VIP会

            break;

        // a file was delivered to this site, it is to be used for execution
        // of a DataGridlet
        case DataGridTags.FILE_DELIVERY:
            file = (File) ev.get_data();
            receiveFileDelivery(file);
            break;

        default:
            System.out.println(super.get_name()
                    + ".processOtherEvent(): Warning - unknown tag = "
                    + ev.get_tag());
            result = false;
            break;
        }

        return result;
    }

    //------------------PROCESS USER REQUESTS----------------------------

    /**
     * Processes the request for adding a master file to the resource.
     * Firstly, the file is added to the storage.
     * <ul>
     * <li>if there are no errors, a request for registration is sent to the
     * Replica Catalogue. The request is saved in an array, to be furher
     * processed when the Replica Catalogue returns a unique ID of this file
     * (see the {@link #processMasterAddResult(Sim_event)} method).
     * <br>
     * <li>if an error occurs while adding the file to the storage, sends an
     * error message back to the sender.
     * </ul>
     *
     * @param ev    the event sent by the sender to be processed
     */
    private void processAddMasterFile(Sim_event ev) {
        if (ev == null) {
            return;
        }

        Object[] pack = (Object[]) ev.get_data();
        if (pack == null) {
            return;
        }

        File file = (File) pack[0]; // get the file
        file.setMasterCopy(true); // set the file into a master copy
        int sentFrom = ((Integer) pack[1]).intValue(); // get sender ID

        /******     // DEBUG
         System.out.println(super.get_name() + ".addMasterFile(): " +
         file.getName() + " from " + GridSim.getEntityName(sentFrom));
         *******/

        Object[] data = new Object[3];
        data[0] = file.getName();

        int msg = addFile(file); // add the file
        if (msg == DataGridTags.FILE_ADD_SUCCESSFUL) {
            registerMasterFile(file);
            data[1] = new Integer(sentFrom);
            masterFilesWaitingForAddACK_.add(data);
        } else {
            data[1] = new Integer(-1); // no sender id
            data[2] = new Integer(msg); // the result of adding a master file

            sim_schedule(outputPort_, 0, DataGridTags.FILE_ADD_MASTER_RESULT,
                    new IO_data(data, DataGridTags.PKT_SIZE, sentFrom));
        }
    }

    /**
     * Processes the request for adding a replica to the resource. Firstly, the
     * file is added to the storage.
     * <ul>
     * <li>if there are no errors, a request for registration is sent to the
     * Replica Catalogue. The request is saved in an array, to be furher
     * processed when the Replica Catalogue returns the result of the
     * registration (see the {@link #processCatalogueAddResult(Sim_event)}
     * method).
     * <br>
     * <li>if an error occurs while adding the file to the storage, sends an
     * error message to the user.
     * </ul>
     *
     * @param ev    the event sent by the sender to be processed
     */
    private void processAddReplica(Sim_event ev) {
        if (ev == null) {
            return;
        }

        Object[] data = (Object[]) ev.get_data();
        if (data == null) {
            return;
        }

        File file = (File) data[0]; // get file
        file.setMasterCopy(false); // set file as a replica
        int req_source = ((Integer) data[1]).intValue(); // get sender id

        int msg = addFile(file); // add file
        if (msg == DataGridTags.FILE_ADD_SUCCESSFUL) {
            registerFile(file); // register file to RC
            data[0] = file.getName();
            filesWaitingForAddACK_.add(data);
        } else { // if an error occured, the notify the sender
            sendResult(file.getName(), DataGridTags.FILE_ADD_REPLICA_RESULT,
                    msg, req_source);
        }
    }

    /**
     * Deletes a master file from the storage
     * @param ev    a Sim_event object
     */
    private void processDeleteMasterFile(Sim_event ev) {
        processDelete(ev, true);
    }

    /**
     * Deletes a replica file from the storage
     * @param ev    a Sim_event object
     */
    private void processDeleteReplica(Sim_event ev) {
        processDelete(ev, false);
    }

    /**
     * Processes the request for deleting a file (either a master or a replica)
     * from the resource. Firstly, it checks if it is possible to delete.
     * The file is not deleted from the storage until the change is registered
     * with the Replica Catalogue. When the result from the delete test is
     * known, there are two possibilities
     * <ul>
     * <li>if there are no errors, a request for removing the registration is
     * sent to the Replica Catalogue. The request is saved in an array, to be
     * furher processed when the Replica Catalogue returns the result of the
     * operation (see the {@link #processCatalogueDeleteResult(Sim_event)}
     * method).
     * <br>
     * <li>if an error occurs while deleting the file from the storage, send an
     * error message to the user.
     * </ul>
     *
     * @param ev        the event sent by the sender to be processed
     * @param isMaster  is the file to be deleted a master file or a replica
     */
    private void processDelete(Sim_event ev, boolean isMaster) {
        if (ev == null) {
            return;
        }
        Object[] data = (Object[]) ev.get_data();
        if (data == null) {
            return;
        }

        String filename = (String) data[0];
        int req_source = ((Integer) data[1]).intValue();
        int tag = -1;

        // check if this file can be deleted (do not delete is right now)
        int msg = deleteFileFromStorage(filename, isMaster, true);
        if (msg == DataGridTags.FILE_DELETE_SUCCESSFUL) {
            if (isMaster == true) // if it is a master file
            {
                masterFilesWaitingForDeleteACK_.add(data);
                tag = DataGridTags.CTLG_DELETE_MASTER;
            } else // if it is a replica
            {
                filesWaitingForDeleteACK_.add(data);
                tag = DataGridTags.CTLG_DELETE_REPLICA;
            }

            // deregister this file from RC
            super.deregisterDeletedFile(filename, tag);
        } else // if an error occured, notify user
        {
            tag = DataGridTags.FILE_DELETE_REPLICA_RESULT;
            if (isMaster == true) {
                tag = DataGridTags.FILE_DELETE_MASTER_RESULT;
            }
            sendResult(filename, tag, msg, req_source);
        }
    }

    /**
     * Sends a file to the user that requested it.
     * @param ev    the event sent by the user to be processed
     */
    private void processFileRequest(Sim_event ev) {
        if (ev == null) {
            return;
        }
        Object[] data = (Object[]) ev.get_data();
        if (data == null) {
            return;
        }

        String filename = (String) data[0]; // get file name
        int req_source = ((Integer) data[1]).intValue(); // get sender

        int ToS = 0; // a priority number for sending over the network
        if (data.length == 3) {
            ToS = ((Integer) data[2]).intValue(); // get ToS
        }

        File file = getFile(filename); // get the file
        int size = 0;
        if (file != null) {
            size = file.getSizeInByte();
        } else { // if file is not found
            size = DataGridTags.PKT_SIZE;
        }
        super.sim_schedule(outputPort_, 0, DataGridTags.FILE_DELIVERY,
                new IO_data(file, size, req_source, ToS));
    }

    //  -------------------PROCESS CATALOGUE RESPONSES/RESULTS-------------
    /**
     * If the addition to the Replica Catalogue is not successful, the file is
     * deleted from the resource. The message is forwarded to the user that
     * requested the addition of the replica.
     *
     * @param ev    the event sent by the Replica Catalogue
     */
    private void processCatalogueAddResult(Sim_event ev) {
        if (ev == null) {
            return;
        }

        Object[] pack = (Object[]) ev.get_data();
        if (pack == null) {
            return;
        }

        String filename = (String) pack[0]; // replica name
        int msg = ((Integer) pack[1]).intValue(); // a message: error or not

        /*******  // DEBUG
         System.out.println(super.get_name() + ".processCatalogueAddResult(): " +
         "received result of " + filename);
         ******/

        // find the event in the waiting list
        Object[] dataTemp = searchEvent(filename, this.filesWaitingForAddACK_);
        if (dataTemp != null) {
            // if the addition was not successful, delete the file
            if (msg != DataGridTags.CTLG_ADD_REPLICA_SUCCESSFUL) {
                this.deleteFileFromStorage(filename, false, false);
            } else {
                msg = DataGridTags.FILE_ADD_SUCCESSFUL;
            }

            // delete this event from the waiting list
            filesWaitingForAddACK_.remove(dataTemp);

            // send message (error/success) to the user
            sendResult(filename, DataGridTags.FILE_ADD_REPLICA_RESULT, msg,
                    ((Integer) dataTemp[1]).intValue());
        }
    }

    /**
     * This method is very similar to
     * {@link #processCatalogueAddResult(Sim_event)}. The only
     * difference is that Replica Catalogue returns a uniqueID, i.e. a unique
     * number that prevents having the same name represent different files. This
     * uniqueId is added to the initial name. That means that the file is known
     * by the new name also on the local resource.
     * <br>
     * <b>Example: </b> if the name of the file is "researchResults" and the
     * uniqueID sent by the Replica Catalogue is 17, then the file is renamed to
     * "researchResults17".
     *
     * @param ev    a Sim_event object
     */
    private void processMasterAddResult(Sim_event ev) {
        if (ev == null) {
            return;
        }

        Object[] data = (Object[]) ev.get_data();
        if (data == null) {
            return;
        }

        String filename = (String) data[0]; // get file name
        int registrationID = ((Integer) data[1]).intValue(); // get unique ID
        int msg = ((Integer) data[2]).intValue(); // get result

        // if registration is successful
        if (msg == DataGridTags.CTLG_ADD_MASTER_SUCCESSFUL) {
            setID(filename, registrationID); // set the id of this file
        }

        // search this request from the waiting list
        Object[] dataTemp = searchEvent(filename, masterFilesWaitingForAddACK_);
        if (dataTemp != null) {
            // if the addition was not successful, delete the file
            if (msg != DataGridTags.CTLG_ADD_MASTER_SUCCESSFUL) {
                this.deleteFileFromStorage(filename, true, false);
            } else {
                msg = DataGridTags.FILE_ADD_SUCCESSFUL;
            }

            // delete this event from the waiting list
            masterFilesWaitingForAddACK_.remove(dataTemp);

            // send back the result to sender
            int senderID = ((Integer) dataTemp[1]).intValue();
            Object pack[] = new Object[3];
            pack[0] = filename; // file name
            pack[1] = new Integer(registrationID); // unique id
            pack[2] = new Integer(msg); // message

            sim_schedule(outputPort_, 0, DataGridTags.FILE_ADD_MASTER_RESULT,
                    new IO_data(pack, DataGridTags.PKT_SIZE, senderID));
        }
    }

    /**
     * Manages the response of the Replica Catalogue to a delete master request.
     * @param ev    a Sim_event object
     */
    private void processMasterDeleteResult(Sim_event ev) {
        processDeleteResult(ev, true);
    }

    /**
     * Manages the response of the Replica Catalogue to a delete master request.
     * @param ev    a Sim_event object
     */
    private void processCatalogueDeleteResult(Sim_event ev) {
        processDeleteResult(ev, false);