1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 package org.ogf.graap.wsag.server.persistence.impl;
36
37 import java.lang.reflect.Constructor;
38 import java.text.MessageFormat;
39 import java.util.Iterator;
40 import java.util.Map;
41 import java.util.Observable;
42 import java.util.Observer;
43
44 import javax.persistence.EntityManager;
45 import javax.persistence.NoResultException;
46 import javax.persistence.NonUniqueResultException;
47 import javax.persistence.Query;
48 import javax.persistence.RollbackException;
49
50 import org.apache.log4j.Logger;
51 import org.apache.xmlbeans.XmlObject;
52 import org.ogf.graap.wsag.api.Agreement;
53 import org.ogf.graap.wsag.api.AgreementOffer;
54 import org.ogf.graap.wsag.api.exceptions.AgreementFactoryException;
55 import org.ogf.graap.wsag.api.logging.LogMessage;
56 import org.ogf.graap.wsag.api.types.AbstractAgreementType;
57 import org.ogf.graap.wsag.api.types.AgreementOfferType;
58 import org.ogf.graap.wsag.server.monitoring.MonitorableAgreement;
59 import org.ogf.graap.wsag.server.persistence.EmfRegistry;
60 import org.ogf.graap.wsag.server.persistence.PersistentAgreement;
61 import org.ogf.graap.wsag4j.types.engine.PersistenceAgreementContextType;
62 import org.ogf.graap.wsag4j.types.engine.PersistenceAgreementContextType.Entry;
63 import org.ogf.schemas.graap.wsAgreement.AgreementContextType;
64 import org.ogf.schemas.graap.wsAgreement.AgreementPropertiesType;
65 import org.ogf.schemas.graap.wsAgreement.AgreementStateType;
66 import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
67 import org.ogf.schemas.graap.wsAgreement.GuaranteeTermStateType;
68 import org.ogf.schemas.graap.wsAgreement.ServiceTermStateType;
69 import org.ogf.schemas.graap.wsAgreement.TermTreeType;
70 import org.ogf.schemas.graap.wsAgreement.TerminateInputType;
71 import org.w3.x2005.x08.addressing.EndpointReferenceType;
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88 public class DatabasePersistentAgreement
89 implements PersistentAgreement, Agreement, Observer
90 {
91
92
93
94
95
96 public static final String AGREEMENT_CONTEXT_ENTRY = "agreement_context";
97
98
99
100
101
102 public static final String AGREEMENT_PROPERTIES_ENTRY = "agreement_properties";
103
104 private static final Logger LOG = Logger.getLogger( DatabasePersistentAgreement.class );
105
106
107
108
109
110
111
112
113 protected MonitorableAgreement agreement;
114
115
116
117
118
119
120
121 protected PersistentAgreementContainer persistentAgreementContainer;
122
123
124
125
126 protected String agreementFactoryId;
127
128 private DatabasePersistentAgreement()
129 {
130 super();
131 }
132
133
134
135
136
137
138
139
140
141
142
143 public DatabasePersistentAgreement( PersistentAgreementContainer persistentAgreementContainer,
144 String agreementFactoryId )
145 {
146 if ( LOG.isTraceEnabled() )
147 {
148 LOG.trace( "Create a new DatabasePersistentAgreement instance." );
149 }
150
151 this.persistentAgreementContainer = persistentAgreementContainer;
152 this.agreementFactoryId = agreementFactoryId;
153 }
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168 public static DatabasePersistentAgreement
169 insertAgreement( Agreement agreement, String agreementFactoryId ) throws AgreementFactoryException
170 {
171
172 if ( LOG.isDebugEnabled() )
173 {
174 LOG.debug( LogMessage.getMessage(
175 "Try to persist the PersistentAgreementContainer for agreement ''{0}''.",
176 agreement.getAgreementId() ) );
177 }
178
179 PersistentAgreementContainer container =
180 PersistentAgreementContainer.createContainer( agreement, agreementFactoryId );
181
182 if ( LOG.isDebugEnabled() )
183 {
184 LOG.debug( LogMessage.getMessage(
185 "PersistentAgreementContainer for agreement ''{0}'' persisted.", agreement.getAgreementId() ) );
186 }
187
188 if ( LOG.isDebugEnabled() )
189 {
190 LOG.debug( "Insert new DatabasePersistentAgreement instance into database." );
191 }
192
193 MonitorableAgreement monitorable =
194 initializeMonitorableAgreement( agreement, container.getPersistedAgreementContextType() );
195
196 DatabasePersistentAgreement result = new DatabasePersistentAgreement();
197 result.persistentAgreementContainer = container;
198 result.agreementFactoryId = agreementFactoryId;
199 result.agreement = monitorable;
200
201 monitorable.addObserver( result );
202 monitorable.notifyObservers();
203
204 return result;
205 }
206
207
208
209
210
211
212
213
214
215
216
217 public GuaranteeTermStateType[] getGuaranteeTermStates()
218 {
219 return agreement.getGuaranteeTermStates();
220 }
221
222
223
224
225
226
227 public String getAgreementId()
228 {
229 return agreement.getAgreementId();
230 }
231
232
233
234
235
236
237 public AgreementContextType getContext()
238 {
239 return agreement.getContext();
240 }
241
242
243
244
245
246
247 public String getName()
248 {
249 return agreement.getName();
250 }
251
252
253
254
255
256
257 public ServiceTermStateType[] getServiceTermStates()
258 {
259 return agreement.getServiceTermStates();
260 }
261
262
263
264
265
266
267 public AgreementStateType getState()
268 {
269 return agreement.getState();
270 }
271
272
273
274
275
276
277 public TermTreeType getTerms()
278 {
279 return agreement.getTerms();
280 }
281
282
283
284
285
286
287 public AbstractAgreementType getAgreementInstance()
288 {
289 return agreement.getAgreementInstance();
290 }
291
292
293
294
295
296
297 public void terminate( TerminateInputType reason )
298 {
299 agreement.terminate( reason );
300 }
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321 @SuppressWarnings( "unchecked" )
322 public synchronized void load() throws Exception
323 {
324
325
326
327
328
329 if ( agreement != null )
330 {
331 agreement.stopMonitoring();
332 }
333
334 if ( LOG.isDebugEnabled() )
335 {
336 LOG.debug( "Load DatabasePersistentAgreement." );
337 }
338
339
340 PersistenceAgreementContextType persistenceAgreementContext =
341 persistentAgreementContainer.getPersistedAgreementContextType();
342
343
344 AgreementPropertiesType agreementPropertiesType =
345 persistenceAgreementContext.getAgreementProperties();
346
347
348 String className = persistentAgreementContainer.getAgreementClassName();
349
350 LOG.debug( LogMessage.getMessage( "Re-load the original agreement using class ''{0}''.", className ) );
351
352 Class<AbstractAgreementType> clazz;
353 try
354 {
355 clazz = (Class<AbstractAgreementType>) this.getClass().getClassLoader().loadClass( className );
356 }
357 catch ( ClassCastException e )
358 {
359 throw new Exception(
360 "Load agreement failed. Agreement must inherit from AbstractAgreement class.", e );
361 }
362
363 AbstractAgreementType abstractAgreementType = null;
364
365
366
367
368 try
369 {
370 Constructor<AbstractAgreementType> constructor = clazz.getConstructor();
371 abstractAgreementType = constructor.newInstance();
372 abstractAgreementType.setXmlObject( agreementPropertiesType );
373 }
374 catch ( NoSuchMethodException e )
375 {
376 LOG.trace( LogMessage.getMessage( "Default constructor for class {0} not implemented.",
377 clazz.getName() ) );
378 }
379
380
381
382
383 if ( abstractAgreementType == null )
384 {
385 try
386 {
387 Constructor<AbstractAgreementType> constructor =
388 clazz.getConstructor( AgreementPropertiesType.class );
389 abstractAgreementType = constructor.newInstance( agreementPropertiesType );
390 }
391 catch ( NoSuchMethodException e )
392 {
393 LOG.trace( LogMessage.getMessage(
394 "Constructor AgreementTypeImpl(AgreementPropertiesType) for class {0} not implemented.",
395 clazz.getName() ) );
396 }
397 }
398
399
400
401
402 if ( abstractAgreementType == null )
403 {
404 try
405 {
406 Constructor<AbstractAgreementType> constructor = clazz.getConstructor( AgreementOffer.class );
407
408
409
410
411 AgreementTemplateType template = AgreementTemplateType.Factory.newInstance();
412 template.addNewCreationConstraints();
413 template.addNewContext().set( agreementPropertiesType.getContext() );
414 template.addNewTerms().set( agreementPropertiesType.getTerms() );
415 template.setName( agreementPropertiesType.getContext().getTemplateName() );
416 template.setTemplateId( agreementPropertiesType.getContext().getTemplateId() );
417
418
419
420
421 abstractAgreementType = constructor.newInstance( new AgreementOfferType( template ) );
422 abstractAgreementType.setXmlObject( agreementPropertiesType );
423 }
424 catch ( NoSuchMethodException e )
425 {
426 LOG.trace( MessageFormat.format(
427 "Constructor AgreementTypeImpl(AgreementOffer) for class {0} not implemented.",
428 clazz.getName() ) );
429 }
430 }
431
432
433
434 if ( abstractAgreementType == null )
435 {
436 String message =
437 MessageFormat.format( "Could not instantiate agreement class ''{0}''.\n"
438 + "Agreement class does neither implement default constructor "
439 + "nor constructor Ageement(AgreementPropertiesType).", clazz.getName() );
440 LOG.error( message );
441 throw new Exception( message );
442 }
443
444 Entry[] entries = persistenceAgreementContext.getEntryArray();
445 for ( int i = 0; i < entries.length; i++ )
446 {
447 abstractAgreementType.getExecutionContext().put( entries[i].getName(), entries[i].getValue() );
448 }
449
450 agreement = initializeMonitorableAgreement( abstractAgreementType, persistenceAgreementContext );
451 agreement.addObserver( this );
452
453
454
455
456 agreement.notifyReload();
457
458 if ( LOG.isDebugEnabled() )
459 {
460 LOG.debug( "Instantiated Monitorable Agreement instance for persisted agreement." );
461 }
462 }
463
464 private static MonitorableAgreement
465 initializeMonitorableAgreement( Agreement agreement, PersistenceAgreementContextType pContext )
466 {
467
468
469
470
471
472
473
474 if ( agreement instanceof MonitorableAgreement )
475 {
476 return (MonitorableAgreement) agreement;
477 }
478
479
480
481
482 AbstractAgreementType instance = null;
483
484 if ( agreement instanceof AbstractAgreementType )
485 {
486 instance = (AbstractAgreementType) agreement;
487 }
488 else
489 {
490 instance = agreement.getAgreementInstance();
491 }
492
493
494
495
496 MonitorableAgreement monitorable = new MonitorableAgreement( instance );
497
498 return monitorable;
499 }
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516 public synchronized void save() throws Exception
517 {
518 if ( LOG.isDebugEnabled() )
519 {
520 LOG.debug( LogMessage.getMessage( "Save DatabasePersistentAgreement ''{0}''.",
521 agreement.getAgreementId() ) );
522 }
523
524
525
526
527
528 EntityManager em = EmfRegistry.getEntityManager();
529 Query query = em.createNamedQuery( "PersistentAgreementContainer.findByAgreementId" );
530 query.setParameter( "agreementId", agreement.getAgreementId() );
531
532 PersistentAgreementContainer container = null;
533 boolean persistentAgreementContainerExists = true;
534 try
535 {
536 container = (PersistentAgreementContainer) query.getSingleResult();
537 }
538 catch ( NonUniqueResultException ex )
539 {
540 LOG.error( LogMessage.getMessage(
541 "Found more than one PersistentAgreementContainer for the agreement id ''{0}''.",
542 agreement.getAgreementId() ), ex );
543
544 throw new Exception( MessageFormat.format(
545 "Found more than one PersistentAgreementContainer for the agreement id ''{0}''.",
546 agreement.getAgreementId() ) );
547 }
548 catch ( NoResultException ex )
549 {
550 persistentAgreementContainerExists = false;
551 }
552
553
554 if ( persistentAgreementContainerExists )
555 {
556 LOG.debug( LogMessage.getMessage( "Update PersistentAgreementContainer ''{0}''.",
557 agreement.getAgreementId() ) );
558
559
560 PersistenceAgreementContextType persistenceAgreementContext =
561 PersistenceAgreementContextType.Factory.newInstance();
562
563
564 persistenceAgreementContext.addNewAgreementProperties();
565
566
567 AbstractAgreementType abstractAgreementType = agreement.getAgreementInstance();
568 persistenceAgreementContext.getAgreementProperties().set( abstractAgreementType.getXMLObject() );
569
570
571
572
573 Map<String, XmlObject> executionProperties =
574 agreement.getExecutionContext().getExecutionProperties();
575 persistenceAgreementContext.setEntryArray( new PersistenceAgreementContextType.Entry[0] );
576 Iterator<String> keys = executionProperties.keySet().iterator();
577 while ( keys.hasNext() )
578 {
579 String key = keys.next();
580 XmlObject value = executionProperties.get( key );
581 PersistenceAgreementContextType.Entry entry = persistenceAgreementContext.addNewEntry();
582 entry.setName( key );
583 entry.addNewValue().set( value );
584 entry.getValue().changeType( value.schemaType() );
585 }
586
587
588
589
590
591
592 container.setPersistedAgreementContextType( persistenceAgreementContext );
593
594
595 container.setState( agreement.getState() );
596
597
598 container.setAgreementClassName( abstractAgreementType.getClass().getName() );
599
600
601 em.getTransaction().begin();
602
603 try
604 {
605
606 em.merge( container );
607 em.getTransaction().commit();
608 }
609 catch ( RollbackException ex )
610 {
611 LOG.error( LogMessage.getMessage( "Could not update the wrapped agreement with id ''{0}''.",
612 agreement.getAgreementId() ), ex );
613
614
615 em.getTransaction().rollback();
616
617 throw new Exception( MessageFormat.format(
618 "Could not update the wrapped agreement with id ''{0}''.", agreement.getAgreementId() ) );
619 }
620 finally
621 {
622 em.close();
623 }
624 }
625
626 else
627 {
628 String msgNoAgreementFound =
629 "No agreement instance found in database. "
630 + "Save operation can only be executed on exosting agreement instances.";
631 throw new AgreementFactoryException( msgNoAgreementFound );
632 }
633 }
634
635
636
637
638 public Agreement getAgreement()
639 {
640 return agreement;
641 }
642
643
644
645
646
647
648 @Deprecated
649 public EndpointReferenceType getAgreementEPR()
650 {
651 throw new UnsupportedOperationException( "Not implemented yet." );
652 }
653
654
655
656
657
658 public PersistentAgreementContainer getPersistentAgreementContainer()
659 {
660 return persistentAgreementContainer;
661 }
662
663
664
665
666
667
668
669
670
671 public void update( Observable o, Object arg )
672 {
673
674
675
676
677 if ( o == agreement )
678 {
679 try
680 {
681 save();
682 }
683 catch ( Exception e )
684 {
685 LOG.error( "Failed to save agreement instance.", e );
686 }
687 }
688 else
689 {
690 LOG.error( "Received a state change notification for an greement instance different than the registered." );
691 }
692 }
693 }