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.monitoring;
36
37 import java.text.MessageFormat;
38 import java.util.HashMap;
39 import java.util.Iterator;
40 import java.util.Map;
41 import java.util.Vector;
42
43 import org.apache.log4j.Logger;
44 import org.apache.xmlbeans.XmlObject;
45 import org.ogf.graap.wsag.api.logging.LogMessage;
46 import org.ogf.graap.wsag.api.types.AbstractAgreementType;
47 import org.ogf.graap.wsag4j.types.engine.GuaranteeEvaluationResultType;
48 import org.ogf.graap.wsag4j.types.engine.SLAMonitoringNotificationEventType;
49 import org.ogf.schemas.graap.wsAgreement.AgreementPropertiesDocument;
50 import org.ogf.schemas.graap.wsAgreement.AgreementPropertiesType;
51 import org.ogf.schemas.graap.wsAgreement.AgreementStateDefinition;
52 import org.ogf.schemas.graap.wsAgreement.AgreementStateType;
53 import org.ogf.schemas.graap.wsAgreement.GuaranteeTermStateDefinition;
54 import org.ogf.schemas.graap.wsAgreement.GuaranteeTermStateType;
55 import org.ogf.schemas.graap.wsAgreement.GuaranteeTermType;
56 import org.ogf.schemas.graap.wsAgreement.ServicePropertiesType;
57 import org.ogf.schemas.graap.wsAgreement.ServiceSelectorType;
58 import org.ogf.schemas.graap.wsAgreement.ServiceTermStateDefinition;
59 import org.ogf.schemas.graap.wsAgreement.ServiceTermStateType;
60
61
62
63
64
65
66
67
68
69
70 public class AgreementMonitor
71 {
72
73 private static final String XPATH_NS_DECL_WSAG =
74 "declare namespace wsag='http://schemas.ggf.org/graap/2007/03/ws-agreement';";
75
76 private static final String XPATH_QUERY_GUARANTEE_TERM =
77 "$this/wsag:Terms/wsag:All//wsag:GuaranteeTerm[ @wsag:Name = ''{0}'']";
78
79 private static final String XPATH_QUERY_SERVICE_PROPERTIES =
80 "$this/wsag:Terms/wsag:All//wsag:ServiceProperties[ @wsag:ServiceName = ''{0}'']";
81
82
83
84
85 private static final Logger LOG = Logger.getLogger( AgreementMonitor.class );
86
87
88
89
90 private AbstractAgreementType agreementInstance;
91
92 private IMonitoringContext monitoringContext;
93
94 private ServiceTermStateMonitor stateMonitor = new ServiceTermStateMonitor();
95
96
97
98
99 static final String ERR_UPDATE_GUARANTEE_STATE = "AgreementMonitor.ERR_UPDATE_GUARANTEE_STATE";
100
101 static final String ERR_UPDATE_AGREEMENT_STATE = "AgreementMonitor.ERR_UPDATE_AGREEMENT_STATE";
102
103 static final String ERR_GET_STD_STATES = "AgreementMonitor.ERR_GET_STD_STATES";
104
105 static final String ERR_INIT_SDT_STATES = "AgreementMonitor.ERR_INIT_SDT_STATES";
106
107 static final String ERR_UPD_STD_STATES = "AgreementMonitor.ERR_UPD_STD_STATES";
108
109 private static final String ERR_GET_GUARANTEE_STATES = "AgreementMonitor.ERR_GET_GUARANTEE_STATES";
110
111 static final String WARN_MULTIPLE_GUARANTEES = "AgreementMonitor.WARN_MULTIPLE_GUARANTEE_OCCOURENCES";
112
113 static final String WARN_SP_DEF_NOT_FOUND = "AgreementMonitor.WARN_SP_DEF_NOT_FOUND";
114
115 static final String WARN_MULTIPLE_SP_DEFS = "AgreementMonitor.WARN_SP_DEF_MULTIPLE_OCCURENCES";
116
117 static final String WARN_GURANTEE_NOT_FOUND = "AgreementMonitor.WARN_GURANTEE_TERM_NOT_FOUND";
118
119 static final String DBG_EVAL_GUARANTEE_STATE = "AgreementMonitor.DBG_EVAL_GUARANTEE_STATE";
120
121 static final String DBG_SERVICE_PROPERTIES = "AgreementMonitor.DBG_SERVICE_PROPERTIES";
122
123 static final String DBG_DUPLICATE_VAR_DEF = "AgreementMonitor.DEBUG_DUPLICATE_VAR_DEF";
124
125
126
127
128
129
130
131
132 public AbstractAgreementType getAgreementInstance()
133 {
134 return agreementInstance;
135 }
136
137
138
139
140
141 public void setAgreementInstance( AbstractAgreementType agreementInstance )
142 {
143 this.agreementInstance = agreementInstance;
144 }
145
146
147
148
149 public IMonitoringContext getMonitoringContext()
150 {
151 return monitoringContext;
152 }
153
154
155
156
157
158 public void setMonitoringContext( IMonitoringContext monitoringContext )
159 {
160 this.monitoringContext = monitoringContext;
161 }
162
163
164
165
166
167
168
169
170
171
172
173
174 public void updateStates() throws Exception
175 {
176
177
178
179 IMonitoringContext mutex = monitoringContext;
180
181 synchronized ( mutex )
182 {
183
184
185
186
187
188
189
190
191
192
193 AgreementPropertiesDocument apDoc = AgreementPropertiesDocument.Factory.newInstance();
194 AgreementPropertiesType apCopy =
195 (AgreementPropertiesType) getAgreementInstance().getXMLObject().copy();
196 apDoc.setAgreementProperties( apCopy );
197
198
199
200
201 AgreementPropertiesType agreementProperties = apDoc.getAgreementProperties();
202
203 AgreementStateType agreementState = agreementProperties.getAgreementState();
204 if ( ( agreementState.getState() == AgreementStateDefinition.OBSERVED )
205 || ( agreementState.getState() == AgreementStateDefinition.OBSERVED_AND_TERMINATING ) )
206 {
207
208 doUpdateStates( agreementProperties );
209
210
211
212
213 synchronized ( getAgreementInstance().getXMLObject() )
214 {
215 getAgreementInstance().setState( agreementProperties.getAgreementState() );
216 getAgreementInstance().setServiceTermStates(
217 agreementProperties.getServiceTermStateArray() );
218 getAgreementInstance().setGuaranteeTermStates(
219 agreementProperties.getGuaranteeTermStateArray() );
220
221 getAgreementInstance().getExecutionContext().putAll( monitoringContext.getProperties() );
222
223 }
224 }
225
226 getAgreementInstance().notifyObservers();
227 }
228 }
229
230 private void doUpdateStates( AgreementPropertiesType agreementProperties ) throws Exception
231 {
232 try
233 {
234
235
236
237 boolean monitoringResult = updateServiceTermStates( agreementProperties );
238
239
240
241
242 GuaranteeTermStateType[] gStates = new GuaranteeTermStateType[0];
243
244 try
245 {
246
247
248
249 gStates = agreementProperties.getGuaranteeTermStateArray();
250 }
251 catch ( Exception e )
252 {
253 String error = Messages.formatString( ERR_GET_GUARANTEE_STATES, e.getMessage() );
254 throw new Exception( error, e );
255 }
256
257
258
259
260
261
262 if ( monitoringResult )
263 {
264 Vector<GuaranteeEvaluationResultType> evalResults =
265 new Vector<GuaranteeEvaluationResultType>();
266
267
268
269 for ( int i = 0; i < gStates.length; i++ )
270 {
271 try
272 {
273 GuaranteeEvaluationResultType result =
274 updateGuaranteeTermState( gStates[i].getTermName(), agreementProperties );
275 evalResults.add( result );
276 }
277 catch ( Exception e )
278 {
279 String error =
280 Messages.formatString( ERR_UPDATE_GUARANTEE_STATE, gStates[i].getTermName(),
281 e.getMessage() );
282 throw new Exception( error, e );
283 }
284 }
285
286
287
288
289 SLAMonitoringNotificationEventType monitoringEvent =
290 SLAMonitoringNotificationEventType.Factory.newInstance();
291
292 monitoringEvent.setAgreementId( getAgreementInstance().getAgreementId() );
293
294 for ( int i = 0; i < gStates.length; i++ )
295 {
296 GuaranteeEvaluationResultType result = evalResults.get( i );
297 gStates[i] = result.getDetails().getGuaranteeState();
298 monitoringEvent.addNewGuaranteeEvaluationResult().set( result );
299 }
300
301 getMonitoringContext().getAccountingSystem().issueCompensation( monitoringEvent );
302 }
303 else
304 {
305 for ( int i = 0; i < gStates.length; i++ )
306 {
307 gStates[i].setState( GuaranteeTermStateDefinition.NOT_DETERMINED );
308 }
309 }
310
311
312
313 agreementProperties.setGuaranteeTermStateArray( gStates );
314 updateAgreementState( agreementProperties );
315
316 }
317 catch ( Exception e )
318 {
319 LOG.error( e.getMessage() );
320 throw e;
321 }
322 }
323
324 private void updateAgreementState( AgreementPropertiesType agreementProperties )
325 {
326 try
327 {
328 AgreementStateType state = agreementProperties.getAgreementState();
329
330 ServiceTermStateType[] sdtstates = agreementProperties.getServiceTermStateArray();
331 for ( int i = 0; i < sdtstates.length; i++ )
332 {
333 if ( ( sdtstates[i].getState() == ServiceTermStateDefinition.NOT_READY )
334 || ( sdtstates[i].getState() == ServiceTermStateDefinition.READY ) )
335 {
336 if ( state.getState() == AgreementStateDefinition.OBSERVED_AND_TERMINATING )
337 {
338
339
340
341 return;
342 }
343 else
344 {
345
346
347
348 state.setState( AgreementStateDefinition.OBSERVED );
349 }
350 return;
351 }
352 }
353
354
355
356
357 state.setState( AgreementStateDefinition.COMPLETE );
358 }
359 catch ( Exception e )
360 {
361 LOG.error( LogMessage.getMessage( ERR_UPDATE_AGREEMENT_STATE, e.getMessage() ) );
362 LOG.debug( e );
363 }
364 }
365
366 private boolean updateServiceTermStates( AgreementPropertiesType agreementProperties ) throws Exception
367 {
368 try
369 {
370
371
372
373 ServiceTermStateType[] states = new ServiceTermStateType[0];
374 try
375 {
376 states = agreementProperties.getServiceTermStateArray();
377 }
378 catch ( Exception e )
379 {
380 String error = Messages.formatString( ERR_GET_STD_STATES, e.getMessage() );
381 throw new Exception( error, e );
382 }
383
384
385
386
387 IMonitoringContext currentMonitoringContext = (IMonitoringContext) monitoringContext.clone();
388
389 try
390 {
391 currentMonitoringContext.setServiceTemState( new ServiceTermStateType[0] );
392
393
394
395
396 for ( int i = 0; i < states.length; i++ )
397 {
398 states[i] = (ServiceTermStateType) states[i].copy();
399 }
400
401 currentMonitoringContext.setServiceTemState( states );
402 }
403 catch ( Exception e )
404 {
405 throw new IllegalStateException( Messages.getString( ERR_INIT_SDT_STATES ), e );
406 }
407
408
409
410
411 boolean monitoringResult = stateMonitor.monitor( currentMonitoringContext );
412
413
414
415
416
417 agreementProperties.setServiceTermStateArray( currentMonitoringContext.getServiceTermStates() );
418 monitoringContext = currentMonitoringContext;
419
420 return monitoringResult;
421 }
422 catch ( Exception e )
423 {
424 String message = LogMessage.format( ERR_UPD_STD_STATES, e.getMessage() );
425 throw new Exception( message, e );
426 }
427 }
428
429 private GuaranteeTermType loadGuaranteeTerm( String name, AgreementPropertiesType agreementProperties )
430 {
431 String xpath = XPATH_NS_DECL_WSAG + MessageFormat.format( XPATH_QUERY_GUARANTEE_TERM, name );
432 XmlObject[] result = agreementProperties.selectPath( xpath );
433
434 if ( result.length == 0 )
435 {
436 LOG.warn( Messages.formatString( WARN_GURANTEE_NOT_FOUND, name ) );
437 return null;
438 }
439
440 if ( result.length > 1 )
441 {
442 LOG.warn( Messages.formatString( WARN_MULTIPLE_GUARANTEES, name ) );
443 }
444
445 return (GuaranteeTermType) result[0];
446 }
447
448 private ServicePropertiesType loadServiceProperties( String serviceName,
449 AgreementPropertiesType agreementProperties )
450 {
451 String xpath =
452 XPATH_NS_DECL_WSAG + MessageFormat.format( XPATH_QUERY_SERVICE_PROPERTIES, serviceName );
453
454 XmlObject[] result = agreementProperties.selectPath( xpath );
455
456 if ( result.length == 0 )
457 {
458 LOG.warn( Messages.formatString( WARN_SP_DEF_NOT_FOUND, serviceName ) );
459 ServicePropertiesType empty = ServicePropertiesType.Factory.newInstance();
460 empty.setName( "empty" );
461 empty.setServiceName( serviceName );
462 empty.addNewVariableSet();
463 return empty;
464 }
465
466 if ( result.length > 1 )
467 {
468 String warn = Messages.formatString( WARN_MULTIPLE_SP_DEFS, serviceName );
469 LOG.warn( warn );
470 }
471
472 return (ServicePropertiesType) result[0];
473 }
474
475 private GuaranteeEvaluationResultType
476 updateGuaranteeTermState( String termName, AgreementPropertiesType agreementProperties )
477 throws Exception
478 {
479 GuaranteeTermType guarantee = loadGuaranteeTerm( termName, agreementProperties );
480
481 LOG.debug( LogMessage.getMessage( DBG_EVAL_GUARANTEE_STATE, termName ) );
482
483 Map<String, Object> variableMap = new HashMap<String, Object>();
484
485 for ( int i = 0; i < guarantee.getServiceScopeArray().length; i++ )
486 {
487
488
489
490
491 ServiceSelectorType scope = guarantee.getServiceScopeArray( i );
492 ServicePropertiesType properties =
493 loadServiceProperties( scope.getServiceName(), agreementProperties );
494
495 LOG.debug( LogMessage.getMessage( DBG_SERVICE_PROPERTIES, properties.getServiceName(),
496 properties.getName() ) );
497
498 ServicePropertyResolver resolver = new ServicePropertyResolver( properties, agreementProperties );
499 Map<String, Object> var = resolver.resolveServiceProperties();
500
501 Iterator<String> keys = var.keySet().iterator();
502 while ( keys.hasNext() )
503 {
504 String variableName = (String) keys.next();
505 if ( variableMap.containsKey( variableName ) )
506 {
507 LOG.debug( LogMessage.getMessage( DBG_DUPLICATE_VAR_DEF, variableName ) );
508 }
509 else
510 {
511 variableMap.put( variableName, var.get( variableName ) );
512 }
513 }
514 }
515
516 IGuaranteeEvaluator evaluator = new SimpleGuaranteeEvaluator();
517 return evaluator.evaluate( guarantee, variableMap );
518 }
519
520 }