/**
* Copyright (C) 2008 - Abiquo Holdings S.L. All rights reserved.
*
* Please see /opt/abiquo/tomcat/webapps/legal/ on Abiquo server
* or contact contact@abiquo.com for licensing information.
*/
package com.abiquo.hypervisor.model.redis;
import static com.abiquo.redis.util.RedisUtils.nest;
import static com.google.common.base.Optional.absent;
import static com.google.common.base.Strings.isNullOrEmpty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.exceptions.JedisException;
import com.abiquo.hypervisor.model.VirtualMachineDefinition;
import com.abiquo.hypervisor.model.VirtualMachineIdentifier;
import com.abiquo.redis.AbstractRedisDAO;
import com.abiquo.redis.client.TransactionBlock2;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.introspect.AnnotationIntrospectorPair;
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.module.jaxb.JaxbAnnotationIntrospector;
import com.google.common.base.Optional;
public class VirtualMachineDefinitionDAO extends AbstractRedisDAO<VirtualMachineDefinition>
{
private final static Logger LOG = LoggerFactory.getLogger(VirtualMachineDefinitionDAO.class);
@Override
public Optional<TransactionBlock2> insert(final VirtualMachineDefinition definition,
final Jedis redis)
{
if (isNullOrEmpty(definition.getName()))
{
throw new RuntimeException("VirtualMachineIdentifier name is a required field");
}
TransactionBlock2 transactionBlock = new TransactionBlock2()
{
@Override
public void execute() throws JedisException
{
set(generateKey(definition), serialize(definition));
}
};
return Optional.of(transactionBlock);
}
@Override
public Optional<TransactionBlock2> delete(final VirtualMachineDefinition definition,
final Jedis redis)
{
if (!find(definition, redis).isPresent())
{
return absent();
}
TransactionBlock2 transactionBlock = new TransactionBlock2()
{
@Override
public void execute() throws JedisException
{
del(generateKey(definition));
}
};
return Optional.of(transactionBlock);
}
@Override
public Optional<VirtualMachineDefinition> find(final String name, final Jedis redis)
{
return find(new VirtualMachineIdentifier(name), redis);
}
public Optional<VirtualMachineDefinition> find(final VirtualMachineIdentifier identifier,
final Jedis redis)
{
return deserialize(redis.get(generateKey(identifier)));
}
private String generateKey(final VirtualMachineIdentifier identifier)
{
return nest("vm", identifier.getName(), "definition");
}
private String serialize(final VirtualMachineDefinition definition)
{
try
{
return new String(newObjectMapper().writeValueAsBytes(definition));
}
catch (JsonProcessingException e)
{
LOG.error("Unable to serialize the given VirtualMachineDefinition", e);
throw new RuntimeException("Unable to serialize the given VirtualMachineDefinition", e);
}
}
private Optional<VirtualMachineDefinition> deserialize(final String bytes)
{
VirtualMachineDefinition definition = null;
try
{
if (!isNullOrEmpty(bytes))
{
definition = newObjectMapper().readValue(bytes, VirtualMachineDefinition.class);
}
}
catch (Exception e)
{
LOG.error("Unable to deserialize the VirtualMachineDefinition: " + bytes, e);
throw new RuntimeException("Unable to deserialize the given VirtualMachineDefinition",
e);
}
return Optional.fromNullable(definition);
}
private ObjectMapper newObjectMapper()
{
return new ObjectMapper()
.setAnnotationIntrospector(new AnnotationIntrospectorPair(new JacksonAnnotationIntrospector(),
new JaxbAnnotationIntrospector(TypeFactory.defaultInstance())));
}
}