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.Level;
  29 import java.util.logging.Logger;
  30
  31 import net.pterodactylus.fcp.highlevel.GetRequestResult;
  32 import net.pterodactylus.fcp.highlevel.HighLevelCallback;
  33 import net.pterodactylus.fcp.highlevel.HighLevelCallbackListener;
  34 import net.pterodactylus.fcp.highlevel.HighLevelClient;
  35 import net.pterodactylus.fcp.highlevel.HighLevelException;
  36 import net.pterodactylus.fcp.highlevel.HighLevelProgress;
  37 import net.pterodactylus.fcp.highlevel.HighLevelProgressListener;
  38 import net.pterodactylus.fcp.highlevel.PutDirRequestResult;
  39 import net.pterodactylus.fcp.highlevel.PutRequestResult;
  40 import net.pterodactylus.fcp.highlevel.RequestListResult;
  41 import net.pterodactylus.fcp.highlevel.RequestResult;
  42 import net.pterodactylus.jsite.core.Request.Type;
  43 import net.pterodactylus.util.logging.Logging;
  44
  45 /**
  46  * The request manager keeps track of all the request on all connected nodes.
  47  * The request manager is added to the {@link NodeManager} as a
  48  * {@link NodeListener} so that it can fire request-removed events in case a
  49  * node is disconnected.
  50  *
  51  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  52  * @version $Id$
  53  */
  54 public class RequestManager implements NodeListener, HighLevelProgressListener {
  55
  56         /** Logger. */
  57         private static final Logger logger = Logging.getLogger(RequestManager.class.getName());
  58
  59         /** Request listeners. */
  60         private List<RequestListener> requestListeners = Collections.synchronizedList(new ArrayList<RequestListener>());
  61
  62         /** The node manager. */
  63         private NodeManager nodeManager;
  64
  65         /** Request lists for all nodes. */
  66         @SuppressWarnings("unused")
  67         private Map<Node, Map<String, Request>> nodeRequests = Collections.synchronizedMap(new HashMap<Node, Map<String, Request>>());
  68
  69         //
  70         // EVENT MANAGEMENT
  71         //
  72
  73         /**
  74          * Adds a request listener.
  75          *
  76          * @param requestListener
  77          *            The request listener to add
  78          */
  79         public void addRequestListener(RequestListener requestListener) {
  80                 requestListeners.add(requestListener);
  81         }
  82
  83         /**
  84          * Removes a request listener.
  85          *
  86          * @param requestListener
  87          *            The request listener to remove
  88          */
  89         public void removeRequestListener(RequestListener requestListener) {
  90                 requestListeners.remove(requestListener);
  91         }
  92
  93         /**
  94          * Notifies all listeners that a request was added.
  95          *
  96          * @param request
  97          *            The request that was added
  98          */
  99         private void fireRequestAdded(Request request) {
 100                 for (RequestListener requestListener: requestListeners) {
 101                         requestListener.requestAdded(request);
 102                 }
 103         }
 104
 105         /**
 106          * Notifies all listeners that a request progressed.
 107          *
 108          * @param request
 109          *            The request
 110          */
 111         private void fireRequestProgressed(Request request) {
 112                 for (RequestListener requestListener: requestListeners) {
 113                         requestListener.requestProgressed(request);
 114                 }
 115         }
 116
 117         /**
 118          * Notifies all listeners that a request was removed.
 119          *
 120          * @param request
 121          *            The request that was removed
 122          */
 123         private void fireRequestRemoved(Request request) {
 124                 for (RequestListener requestListener: requestListeners) {
 125                         requestListener.requestRemoved(request);
 126                 }
 127         }
 128
 129         //
 130         // ACCESSORS
 131         //
 132
 133         /**
 134          * Sets the node manager to use.
 135          *
 136          * @param nodeManager
 137          *            The node manager
 138          */
 139         public void setNodeManager(NodeManager nodeManager) {
 140                 this.nodeManager = nodeManager;
 141         }
 142
 143         //
 144         // ACTIONS
 145         //
 146
 147         //
 148         // PRIVATE ACTIONS
 149         //
 150
 151         /**
 152          * Requests a list of all running requests from a node. This method will
 153          * block until the request has been sent!
 154          *
 155          * @param node
 156          *            The node to get all requests for
 157          * @throws IOException
 158          *             if an I/O error occurs while communicating with the node
 159          * @throws JSiteException
 160          *             if there is a problem with the node
 161          */
 162         private void getRequests(final Node node) throws IOException, JSiteException {
 163                 HighLevelClient highLevelClient = nodeManager.getHighLevelClient(node);
 164                 if (highLevelClient == null) {
 165                         logger.log(Level.WARNING, "no client for node: " + node);
 166                         return;
 167                 }
 168                 final Map<String, Request> identifierRequests = Collections.synchronizedMap(new HashMap<String, Request>());
 169                 nodeRequests.put(node, identifierRequests);
 170                 HighLevelCallback<RequestListResult> requestListCallback;
 171                 try {
 172                         requestListCallback = highLevelClient.getRequests();
 173                         requestListCallback.addHighLevelCallbackListener(new HighLevelCallbackListener<RequestListResult>() {
 174
 175                                 @SuppressWarnings("synthetic-access")
 176                                 public void gotResult(HighLevelCallback<RequestListResult> highLevelCallback) {
 177                                         RequestListResult requestListResult;
 178                                         try {
 179                                                 requestListResult = highLevelCallback.getResult();
 180                                         } catch (InterruptedException e) {
 181                                                 logger.log(Level.SEVERE, "getResult() blocked and was interrupted");
 182                                                 return;
 183                                         }
 184                                         for (RequestResult requestResult: requestListResult) {
 185                                                 String identifier = requestResult.getIdentifier();
 186                                                 logger.log(Level.FINER, "got identifier: " + identifier);
 187                                                 Request request = identifierRequests.get(identifier);
 188                                                 if (request == null) {
 189                                                         request = new Request(node, identifier);
 190                                                 }
 191                                                 if (request.getType() == null) {
 192                                                         if (requestResult instanceof GetRequestResult) {
 193                                                                 request.setType(Type.get);
 194                                                         } else if (requestResult instanceof PutRequestResult) {
 195                                                                 request.setType(Type.put);
 196                                                         } else if (requestResult instanceof PutDirRequestResult) {
 197                                                                 request.setType(Type.putDir);
 198                                                         }
 199                                                 }
 200                                                 if (identifierRequests.containsKey(identifier)) {
 201                                                         continue;
 202                                                 }
 203                                                 identifierRequests.put(requestResult.getIdentifier(), request);
 204                                                 fireRequestAdded(request);
 205                                         }
 206                                 }
 207                         });
 208                 } catch (HighLevelException hle1) {
 209                         throw new BackendException(hle1);
 210                 }
 211         }
 212
 213         //
 214         // INTERFACE NodeListener
 215         //
 216
 217         /**
 218          * {@inheritDoc}
 219          */
 220         public void nodeAdded(Node node) {
 221                 HighLevelClient highLevelClient = nodeManager.getHighLevelClient(node);
 222                 if (highLevelClient == null) {
 223                         logger.warning("got nodeAdded but no high-level client: " + node);
 224                         return;
 225                 }
 226                 highLevelClient.addHighLevelProgressListener(this);
 227         }
 228
 229         /**
 230          * {@inheritDoc}
 231          */
 232         public void nodeRemoved(Node node) {
 233                 HighLevelClient highLevelClient = nodeManager.getHighLevelClient(node);
 234                 if (highLevelClient == null) {
 235                         logger.warning("got nodeRemoved but no high-level client: " + node);
 236                         return;
 237                 }
 238                 highLevelClient.removeHighLevelProgressListener(this);
 239         }
 240
 241         /**
 242          * {@inheritDoc}
 243          */
 244         public void nodeConnected(Node node) {
 245                 HighLevelClient highLevelClient = nodeManager.getHighLevelClient(node);
 246                 if (highLevelClient == null) {
 247                         logger.log(Level.WARNING, "got no high-level client for node " + node);
 248                         return;
 249                 }
 250                 try {
 251                         highLevelClient.setWatchGlobal(true);
 252                         getRequests(node);
 253                 } catch (HighLevelException hle1) {
 254                         logger.log(Level.WARNING, "error in backend", hle1);
 255                 } catch (JSiteException jse1) {
 256                         logger.log(Level.WARNING, "error in backend", jse1);
 257                 } catch (IOException e) {
 258                         /* ignore exception, disconnects are handled elsewhere. */
 259                 }
 260         }
 261
 262         /**
 263          * {@inheritDoc}
 264          */
 265         public void nodeConnectionFailed(Node node, Throwable cause) {
 266                 /* we don't care about this. */
 267         }
 268
 269         /**
 270          * {@inheritDoc}
 271          */
 272         public void nodeDisconnected(Node node, Throwable throwable) {
 273                 Map<String, Request> identifierRequests = nodeRequests.get(node);
 274                 if (identifierRequests == null) {
 275                         logger.warning("got node without request map: " + node);
 276                         return;
 277                 }
 278                 for (Request request: identifierRequests.values()) {
 279                         fireRequestRemoved(request);
 280                 }
 281                 identifierRequests.clear();
 282         }
 283
 284         //
 285         // INTERFACE HighLevelProgressListener
 286         //
 287
 288         /**
 289          * @see net.pterodactylus.fcp.highlevel.HighLevelProgressListener#progressReceived(HighLevelClient,
 290          *      String, HighLevelProgress)
 291          */
 292         public void progressReceived(HighLevelClient highLevelClient, String identifier, HighLevelProgress highLevelProgress) {
 293                 Node node = nodeManager.getNode(highLevelClient);
 294                 if (node == null) {
 295                         logger.warning("got high-level client without node: " + highLevelClient);
 296                         return;
 297                 }
 298                 Map<String, Request> identifierRequests = nodeRequests.get(node);
 299                 if (identifierRequests == null) {
 300                         logger.warning("got node without request map: " + node);
 301                         identifierRequests = Collections.synchronizedMap(new HashMap<String, Request>());
 302                         nodeRequests.put(node, identifierRequests);
 303                 }
 304                 Request request = identifierRequests.get(identifier);
 305                 if (request == null) {
 306                         logger.warning("got progress for unknown request: " + identifier);
 307                         request = new Request(node, identifier);
 308                         identifierRequests.put(identifier, request);
 309                         fireRequestAdded(request);
 310                 }
 311                 request.setTotalBlocks(highLevelProgress.getTotalBlocks());
 312                 request.setRequiredBlocks(highLevelProgress.getRequiredBlocks());
 313                 request.setSuccessfulBlocks(highLevelProgress.getSuccessfulBlocks());
 314                 request.setFailedBlocks(highLevelProgress.getFailedBlocks());
 315                 request.setFatallyFailedBlocks(highLevelProgress.getFatallyFailedBlocks());
 316                 request.setTotalFinalized(highLevelProgress.isTotalFinalized());
 317                 fireRequestProgressed(request);
 318         }
 319
 320 }