← Back to branch summary

~ubuntu-branches/ubuntu/precise/tomcat7/precise-updates

« back to all changes in this revision

Viewing changes to java/org/apache/coyote/ajp/AjpProtocol.java

  • Committer: Bazaar Package Importer
  • Author(s): tony mancill, Miguel Landaeta, tony mancill
  • Date: 2011-06-23 20:26:29 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110623202629-w1v0jejj19swux10
Tags: 7.0.16-1
[ Miguel Landaeta ]
* New upstream release.
* Add missing deps and symlinks for commons-pool ands commons-dbcp jars.

[ tony mancill ]
* Add logrotate file for catalina.out.
* Add build-arch target to debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/org/apache/coyote/ajp/AjpProtocol.java
19
19
 
20
20
import java.net.Socket;
21
21
import java.util.concurrent.ConcurrentHashMap;
22
 
import java.util.concurrent.ConcurrentLinkedQueue;
23
 
import java.util.concurrent.atomic.AtomicInteger;
24
 
import java.util.concurrent.atomic.AtomicLong;
25
 
 
26
 
import javax.management.ObjectName;
27
 
 
28
 
import org.apache.coyote.RequestGroupInfo;
29
 
import org.apache.coyote.RequestInfo;
 
22
 
 
23
import org.apache.coyote.AbstractProtocol;
30
24
import org.apache.juli.logging.Log;
31
25
import org.apache.juli.logging.LogFactory;
32
26
import org.apache.tomcat.util.ExceptionUtils;
33
 
import org.apache.tomcat.util.modeler.Registry;
34
27
import org.apache.tomcat.util.net.AbstractEndpoint;
35
28
import org.apache.tomcat.util.net.JIoEndpoint;
36
29
import org.apache.tomcat.util.net.JIoEndpoint.Handler;
95
88
    // --------------------------------------  AjpConnectionHandler Inner Class
96
89
 
97
90
 
98
 
    protected static class AjpConnectionHandler implements Handler {
 
91
    protected static class AjpConnectionHandler
 
92
            extends AbstractConnectionHandler implements Handler {
99
93
 
100
94
        protected AjpProtocol proto;
101
 
        protected AtomicLong registerCount = new AtomicLong(0);
102
 
        protected RequestGroupInfo global = new RequestGroupInfo();
103
95
 
104
96
        protected ConcurrentHashMap<SocketWrapper<Socket>, AjpProcessor> connections =
105
97
            new ConcurrentHashMap<SocketWrapper<Socket>, AjpProcessor>();
106
98
 
107
 
        protected ConcurrentLinkedQueue<AjpProcessor> recycledProcessors = 
108
 
            new ConcurrentLinkedQueue<AjpProcessor>() {
109
 
            private static final long serialVersionUID = 1L;
110
 
            protected AtomicInteger size = new AtomicInteger(0);
111
 
            @Override
112
 
            public boolean offer(AjpProcessor processor) {
113
 
                boolean offer = (proto.processorCache == -1) ? true : (size.get() < proto.processorCache);
114
 
                //avoid over growing our cache or add after we have stopped
115
 
                boolean result = false;
116
 
                if ( offer ) {
117
 
                    result = super.offer(processor);
118
 
                    if ( result ) {
119
 
                        size.incrementAndGet();
120
 
                    }
121
 
                }
122
 
                if (!result) unregister(processor);
123
 
                return result;
124
 
            }
125
 
            
126
 
            @Override
127
 
            public AjpProcessor poll() {
128
 
                AjpProcessor result = super.poll();
129
 
                if ( result != null ) {
130
 
                    size.decrementAndGet();
131
 
                }
132
 
                return result;
133
 
            }
134
 
            
135
 
            @Override
136
 
            public void clear() {
137
 
                AjpProcessor next = poll();
138
 
                while ( next != null ) {
139
 
                    unregister(next);
140
 
                    next = poll();
141
 
                }
142
 
                super.clear();
143
 
                size.set(0);
144
 
            }
145
 
        };
 
99
        protected RecycledProcessors<AjpProcessor> recycledProcessors =
 
100
            new RecycledProcessors<AjpProcessor>(this);
146
101
 
147
102
        public AjpConnectionHandler(AjpProtocol proto) {
148
103
            this.proto = proto;
149
104
        }
150
105
        
151
106
        @Override
152
 
        public Object getGlobal() {
153
 
            return global;
 
107
        protected AbstractProtocol getProtocol() {
 
108
            return proto;
 
109
        }
 
110
 
 
111
        @Override
 
112
        protected Log getLog() {
 
113
            return log;
154
114
        }
155
115
 
156
116
        @Override
227
187
            register(processor);
228
188
            return processor;
229
189
        }
230
 
        
231
 
        protected void register(AjpProcessor processor) {
232
 
            if (proto.getDomain() != null) {
233
 
                synchronized (this) {
234
 
                    try {
235
 
                        long count = registerCount.incrementAndGet();
236
 
                        RequestInfo rp = processor.getRequest().getRequestProcessor();
237
 
                        rp.setGlobalProcessor(global);
238
 
                        ObjectName rpName = new ObjectName
239
 
                            (proto.getDomain() + ":type=RequestProcessor,worker="
240
 
                                + proto.getName() + ",name=AjpRequest" + count);
241
 
                        if (log.isDebugEnabled()) {
242
 
                            log.debug("Register " + rpName);
243
 
                        }
244
 
                        Registry.getRegistry(null, null).registerComponent(rp, rpName, null);
245
 
                        rp.setRpName(rpName);
246
 
                    } catch (Exception e) {
247
 
                        log.warn("Error registering request");
248
 
                    }
249
 
                }
250
 
            }
251
 
        }
252
 
 
253
 
        protected void unregister(AjpProcessor processor) {
254
 
            if (proto.getDomain() != null) {
255
 
                synchronized (this) {
256
 
                    try {
257
 
                        RequestInfo rp = processor.getRequest().getRequestProcessor();
258
 
                        rp.setGlobalProcessor(null);
259
 
                        ObjectName rpName = rp.getRpName();
260
 
                        if (log.isDebugEnabled()) {
261
 
                            log.debug("Unregister " + rpName);
262
 
                        }
263
 
                        Registry.getRegistry(null, null).unregisterComponent(rpName);
264
 
                        rp.setRpName(null);
265
 
                    } catch (Exception e) {
266
 
                        log.warn("Error unregistering request", e);
267
 
                    }
268
 
                }
269
 
            }
270
 
        }
271
190
    }
272
 
 
273
191
}