View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.jetspeed.aggregator.impl;
18  
19  import java.util.ArrayList;
20  import java.util.Collections;
21  import java.util.HashMap;
22  import java.util.Iterator;
23  import java.util.List;
24  import java.util.Map;
25  
26  import org.apache.jetspeed.aggregator.PortletTrackingManager;
27  import org.apache.jetspeed.aggregator.RenderTrackable;
28  import org.apache.jetspeed.container.window.PortletWindowAccessor;
29  import org.apache.jetspeed.om.common.portlet.PortletDefinitionComposite;
30  import org.apache.pluto.om.window.PortletWindow;
31  
32  /***
33   * Tracks out of service status for portlets
34   *  
35   * @author <a href="mailto:taylor@apache.org">David Sean Taylor</a>
36   * @version $Id: $
37   */
38  public class PortletTrackingManagerImpl implements PortletTrackingManager
39  {
40      protected Map outOfService = Collections.synchronizedMap(new HashMap());
41  
42      /***
43       * when rendering a portlet, the default timeout period in milliseconds
44       * setting to zero will disable (no timeout) the timeout
45       *  
46       */
47      protected long defaultPortletTimeout; 
48      
49      /***
50       * Out of service limit, if a portlet entity times out past its limit (or default limit) n consecutive times, 
51       * it is taken out of service
52       */
53      protected int outOfServiceLimit;
54      
55      protected PortletWindowAccessor windowAccessor;
56      
57      public PortletTrackingManagerImpl(PortletWindowAccessor windowAccessor, long defaultPortletTimeout, int outOfServiceLimit)
58      {
59          this.windowAccessor = windowAccessor;
60          this.defaultPortletTimeout = defaultPortletTimeout;
61          this.outOfServiceLimit = outOfServiceLimit;
62      }
63      
64      public long getDefaultPortletTimeout()
65      {
66          return this.defaultPortletTimeout;
67      }
68  
69      public boolean exceededTimeout(long renderTime, PortletWindow window)
70      {
71          RenderTrackable trackInfo = (RenderTrackable)window.getPortletEntity();
72          long defaultTimeout = this.getDefaultPortletTimeout();
73          if (trackInfo.getExpiration() > 0)
74          {
75              return (renderTime > trackInfo.getExpiration());
76          }
77          else if (defaultTimeout > 0)
78          {
79              return (renderTime > defaultTimeout);
80          }
81          return false;
82      }
83      
84      public boolean isOutOfService(PortletWindow window)
85      {
86          RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
87          if (trackable.getRenderTimeoutCount() > this.outOfServiceLimit)
88          {
89              return true;
90          }
91          return false;
92      }
93      
94      public int getOutOfServiceLimit()
95      {
96          return this.outOfServiceLimit;
97      }
98      
99      public void incrementRenderTimeoutCount(PortletWindow window)
100     {
101         RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
102         trackable.incrementRenderTimeoutCount();       
103     }
104    
105     public void success(PortletWindow window)
106     {
107         RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
108         trackable.success();
109     }
110     
111     public void setExpiration(PortletWindow window, long expiration)
112     {
113         RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
114         trackable.setExpiration(expiration); // * 1000);                
115     }
116         
117     public void takeOutOfService(PortletWindow window)
118     {
119         RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
120         trackable.setRenderTimeoutCount((int)this.defaultPortletTimeout + 1);
121     }
122     
123     public void putIntoService(PortletWindow window)
124     {
125         RenderTrackable trackable = (RenderTrackable)window.getPortletEntity();
126         trackable.setRenderTimeoutCount(0);        
127     }
128     
129     public void putIntoService(List fullPortletNames)
130     {
131         Iterator windows = this.windowAccessor.getPortletWindows().iterator();
132         while (windows.hasNext())
133         {
134             Map.Entry entry = (Map.Entry)windows.next();
135             PortletWindow window = (PortletWindow)entry.getValue();
136             PortletDefinitionComposite pd = (PortletDefinitionComposite)window.getPortletEntity().getPortletDefinition();          
137             for (int ix = 0; ix < fullPortletNames.size(); ix++)
138             {
139                 if (pd.getUniqueName().equals(fullPortletNames.get(ix)))
140                 {
141                     putIntoService(window);
142                 }
143             }
144         }        
145     }
146     
147     public List getOutOfServiceList(String fullPortletName)
148     {
149         List outs = new ArrayList();
150         Iterator windows = this.windowAccessor.getPortletWindows().iterator();
151         while (windows.hasNext())
152         {
153             Map.Entry entry = (Map.Entry)windows.next();
154             PortletWindow window = (PortletWindow)entry.getValue();
155             PortletDefinitionComposite pd = (PortletDefinitionComposite)window.getPortletEntity().getPortletDefinition();
156             if (pd.getUniqueName().equals(fullPortletName) && isOutOfService(window))
157             {
158                 outs.add(window);
159             }
160         }
161         return outs;
162     }
163     
164     public List getOutOfServiceList()
165     {
166         List outs = new ArrayList();
167         Iterator windows = this.windowAccessor.getPortletWindows().iterator();
168         while (windows.hasNext())
169         {
170             Map.Entry entry = (Map.Entry)windows.next();
171             PortletWindow window = (PortletWindow)entry.getValue();
172             if (isOutOfService(window))
173             {
174                 outs.add(window);                
175             }
176         }
177         return outs;
178     }
179 }