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.ArrayList;
  25 import java.util.List;
  26 import java.util.concurrent.Executor;
  27 import java.util.concurrent.Executors;
  28 import java.util.logging.Level;
  29 import java.util.logging.Logger;
  30
  31 import net.pterodactylus.util.logging.Logging;
  32
  33 /**
  34  * The core of jSite.
  35  *
  36  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  37  */
  38 public class CoreImpl implements Core, NodeListener, RequestListener {
  39
  40         /** The logger. */
  41         private static final Logger logger = Logging.getLogger(CoreImpl.class.getName());
  42
  43         /** The core listeners. */
  44         private final List<CoreListener> coreListeners = new ArrayList<CoreListener>();
  45
  46         /** Thread pool. */
  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         //
  61         // LISTENER MANAGEMENT
  62         //
  63
  64         /**
  65          * {@inheritDoc}
  66          */
  67         public void addCoreListener(CoreListener coreListener) {
  68                 logger.log(Level.FINEST, "adding core listener: " + coreListener);
  69                 coreListeners.add(coreListener);
  70         }
  71
  72         /**
  73          * {@inheritDoc}
  74          */
  75         public void removeCoreListener(CoreListener coreListener) {
  76                 logger.log(Level.FINEST, "removing core listener: " + coreListener);
  77                 coreListeners.remove(coreListener);
  78         }
  79
  80         /**
  81          * Notifies all listeners that the projects were loaded successfully.
  82          *
  83          * @param directory
  84          *            The directory the projects were loaded from
  85          */
  86         private void fireLoadingProjectsDone(String directory) {
  87                 logger.log(Level.FINEST, "firing loadingProjectsDone event with [directory=" + directory + "]");
  88                 for (CoreListener coreListener : coreListeners) {
  89                         coreListener.loadingProjectsDone(directory);
  90                 }
  91         }
  92
  93         /**
  94          * Notifies all core listeners that loading the projects from the given
  95          * directory has failed.
  96          *
  97          * @param directory
  98          *            The directory the projects were tried to load from
  99          * @param throwable
 100          *            The exception that occured when loading projects
 101          */
 102         private void fireLoadingProjectsFailed(String directory, Throwable throwable) {
 103                 logger.log(Level.FINEST, "firing loadingProjectsFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 104                 for (CoreListener coreListener : coreListeners) {
 105                         coreListener.loadingProjectsFailed(directory, throwable);
 106                 }
 107         }
 108
 109         /**
 110          * Notifies all listeners that the projects were successfully saved.
 111          *
 112          * @param directory
 113          *            The directory the projects were saved to
 114          */
 115         private void fireSavingProjectsDone(String directory) {
 116                 logger.log(Level.FINEST, "firing savingProjectsDone event with [directory=" + directory + "]");
 117                 for (CoreListener coreListener : coreListeners) {
 118                         coreListener.savingProjectsDone(directory);
 119                 }
 120         }
 121
 122         /**
 123          * Notifies all listeners that the projects could not be saved.
 124          *
 125          * @param directory
 126          *            The directory the projects were to be saved to
 127          * @param throwable
 128          *            The exception that occured when saving the projects
 129          */
 130         private void fireSavingProjectsFailed(String directory, Throwable throwable) {
 131                 logger.log(Level.FINEST, "firing savingProjectsFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 132                 for (CoreListener coreListener : coreListeners) {
 133                         coreListener.savingProjectsFailed(directory, throwable);
 134                 }
 135         }
 136
 137         /**
 138          * Notifies all listeners that a project was added.
 139          *
 140          * @param project
 141          *            The project that was added
 142          */
 143         private void fireProjectAdded(Project project) {
 144                 logger.log(Level.FINEST, "firing projectAdded event with [project=" + project + "]");
 145                 for (CoreListener coreListener : coreListeners) {
 146                         coreListener.projectAdded(project);
 147                 }
 148         }
 149
 150         /**
 151          * Notifies all listeners that a project was cloned.
 152          *
 153          * @param clonedProject
 154          *            The project that was cloned
 155          * @param projectClone
 156          *            The clone of the project
 157          */
 158         private void fireProjectCloned(Project clonedProject, Project projectClone) {
 159                 logger.log(Level.FINEST, "firing projectCloned event with [clonedProject=" + clonedProject + ",projectClone=" + projectClone + "]");
 160                 for (CoreListener coreListener : coreListeners) {
 161                         coreListener.projectCloned(clonedProject, projectClone);
 162                 }
 163         }
 164
 165         /**
 166          * Notifies all listeners that a project was removed.
 167          *
 168          * @param project
 169          *            The project that was removed
 170          */
 171         private void fireProjectRemoved(Project project) {
 172                 logger.log(Level.FINEST, "firing projectRemoved event with [project=" + project + "]");
 173                 for (CoreListener coreListener : coreListeners) {
 174                         coreListener.projectRemoved(project);
 175                 }
 176         }
 177
 178         /**
 179          * Notifies all listeners that the nodes were successfully loaded.
 180          *
 181          * @param directory
 182          *            The directory the nodes were loaded from
 183          */
 184         private void fireLoadingNodesDone(String directory) {
 185                 logger.log(Level.FINEST, "firing loadingNodesDone event with [directory=" + directory + "]");
 186                 for (CoreListener coreListener : coreListeners) {
 187                         coreListener.loadingNodesDone(directory);
 188                 }
 189         }
 190
 191         /**
 192          * Notifies all listeners that loading the nodes has failed.
 193          *
 194          * @param directory
 195          *            The directory the nodes were loaded from
 196          * @param throwable
 197          *            The exception that occured while loading the nodes
 198          */
 199         private void fireLoadingNodesFailed(String directory, Throwable throwable) {
 200                 logger.log(Level.FINEST, "firing loadingNodesFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 201                 for (CoreListener coreListener : coreListeners) {
 202                         coreListener.loadingNodesFailed(directory, throwable);
 203                 }
 204         }
 205
 206         /**
 207          * Notifies all listeners that the nodes were saved successfully.
 208          *
 209          * @param directory
 210          *            The directory the nodes were saved to
 211          */
 212         private void fireSavingNodesDone(String directory) {
 213                 logger.log(Level.FINEST, "firing savingNodesDone event with [directory=" + directory + "]");
 214                 for (CoreListener coreListener : coreListeners) {
 215                         coreListener.savingNodesDone(directory);
 216                 }
 217         }
 218
 219         /**
 220          * Notifies all listeners that saving the nodes has failed.
 221          *
 222          * @param directory
 223          *            The directory the nodes were saved to
 224          * @param throwable
 225          *            The exception that occured while saving the nodes
 226          */
 227         private void fireSavingNodesFailed(String directory, Throwable throwable) {
 228                 logger.log(Level.FINEST, "firing savingNodesFailed event with [directory=" + directory + ",throwable=" + throwable + "]");
 229                 for (CoreListener coreListener : coreListeners) {
 230                         coreListener.savingProjectsFailed(directory, throwable);
 231                 }
 232         }
 233
 234         /**
 235          * Notifies all core listeners that the core has loaded and is ready to run.
 236          */
 237         private void fireCoreLoaded() {
 238                 logger.log(Level.FINEST, "firing coreLoaded event");
 239                 for (CoreListener coreListener : coreListeners) {
 240                         coreListener.coreLoaded();
 241                 }
 242         }
 243
 244         /**
 245          * Notifies all listeners that the core was stopped.
 246          */
 247         private void fireCoreStopped() {
 248                 logger.log(Level.FINEST, "firing coreStopped event");
 249                 for (CoreListener coreListener : coreListeners) {
 250                         coreListener.coreStopped();
 251                 }
 252         }
 253
 254         /**
 255          * Notifies all listeners that a node was added to the core.
 256          *
 257          * @param node
 258          *            The node that was added
 259          */
 260         private void fireNodeAdded(Node node) {
 261                 logger.log(Level.FINEST, "firing nodeAdded event with [node=" + node + "]");
 262                 for (CoreListener coreListener : coreListeners) {
 263                         coreListener.nodeAdded(node);
 264                 }
 265         }
 266
 267         /**
 268          * Notifies all listeners that a node was removed from the core.
 269          *
 270          * @param node
 271          *            The node that was removed
 272          */
 273         private void fireNodeRemoved(Node node) {
 274                 logger.log(Level.FINEST, "firing nodeRemoved event with [node=" + node + "]");
 275                 for (CoreListener coreListener : coreListeners) {
 276                         coreListener.nodeRemoved(node);
 277                 }
 278         }
 279
 280         /**
 281          * Notifies all listeners that a connection to the given node is now being
 282          * established.
 283          *
 284          * @param node
 285          *            The node that is being connected to
 286          */
 287         private void fireNodeConnecting(Node node) {
 288                 logger.log(Level.FINEST, "firing nodeConnecting event with [node=" + node + "]");
 289                 for (CoreListener coreListener : coreListeners) {
 290                         coreListener.nodeConnecting(node);
 291                 }
 292         }
 293
 294         /**
 295          * Notifies all listeners that the given node is now connected.
 296          *
 297          * @param node
 298          *            The node that is now connected
 299          */
 300         private void fireNodeConnected(Node node) {
 301                 logger.log(Level.FINEST, "firing nodeConnected event with [node=" + node + "]");
 302                 for (CoreListener coreListener : coreListeners) {
 303                         coreListener.nodeConnected(node);
 304                 }
 305         }
 306
 307         /**
 308          * Notifies all listeners that a connection to a node has failed.
 309          *
 310          * @param node
 311          *            The node that could not be connected
 312          * @param cause
 313          *            The cause of the failure
 314          */
 315         private void fireNodeConnectionFailed(Node node, Throwable cause) {
 316                 logger.log(Level.FINEST, "firing nodeConnectionFailed event with [node=" + node + ",cause=" + cause + "]");
 317                 for (CoreListener coreListener : coreListeners) {
 318                         coreListener.nodeConnectionFailed(node, cause);
 319                 }
 320         }
 321
 322         /**
 323          * Notifies all listeners that the given node was disconnected.
 324          *
 325          * @param node
 326          *            The node that is now disconnected
 327          * @param throwable
 328          *            The exception that caused the disconnect, or <code>null</code>
 329          *            if there was no exception
 330          */
 331         private void fireNodeDisconnected(Node node, Throwable throwable) {
 332                 logger.log(Level.FINEST, "firing nodeDisconnected event with [node=" + node + ",throwable=" + throwable + "]");
 333                 for (CoreListener coreListener : coreListeners) {
 334                         coreListener.nodeDisconnected(node, throwable);
 335                 }
 336         }
 337
 338         //
 339         // ACCESSORS
 340         //
 341
 342         /**
 343          * {@inheritDoc}
 344          */
 345         public Executor getThreadPool() {
 346                 return threadPool;
 347         }
 348
 349         /**
 350          * Returns the project manager.
 351          *
 352          * @return The project manager
 353          */
 354         public ProjectManager getProjectManager() {
 355                 return projectManager;
 356         }
 357
 358         /**
 359          * Sets the project manager to use.
 360          *
 361          * @param projectManager
 362          *            The project manager to use
 363          */
 364         public void setProjectManager(ProjectManager projectManager) {
 365                 this.projectManager = projectManager;
 366         }
 367
 368         /**
 369          * Returns the node manager.
 370          *
 371          * @return The node manager
 372          */
 373         public NodeManager getNodeManager() {
 374                 return nodeManager;
 375         }
 376
 377         /**
 378          * Sets the node manager to use.
 379          *
 380          * @param nodeManager
 381          *            The node manager to use
 382          */
 383         public void setNodeManager(NodeManager nodeManager) {
 384                 this.nodeManager = nodeManager;
 385         }
 386
 387         /**
 388          * Sets the request manager to use.
 389          *
 390          * @param requestManager
 391          *            The request manager to use
 392          */
 393         public void setRequestManager(RequestManager requestManager) {
 394                 this.requestManager = requestManager;
 395         }
 396
 397         /**
 398          * {@inheritDoc}
 399          */
 400         public List<Node> getNodes() {
 401                 return nodeManager.getNodes();
 402         }
 403
 404         /**
 405          * {@inheritDoc}
 406          */
 407         public boolean isNodeConnected(Node node) {
 408                 return nodeManager.hasNode(node);
 409         }
 410
 411         /**
 412          * {@inheritDoc}
 413          */
 414         public List<Project> getProjects() {
 415                 return projectManager.getProjects();
 416         }
 417
 418         //
 419         // ACTIONS
 420         //
 421
 422         /**
 423          * {@inheritDoc}
 424          */
 425         public void start() {
 426                 logger.log(Level.INFO, "starting core…");
 427                 try {
 428                         nodeManager.load();
 429                         fireLoadingNodesDone(nodeManager.getDirectory());
 430                 } catch (IOException ioe1) {
 431                         fireLoadingNodesFailed(nodeManager.getDirectory(), ioe1);
 432                 }
 433                 try {
 434                         projectManager.load();
 435                         fireLoadingProjectsDone(projectManager.getDirectory());
 436                 } catch (IOException ioe1) {
 437                         fireLoadingProjectsFailed(projectManager.getDirectory(), ioe1);
 438                 }
 439                 fireCoreLoaded();
 440         }
 441
 442         /**
 443          * {@inheritDoc}
 444          */
 445         public void stop() {
 446                 logger.log(Level.INFO, "stopping core…");
 447                 try {
 448                         projectManager.save();
 449                         fireSavingProjectsDone(projectManager.getDirectory());
 450                 } catch (IOException ioe1) {
 451                         fireSavingProjectsFailed(projectManager.getDirectory(), ioe1);
 452                 }
 453                 try {
 454                         nodeManager.save();
 455                         fireSavingNodesDone(nodeManager.getDirectory());
 456                 } catch (IOException ioe1) {
 457                         fireSavingNodesFailed(nodeManager.getDirectory(), ioe1);
 458                 }
 459                 fireCoreStopped();
 460         }
 461
 462         /**
 463          * {@inheritDoc}
 464          */
 465         public boolean addNode(Node node) throws UnknownHostException {
 466                 logger.log(Level.FINEST, "addNode(node=" + node + ")");
 467                 return nodeManager.addNode(node);
 468         }
 469
 470         /**
 471          * {@inheritDoc}
 472          */
 473         public void removeNode(Node node) {
 474                 logger.log(Level.FINEST, "removeNode(node=" + node + ")");
 475                 nodeManager.removeNode(node);
 476         }
 477
 478         /**
 479          * {@inheritDoc}
 480          */
 481         public void connectToNode(Node node) {
 482                 logger.log(Level.FINEST, "connectToNode(node=" + node + ")");
 483                 fireNodeConnecting(node);
 484                 nodeManager.connect(node);
 485         }
 486
 487         /**
 488          * {@inheritDoc}
 489          */
 490         public void disconnectFromNode(Node node) {
 491                 logger.log(Level.FINEST, "disconnectFromNode(node=" + node + ")");
 492                 nodeManager.disconnect(node);
 493         }
 494
 495         /**
 496          * {@inheritDoc}
 497          */
 498         public void createProject() throws IOException, JSiteException {
 499                 logger.log(Level.FINEST, "createProject()");
 500                 Project newProject = projectManager.createProject();
 501                 fireProjectAdded(newProject);
 502         }
 503
 504         /**
 505          * {@inheritDoc}
 506          */
 507         public void cloneProject(Project project) {
 508                 logger.log(Level.FINEST, "cloneProject(project=" + project + ")");
 509                 Project projectClone = projectManager.cloneProject(project);
 510                 fireProjectCloned(project, projectClone);
 511         }
 512
 513         /**
 514          * {@inheritDoc}
 515          */
 516         public void removeProject(Project project) {
 517                 logger.log(Level.FINEST, "removeProject(project=" + project + ")");
 518                 projectManager.removeProject(project);
 519                 fireProjectRemoved(project);
 520         }
 521
 522         //
 523         // PRIVATE METHODS
 524         //
 525
 526         /**
 527          * Loads the configuration.
 528          */
 529         @SuppressWarnings("unused")
 530         private void loadConfig() {
 531                 logger.log(Level.FINEST, "loadConfig()");
 532                 /* TODO */
 533         }
 534
 535         /**
 536          * Saves the configuration.
 537          */
 538         @SuppressWarnings("unused")
 539         private void saveConfig() {
 540                 logger.log(Level.FINEST, "saveConfig()");
 541                 /* TODO */
 542         }
 543
 544         //
 545         // INTERFACE NodeListener
 546         //
 547
 548         /**
 549          * {@inheritDoc}
 550          */
 551         public void nodeAdded(Node node) {
 552                 fireNodeAdded(node);
 553         }
 554
 555         /**
 556          * {@inheritDoc}
 557          */
 558         public void nodeRemoved(Node node) {
 559                 fireNodeRemoved(node);
 560         }
 561
 562         /**
 563          * {@inheritDoc}
 564          */
 565         public void nodeConnected(Node node) {
 566                 fireNodeConnected(node);
 567         }
 568
 569         /**
 570          * {@inheritDoc}
 571          */
 572         public void nodeConnectionFailed(Node node, Throwable cause) {
 573                 fireNodeConnectionFailed(node, cause);
 574         }
 575
 576         /**
 577          * {@inheritDoc}
 578          */
 579         public void nodeDisconnected(Node node, Throwable throwable) {
 580                 fireNodeDisconnected(node, throwable);
 581         }
 582
 583         //
 584         // INTERFACE RequestListener
 585         //
 586
 587         /**
 588          * {@inheritDoc}
 589          */
 590         public void requestAdded(Request request) {
 591                 /* TODO - find project and process request */
 592         }
 593
 594         /**
 595          * @see net.pterodactylus.jsite.core.RequestListener#requestProgressed(Request)
 596          */
 597         public void requestProgressed(Request request) {
 598                 /* TODO - find project and process request */
 599         }
 600
 601         /**
 602          * @see net.pterodactylus.jsite.core.RequestListener#requestRemoved(net.pterodactylus.jsite.core.Request)
 603          */
 604         public void requestRemoved(Request request) {
 605                 /* TODO - find project and process request */
 606         }
 607
 608         /**
 609          * @see net.pterodactylus.jsite.core.RequestListener#requestGeneratedURI(net.pterodactylus.jsite.core.Request,
 610          *      java.lang.String)
 611          */
 612         public void requestGeneratedURI(Request request, String uri) {
 613                 /* TODO - find project and process request */
 614         }
 615
 616         /**
 617          * @see net.pterodactylus.jsite.core.RequestListener#requestFinished(net.pterodactylus.jsite.core.Request)
 618          */
 619         public void requestFinished(Request request) {
 620                 /* TODO - find project and process request */
 621         }
 622
 623 }