first spike of CookieJar

Author: simotripo

src/main/java/com/ning/http/client/cookiejar/AbstractCookieJar.java

@@ -0,0 +1,59 @@
+package com.ning.http.client.cookiejar;
+
+import java.util.Collection;
+
+import com.ning.http.client.Cookie;
+import com.ning.http.client.filter.RequestFilter;
+import com.ning.http.client.filter.ResponseFilter;
+
+public abstract class AbstractCookieJar
+{
+
+    private final RequestFilter requestFilter = new CookieJarRequestFilter( this );
+
+    private final ResponseFilter responseFilter = new CookieJarResponseFilter( this );
+
+    public final RequestFilter getRequestFilter()
+    {
+        return requestFilter;
+    }
+
+    public final ResponseFilter getResponseFilter()
+    {
+        return responseFilter;
+    }
+
+    protected final void store( String host, Cookie cookie )
+        throws Exception
+    {
+        persist( host, cookie );
+
+        String domain = cookie.getDomain();
+        if ( !host.equals( domain ) )
+        {
+            persist( domain, cookie );
+        }
+    }
+
+    protected abstract void persist( String host, Cookie cookie )
+        throws Exception;
+
+    protected abstract Collection<Cookie> retrieve( String host )
+        throws Exception;
+
+    protected final void delete( String host, Cookie cookie )
+        throws Exception
+    {
+        remove( host, cookie );
+
+        String domain = cookie.getDomain();
+        if ( !host.equals( domain ) )
+        {
+            remove( domain, cookie );
+        }
+    }
+
+    protected abstract void remove( String host, Cookie cookie )
+        throws Exception;
+
+}

src/main/java/com/ning/http/client/cookiejar/AbstractCookieJarFilter.java

@@ -0,0 +1,15 @@
+package com.ning.http.client.cookiejar;
+
+abstract class AbstractCookieJarFilter
+{
+
+    protected static final String HOST = "Host";
+
+    protected final AbstractCookieJar cookieJar;
+
+    public AbstractCookieJarFilter(AbstractCookieJar cookieJar)
+    {
+        this.cookieJar = cookieJar;
+    }
+
+}

src/main/java/com/ning/http/client/cookiejar/CookieJarRequestFilter.java

@@ -0,0 +1,58 @@
+package com.ning.http.client.cookiejar;
+
+import static java.lang.String.format;
+
+import java.util.Collection;
+
+import com.ning.http.client.Cookie;
+import com.ning.http.client.RequestBuilder;
+import com.ning.http.client.filter.FilterContext;
+import com.ning.http.client.filter.FilterException;
+import com.ning.http.client.filter.RequestFilter;
+
+final class CookieJarRequestFilter
+    extends AbstractCookieJarFilter
+    implements RequestFilter
+{
+
+    public CookieJarRequestFilter(AbstractCookieJar cookieJar)
+    {
+        super( cookieJar );
+    }
+
+    @SuppressWarnings( "rawtypes" )
+    public final FilterContext filter( FilterContext ctx )
+        throws FilterException
+    {
+        String domain = "";
+
+        Collection<Cookie> cookies = null;
+        try
+        {
+            cookies = cookieJar.retrieve( domain );
+        }
+        catch ( Exception e )
+        {
+            throw new FilterException( format( "Impossible to retrieve cookies from domain %s: %s",
+                                               domain, e.getMessage() ),
+                                       e );
+        }
+
+        if ( cookies == null || cookies.isEmpty() )
+        {
+            return ctx;
+        }
+
+        final RequestBuilder requestBuilder = new RequestBuilder( ctx.getRequest() );
+
+        for ( Cookie cookie : cookies )
+        {
+            requestBuilder.addCookie( cookie );
+        }
+
+        return new FilterContext.FilterContextBuilder( ctx )
+                                .request( requestBuilder.build() )
+                                .build();
+    }
+
+}

src/main/java/com/ning/http/client/cookiejar/CookieJarResponseFilter.java

@@ -0,0 +1,54 @@
+package com.ning.http.client.cookiejar;
+
+import static java.lang.String.format;
+import static com.ning.http.util.AsyncHttpProviderUtils.parseCookie;
+
+import java.util.List;
+
+import com.ning.http.client.Cookie;
+import com.ning.http.client.filter.FilterContext;
+import com.ning.http.client.filter.FilterException;
+import com.ning.http.client.filter.ResponseFilter;
+
+final class CookieJarResponseFilter
+    extends AbstractCookieJarFilter
+    implements ResponseFilter
+{
+
+    private static final String SET_COOKIE = "Set-Cookie";
+
+    public CookieJarResponseFilter(AbstractCookieJar cookieJar)
+    {
+        super( cookieJar );
+    }
+
+    @SuppressWarnings( "rawtypes" )
+    public FilterContext filter( FilterContext ctx )
+        throws FilterException
+    {
+        final List<String> cookiesString = ctx.getResponseHeaders().getHeaders().get( SET_COOKIE );
+
+        if ( cookiesString != null && !cookiesString.isEmpty() )
+        {
+            String host = ctx.getRequest().getHeaders().getFirstValue( HOST );
+
+            for ( String cookieValue : cookiesString )
+            {
+                Cookie currentCookie = parseCookie( cookieValue );
+
+                try
+                {
+                    cookieJar.store( host, currentCookie );
+                }
+                catch ( Exception e )
+                {
+                    throw new FilterException( format( "Impossible to store cookie %s: %s", cookieValue, e.getMessage() ),
+                                               e );
+                }
+            }
+        }
+
+        return ctx;
+    }
+
+}

src/main/java/com/ning/http/client/cookiejar/InMemoryCookieJar.java

@@ -0,0 +1,85 @@
+package com.ning.http.client.cookiejar;
+
+import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import com.ning.http.client.Cookie;
+
+public final class InMemoryCookieJar
+    extends AbstractCookieJar
+{
+
+    private final ConcurrentMap<String, ConcurrentMap<String, Cookie>> cookiesRegistry =
+                    new ConcurrentHashMap<String, ConcurrentMap<String, Cookie>>();
+
+    private final Lock lock = new ReentrantLock();
+
+    @Override
+    protected void persist( String host, Cookie cookie )
+        throws Exception
+    {
+        lock.lock();
+
+        try
+        {
+            ConcurrentMap<String, Cookie> domainCookies = cookiesRegistry.get( host );
+            if ( domainCookies == null )
+            {
+                // create the index and store it
+                domainCookies = new ConcurrentHashMap<String, Cookie>();
+                cookiesRegistry.put( host, domainCookies );
+            }
+
+            domainCookies.put( cookie.getName(), cookie );
+        }
+        finally
+        {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    protected Collection<Cookie> retrieve( String host )
+        throws Exception
+    {
+        lock.lock();
+
+        try
+        {
+            ConcurrentMap<String, Cookie> hostCookies = cookiesRegistry.get( host );
+            if ( hostCookies != null )
+            {
+                return hostCookies.values();
+            }
+            return null;
+        }
+        finally
+        {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    protected void remove( String host, Cookie cookie )
+        throws Exception
+    {
+        lock.lock();
+
+        try
+        {
+            ConcurrentMap<String, Cookie> hostCookies = cookiesRegistry.get( host );
+            if ( hostCookies != null )
+            {
+                hostCookies.remove( cookie.getName() );
+            }
+        }
+        finally
+        {
+            lock.unlock();
+        }
+    }
+
+}