1
2
3
4
5
6 package pt.digitalis.dif.dem.managers.impl;
7
8 import java.util.HashMap;
9 import java.util.Map;
10 import java.util.Properties;
11
12 import pt.digitalis.dif.dem.Entity;
13 import pt.digitalis.dif.dem.interfaces.IStage;
14 import pt.digitalis.dif.dem.managers.IRegistrationManager;
15 import pt.digitalis.dif.dem.objects.ILicense;
16 import pt.digitalis.dif.dem.objects.LicenseEditionType;
17 import pt.digitalis.dif.exception.manager.RegistrationManagerException;
18 import pt.digitalis.dif.ioc.DIFIoCRegistry;
19 import pt.digitalis.dif.startup.DIFGeneralConfigurationParameters;
20 import pt.digitalis.utils.config.IConfigurations;
21
22 import com.google.inject.Inject;
23
24
25
26
27
28
29
30
31 public class RegistrationManagerImpl implements IRegistrationManager {
32
33
34 static private String MISSING_REGISTRABLE_INFO = "DIF auto-generated: Missing registrable information!";
35
36
37 static private Map<String, ILicense> registrations = new HashMap<String, ILicense>();
38
39
40 final static String REPOSITORY_CONFIG_ID = "dif2";
41
42
43 final static String REPOSITORY_KEY_ID = "key";
44
45
46 final static String REPOSITORY_NAME_ID = "name";
47
48
49 final static String REPOSITORY_SECTION_ID = "Registrations";
50
51
52 @Inject
53 IConfigurations configRepository;
54
55
56
57
58
59 public void addToRegistry(Entity type, String entityID, String name, boolean registrable)
60 {
61
62 String id = Entity.getID(type, entityID.toLowerCase());
63
64 ILicense license = DIFIoCRegistry.getRegistry().getImplementation(ILicense.class);
65 license.setName(name);
66 license.setRegistrable(registrable);
67
68
69 license = checkRepositoryForPersistentRegistration(id, license);
70
71 registrations.put(id, license);
72 }
73
74
75
76
77
78
79
80
81
82
83 private ILicense checkRepositoryForPersistentRegistration(String id, ILicense license)
84 {
85
86 Properties props = configRepository.readConfiguration(REPOSITORY_CONFIG_ID, REPOSITORY_SECTION_ID);
87
88
89 Object savedKey = props.get(id + "." + REPOSITORY_KEY_ID);
90
91 if (savedKey != null)
92 license.register(savedKey.toString(), id);
93
94 return license;
95 }
96
97
98
99
100 public LicenseEditionType getApplicationEdition(String applicationID)
101 {
102 return getRegistrationRecord(Entity.APPLICATION, applicationID).getEdition();
103 }
104
105
106
107
108 public LicenseEditionType getProviderEdition(String providerID)
109 {
110 return getRegistrationRecord(Entity.PROVIDER, providerID).getEdition();
111 }
112
113
114
115
116
117
118
119
120
121
122
123
124 private ILicense getRegistrationRecord(Entity type, String id)
125 {
126 String entityID = Entity.getID(type, id);
127 ILicense license = registrations.get(entityID);
128
129 if (license == null)
130 {
131
132
133
134
135 license = DIFIoCRegistry.getRegistry().getImplementation(ILicense.class);
136 license.setName(MISSING_REGISTRABLE_INFO);
137 license.setRegistrable(false);
138
139
140
141 registrations.put(entityID, license);
142 }
143
144 return license;
145 }
146
147
148
149
150 public LicenseEditionType getServiceEdition(String serviceID)
151 {
152 return getRegistrationRecord(Entity.SERVICE, serviceID).getEdition();
153 }
154
155
156
157
158 public String getStageClientName(IStage stage)
159 {
160 String result = getRegistrationRecord(Entity.STAGE, stage.getID()).getName();
161 if (MISSING_REGISTRABLE_INFO.equals(result))
162 {
163 result = getRegistrationRecord(Entity.SERVICE, stage.getService().getID()).getName();
164 if (MISSING_REGISTRABLE_INFO.equals(result))
165 {
166 result = getRegistrationRecord(Entity.APPLICATION, stage.getService().getApplication().getID())
167 .getName();
168 if (MISSING_REGISTRABLE_INFO.equals(result))
169 {
170 result = getRegistrationRecord(Entity.PROVIDER,
171 stage.getService().getApplication().getProvider().getID()).getName();
172 if (MISSING_REGISTRABLE_INFO.equals(result))
173 {
174 result = DIFGeneralConfigurationParameters.getInstance().getClient();
175 }
176 }
177 }
178 }
179 return result;
180 }
181
182
183
184
185 public LicenseEditionType getStageEdition(String stageID)
186 {
187 return getRegistrationRecord(Entity.STAGE, stageID).getEdition();
188 }
189
190
191
192
193 public boolean isApplicationRegistered(String applicationID)
194 {
195 return getRegistrationRecord(Entity.APPLICATION, applicationID).isRegistered();
196 }
197
198
199
200
201 public boolean isApplicationRegistrable(String applicationID)
202 {
203 return getRegistrationRecord(Entity.APPLICATION, applicationID).isRegistrable();
204 }
205
206
207
208
209 public boolean isProviderRegistered(String providerID)
210 {
211 return getRegistrationRecord(Entity.PROVIDER, providerID).isRegistered();
212 }
213
214
215
216
217 public boolean isProviderRegistrable(String providerID)
218 {
219 return getRegistrationRecord(Entity.PROVIDER, providerID).isRegistrable();
220 }
221
222
223
224
225 public boolean isServiceRegistered(String serviceID)
226 {
227 return getRegistrationRecord(Entity.SERVICE, serviceID).isRegistered();
228 }
229
230
231
232
233 public boolean isServiceRegistrable(String serviceID)
234 {
235 return getRegistrationRecord(Entity.SERVICE, serviceID).isRegistrable();
236 }
237
238
239
240
241 public boolean isStageRegistered(String stageId)
242 {
243 return getRegistrationRecord(Entity.STAGE, stageId).isRegistered();
244 }
245
246
247
248
249 public boolean isStageRegistrable(String stageId)
250 {
251 return getRegistrationRecord(Entity.STAGE, stageId).isRegistrable();
252 }
253
254
255
256
257
258
259
260
261
262
263 private boolean persistRegistration(String id, ILicense license)
264 {
265
266 Properties props = new Properties();
267
268 props.put(id + "." + REPOSITORY_NAME_ID, license.getName() != null ? license.getName() : "");
269
270 if (license.getKey() == null)
271 props.put(id + "." + REPOSITORY_KEY_ID, "");
272 else
273 props.put(id + "." + REPOSITORY_KEY_ID, license.getKey());
274
275 return configRepository.writeConfiguration(REPOSITORY_CONFIG_ID, REPOSITORY_SECTION_ID, props);
276 }
277
278
279
280
281
282 public boolean registerApplication(String applicationID, String name, String key)
283 throws RegistrationManagerException
284 {
285 return registerEntity(Entity.APPLICATION, applicationID, name, key);
286 }
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303 private boolean registerEntity(Entity type, String entityID, String name, String key)
304 throws RegistrationManagerException
305 {
306 String id = Entity.getID(type, entityID);
307 ILicense license = getRegistrationRecord(type, entityID);
308
309 if (!license.isRegistrable())
310 throw new RegistrationManagerException("You are trying to register a unregistrable entity");
311
312 license.setName(name);
313 license.register(key, id);
314
315
316 registrations.put(id, license);
317
318
319 persistRegistration(id, license);
320
321 return license.isRegistered();
322 }
323
324
325
326
327
328 public boolean registerProvider(String providerID, String name, String key) throws RegistrationManagerException
329 {
330 return registerEntity(Entity.PROVIDER, providerID, name, key);
331 }
332
333
334
335
336
337 public boolean registerService(String serviceID, String name, String key) throws RegistrationManagerException
338 {
339 return registerEntity(Entity.SERVICE, serviceID, name, key);
340 }
341
342
343
344
345
346 public boolean registerStage(String stageId, String name, String key) throws RegistrationManagerException
347 {
348 return registerEntity(Entity.STAGE, stageId, name, key);
349 }
350
351
352
353
354 public void unregisterApplication(String applicationID)
355 {
356 unregisterEntity(Entity.APPLICATION, applicationID);
357 }
358
359
360
361
362
363
364
365
366
367 private void unregisterEntity(Entity type, String entityID)
368 {
369 String id = Entity.getID(type, entityID);
370 ILicense license = getRegistrationRecord(type, entityID);
371
372 license.unregister();
373
374
375 registrations.put(id, license);
376
377
378 persistRegistration(id, license);
379 }
380
381
382
383
384 public void unregisterProvider(String providerID)
385 {
386 unregisterEntity(Entity.PROVIDER, providerID);
387 }
388
389
390
391
392 public void unregisterService(String serviceID)
393 {
394 unregisterEntity(Entity.SERVICE, serviceID);
395 }
396
397
398
399
400 public void unregisterStage(String stageId)
401 {
402 unregisterEntity(Entity.STAGE, stageId);
403 }
404 }