extensions/cache-memcache/src/main/java/org/apache/zest/cache/memcache/MemcachePoolMixin.java

/*
 * Copyright 2014 Paul Merlin.
 *
 * 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.apache.zest.cache.memcache;

import java.util.HashMap;
import java.util.Map;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.ConnectionFactoryBuilder.Protocol;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.auth.AuthDescriptor;
import net.spy.memcached.auth.PlainCallbackHandler;
import org.apache.zest.api.common.Optional;
import org.apache.zest.api.configuration.Configuration;
import org.apache.zest.api.injection.scope.This;
import org.apache.zest.spi.cache.Cache;

import static org.apache.zest.api.util.NullArgumentException.validateNotEmpty;

/**
 * Memcache CachePool Mixin.
 */
public class MemcachePoolMixin
    implements MemcachePoolService
{
    private final Map<String, MemcacheImpl<?>> caches = new HashMap<>();
    @This @Optional
    private Configuration<MemcacheConfiguration> configuration;
    private MemcachedClient client;
    private int expiration;

    @Override
    public void activateService()
        throws Exception
    {
        if( configuration != null )
        {
            MemcacheConfiguration config = configuration.get();
            expiration = ( config.expiration().get() == null )
                         ? 3600
                         : config.expiration().get();
            String addresses = ( config.addresses().get() == null )
                               ? "localhost:11211"
                               : config.addresses().get();
            Protocol protocol = ( config.protocol().get() == null )
                                ? Protocol.TEXT
                                : Protocol.valueOf( config.protocol().get().toUpperCase() );
            String username = config.username().get();
            String password = config.password().get();
            String authMech = config.authMechanism().get() == null
                              ? "PLAIN"
                              : config.authMechanism().get();

            ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
            builder.setProtocol( protocol );
            if( username != null && !username.isEmpty() )
            {
                builder.setAuthDescriptor(
                    new AuthDescriptor(
                        new String[]
                        {
                            authMech
                        },
                        new PlainCallbackHandler( username, password )
                    )
                );
            }

            client = new MemcachedClient( builder.build(), AddrUtil.getAddresses( addresses ) );
        }
    }

    @Override
    public void passivateService()
        throws Exception
    {
        if( client != null )
        {
            client.shutdown();
        }
    }

    @Override
    @SuppressWarnings( "unchecked" )
    public <T> Cache<T> fetchCache( String cacheId, Class<T> valueType )
    {
        validateNotEmpty( "cacheId", cacheId );
        synchronized( caches )
        {
            MemcacheImpl<?> cache = caches.get( cacheId );
            if( cache == null )
            {
                cache = new MemcacheImpl<>( client, cacheId, valueType, expiration );
                caches.put( cacheId, cache );
            }
            cache.incRefCount();
            return (Cache<T>) cache;
        }
    }

    @Override
    public void returnCache( Cache<?> cache )
    {
        MemcacheImpl<?> memcache = (MemcacheImpl<?>) cache;
        memcache.decRefCount();
        synchronized( caches )
        {
            if( memcache.isNotUsed() )
            {
                caches.remove( memcache.cacheId() );
            }
        }
    }
}