🔀 Merge branch 'release/v82'
[Sone.git] / freenet / wot / IdentityManagerImpl.java
1 /*
2  * Sone - IdentityManager.java - Copyright Â© 2010–2013 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.Collection;
21 import java.util.HashMap;
22 import java.util.HashSet;
23 import java.util.Map;
24 import java.util.Set;
25 import java.util.logging.Level;
26 import java.util.logging.Logger;
27
28 import net.pterodactylus.sone.freenet.plugin.PluginException;
29 import net.pterodactylus.util.logging.Logging;
30 import net.pterodactylus.util.service.AbstractService;
31
32 import com.google.common.collect.Sets;
33 import com.google.common.eventbus.EventBus;
34 import com.google.inject.Inject;
35 import com.google.inject.Singleton;
36
37 /**
38  * The identity manager takes care of loading and storing identities, their
39  * contexts, and properties. It does so in a way that does not expose errors via
40  * exceptions but it only logs them and tries to return sensible defaults.
41  * <p>
42  * It is also responsible for polling identities from the Web of Trust plugin
43  * and sending events to the {@link EventBus} when {@link Identity}s and
44  * {@link OwnIdentity}s are discovered or disappearing.
45  *
46  * @author <a href="mailto:bombe@pterodactylus.net">David â€˜Bombe’ Roden</a>
47  */
48 @Singleton
49 public class IdentityManagerImpl extends AbstractService implements IdentityManager {
50
51         /** The logger. */
52         private static final Logger logger = Logging.getLogger(IdentityManagerImpl.class);
53
54         /** The event bus. */
55         private final EventBus eventBus;
56
57         private final IdentityLoader identityLoader;
58
59         /** The Web of Trust connector. */
60         private final WebOfTrustConnector webOfTrustConnector;
61
62         /** The currently known own identities. */
63         private final Set<OwnIdentity> currentOwnIdentities = Sets.newHashSet();
64
65         /**
66          * Creates a new identity manager.
67          *
68          * @param eventBus
69          *            The event bus
70          * @param webOfTrustConnector
71          *            The Web of Trust connector
72          */
73         @Inject
74         public IdentityManagerImpl(EventBus eventBus, WebOfTrustConnector webOfTrustConnector, IdentityLoader identityLoader) {
75                 super("Sone Identity Manager", false);
76                 this.eventBus = eventBus;
77                 this.webOfTrustConnector = webOfTrustConnector;
78                 this.identityLoader = identityLoader;
79         }
80
81         //
82         // ACCESSORS
83         //
84
85         /**
86          * Returns whether the Web of Trust plugin could be reached during the last
87          * try.
88          *
89          * @return {@code true} if the Web of Trust plugin is connected,
90          *         {@code false} otherwise
91          */
92         @Override
93         public boolean isConnected() {
94                 try {
95                         webOfTrustConnector.ping();
96                         return true;
97                 } catch (PluginException pe1) {
98                         /* not connected, ignore. */
99                         return false;
100                 }
101         }
102
103         /**
104          * Returns all own identities.
105          *
106          * @return All own identities
107          */
108         @Override
109         public Set<OwnIdentity> getAllOwnIdentities() {
110                 synchronized (currentOwnIdentities) {
111                         return new HashSet<OwnIdentity>(currentOwnIdentities);
112                 }
113         }
114
115         //
116         // SERVICE METHODS
117         //
118
119         /**
120          * {@inheritDoc}
121          */
122         @Override
123         protected void serviceRun() {
124                 Map<OwnIdentity, Collection<Identity>> oldIdentities = new HashMap<OwnIdentity, Collection<Identity>>();
125
126                 while (!shouldStop()) {
127                         try {
128                                 Map<OwnIdentity, Collection<Identity>> currentIdentities = identityLoader.loadIdentities();
129
130                                 IdentityChangeEventSender identityChangeEventSender = new IdentityChangeEventSender(eventBus, oldIdentities);
131                                 identityChangeEventSender.detectChanges(currentIdentities);
132
133                                 oldIdentities = currentIdentities;
134
135                                 synchronized (currentOwnIdentities) {
136                                         currentOwnIdentities.clear();
137                                         currentOwnIdentities.addAll(currentIdentities.keySet());
138                                 }
139                         } catch (WebOfTrustException wote1) {
140                                 logger.log(Level.WARNING, "WoT has disappeared!", wote1);
141                         }
142
143                         /* wait a minute before checking again. */
144                         sleep(60 * 1000);
145                 }
146         }
147
148 }