jailgameclient.java

Java P2P技术内幕：《Java P2P技术内幕》源码

                Advertisement ad = (Advertisement) enum.nextElement();
                // We want to discover the jail group
                if (ad instanceof PeerGroupAdvertisement) {
                    
                    try {
                        System.out.println("Creating the group.");
                        jailPeerGroup = netPeerGroup.newGroup(ad);
                        System.out.println("Done with group creation.");
                        groupFound = true;
                        return;
                    } catch (PeerGroupException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.print(".");

        }
    }
    
    /**
     * Sets up the broadcast and unicast pipe and its listeners.
     */
    private void createPipes()
        throws IOException
    {
        PipeService pipeSvc = jailPeerGroup.getPipeService();

        if (unicastListener == null) {
            // Create a message listener to accept jail tokens
            unicastListener = new PipeMsgListener() {
                    public void pipeMsgEvent(PipeMsgEvent pipeMsgEvent)
                    {
                        // We Received a message!
                        Message message = pipeMsgEvent.getMessage();
                        if (message.hasElement("key") && message.hasElement("sender")) {
                            // Determine the sender and the key.
                            MessageElement element = message.getElement("key");
                            InputStream stream = element.getStream();
                            MessageElement senderElement = message.getElement("sender");
                            InputStream senderStream = senderElement.getStream();

                            try {
                                byte [] bytes = new byte[stream.available()];
                                stream.read(bytes);
                                jailTokenString = new String(bytes);
                                hasJailToken = true;

                                bytes = new byte[senderStream.available()];
                                senderStream.read(bytes);
                                String sender = new String(bytes);

                                String msg = "Received key " + jailTokenString + 
                                    " from peer " + sender;
                                System.out.println(msg);
                                
                            } catch (IOException io) {
                                io.printStackTrace();
                            } finally {
                                try {
                                    stream.close();
                                    senderStream.close();
                                } catch (Exception ignore) { }
                            }
                        } else {
                            // ignore this message.
                        }
                        
                    }
                };
        }

        // Create the actual pipe based on the advertisement and the listener.
        this.inputUnicastPipe =
            pipeSvc.createInputPipe(jailUnicastPipeAdv, unicastListener);
    }

    /**
     * Sets up two QueryHandler listeners.  One for the jail token requestor.
     * Another for the jail token locator.
     */
    private void setResolverHandler()
    {
        System.out.println("Setting up the resolver handlers");
        ResolverService jailResolverService = jailPeerGroup.getResolverService();
        // Create a handler to process all incoming queries, and process responses to
        // any queries we send.
        QueryHandler handler = new QueryHandler() {
                /**
                 * Processes any incoming queries.  If this client has the key, we
                 * will send it to the requestor.  Otherwise, we will send a "Sorry"
                 * response.
                 */
                public ResolverResponseMsg processQuery(ResolverQueryMsg query)
                {
                    //System.out.println("Key Requestor Query Handler: " + query.getQuery());
                    if (JailGameClient.this.hasJailToken) {
                        String msg = "Sending jail token to another peer";
                        System.out.println(msg);
                    }
                    String response = null;
                    // If we have the key, send it.  Otherwise send a "Sorry" response.
                    response = (JailGameClient.this.hasJailToken) ? 
                        JailGameClient.this.jailTokenString : "Sorry";
                    JailGameClient.this.hasJailToken = false;
                    JailGameClient.this.jailTokenString = null;
                    // Send our response
                    return new ResolverResponse(JailGameClient.JAIL_KEY_QUERY_HANDLER, "JXTACRED", query.getQueryId(), response);
                }

                /**
                 * Process any responses to our jail key search queries.  If 
                 * we receive any non "Sorry" responses, we have received the 
                 * key.
                 */
                public void processResponse(ResolverResponseMsg responseMsg)
                {
                    String response = responseMsg.getResponse();
                    //System.out.println("Key Requestor Query Handler: " + response);
                    if (!response.equals("Sorry")) {
                        System.out.println("Received jail token.");
                        hasJailToken = true;
                        jailTokenString = response;
                    }
                }
            };
        // Register the handler
        jailResolverService.registerHandler(JailGameClient.JAIL_KEY_QUERY_HANDLER,
                                            handler);

        // Create a handler to locate the keys
        QueryHandler keyLocatorHandler = new QueryHandler() {
                /**
                 * Processes queries requesting to see if we have the jail key.
                 * If this peer has the jail key, respond with the name of this peer.
                 */
                public ResolverResponseMsg processQuery(ResolverQueryMsg query)
                {
                    //System.out.println("Key Locator Query Handler: " + query.getQuery());
                    String response = null;
                    response = (JailGameClient.this.hasJailToken) ? 
                        JailGameClient.this.jailPeerGroup.getPeerName() : "";
                    return new ResolverResponse(JailGameClient.JAIL_KEY_LOCATOR_HANDLER, "JXTACRED", query.getQueryId(), response);
                }

                /**
                 * Processes any responses to our jail key search queries.  If
                 * the response is not a blank string, the response is the name
                 * of the peer that has the key.
                 */
                public void processResponse(ResolverResponseMsg responseMsg)
                {
                    String response = responseMsg.getResponse();
                    //System.out.println("Key Locator Query Handler: " + response);
                    if (!response.equals("")) {
                        System.out.println("Peer: " + response + " has the token");
                    }
                }
            };
        // register the handler
        jailResolverService.registerHandler(JailGameClient.JAIL_KEY_LOCATOR_HANDLER,
                                            keyLocatorHandler);
    }

    /**
     * This method uses the resolver service to broadcast a request for the jail
     * token.  It does not does the job of retrieving the token.
     */
    private void requestJailToken()
    {
        if (this.hasJailToken) {
            System.out.println("I already have the token.");
            return;
        }
        System.out.println("Requesting the jail token");
        ResolverService jailResolverService = jailPeerGroup.getResolverService();
        ResolverQueryMsg query = null;
        query = new ResolverQuery(JailGameClient.JAIL_KEY_QUERY_HANDLER,
                                 "cred", jailPeerGroup.getPeerID().toString(), "Key request", 1);
        jailResolverService.sendQuery(null, query);
    }

    /**
     * Does a broadcast using the resolver service to determine the location
     * of the jail token.
     */
    private void findJailToken()
    {
        if (this.hasJailToken) {
            System.out.println("I have the token.");
            return;
        }
        ResolverService jailResolverService = jailPeerGroup.getResolverService();
        ResolverQueryMsg query = null;
        query = new ResolverQuery(JailGameClient.JAIL_KEY_LOCATOR_HANDLER,
                                 "cred", jailPeerGroup.getPeerID().toString(), "Key location request", 1);
        jailResolverService.sendQuery(null, query);        
    }

    /**
     * Leaves jail if the peer has the key.  Passes the jail token to peerName.
     *
     * @param peerName The peer name to pass the jail token to.
     */
    private void leaveJail(String peerName)
    {
        if (!this.inJail) {
            System.out.println("You are not in jail");
            return;
        }

        if (!hasJailToken) {
            System.out.println("You do not have the token");
            return;
        }
        if (!transferJailKey(peerName)) {
            return;
        }

        System.out.println("Leaving Jail");
        MembershipService membershipSvc = this.jailPeerGroup.getMembershipService();
        // Quit the group and flush all local advertisements.
        try {
            membershipSvc.resign();
            this.jailPeerGroup.stopApp();
            try {
                this.discoverySvc.flushAdvertisements(null, DiscoveryService.GROUP);
                this.discoverySvc.flushAdvertisements(null, DiscoveryService.PEER);
                this.discoverySvc.flushAdvertisements(null, DiscoveryService.ADV);
            } catch (IOException ignore) { ignore.printStackTrace();}

            this.inJail = false;
        } catch (PeerGroupException pge) {
            pge.printStackTrace();
        }
        this.cleanResources();
    }

    /**
     * Quits the application only if the user has left jail.
     */
    private void quit()
    {
        if (this.hasJailToken) {
            System.out.println("You have the jail token.  Existing players " +
                               "cannot leave the jail without a token.");
        }
        System.out.println("Quitting.");
        System.exit(0);
    }

    /**
     * Creates an output pipe to the peer indicated by peerName and sends the
     * jail token
     *
     * @return true If the transfer is successful, false otherwise.
     */
    private boolean transferJailKey(String peerName)
    {
        if (!this.hasJailToken) {
            System.out.println("You do not have the jail token.");
            return false;
        }
        refreshPeerSet();
        try {