Add plugins to template factory.
[Sone.git] / src / main / java / net / pterodactylus / sone / main / SonePlugin.java
1 /*
2  * FreenetSone - SonePlugin.java - Copyright © 2010 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.main;
19
20 import java.io.File;
21 import java.util.Collections;
22 import java.util.logging.Level;
23 import java.util.logging.Logger;
24
25 import net.pterodactylus.sone.core.Core;
26 import net.pterodactylus.sone.core.FreenetInterface;
27 import net.pterodactylus.sone.freenet.PluginStoreConfigurationBackend;
28 import net.pterodactylus.sone.web.WebInterface;
29 import net.pterodactylus.util.config.Configuration;
30 import net.pterodactylus.util.config.ConfigurationException;
31 import net.pterodactylus.util.config.MapConfigurationBackend;
32 import net.pterodactylus.util.config.XMLConfigurationBackend;
33 import net.pterodactylus.util.logging.Logging;
34 import net.pterodactylus.util.version.Version;
35 import freenet.client.async.DatabaseDisabledException;
36 import freenet.l10n.BaseL10n.LANGUAGE;
37 import freenet.l10n.PluginL10n;
38 import freenet.pluginmanager.FredPlugin;
39 import freenet.pluginmanager.FredPluginBaseL10n;
40 import freenet.pluginmanager.FredPluginL10n;
41 import freenet.pluginmanager.FredPluginThreadless;
42 import freenet.pluginmanager.FredPluginVersioned;
43 import freenet.pluginmanager.PluginRespirator;
44 import freenet.pluginmanager.PluginStore;
45
46 /**
47  * This class interfaces with Freenet. It is the class that is loaded by the
48  * node and starts up the whole Sone system.
49  *
50  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
51  */
52 public class SonePlugin implements FredPlugin, FredPluginL10n, FredPluginBaseL10n, FredPluginThreadless, FredPluginVersioned {
53
54         static {
55                 /* initialize logging. */
56                 Logging.setup("sone");
57         }
58
59         /** The version. */
60         private static final Version VERSION = new Version("SNAPSHOT", 0, 1);
61
62         /** The logger. */
63         private static final Logger logger = Logging.getLogger(SonePlugin.class);
64
65         /** The plugin respirator. */
66         private PluginRespirator pluginRespirator;
67
68         /** The core. */
69         private Core core;
70
71         /** The web interface. */
72         private WebInterface webInterface;
73
74         /** The l10n helper. */
75         private PluginL10n l10n;
76
77         /** The plugin store. */
78         private PluginStore pluginStore;
79
80         //
81         // ACCESSORS
82         //
83
84         /**
85          * Returns the plugin respirator for this plugin.
86          *
87          * @return The plugin respirator
88          */
89         public PluginRespirator pluginRespirator() {
90                 return pluginRespirator;
91         }
92
93         /**
94          * Returns the core started by this plugin.
95          *
96          * @return The core
97          */
98         public Core core() {
99                 return core;
100         }
101
102         /**
103          * Returns the plugin’s l10n helper.
104          *
105          * @return The plugin’s l10n helper
106          */
107         public PluginL10n l10n() {
108                 return l10n;
109         }
110
111         //
112         // FREDPLUGIN METHODS
113         //
114
115         /**
116          * {@inheritDoc}
117          */
118         @Override
119         public void runPlugin(PluginRespirator pluginRespirator) {
120                 this.pluginRespirator = pluginRespirator;
121
122                 /* create a configuration. */
123                 Configuration configuration;
124                 try {
125                         configuration = new Configuration(new PluginStoreConfigurationBackend(pluginStore = pluginRespirator.getStore()));
126                 } catch (DatabaseDisabledException dde1) {
127                         logger.log(Level.WARNING, "Could not load plugin store, using XML files.");
128                         try {
129                                 configuration = new Configuration(new XMLConfigurationBackend(new File("sone.xml"), true));
130                         } catch (ConfigurationException ce1) {
131                                 logger.log(Level.SEVERE, "Could not load or create the “sone.xml” configuration file!");
132                                 configuration = new Configuration(new MapConfigurationBackend(Collections.<String, String> emptyMap()));
133                         }
134                 }
135
136                 /* create freenet interface. */
137                 FreenetInterface freenetInterface = new FreenetInterface(pluginRespirator.getNode(), pluginRespirator.getHLSimpleClient());
138
139                 /* create the web interface. */
140                 webInterface = new WebInterface(this);
141
142                 /* create core. */
143                 core = new Core();
144                 core.configuration(configuration);
145                 core.freenetInterface(freenetInterface);
146
147                 /* start core! */
148                 boolean startupFailed = true;
149                 try {
150                         core.start();
151                         webInterface.start();
152                         startupFailed = false;
153                 } finally {
154                         if (startupFailed) {
155                                 /*
156                                  * we let the exception bubble up but shut the logging down so
157                                  * that the logfile is not swamped by the installed logging
158                                  * handlers of the failed instances.
159                                  */
160                                 Logging.shutdown();
161                         }
162                 }
163         }
164
165         /**
166          * {@inheritDoc}
167          */
168         @Override
169         public void terminate() {
170                 /* stop the web interface. */
171                 webInterface.stop();
172
173                 /* stop the core. */
174                 core.stop();
175
176                 /* TODO wait for core to stop? */
177                 try {
178                         pluginRespirator.putStore(pluginStore);
179                 } catch (DatabaseDisabledException dde1) {
180                         logger.log(Level.WARNING, "Could not store plugin store, database is disabled.", dde1);
181                 }
182
183                 /* shutdown logger. */
184                 Logging.shutdown();
185         }
186
187         //
188         // INTERFACE FredPluginL10n
189         //
190
191         /**
192          * {@inheritDoc}
193          */
194         @Override
195         public String getString(String key) {
196                 return l10n.getBase().getString(key);
197         }
198
199         /**
200          * {@inheritDoc}
201          */
202         @Override
203         public void setLanguage(LANGUAGE newLanguage) {
204                 l10n = new PluginL10n(this, newLanguage);
205         }
206
207         //
208         // INTERFACE FredPluginBaseL10n
209         //
210
211         /**
212          * {@inheritDoc}
213          */
214         @Override
215         public String getL10nFilesBasePath() {
216                 return "i18n";
217         }
218
219         /**
220          * {@inheritDoc}
221          */
222         @Override
223         public String getL10nFilesMask() {
224                 return "sone.${lang}.properties";
225         }
226
227         /**
228          * {@inheritDoc}
229          */
230         @Override
231         public String getL10nOverrideFilesMask() {
232                 return "sone.${lang}.override.properties";
233         }
234
235         /**
236          * {@inheritDoc}
237          */
238         @Override
239         public ClassLoader getPluginClassLoader() {
240                 return SonePlugin.class.getClassLoader();
241         }
242
243         //
244         // INTERFACE FredPluginVersioned
245         //
246
247         /**
248          * {@inheritDoc}
249          */
250         @Override
251         public String getVersion() {
252                 return VERSION.toString();
253         }
254
255 }