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