Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.pubnub.api;
  
  import java.util.Vector;
  
  abstract class Worker implements Runnable {
      private Vector _requestQueue;
      protected volatile boolean _die;
      private Thread thread;
     protected HttpClient httpclient;
 
     protected static Logger log = new Logger(Worker.class);
 
     public Thread getThread() {
         return ;
     }
 
     void setThread(Thread thread) {
         this. = thread;
     }
 
     void startWorker() {
         .start();
     }
 
     void interruptWorker() {
         .interrupt();
     }
 
     void resetConnection() {
         .reset();
     }
 
     Worker(Vector _requestQueueint connectionTimeoutint requestTimeoutHashtable headers) {
         this. = _requestQueue;
         this. = HttpClient.getClient(connectionTimeout,
                                                requestTimeoutheaders);
     }
 
     void setConnectionTimeout(int timeout) {
         if ( != null) {
             .setConnectionTimeout(timeout);
         }
     }
 
     void setRequestTimeout(int timeout) {
         if ( != null) {
             .setRequestTimeout(timeout);
         }
     }
 
     public abstract void shutdown();
 
     void die() {
          = true;
     }
 
     abstract void process(HttpRequest hreq);
 
     public void run() {
         do {
             HttpRequest hreq = null;
             while (!) {
 
                 synchronized () {
 
                     if (.size() != 0) {
                         hreq = (HttpRequest.firstElement();
                         .removeElementAt(0);
                         break;
                     }
                     try {
                         .wait(1000);
                     } catch (InterruptedException e) {
                     }
                 }
             }
             if (hreq != null) {
                 if (!) {
                     process(hreq);
                 }
             }
         } while (!);
         shutdown();
     }
 }
 
 class NonSubscribeWorker extends Worker {
 
     NonSubscribeWorker(Vector _requestQueueint connectionTimeout,
                        int requestTimeoutHashtable headers) {
         super(_requestQueueconnectionTimeoutrequestTimeoutheaders);
     }
 
     void process(HttpRequest hreq) {
         HttpResponse hresp = null;
         try {
             .debug(hreq.getUrl());
             hresp = .fetch(hreq.getUrl(), hreq.getHeaders());
        } catch (PubnubException pe) {
            .debug("Pubnub Exception in Fetch : " + pe.getPubnubError());
            if (!)
                hreq.getResponseHandler().handleError(hreqpe.getPubnubError());
            return;
        } catch (Exception e) {
            .debug("Exception in Fetch : " + e.toString());
            if (!)
                hreq.getResponseHandler().handleError(hreq, PubnubError.getErrorObject(., 2, e.toString()));
            return;
        }
        if (!) {
            if (hresp == null) {
                .debug("Error in fetching url : " + hreq.getUrl());
                hreq.getResponseHandler().handleError(hreq, PubnubError.getErrorObject(. , 3));
                return;
            }
            hreq.getResponseHandler().handleResponse(hreqhresp.getResponse());
        }
    }
    public void shutdown() {
        if ( != null.shutdown();
    }
abstract class RequestManager {
    private static int _maxWorkers = 1;
    protected Vector _waiting = new Vector();
    protected Worker _workers[];
    protected String name;
    protected volatile int connectionTimeout;
    protected volatile int requestTimeout;
    protected Hashtable headers;
    private static int count = 0;
    protected static Logger log = new Logger(RequestManager.class);
    public static int getWorkerCount() {
        return ;
    }
    public abstract Worker getWorker();
    private void initManager(int maxCallsString name) {
        if (maxCalls < 1) {
            maxCalls = 1;
        }
        this. = name;
        this. = new Hashtable();
         = new Worker[maxCalls];
        synchronized () {
            for (int i = 0; i < maxCalls; ++i) {
                Worker w = getWorker();
                w.setThread(new Thread(wname + "-" + ++));
                [i] = w;
                .verbose("Starting new worker " + [i].getThread().getName());
                w.startWorker();
            }
        }
    }
    public RequestManager(String nameint connectionTimeoutint requestTimeout) {
        this. = connectionTimeout;
        this. = requestTimeout;
        initManager(name);
    }
    private void interruptWorkers() {
        synchronized () {
            for (int i = 0; i < .i++) {
                [i].interruptWorker();
            }
        }
    }
    
    class ConnectionResetter implements Runnable {
    	Worker worker;
    		this. = w;
    	}
		public void run() {
			if (this. != null) {
			}
		}
    }
    public void resetWorkers() {
        synchronized () {
            for (int i = 0; i < .i++) {
                .verbose("Sending DIE to " + [i].getThread().getName());
                [i].die();
                new Thread(new ConnectionResetter([i])).start();
                [i].interruptWorker();
                Worker w = getWorker();
                w.setThread(new Thread(w + "-" + ++));
                [i] = w;
                .verbose("Starting new worker " + [i].getThread().getName());
                w.startWorker();
            }
        }
    }
    public void setHeader(String keyString value) {
        this..put(keyvalue);
    }
    public abstract void clearRequestQueue();
    public void resetHttpManager() {
        clearRequestQueue();
        resetWorkers();
    }
    public void abortClearAndQueue(HttpRequest hreq) {
        resetHttpManager();
        queue(hreq);
    }
    public void queue(HttpRequest hreq) {
        .debug("Queued : " + hreq.getUrl());
        synchronized () {
            .addElement(hreq);
            .notifyAll();
        }
    }
    public static void setWorkerCount(int count) {
         = count;
    }
    public void stop() {
        synchronized () {
            for (int i = 0; i < ; ++i) {
                Worker w = [i];
                w.die();
            }
        }
        synchronized () {
            .notifyAll();
        }
    }
abstract class AbstractSubscribeManager extends RequestManager {
    protected volatile int maxRetries = 5;
    protected volatile int retryInterval = 5000;
    protected volatile int windowInterval = 0;
    public AbstractSubscribeManager(String nameint connectionTimeout,
                                    int requestTimeout) {
        super(nameconnectionTimeoutrequestTimeout);
    }
    public Worker getWorker() {
        return new SubscribeWorker(,
                                   ,
                                   );
    }
    public void setMaxRetries(int maxRetries) {
        this. = maxRetries;
        for (int i = 0; i < .i++) {
            ((SubscribeWorker[i]).setMaxRetries(maxRetries);
        }
    }
    public void setRetryInterval(int retryInterval) {
        this. = retryInterval;
        for (int i = 0; i < .i++) {
            ((SubscribeWorker[i]).setRetryInterval(retryInterval);
        }
    }
    public void setWindowInterval(int windowInterval) {
        this. = windowInterval;
        for (int i = 0; i < .i++) {
            ((SubscribeWorker[i]).setWindowInterval(windowInterval);
        }
    }
    public void setConnectionTimeout(int timeout) {
        this. = timeout;
    }
    public void setRequestTimeout(int timeout) {
        this. = timeout;
    }
    public void queue(HttpRequest hreq) {
        synchronized () {
            clearRequestQueue();
            super.queue(hreq);
        }
    }
abstract class AbstractNonSubscribeManager extends RequestManager {
    public AbstractNonSubscribeManager(String nameint connectionTimeout,
                                       int requestTimeout) {
        super(nameconnectionTimeoutrequestTimeout);
    }
    public Worker getWorker() {
        return new NonSubscribeWorker(,
                                      );
    }
    public void setConnectionTimeout(int timeout) {
        this. = timeout;
        for (int i = 0; i < .i++) {
            [i].setConnectionTimeout(timeout);
        }
    }
    public void setRequestTimeout(int timeout) {
        this. = timeout;
        for (int i = 0; i < .i++) {
            [i].setRequestTimeout(timeout);
        }
    }
abstract class AbstractSubscribeWorker extends Worker {
    protected volatile int maxRetries = 5;
    protected volatile int retryInterval = 5000;
    protected volatile int windowInterval = 0;
    AbstractSubscribeWorker(Vector _requestQueueint connectionTimeout,
                            int requestTimeoutint maxRetriesint retryIntervalHashtable headers) {
        super(_requestQueueconnectionTimeoutrequestTimeoutheaders);
        this. = maxRetries;
        this.retryInterval;
    }
    AbstractSubscribeWorker(Vector _requestQueueint connectionTimeout,
            int requestTimeoutint maxRetriesint retryIntervalint windowIntervalHashtable headers) {
        super(_requestQueueconnectionTimeoutrequestTimeoutheaders);
        this. = maxRetries;
        this.retryInterval;
        this. = windowInterval;
    }
    public void setMaxRetries(int maxRetries) {
        this. = maxRetries;
    }
    public void setRetryInterval(int retryInterval) {
        this. = retryInterval;
    }
    public void setWindowInterval(int windowInterval) {
        this. = windowInterval;
    }
New to GrepCode? Check out our FAQ X