qosfiltertest.java

是离开的肌肤了卡机是离开的就富利卡及是了的开发及拉考试及的福利科技阿斯利康的肌肤莱卡及时的离开福建阿斯顿发

// ========================================================================
// Copyright 2004-2008 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at 
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
package org.mortbay.servlet;

import java.io.IOException;
import java.net.URL;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import junit.framework.TestCase;

import org.mortbay.jetty.Handler;
import org.mortbay.jetty.LocalConnector;
import org.mortbay.jetty.servlet.FilterHolder;
import org.mortbay.jetty.testing.HttpTester;
import org.mortbay.jetty.testing.ServletTester;
import org.mortbay.log.Log;

public class QoSFilterTest extends TestCase 
{
    private ServletTester _tester;
    private FakeCountDownLatch _doneRequests;
    private final int NUM_CONNECTIONS = 20;
    private final int NUM_LOOPS = 10;
    private final int MAX_QOS = 5;
    
    protected void setUp() throws Exception 
    {
        _tester = new ServletTester();
        _tester.setContextPath("/context");
        _tester.addServlet(TestServlet.class, "/test");
        TestServlet.__maxSleepers=0;
        TestServlet.__sleepers=0;
        
        _doneRequests = new FakeCountDownLatch(NUM_CONNECTIONS*NUM_LOOPS);
        
        _tester.start();
    }
        
    protected void tearDown() throws Exception 
    {
        _tester.stop();
    }

    public void testNoFilter() throws Exception
    {    
        for(int i = 0; i < NUM_CONNECTIONS; ++i )
        {
            new Thread(new Worker(i)).start();
        }
        
        _doneRequests.await(10);
        
        if (TestServlet.__maxSleepers<=MAX_QOS)
            Log.warn("TEST WAS NOT PARALLEL ENOUGH!");
        assertTrue(TestServlet.__maxSleepers<=NUM_CONNECTIONS);
    }

    public void testBlockingQosFilter() throws Exception
    {    
        FilterHolder holder = new FilterHolder(QoSFilter2.class);
        holder.setInitParameter(QoSFilter.MAX_REQUESTS_INIT_PARAM, ""+MAX_QOS);
        _tester.getContext().getServletHandler().addFilterWithMapping(holder,"/*",Handler.REQUEST);
        
        for(int i = 0; i < NUM_CONNECTIONS; ++i )
        {
            new Thread(new Worker(i)).start();
        }
        
        _doneRequests.await(10);
        if (TestServlet.__maxSleepers<MAX_QOS)
            Log.warn("TEST WAS NOT PARALLEL ENOUGH!");
        assertTrue(TestServlet.__maxSleepers<=MAX_QOS);
    }

    public void testQosFilter() throws Exception
    {    
        FilterHolder holder = new FilterHolder(QoSFilter2.class);
        holder.setInitParameter(QoSFilter.MAX_REQUESTS_INIT_PARAM, ""+MAX_QOS);
        _tester.getContext().getServletHandler().addFilterWithMapping(holder,"/*",Handler.REQUEST);
        
        for(int i = 0; i < NUM_CONNECTIONS; ++i )
        {
            new Thread(new Worker2(i)).start();
        }
        
        _doneRequests.await(10);
        if (TestServlet.__maxSleepers<MAX_QOS)
            Log.warn("TEST WAS NOT PARALLEL ENOUGH!");
        assertTrue(TestServlet.__maxSleepers<=MAX_QOS);
    }
    
    class Worker implements Runnable {
        private int _num;
        public Worker(int num)
        {
            _num = num;
        }

        public void run()
        {
            try
            {
                LocalConnector connector = _tester.createLocalConnector();
                for (int i=0;i<NUM_LOOPS;i++)
                {
                    HttpTester request = new HttpTester();
                    HttpTester response = new HttpTester();

                    request.setMethod("GET");
                    request.setHeader("host", "tester");
                    request.setURI("/context/test?priority="+(_num%QoSFilter.__DEFAULT_MAX_PRIORITY)+"&n="+_num+"&l="+i);
                    request.setHeader("num", _num+"");
                    try
                    {
                        String responseString = _tester.getResponses(request.generate(), connector);
                        int index=-1;
                        if((index = responseString.indexOf("HTTP", index+1))!=-1)
                        {
                            responseString = response.parse(responseString);
                            _doneRequests.countDown();
                        }
                    }
                    catch (IOException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    catch (Exception e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
    
    class Worker2 implements Runnable {
        private int _num;
        public Worker2(int num)
        {
            _num = num;
        }

        public void run()
        {
            try
            {
                String addr = _tester.createSocketConnector(true);
                for (int i=0;i<NUM_LOOPS;i++)
                {
                    URL url=new URL(addr+"/context/test?priority="+(_num%QoSFilter.__DEFAULT_MAX_PRIORITY)+"&n="+_num+"&l="+i);
                    url.getContent();
                    _doneRequests.countDown();
                }
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
    
    public static class TestServlet extends HttpServlet implements Servlet
    {
        private static int __sleepers;
        private static int __maxSleepers;
         
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
        {
            try
            {
                synchronized(TestServlet.class)
                {
                    __sleepers++;
                    if(__sleepers > __maxSleepers)
                        __maxSleepers = __sleepers;
                }

                Thread.sleep(200);

                synchronized(TestServlet.class)
                {
                    __sleepers--;
                    if(__sleepers > __maxSleepers)
                        __maxSleepers = __sleepers;
                }

                response.setContentType("text/plain");
                response.getWriter().println("DONE!");     
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
                response.sendError(500);
            }           
        }
    }
    
    public static class QoSFilter2 extends QoSFilter
    {
        public int getPriority(ServletRequest request)
        {
            String p = ((HttpServletRequest)request).getParameter("priority");
            if (p!=null)
                return Integer.parseInt(p);
            return 0;
        }
    }
    
    static class FakeCountDownLatch
    {
        int _latch;

        public FakeCountDownLatch(int i)
        {
            _latch=i;
        }

        public void countDown()
        {
            synchronized(this)
            {
                _latch--;
                if (_latch<=0)
                    this.notifyAll();
            }
        }

        public void await(int seconds)
        {
            long wait_until = System.currentTimeMillis()+seconds*1000;
            synchronized(this)
            {
                while(_latch>0 && System.currentTimeMillis()<wait_until)
                {
                    try
                    {
                        this.wait(1000);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
        
    }
    
}