src/net/pterodactylus/jsite/core/RequestManager.java

   1 /*
   2  * jSite2 - RequestManager.java -
   3  * Copyright © 2008 David Roden
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 package net.pterodactylus.jsite.core;
  21
  22 import java.io.IOException;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.logging.Logger;
  29
  30 import net.pterodactylus.util.logging.Logging;
  31
  32 /**
  33  * The request manager keeps track of all the request on all connected nodes.
  34  * The request manager is added to the {@link NodeManager} as a
  35  * {@link NodeListener} so that it can fire request-removed events in case a
  36  * node is disconnected.
  37  *
  38  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  39  */
  40 public class RequestManager implements NodeListener {
  41
  42         /** Logger. */
  43         private static final Logger logger = Logging.getLogger(RequestManager.class.getName());
  44
  45         /** Request listeners. */
  46         private List<RequestListener> requestListeners = Collections.synchronizedList(new ArrayList<RequestListener>());
  47
  48         /** The node manager. */
  49         private NodeManager nodeManager;
  50
  51         /** Request lists for all nodes. */
  52         private Map<Node, Map<String, Request>> nodeRequests = Collections.synchronizedMap(new HashMap<Node, Map<String, Request>>());
  53
  54         //
  55         // EVENT MANAGEMENT
  56         //
  57
  58         /**
  59          * Adds a request listener.
  60          *
  61          * @param requestListener
  62          *            The request listener to add
  63          */
  64         public void addRequestListener(RequestListener requestListener) {
  65                 requestListeners.add(requestListener);
  66         }
  67
  68         /**
  69          * Removes a request listener.
  70          *
  71          * @param requestListener
  72          *            The request listener to remove
  73          */
  74         public void removeRequestListener(RequestListener requestListener) {
  75                 requestListeners.remove(requestListener);
  76         }
  77
  78         /**
  79          * Notifies all listeners that a request was added.
  80          *
  81          * @param request
  82          *            The request that was added
  83          */
  84         private void fireRequestAdded(Request request) {
  85                 for (RequestListener requestListener : requestListeners) {
  86                         requestListener.requestAdded(request);
  87                 }
  88         }
  89
  90         /**
  91          * Notifies all listeners that a request progressed.
  92          *
  93          * @param request
  94          *            The request
  95          */
  96         private void fireRequestProgressed(Request request) {
  97                 for (RequestListener requestListener : requestListeners) {
  98                         requestListener.requestProgressed(request);
  99                 }
 100         }
 101
 102         /**
 103          * Notifies all listeners that a request was removed.
 104          *
 105          * @param request
 106          *            The request that was removed
 107          */
 108         private void fireRequestRemoved(Request request) {
 109                 for (RequestListener requestListener : requestListeners) {
 110                         requestListener.requestRemoved(request);
 111                 }
 112         }
 113
 114         /**
 115          * Notifies all listeners that a request has finished.
 116          *
 117          * @see RequestListener#requestFinished(Request)
 118          * @param request
 119          *            The request that has finished
 120          */
 121         private void fireRequestFinished(Request request) {
 122                 for (RequestListener requestListener : requestListeners) {
 123                         requestListener.requestFinished(request);
 124                 }
 125         }
 126
 127         /**
 128          * Notifies all listeners that a request has generated a URI.
 129          *
 130          * @see RequestListener#requestGeneratedURI(Request, String)
 131          * @param request
 132          *            The request that has generated a URI
 133          * @param uri
 134          *            The generated URI
 135          */
 136         private void fireRequestGeneratedURI(Request request, String uri) {
 137                 for (RequestListener requestListener : requestListeners) {
 138                         requestListener.requestGeneratedURI(request, uri);
 139                 }
 140         }
 141
 142         //
 143         // ACCESSORS
 144         //
 145
 146         /**
 147          * Sets the node manager to use.
 148          *
 149          * @param nodeManager
 150          *            The node manager
 151          */
 152         public void setNodeManager(NodeManager nodeManager) {
 153                 this.nodeManager = nodeManager;
 154         }
 155
 156         //
 157         // ACTIONS
 158         //
 159
 160         //
 161         // PRIVATE ACTIONS
 162         //
 163
 164         /**
 165          * Requests a list of all running requests from a node. This method will
 166          * block until the request has been sent!
 167          *
 168          * @param node
 169          *            The node to get all requests for
 170          * @throws IOException
 171          *             if an I/O error occurs while communicating with the node
 172          * @throws JSiteException
 173          *             if there is a problem with the node
 174          */
 175         private void getRequests(final Node node) throws IOException, JSiteException {
 176         }
 177
 178         //
 179         // INTERFACE NodeListener
 180         //
 181
 182         /**
 183          * {@inheritDoc}
 184          */
 185         public void nodeAdded(Node node) {
 186         }
 187
 188         /**
 189          * {@inheritDoc}
 190          */
 191         public void nodeRemoved(Node node) {
 192         }
 193
 194         /**
 195          * {@inheritDoc}
 196          */
 197         public void nodeConnected(Node node) {
 198         }
 199
 200         /**
 201          * {@inheritDoc}
 202          */
 203         public void nodeConnectionFailed(Node node, Throwable cause) {
 204                 /* we don't care about this. */
 205         }
 206
 207         /**
 208          * {@inheritDoc}
 209          */
 210         public void nodeDisconnected(Node node, Throwable throwable) {
 211                 Map<String, Request> identifierRequests = nodeRequests.get(node);
 212                 if (identifierRequests == null) {
 213                         logger.warning("got node without request map: " + node);
 214                         return;
 215                 }
 216                 for (Request request : identifierRequests.values()) {
 217                         fireRequestRemoved(request);
 218                 }
 219                 identifierRequests.clear();
 220         }
 221
 222 }