todolistservice.java

Java p2p程序设计2002年版

/*
 * AddressBookService.java
 *
 * Created on November 29, 2001, 1:27 PM
 */

package com.sams.jxta.pda;
import com.sams.jxta.xcal.*;
import net.jxta.resolver.QueryHandler;
import java.util.Date;
import java.text.SimpleDateFormat;
import net.jxta.impl.resolver.*;
import net.jxta.protocol.*;
import net.jxta.impl.protocol.*;

import org.jdom.*;
import org.jdom.output.*;
import org.jdom.input.*;

import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.util.*;
import net.jxta.document.AdvertisementFactory;
import  net.jxta.peergroup.*;
import  net.jxta.pipe.*;
import net.jxta.discovery.*;
//import net.jxta.document.*;
import net.jxta.document.MimeMediaType;
import net.jxta.endpoint.*;
import net.jxta.id.*;
import net.jxta.exception.*;
import net.jxta.peer.*;
import net.jxta.pipe.*;
import net.jxta.peergroup.*;
import net.jxta.platform.*;
import net.jxta.protocol.*;
import net.jxta.service.*;
import javax.swing.DefaultListModel;
import org.apache.log4j.Category;

/**
 *
 * @author  Administrator
 */
public class ToDoListService {
    private static final Category LOG =  Category.getInstance(ToDoListService.class.getName());
    
    String syncHandlerName = "SyncToDoList";//Pull
    String pushHandlerName = "PushToDoList";//Push
    String credential ="SAMS";
    String peerName;
    //Hashtable entryGroups = new Hashtable();
    Hashtable allToDoItems = new Hashtable();
    net.jxta.peer.PeerID peerID;
    /** Creates new CalendarService */
    PeerGroup rootPeerGroup;
    //InfoResolver resolverX;
    private DiscoveryService discovery;
    net.jxta.impl.resolver.ResolverServiceImpl resolver;
    //SynchronizerResolver synchronizerResolver;
    /** Creates new AddressBookService */
    public ToDoListService(PeerGroup rootPeerGroup) {
        this.rootPeerGroup = rootPeerGroup;
        syncHandlerName += "-"+rootPeerGroup.getPeerGroupName();
        pushHandlerName += "-"+rootPeerGroup.getPeerGroupName();
        
        peerID = rootPeerGroup.getPeerID();
        peerName = rootPeerGroup.getPeerName();
        discovery = rootPeerGroup.getDiscoveryService();
        //addGroupInterest(rootPeerGroup);
        
        PushHandler pushHandler = new  PushHandler(pushHandlerName,credential);
        SyncHandler syncHandler = new  SyncHandler(syncHandlerName,allToDoItems,credential);
        
        resolver = (ResolverServiceImpl)rootPeerGroup.getResolverService();
        
        resolver.registerHandler(pushHandlerName, pushHandler);
        resolver.registerHandler(syncHandlerName, syncHandler);
        
    }
    
    
    static Vector models = new Vector(1);
    
    public void addModel(DefaultListModel model){
        models.add(model);
    }
    public void addEntry( VToDo vToDo){
        vToDo.setGroupID(rootPeerGroup.getPeerGroupID().toString());
        vToDo.setGroupName(rootPeerGroup.getPeerGroupName());
        vToDo.setPeerID(rootPeerGroup.getPeerID().toString());
        vToDo.setPeerName(rootPeerGroup.getPeerName());
        vToDo.setGroupDesc( rootPeerGroup.getPeerGroupAdvertisement().getDescription());
        merge(vToDo);
        update(vToDo.toXML());
        
    }
    public void  update(String message){
        LOG.debug("Resolver sending messages");
        ResolverQueryMsg resolverQueryMsg = null;
        resolverQueryMsg = new ResolverQuery(pushHandlerName, credential,rootPeerGroup.getPeerID().toString(), message,1);
        ResolverSend resolverSend = new  ResolverSend(resolver, null, resolverQueryMsg);
        
        resolverSend.start();
    }
    
    public void synchronize(){
        //synchronizerResolver.synchronize();
        LOG.debug("Resolver sending synchronize");
        ResolverQueryMsg resolverQueryMsg = null;
        resolverQueryMsg = new ResolverQuery(syncHandlerName, credential,rootPeerGroup.getPeerID().toString(), "",1);
        ResolverSend resolverSend = new  ResolverSend(resolver, null, resolverQueryMsg);
        resolverSend.start();
    }
    public void updateAddress(VToDo vToDo){
        
    }
    public void deleteAddress(VToDo vToDo){
    }
    /**
     * Merge the new event into our database.
     */
    public synchronized void merge(VToDo vToDo){
        VToDo old = (VToDo)allToDoItems.get(vToDo.getID());
        if ( old !=null){
            LOG.debug("To do list already has this message");
            if (!vToDo.getDtstamp().equals(old.getDtstamp()) ){
                LOG.debug("Update because it is newer");
                allToDoItems.put(vToDo.getID(),vToDo);
            }
            
            return;
        }else{
            LOG.debug("New todo  message");
            allToDoItems.put(vToDo.getID(),vToDo);
        }
        // Update displays
        LOG.debug("Updating list in display");
        for (int i =0;i <models.size();i++){
            LOG.debug("Updating list item:"+vToDo);
            ((DefaultListModel)models.elementAt(i)).addElement(vToDo);
        }
    }// end of merge()
    /**
     * implementation of QueryHandler for for synchronization.
     */
    class SyncHandler implements QueryHandler{
        protected String handlerName;
        protected String credential;
        protected Hashtable entryBook;
        protected SimpleDateFormat format   = new SimpleDateFormat("MM, dd, yyyy hh:mm:ss.S");
        
        public SyncHandler(String handlerName,Hashtable entryBook, String credential){
            this.handlerName = handlerName;
            this.credential = credential;
            this.entryBook = entryBook;
            
        }// end of constructor PullHandler()
        /**
         * call back method, when messages are received by the ResolverService
         * it calls back this method to deal with received responses
         * @param response ResolverQueryMsg reponse
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public void processResponse(ResolverResponseMsg response) {
            LOG.debug("Received a response");
            String textDoc = response.getResponse();
            if (textDoc ==null)return;
            //System.out.println("Received a response:"+textDoc);
            
            try{
                ByteArrayInputStream in = new ByteArrayInputStream(textDoc.getBytes());
                org.jdom.input.SAXBuilder builder = new org.jdom.input.SAXBuilder();
                org.jdom.Document doc = builder.build(in);
                org.jdom.Element root = doc.getRootElement();
                //specific to todo
                List book = (List) root .getChildren("icalendar");
                ListIterator lister = book.listIterator();
                
                LOG.debug("name:"+root.getName());
                while (lister.hasNext()){
                    org.jdom.Element entry = (org.jdom.Element) lister.next();
                    entry = entry .getChild("vcalendar").getChild("vtodo");
                    
                    LOG.debug("Received a response:"+entry.getText());
                    XMLOutputter putter = new XMLOutputter("  ",true);
                    StringWriter writer = new StringWriter();
                    putter.output(entry,writer);
                    
                    LOG.debug(" sync messag:"+writer.toString());
                    String xml = writer.toString();
                    merge(new VToDo(xml));
                }
                
            }catch(Exception je){//org.jdom.JDOMException je){
                je.printStackTrace();
                LOG.error("Error processing incoming message.",je);
            }
        }// End of processResponse()
        
        /**
         * Process the resolver query, and generate response
         * @return GenericResolverMsg Response to the query
         * @param query ResolverQueryMsg query
         */
        public ResolverResponseMsg processQuery(ResolverQueryMsg query) throws NoResponseException, ResendQueryException, DiscardQueryException{
            try{
                LOG.debug("Received a synchronizer query");
                
                org.jdom.Element root = new org.jdom.Element("todo-list");//,format.format( new Date(now)));
                org.jdom.Document doc = new org.jdom.Document(root);
                
                Enumeration enum = entryBook.elements();
                for(;enum.hasMoreElements();){
                    org.jdom.Document d2 =((VToDo)enum.nextElement()).toJDOM();
                    org.jdom.Element ele = d2.getRootElement();
                    ele.detach();
                    root.addContent(ele);
                }
                // Return a generic response;
                ResolverResponseMsg message = null;
                XMLOutputter putter = new XMLOutputter("  ",true);
                StringWriter writer = new StringWriter();
                putter.output(doc,writer);
                
                LOG.debug(" sync messag:"+writer.toString());
                message = new ResolverResponse(handlerName, credential,query.getQueryId(), writer.toString());
                return (ResolverResponseMsg)message;
            }catch(Exception e ){
                e.printStackTrace();
                LOG.error("Error processing query",e);
                throw new NoResponseException("Error processing query");
            }
        }// end of processQuery()
        
    }// end of class SyncHandler
    /************************************************************************
     *
     *
     ************************************************************************/
    class PushHandler implements QueryHandler{
        protected String handlerName;
        protected String credential;
        protected SimpleDateFormat format   = new SimpleDateFormat("MM, dd, yyyy hh:mm:ss.S");
        
        public PushHandler(String handlerName, String credential){
            this.handlerName = handlerName;
            this.credential = credential;
        }// end of constructor CalendarHandler()
        /**
         * Process the resolver query, and generate response
         * @return GenericResolverMsg Response to the query
         * @param query ResolverQueryMsg query
         *
         * @exception NoResponseException is thrown when the resolver service
         * does not have an response and is not interested by the response.
         * @exception ResendQueryException is thrown when the resolver service
         * does not have a response, but is interested by the response. In that
         * case, the resolver service is responsible for forward the response
         * to the original peer that has issued the query.
         * @exception DiscardQueryException is thrown when the resolver service
         * has decided that the query should simply be ignored.
         * @exception IOException is thrown when the service resolver was not able to
         * process the query
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public ResolverResponseMsg processQuery(ResolverQueryMsg query) throws NoResponseException, ResendQueryException, DiscardQueryException{
            LOG.debug("Received a query");
            LOG.debug(((ResolverQuery)query).toString());
            //net.jxta.document.StructuredTextDocument doc = null;
            String xml = query.getQuery();
            // Process the incomming data
            merge(new VToDo(xml));
            
            throw new NoResponseException("Got the data we were interested in.");
        }// end of processQuery()
        /**
         * call back method, when messages are received by the ResolverService
         * it calls back this method to deal with received responses
         * @param response ResolverQueryMsg reponse
         *
         * @version $Revision: 1.1 $
         * @since JXTA 1.0
         */
        public void processResponse(ResolverResponseMsg response) {
            LOG.debug("Received a ToDo response");
            //String textDoc = response.getResponse();
            //System.out.println(textDoc);
            LOG.debug(((ResolverResponse)response).toString());
        }// End of processResponse()
        
        
    }// end of class CalendarHandler
    
}