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

   1 /*
   2  * jSite2 - Core.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.net.UnknownHostException;
  24 import java.util.List;
  25 import java.util.concurrent.Executor;
  26 import java.util.concurrent.Executors;
  27 import java.util.logging.Level;
  28 import java.util.logging.Logger;
  29
  30 import net.pterodactylus.util.logging.Logging;
  31
  32 /**
  33  * The core of jSite.
  34  *
  35  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  36  */
  37 public class CoreImpl implements Core, NodeListener, RequestListener, InsertListener {
  38
  39         /** The logger. */
  40         private static final Logger logger = Logging.getLogger(CoreImpl.class.getName());
  41
  42         /** The core listener support. */
  43         private final CoreListenerSupport coreListenerSupport = new CoreListenerSupport();
  44
  45         /** Thread pool. */
  46         @SuppressWarnings("unused")
  47         private Executor threadPool = Executors.newCachedThreadPool();
  48
  49         /** The project manager. */
  50         private ProjectManager projectManager;
  51
  52         /** The node manager. */
  53         private NodeManager nodeManager;
  54
  55         /** The request manager. */
  56         /* TODO - remove */
  57         @SuppressWarnings("unused")
  58         private RequestManager requestManager;
  59
  60         /** The insert manager. */
  61         private InsertManager insertManager;
  62
  63         //
  64         // LISTENER MANAGEMENT
  65         //
  66
  67         /**
  68          * {@inheritDoc}
  69          */
  70         public void addCoreListener(CoreListener coreListener) {
  71                 logger.log(Level.FINEST, "adding core listener: " + coreListener);
  72                 coreListenerSupport.addListener(coreListener);
  73         }
  74
  75         /**
  76          * {@inheritDoc}
  77          */
  78         public void removeCoreListener(CoreListener coreListener) {
  79                 logger.log(Level.FINEST, "removing core listener: " + coreListener);
  80                 coreListenerSupport.removeListener(coreListener);
  81         }
  82
  83         //
  84         // ACCESSORS
  85         //
  86
  87         /**
  88          * Returns the project manager.
  89          *
  90          * @return The project manager
  91          */
  92         public ProjectManager getProjectManager() {
  93                 return projectManager;
  94         }
  95
  96         /**
  97          * Sets the project manager to use.
  98          *
  99          * @param projectManager
 100          *            The project manager to use
 101          */
 102         public void setProjectManager(ProjectManager projectManager) {
 103                 this.projectManager = projectManager;
 104         }
 105
 106         /**
 107          * Returns the node manager.
 108          *
 109          * @return The node manager
 110          */
 111         public NodeManager getNodeManager() {
 112                 return nodeManager;
 113         }
 114
 115         /**
 116          * Sets the node manager to use.
 117          *
 118          * @param nodeManager
 119          *            The node manager to use
 120          */
 121         public void setNodeManager(NodeManager nodeManager) {
 122                 this.nodeManager = nodeManager;
 123         }
 124
 125         /**
 126          * Sets the request manager to use.
 127          *
 128          * @param requestManager
 129          *            The request manager to use
 130          */
 131         public void setRequestManager(RequestManager requestManager) {
 132                 this.requestManager = requestManager;
 133         }
 134
 135         /**
 136          * Sets the insert manager to use.
 137          *
 138          * @param insertManager
 139          *            The insert manager to use
 140          */
 141         public void setInsertManager(InsertManager insertManager) {
 142                 this.insertManager = insertManager;
 143         }
 144
 145         /**
 146          * {@inheritDoc}
 147          */
 148         public List<Node> getNodes() {
 149                 return nodeManager.getNodes();
 150         }
 151
 152         /**
 153          * {@inheritDoc}
 154          */
 155         public boolean isNodeConnected(Node node) {
 156                 return nodeManager.isNodeConnected(node);
 157         }
 158
 159         /**
 160          * {@inheritDoc}
 161          */
 162         public List<Project> getProjects() {
 163                 return projectManager.getProjects();
 164         }
 165
 166         //
 167         // ACTIONS
 168         //
 169
 170         /**
 171          * {@inheritDoc}
 172          */
 173         public void start() {
 174                 logger.log(Level.INFO, "starting core…");
 175                 try {
 176                         nodeManager.load();
 177                         coreListenerSupport.fireLoadingNodesDone(nodeManager.getDirectory());
 178                 } catch (IOException ioe1) {
 179                         coreListenerSupport.fireLoadingNodesFailed(nodeManager.getDirectory(), ioe1);
 180                 }
 181                 try {
 182                         projectManager.load();
 183                         coreListenerSupport.fireLoadingProjectsDone(projectManager.getDirectory());
 184                 } catch (IOException ioe1) {
 185                         coreListenerSupport.fireLoadingProjectsFailed(projectManager.getDirectory(), ioe1);
 186                 }
 187                 coreListenerSupport.fireCoreLoaded();
 188         }
 189
 190         /**
 191          * {@inheritDoc}
 192          */
 193         public void stop() {
 194                 logger.log(Level.INFO, "stopping core…");
 195                 try {
 196                         projectManager.save();
 197                         coreListenerSupport.fireSavingProjectsDone(projectManager.getDirectory());
 198                 } catch (IOException ioe1) {
 199                         coreListenerSupport.fireSavingProjectsFailed(projectManager.getDirectory(), ioe1);
 200                 }
 201                 try {
 202                         nodeManager.save();
 203                         coreListenerSupport.fireSavingNodesDone(nodeManager.getDirectory());
 204                 } catch (IOException ioe1) {
 205                         coreListenerSupport.fireSavingNodesFailed(nodeManager.getDirectory(), ioe1);
 206                 }
 207                 coreListenerSupport.fireCoreStopped();
 208         }
 209
 210         /**
 211          * {@inheritDoc}
 212          */
 213         public boolean addNode(Node node) throws UnknownHostException {
 214                 logger.log(Level.FINEST, "addNode(node=" + node + ")");
 215                 return nodeManager.addNode(node);
 216         }
 217
 218         /**
 219          * {@inheritDoc}
 220          */
 221         public void removeNode(Node node) {
 222                 logger.log(Level.FINEST, "removeNode(node=" + node + ")");
 223                 nodeManager.removeNode(node);
 224         }
 225
 226         /**
 227          * {@inheritDoc}
 228          */
 229         public void connectToNode(Node node) {
 230                 logger.log(Level.FINEST, "connectToNode(node=" + node + ")");
 231                 coreListenerSupport.fireNodeConnecting(node);
 232                 nodeManager.connect(node);
 233         }
 234
 235         /**
 236          * {@inheritDoc}
 237          */
 238         public void disconnectFromNode(Node node) {
 239                 logger.log(Level.FINEST, "disconnectFromNode(node=" + node + ")");
 240                 nodeManager.disconnect(node);
 241         }
 242
 243         /**
 244          * {@inheritDoc}
 245          */
 246         public void createProject() throws IOException, JSiteException {
 247                 logger.log(Level.FINEST, "createProject()");
 248                 Project newProject = projectManager.createProject();
 249                 coreListenerSupport.fireProjectAdded(newProject);
 250         }
 251
 252         /**
 253          * {@inheritDoc}
 254          */
 255         public void insertProject(Node node, Project project) {
 256                 logger.log(Level.FINEST, "insertProject(node=" + node + ", project=" + project + ")");
 257                 insertManager.insertProject(project, node);
 258         }
 259
 260         /**
 261          * {@inheritDoc}
 262          */
 263         public void cloneProject(Project project) {
 264                 logger.log(Level.FINEST, "cloneProject(project=" + project + ")");
 265                 Project projectClone = projectManager.cloneProject(project);
 266                 coreListenerSupport.fireProjectCloned(project, projectClone);
 267         }
 268
 269         /**
 270          * {@inheritDoc}
 271          */
 272         public void removeProject(Project project) {
 273                 logger.log(Level.FINEST, "removeProject(project=" + project + ")");
 274                 projectManager.removeProject(project);
 275                 coreListenerSupport.fireProjectRemoved(project);
 276         }
 277
 278         //
 279         // PRIVATE METHODS
 280         //
 281
 282         /**
 283          * Loads the configuration.
 284          */
 285         @SuppressWarnings("unused")
 286         private void loadConfig() {
 287                 logger.log(Level.FINEST, "loadConfig()");
 288                 /* TODO */
 289         }
 290
 291         /**
 292          * Saves the configuration.
 293          */
 294         @SuppressWarnings("unused")
 295         private void saveConfig() {
 296                 logger.log(Level.FINEST, "saveConfig()");
 297                 /* TODO */
 298         }
 299
 300         //
 301         // INTERFACE NodeListener
 302         //
 303
 304         /**
 305          * {@inheritDoc}
 306          */
 307         public void nodeAdded(Node node) {
 308                 coreListenerSupport.fireNodeAdded(node);
 309         }
 310
 311         /**
 312          * {@inheritDoc}
 313          */
 314         public void nodeRemoved(Node node) {
 315                 coreListenerSupport.fireNodeRemoved(node);
 316         }
 317
 318         /**
 319          * {@inheritDoc}
 320          */
 321         public void nodeConnected(Node node) {
 322                 coreListenerSupport.fireNodeConnected(node);
 323         }
 324
 325         /**
 326          * {@inheritDoc}
 327          */
 328         public void nodeConnectionFailed(Node node, Throwable cause) {
 329                 coreListenerSupport.fireNodeConnectionFailed(node, cause);
 330         }
 331
 332         /**
 333          * {@inheritDoc}
 334          */
 335         public void nodeDisconnected(Node node, Throwable throwable) {
 336                 coreListenerSupport.fireNodeDisconnected(node, throwable);
 337         }
 338
 339         //
 340         // INTERFACE RequestListener
 341         //
 342
 343         /**
 344          * {@inheritDoc}
 345          */
 346         public void requestAdded(Request request) {
 347                 /* TODO - find project and process request */
 348         }
 349
 350         /**
 351          * @see net.pterodactylus.jsite.core.RequestListener#requestProgressed(Request)
 352          */
 353         public void requestProgressed(Request request) {
 354                 /* TODO - find project and process request */
 355         }
 356
 357         /**
 358          * @see net.pterodactylus.jsite.core.RequestListener#requestRemoved(net.pterodactylus.jsite.core.Request)
 359          */
 360         public void requestRemoved(Request request) {
 361                 /* TODO - find project and process request */
 362         }
 363
 364         /**
 365          * @see net.pterodactylus.jsite.core.RequestListener#requestGeneratedURI(net.pterodactylus.jsite.core.Request,
 366          *      java.lang.String)
 367          */
 368         public void requestGeneratedURI(Request request, String uri) {
 369                 /* TODO - find project and process request */
 370         }
 371
 372         /**
 373          * @see net.pterodactylus.jsite.core.RequestListener#requestFinished(net.pterodactylus.jsite.core.Request)
 374          */
 375         public void requestFinished(Request request) {
 376                 /* TODO - find project and process request */
 377         }
 378
 379         //
 380         // INTERFACE InsertListener
 381         //
 382
 383         /**
 384          * {@inheritDoc}
 385          */
 386         public void insertAdded(Insert insert) {
 387                 /* TODO */
 388         }
 389
 390         /**
 391          * {@inheritDoc}
 392          */
 393         public void insertRemoved(Insert insert) {
 394                 /* TODO */
 395         }
 396
 397         /**
 398          * {@inheritDoc}
 399          */
 400         public void insertStarted(Insert insert) {
 401                 /* TODO */
 402         }
 403
 404         /**
 405          * {@inheritDoc}
 406          */
 407         public void insertProgressed(Insert insert) {
 408                 /* TODO */
 409         }
 410
 411         /**
 412          * {@inheritDoc}
 413          */
 414         public void insertGeneratedURI(Insert insert, String uri) {
 415                 /* TODO */
 416         }
 417
 418         /**
 419          * {@inheritDoc}
 420          */
 421         public void insertFinished(Insert insert) {
 422                 /* TODO */
 423         }
 424
 425 }