Download remote Sones first thing after adding them.
[Sone.git] / src / main / java / net / pterodactylus / sone / freenet / wot / IdentityManager.java
1 /*
2  * Sone - IdentityManager.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.freenet.wot;
19
20 import java.util.Collections;
21 import java.util.HashMap;
22 import java.util.Map;
23 import java.util.Map.Entry;
24 import java.util.Set;
25 import java.util.logging.Level;
26 import java.util.logging.Logger;
27
28 import net.pterodactylus.util.filter.Filter;
29 import net.pterodactylus.util.filter.Filters;
30 import net.pterodactylus.util.logging.Logging;
31 import net.pterodactylus.util.service.AbstractService;
32
33 /**
34  * The identity manager takes care of loading and storing identities, their
35  * contexts, and properties. It does so in a way that does not expose errors via
36  * exceptions but it only logs them and tries to return sensible defaults.
37  * <p>
38  * It is also responsible for polling identities from the Web of Trust plugin
39  * and notifying registered {@link IdentityListener}s when {@link Identity}s and
40  * {@link OwnIdentity}s are discovered or disappearing.
41  *
42  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
43  */
44 public class IdentityManager extends AbstractService {
45
46         /** The logger. */
47         private static final Logger logger = Logging.getLogger(IdentityManager.class);
48
49         /** The event manager. */
50         private final IdentityListenerManager identityListenerManager = new IdentityListenerManager();
51
52         /** The Web of Trust connector. */
53         private final WebOfTrustConnector webOfTrustConnector;
54
55         /** The context to filter for. */
56         private volatile String context;
57
58         /**
59          * Creates a new identity manager.
60          *
61          * @param webOfTrustConnector
62          *            The Web of Trust connector
63          */
64         public IdentityManager(WebOfTrustConnector webOfTrustConnector) {
65                 super("Sone Identity Manager", false);
66                 this.webOfTrustConnector = webOfTrustConnector;
67         }
68
69         //
70         // LISTENER MANAGEMENT
71         //
72
73         /**
74          * Adds a listener for identity events.
75          *
76          * @param identityListener
77          *            The listener to add
78          */
79         public void addIdentityListener(IdentityListener identityListener) {
80                 identityListenerManager.addListener(identityListener);
81         }
82
83         /**
84          * Removes a listener for identity events.
85          *
86          * @param identityListener
87          *            The listener to remove
88          */
89         public void removeIdentityListener(IdentityListener identityListener) {
90                 identityListenerManager.removeListener(identityListener);
91         }
92
93         //
94         // ACCESSORS
95         //
96
97         /**
98          * Sets the context to filter own identities and trusted identities for.
99          *
100          * @param context
101          *            The context to filter for, or {@code null} to not filter
102          */
103         public void setContext(String context) {
104                 this.context = context;
105         }
106
107         /**
108          * Returns whether the Web of Trust plugin could be reached during the last
109          * try.
110          *
111          * @return {@code true} if the Web of Trust plugin is connected,
112          *         {@code false} otherwise
113          */
114         public boolean isConnected() {
115                 try {
116                         webOfTrustConnector.ping();
117                         return true;
118                 } catch (PluginException pe1) {
119                         /* not connected, ignore. */
120                         return false;
121                 }
122         }
123
124         /**
125          * Returns the own identity with the given ID.
126          *
127          * @param id
128          *            The ID of the own identity
129          * @return The own identity, or {@code null} if there is no such identity
130          */
131         public OwnIdentity getOwnIdentity(String id) {
132                 Set<OwnIdentity> allOwnIdentities = getAllOwnIdentities();
133                 for (OwnIdentity ownIdentity : allOwnIdentities) {
134                         if (ownIdentity.getId().equals(id)) {
135                                 return ownIdentity;
136                         }
137                 }
138                 return null;
139         }
140
141         /**
142          * Returns all own identities.
143          *
144          * @return All own identities
145          */
146         public Set<OwnIdentity> getAllOwnIdentities() {
147                 try {
148                         return webOfTrustConnector.loadAllOwnIdentities();
149                 } catch (PluginException pe1) {
150                         logger.log(Level.WARNING, "Could not load all own identities!", pe1);
151                         return Collections.emptySet();
152                 }
153         }
154
155         //
156         // ACTIONS
157         //
158
159         /**
160          * Adds a context to the given own identity.
161          *
162          * @param ownIdentity
163          *            The own identity
164          * @param context
165          *            The context to add
166          */
167         public void addContext(OwnIdentity ownIdentity, String context) {
168                 if (ownIdentity.hasContext(context)) {
169                         return;
170                 }
171                 try {
172                         webOfTrustConnector.addContext(ownIdentity, context);
173                         ownIdentity.addContext(context);
174                 } catch (PluginException pe1) {
175                         logger.log(Level.WARNING, "Could not add context " + context + " to OwnIdentity " + ownIdentity + ".", pe1);
176                 }
177         }
178
179         /**
180          * Removes a context from the given own identity.
181          *
182          * @param ownIdentity
183          *            The own identity
184          * @param context
185          *            The context to remove
186          */
187         public void removeContext(OwnIdentity ownIdentity, String context) {
188                 if (!ownIdentity.hasContext(context)) {
189                         return;
190                 }
191                 try {
192                         webOfTrustConnector.removeContext(ownIdentity, context);
193                         ownIdentity.removeContext(context);
194                 } catch (PluginException pe1) {
195                         logger.log(Level.WARNING, "Could not remove context " + context + " from OwnIdentity " + ownIdentity + ".", pe1);
196                 }
197         }
198
199         /**
200          * Sets the property with the given name to the given value.
201          *
202          * @param ownIdentity
203          *            The own identity
204          * @param name
205          *            The name of the property
206          * @param value
207          *            The value of the property
208          */
209         public void setProperty(OwnIdentity ownIdentity, String name, String value) {
210                 try {
211                         webOfTrustConnector.setProperty(ownIdentity, name, value);
212                         ownIdentity.setProperty(name, value);
213                 } catch (PluginException pe1) {
214                         logger.log(Level.WARNING, "Could not set property “" + name + "” to “" + value + "” for OwnIdentity: " + ownIdentity, pe1);
215                 }
216         }
217
218         /**
219          * Removes the property with the given name.
220          *
221          * @param ownIdentity
222          *            The own identity
223          * @param name
224          *            The name of the property to remove
225          */
226         public void removeProperty(OwnIdentity ownIdentity, String name) {
227                 try {
228                         webOfTrustConnector.removeProperty(ownIdentity, name);
229                         ownIdentity.removeProperty(name);
230                 } catch (PluginException pe1) {
231                         logger.log(Level.WARNING, "Could not remove property “" + name + "” from OwnIdentity: " + ownIdentity, pe1);
232                 }
233         }
234
235         //
236         // SERVICE METHODS
237         //
238
239         /**
240          * {@inheritDoc}
241          */
242         @Override
243         protected void serviceRun() {
244                 Map<String, Identity> oldIdentities = Collections.emptyMap();
245                 Map<String, OwnIdentity> oldOwnIdentities = Collections.emptyMap();
246                 while (!shouldStop()) {
247                         Map<String, Identity> currentIdentities = new HashMap<String, Identity>();
248                         Map<String, OwnIdentity> currentOwnIdentities = new HashMap<String, OwnIdentity>();
249
250                         /* get all identities with the wanted context from WoT. */
251                         Set<OwnIdentity> ownIdentities;
252                         try {
253                                 ownIdentities = Filters.filteredSet(webOfTrustConnector.loadAllOwnIdentities(), new Filter<OwnIdentity>() {
254
255                                         @Override
256                                         @SuppressWarnings("synthetic-access")
257                                         public boolean filterObject(OwnIdentity ownIdentity) {
258                                                 return (context == null) || ownIdentity.hasContext(context);
259                                         }
260
261                                 });
262                                 for (OwnIdentity ownIdentity : ownIdentities) {
263                                         currentOwnIdentities.put(ownIdentity.getId(), ownIdentity);
264                                         for (Identity identity : webOfTrustConnector.loadTrustedIdentities(ownIdentity, context)) {
265                                                 currentIdentities.put(identity.getId(), identity);
266                                         }
267                                 }
268
269                                 /* find removed own identities: */
270                                 for (OwnIdentity oldOwnIdentity : oldOwnIdentities.values()) {
271                                         if (!currentOwnIdentities.containsKey(oldOwnIdentity.getId())) {
272                                                 identityListenerManager.fireOwnIdentityRemoved(oldOwnIdentity);
273                                         }
274                                 }
275
276                                 /* find added own identities. */
277                                 for (OwnIdentity currentOwnIdentity : currentOwnIdentities.values()) {
278                                         if (!oldOwnIdentities.containsKey(currentOwnIdentity.getId())) {
279                                                 identityListenerManager.fireOwnIdentityAdded(currentOwnIdentity);
280                                         }
281                                 }
282
283                                 /* find removed identities. */
284                                 for (Identity oldIdentity : oldIdentities.values()) {
285                                         if (!currentIdentities.containsKey(oldIdentity.getId())) {
286                                                 identityListenerManager.fireIdentityRemoved(oldIdentity);
287                                         }
288                                 }
289
290                                 /* find new identities. */
291                                 for (Identity currentIdentity : currentIdentities.values()) {
292                                         if (!oldIdentities.containsKey(currentIdentity.getId())) {
293                                                 identityListenerManager.fireIdentityAdded(currentIdentity);
294                                         }
295                                 }
296
297                                 /* check for changes in the properties. */
298                                 for (Identity oldIdentity : oldIdentities.values()) {
299                                         if (!currentIdentities.containsKey(oldIdentity.getId())) {
300                                                 continue;
301                                         }
302                                         Identity newIdentity = currentIdentities.get(oldIdentity.getId());
303                                         Map<String, String> oldProperties = oldIdentity.getProperties();
304                                         Map<String, String> newProperties = newIdentity.getProperties();
305                                         if (oldProperties.size() != newProperties.size()) {
306                                                 identityListenerManager.fireIdentityUpdated(newIdentity);
307                                                 continue;
308                                         }
309                                         for (Entry<String, String> oldProperty : oldProperties.entrySet()) {
310                                                 if (!newProperties.containsKey(oldProperty.getKey()) || !newProperties.get(oldProperty.getKey()).equals(oldProperty.getValue())) {
311                                                         identityListenerManager.fireIdentityUpdated(newIdentity);
312                                                         break;
313                                                 }
314                                         }
315                                 }
316
317                                 /* remember the current set of identities. */
318                                 oldIdentities = currentIdentities;
319                                 oldOwnIdentities = currentOwnIdentities;
320
321                         } catch (PluginException pe1) {
322                                 logger.log(Level.WARNING, "WoT has disappeared!", pe1);
323                         }
324
325                         /* wait a minute before checking again. */
326                         sleep(60 * 1000);
327                 }
328         }
329
330 }