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