rabbit.handler
Class ImageHandler

java.lang.Object
  extended by rabbit.handler.BaseHandler
      extended by rabbit.handler.ImageHandler
All Implemented Interfaces:
Handler, HandlerFactory, AsyncListener, BlockListener, BlockSentListener, HttpHeaderSentListener

public class ImageHandler
extends BaseHandler

This handler first downloads the image runs convert on it and then serves the smaller image.

Author:
Robert Olofsson

Nested Class Summary
static class ImageHandler.ImageConversionResult
           
 
Field Summary
protected  File convertedFile
           
 
Fields inherited from class rabbit.handler.BaseHandler
cacheChannel, clientHandle, con, content, entry, mayCache, mayFilter, request, response, size, tlh, totalRead
 
Constructor Summary
ImageHandler()
          For creating the factory.
ImageHandler(Connection con, TrafficLoggerHandler tlh, HttpHeader request, BufferHandle clientHandle, HttpHeader response, ResourceSource content, boolean mayCache, boolean mayFilter, long size, SProperties config, boolean doConvert, int minSizeToConvert, ImageConverter imageConverter)
          Create a new ImageHandler for the given request.
 
Method Summary
protected  void addCache()
          Set up the cache stream if available.
 boolean changesContentSize()
          ┬«return true this handler modifies the content.
protected  String checkFileType(File typeFile)
           
protected  void convertImage()
          Convert the image into a small low quality image (normally a jpeg).
protected  void finish(boolean good)
          clear up the mess we made (remove intermediate files etc).
 SProperties getConfig()
           
 boolean getDoConvert()
           
 int getMinSizeToConvert()
           
 Handler getNewInstance(Connection con, TrafficLoggerHandler tlh, HttpHeader header, BufferHandle bufHandle, HttpHeader webHeader, ResourceSource content, boolean mayCache, boolean mayFilter, long size)
          Get a new Handler for the given request made.
 void handle()
          Try to convert the image before letting the superclass handle it.
protected  ImageHandler.ImageConversionResult internalConvertImage(File input, String entryName)
          Perform the actual image conversion.
protected  boolean mayCacheFromSize()
          Images needs to be cacheable to be compressed.
protected  boolean mayRestrictCacheSize()
          Check if this handler may force the cached resource to be less than the cache max size.
protected  void readImage()
          Read in the image
protected  void removeCache()
          Remove the cachestream and the cache entry.
 void setDoConvert(boolean doConvert)
           
 void setup(SProperties prop)
          setup the handler factory.
protected  void tryconvert()
          Try to convert the image.
 
Methods inherited from class rabbit.handler.BaseHandler
blockSent, bufferRead, deleteFile, failed, finishData, finishedRead, getLogger, httpHeaderSent, mayTransfer, prepare, prepareStream, send, sendHeader, setPartialContent, timeout, writeCache
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

convertedFile

protected File convertedFile
Constructor Detail

ImageHandler

public ImageHandler()
For creating the factory.


ImageHandler

public ImageHandler(Connection con,
                    TrafficLoggerHandler tlh,
                    HttpHeader request,
                    BufferHandle clientHandle,
                    HttpHeader response,
                    ResourceSource content,
                    boolean mayCache,
                    boolean mayFilter,
                    long size,
                    SProperties config,
                    boolean doConvert,
                    int minSizeToConvert,
                    ImageConverter imageConverter)
Create a new ImageHandler for the given request.

Parameters:
con - the Connection handling the request.
request - the actual request made.
clientHandle - the client side buffer.
response - the actual response.
content - the resource.
mayCache - May we cache this request?
mayFilter - May we filter this request?
size - the size of the data beeing handled.
Method Detail

getNewInstance

public Handler getNewInstance(Connection con,
                              TrafficLoggerHandler tlh,
                              HttpHeader header,
                              BufferHandle bufHandle,
                              HttpHeader webHeader,
                              ResourceSource content,
                              boolean mayCache,
                              boolean mayFilter,
                              long size)
Description copied from interface: HandlerFactory
Get a new Handler for the given request made.

Specified by:
getNewInstance in interface HandlerFactory
Overrides:
getNewInstance in class BaseHandler
Parameters:
con - the Connection handling the request.
tlh - the Traffic logger handler.
header - the request.
bufHandle - the client side buffer handle (may contain the next request).
webHeader - the response.
content - the resource.
mayCache - if the handler may cache the response.
mayFilter - if the handler may filter the response.
size - the Size of the data beeing handled (-1 = unknown length).

changesContentSize

public boolean changesContentSize()
®return true this handler modifies the content.

Specified by:
changesContentSize in interface Handler
Overrides:
changesContentSize in class BaseHandler
Returns:
true if Content-Lenght may be changed by this handler typically used for handlers that may modify the content. Return false if this handler will not change the size.

mayCacheFromSize

protected boolean mayCacheFromSize()
Images needs to be cacheable to be compressed.

Overrides:
mayCacheFromSize in class BaseHandler
Returns:
true

mayRestrictCacheSize

protected boolean mayRestrictCacheSize()
Check if this handler may force the cached resource to be less than the cache max size.

Overrides:
mayRestrictCacheSize in class BaseHandler
Returns:
false

handle

public void handle()
Try to convert the image before letting the superclass handle it.

Specified by:
handle in interface Handler
Overrides:
handle in class BaseHandler

addCache

protected void addCache()
Description copied from class: BaseHandler
Set up the cache stream if available.

Overrides:
addCache in class BaseHandler

finish

protected void finish(boolean good)
clear up the mess we made (remove intermediate files etc).

Overrides:
finish in class BaseHandler
Parameters:
good - if true then the connection may be restarted, if false then the connection may not be restared

removeCache

protected void removeCache()
Remove the cachestream and the cache entry.

Overrides:
removeCache in class BaseHandler

tryconvert

protected void tryconvert()
                   throws IOException
Try to convert the image. This is done like this: super.addCache (); readImage(); convertImage(); cacheChannel = null; We have to use the cachefile to convert the image, and if we convert it we dont want to write the file to the cache later on.

Throws:
IOException

readImage

protected void readImage()
                  throws IOException
Read in the image

Throws:
IOException - if reading of the image fails.

convertImage

protected void convertImage()
Convert the image into a small low quality image (normally a jpeg).

Throws:
IOException - if conversion fails.

internalConvertImage

protected ImageHandler.ImageConversionResult internalConvertImage(File input,
                                                                  String entryName)
                                                           throws IOException
Perform the actual image conversion.

Parameters:
entryName - the filename of the cache entry to use.
Throws:
IOException

checkFileType

protected String checkFileType(File typeFile)
                        throws IOException
Throws:
IOException

setDoConvert

public void setDoConvert(boolean doConvert)

getDoConvert

public boolean getDoConvert()

getConfig

public SProperties getConfig()

getMinSizeToConvert

public int getMinSizeToConvert()

setup

public void setup(SProperties prop)
Description copied from interface: HandlerFactory
setup the handler factory.

Specified by:
setup in interface HandlerFactory
Overrides:
setup in class BaseHandler