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