View Javadoc

1   /*
2    * Copyright 2007-2008 the original author or authors.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.gwe.persistence.model;
18  
19  /**
20   * @author Marco Ruiz
21   * @since Dec 31, 2008
22   */
23  public class AllocationLive implements Runnable {
24  
25  	private final AllocationInfo alloc;
26  	private long idleDeathTime = -1;
27  	private long oldDeathTime;
28  	private HeadResourceInfo headResource;
29  	
30      // Transients for real. Used while the allocation is alive (between attained and released)
31      private Object lifeControllerLock = new Object();
32      private JobExecutionInfo currentJobExecution = null;
33      private boolean registered = false;
34  
35  	public AllocationLive(AllocationInfo alloc, DaemonConfigDesc config) {
36  		this.alloc = alloc;
37  		this.headResource = config.getHeadResource();
38  		this.oldDeathTime = alloc.getWhenAttained().getTime() + headResource.getMaxHijackMillis();
39      }
40  	
41      public boolean isRegistered() {
42      	return registered;
43      }
44  
45  	public void registerAsRunningOn(ComputeResourceInfo compRes) {
46  		registered = true;
47  		alloc.setCompResource(compRes);
48  	}
49  
50  	public void startIdleCountdown()  {
51  		setIdleDeathTime(System.currentTimeMillis() + headResource.getMaxIdleMillis());
52  	}
53  	
54  	public void cancelIdleCountdown() {
55  		setIdleDeathTime(-1);
56  	}
57  	
58  	private void setIdleDeathTime(long time) {
59  		synchronized (lifeControllerLock) {
60  			idleDeathTime = time;
61  			lifeControllerLock.notifyAll();			
62  		}
63  	}
64  	
65  	public JobExecutionInfo getProcessingExecution() {
66  		synchronized (lifeControllerLock) { 
67  			return currentJobExecution; 
68  		}
69  	}
70  	
71  	public JobExecutionInfo extractProcessingExecution() {
72  		synchronized (lifeControllerLock) {
73  			JobExecutionInfo result = currentJobExecution;
74  			currentJobExecution = null;
75  			return result;
76  		}
77  	}
78  	
79  	public JobExecutionInfo getNextProcessingExecutionBlocking() {
80  		synchronized (lifeControllerLock) { 
81  			while (currentJobExecution == null && alloc.getWhenReleased() == null)
82  				try { lifeControllerLock.wait(); } catch (InterruptedException e) {} 
83  
84  			return currentJobExecution;
85  		}
86  	}
87  	
88  	public boolean setProcessingExecution(JobExecutionInfo execution) {
89  		synchronized (lifeControllerLock) {
90  			if (alloc.getWhenReleased() != null) return false;
91  			
92  			currentJobExecution = execution;
93  			execution.setAllocation(alloc);
94  			cancelIdleCountdown();
95  			lifeControllerLock.notifyAll();
96  			return true;
97  		}
98  	}
99  /*
100 	public JobExecutionInfo dispose(boolean beatOverdue) {
101 		synchronized (lifeControllerLock) {
102 			if (alloc.getWhenReleased() == null)
103 				alloc.setReleaseReason((beatOverdue) ? AllocationReleaseReasons.NON_RESPONSIVE : AllocationReleaseReasons.ERROR);
104 			
105 			alloc.dispose();
106 			lifeControllerLock.notifyAll();
107 			return currentJobExecution;
108 		}
109 	}
110 */
111 	public void run() {
112 		// Verify the allocation will be disposed due to an allocation recycling strategy (age and/or lazyness)
113 		boolean hijack = headResource.getMaxHijackMillis() > 0;
114 		if (!hijack && headResource.getMaxIdleMillis() <= 0) return;
115 		
116 		// Allocation is set for some form of recycling 
117 		boolean isIdleCutTime; 
118 		synchronized (lifeControllerLock) {
119 			// Death dealer cycle
120 			while (true) {
121 				isIdleCutTime = (0 <= idleDeathTime && idleDeathTime <= oldDeathTime);
122 				long remaining = (isIdleCutTime ? idleDeathTime : oldDeathTime) - System.currentTimeMillis();
123 				if (remaining <= 0) break; // Too idle or too old
124 				try { 
125 					lifeControllerLock.wait(remaining); 
126 				} catch (InterruptedException e) {
127 					// TODO: Release allocation due to interruption sent by daemon shutting down sequence ?
128 					// Or do this in "dispose" method from the allocation?
129 				}
130 				if (alloc.getWhenReleased() != null || alloc.getWhenDisposed() != null) break;  // Externally disposed already
131 			}
132 			
133 			// Death dealer finalizing sequence
134 /*
135 			if (alloc.getWhenReleased() == null) {
136 				alloc.setReleaseReason((isIdleCutTime) ? AllocationReleaseReasons.TOO_IDLE : AllocationReleaseReasons.TOO_OLD);
137 				// Force agent API thread to realize this allocation has been released 
138 				// (when waiting for a processing job in getJobProcessing)
139 				lifeControllerLock.notifyAll(); 
140 			}
141 */
142 		}
143 	}
144 }