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