2456e274b0b44f4ea587d5bc865ca282c69405ff
[appc.git] / appc-adapters / appc-iaas-adapter / appc-iaas-adapter-bundle / src / main / java / org / onap / appc / adapter / iaas / impl / RequestContext.java
1 /*
2  * ============LICENSE_START=======================================================
3  * ONAP : APPC
4  * ================================================================================
5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6  * ================================================================================
7  * Copyright (C) 2017 Amdocs
8  * =============================================================================
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  * 
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  * 
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  * 
21  * ============LICENSE_END=========================================================
22  */
23
24 package org.onap.appc.adapter.iaas.impl;
25
26 import org.onap.appc.Constants;
27 import org.onap.appc.configuration.Configuration;
28 import org.onap.appc.configuration.ConfigurationFactory;
29 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
30
31 /**
32  * This class is used to track and maintain recovery and time-to-live information for a request as it is being
33  * processed.
34  */
35 public class RequestContext {
36     /**
37      * The number of seconds of wait time between successive attempts to connect to the provider. This is used to
38      * recover from provider outages or failures. It is not used to recover from logical errors, such as an invalid
39      * request, server not found, etc.
40      */
41     private Integer retryDelay;
42
43     /**
44      * The number of times we will attempt to connect to the provider. This is used to recover from provider outages or
45      * failures. It is not used to recover from logical errors, such as an invalid request, server not found, etc.
46      */
47     private Integer retryLimit;
48
49     /**
50      * The total time, in milliseconds, that the provider can have to process this request. If the accumulated time
51      * exceeds the time to live, then the request is failed with a timeout exception, regardless of the state of the
52      * provider. Note that the caller may supply this as a value in seconds, in which case it must be converted to
53      * milliseconds for the request context.
54      */
55     private Long timeToLive;
56
57     /**
58      * The accumulated time, in milliseconds, that has been used so far to process the request. This is compared to the
59      * time to live each time it is updated. If the accumulated time exceeds the time to live, then the request is
60      * failed with a timeout exception, regardless of the state of the provider.
61      */
62     private long accumulatedTime;
63
64     /**
65      * The total number of retries attempted so far
66      */
67     private int attempt;
68
69     /**
70      * The time when the stopwatch was started
71      */
72     private long startTime = -1;
73
74     /**
75      * The service logic (DG) context from the SLI
76      */
77     private SvcLogicContext svcLogicContext;
78
79     /**
80      * The configuration
81      */
82     private Configuration configuration = ConfigurationFactory.getConfiguration();
83
84     /**
85      * Set to true whenever the retry limit has been exceeded, reset to false when reset() is called.
86      */
87     private boolean retryFailed;
88
89     /**
90      * Creates the request context
91      * 
92      * @param context The service logic (SLI) context associated with the current DG
93      */
94     public RequestContext(SvcLogicContext context) {
95         setSvcLogicContext(context);
96     }
97
98     /**
99      * @return The retry delay, in seconds. If zero, then no retry is to be performed
100      */
101     public int getRetryDelay() {
102         if (retryDelay == null) {
103             int value = configuration.getIntegerProperty(Constants.PROPERTY_RETRY_DELAY);
104             retryDelay = Integer.valueOf(value);
105         }
106
107         return retryDelay.intValue();
108     }
109
110     /**
111      * This method is a helper that allows the caller to delay for the retry interval time and not have to handle the
112      * thread interruption, timer handling, etc.
113      */
114     public void delay() {
115         long time = getRetryDelay() * 1000L;
116         long future = System.currentTimeMillis() + time;
117         if (time != 0) {
118             while (System.currentTimeMillis() < future && time > 0) {
119                 try {
120                     Thread.sleep(time);
121                 } catch (InterruptedException e) {
122                     /*
123                      * This is rare, but it can happen if another thread interrupts us while we are sleeping. In that
124                      * case, the thread is resumed before the delay time has actually expired, so re-calculate the
125                      * amount of delay time needed and reenter the sleep until we get to the future time.
126                      */
127                     time = future - System.currentTimeMillis();
128                 }
129             }
130         }
131     }
132
133     /**
134      * @return The number of retries that are allowed per connection
135      */
136     public int getRetryLimit() {
137         if (retryLimit == null) {
138             int value = configuration.getIntegerProperty(Constants.PROPERTY_RETRY_LIMIT);
139             retryLimit = Integer.valueOf(value);
140         }
141
142         return retryLimit.intValue();
143     }
144
145     /**
146      * Check and count the connection attempt.
147      * 
148      * @return True if the connection should be attempted. False indicates that the number of retries has been exhausted
149      *         and it should NOT be attempted.
150      */
151     public boolean attempt() {
152         if (retryFailed || attempt >= getRetryLimit()) {
153             retryFailed = true;
154             return false;
155         }
156         attempt++;
157
158         return true;
159     }
160
161     /**
162      * @return The number of retry attempts so far
163      */
164     public int getAttempts() {
165         return attempt;
166     }
167
168     /**
169      * @return True if the retry limit has been exceeded, false otherwise
170      */
171     public boolean isFailed() {
172         return retryFailed;
173     }
174
175     /**
176      * This method both checks the time to live to see if it has been exceeded and accumulates the total time used so
177      * far.
178      * <p>
179      * Each time this method is called it accumulates the total duration since the last time it was called to the total
180      * time accumulator. It then checks the total time to the time to live and if greater, it returns false. As long as
181      * the total time used is less than or equal to the time to live limit, the method returns true. It is important to
182      * call this method at the very beginning of the process so that all parts of the process are tracked.
183      * </p>
184      * 
185      * @return True if the total time to live has not been exceeded. False indicates that the total time to live has
186      *         been exceeded and no further processing should be performed.
187      */
188     public boolean isAlive() {
189         long now = System.currentTimeMillis();
190         if (startTime == -1) {
191             startTime = now;
192             return true;
193         }
194         accumulatedTime += (now - startTime);
195         startTime = now;
196         if (accumulatedTime > timeToLive) {
197             return false;
198         }
199         return true;
200     }
201
202     /**
203      * @return The total amount of time used, in milliseconds.
204      */
205     public long getTotalDuration() {
206         return accumulatedTime;
207     }
208
209     /**
210      * This method is called to reset the retry counters. It has no effect on the time to live accumulator.
211      */
212     public void reset() {
213         attempt = 0;
214     }
215
216     /**
217      * Sets the time to live to the value, expressed in seconds
218      * 
219      * @param time The time to live, in seconds
220      */
221     public void setTimeToLiveSeconds(int time) {
222         setTimeToLiveMS(time * 1000L);
223     }
224
225     /**
226      * Sets the time to live to the value, expressed in milliseconds
227      * 
228      * @param time The time to live, in milliseconds
229      */
230     public void setTimeToLiveMS(long time) {
231         this.timeToLive = time;
232     }
233
234     /**
235      * @return The service logic context associated with this request
236      */
237     public SvcLogicContext getSvcLogicContext() {
238         return svcLogicContext;
239     }
240
241     /**
242      * @param svcLogicContext The service logic context to be associated with this request
243      */
244     public void setSvcLogicContext(SvcLogicContext svcLogicContext) {
245         this.svcLogicContext = svcLogicContext;
246     }
247 }