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