/**
* 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.google.common.base.Preconditions.checkNotNull;
import static java.lang.String.valueOf;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import com.abiquo.hypervisor.model.VirtualMachineDefinition;
import com.abiquo.hypervisor.model.VirtualMachineIdentifier;
import com.abiquo.redis.AbstractRedisRep;
import com.abiquo.redis.client.TransactionBlock2;
import com.abiquo.redis.client.TransactionBlockList;
import com.google.common.base.Function;
import com.google.common.base.Optional;
public class MonitorManagerRep extends AbstractRedisRep
{
protected HypervisorDAO hypervisorDao;
protected SubscriptionDAO subscriptionDao;
protected VirtualMachineDefinitionDAO virtualMachineDefinitionDao;
public MonitorManagerRep(final JedisPool redisPool)
{
super(redisPool);
hypervisorDao = new HypervisorDAO();
subscriptionDao = new SubscriptionDAO();
virtualMachineDefinitionDao = new VirtualMachineDefinitionDAO();
}
public Hypervisor save(final Hypervisor hypervisor)
{
executeTransactionBlock(new Function<Jedis, Optional<TransactionBlock2>>()
{
@Override
public Optional<TransactionBlock2> apply(final Jedis redis)
{
return saveHypervisor(hypervisor, redis);
}
});
return hypervisor;
}
public void save(final Set<Hypervisor> hypervisors)
{
executeTransactionBlockList(new Function<Jedis, Optional<TransactionBlockList>>()
{
@Override
public Optional<TransactionBlockList> apply(final Jedis redis)
{
final TransactionBlockList blocks = new TransactionBlockList();
for (Hypervisor hypervisor : hypervisors)
{
blocks.add(saveHypervisor(hypervisor, redis).orNull());
}
return Optional.of(blocks);
}
});
}
private Optional<TransactionBlock2> saveHypervisor(final Hypervisor hypervisor,
final Jedis redis)
{
return hypervisorDao.insert(hypervisor, redis);
}
public void delete(final Hypervisor hypervisor)
{
executeTransactionBlockList(new Function<Jedis, Optional<TransactionBlockList>>()
{
@Override
public Optional<TransactionBlockList> apply(final Jedis redis)
{
return Optional.of(deleteHypervisor(hypervisor, redis));
}
});
}
public void delete(final Set<Hypervisor> hypervisors)
{
executeTransactionBlockList(new Function<Jedis, Optional<TransactionBlockList>>()
{
@Override
public Optional<TransactionBlockList> apply(final Jedis redis)
{
final TransactionBlockList blocks = new TransactionBlockList();
for (Hypervisor hypervisor : hypervisors)
{
blocks.addAll(deleteHypervisor(hypervisor, redis));
}
return Optional.of(blocks);
}
});
}
private TransactionBlockList deleteHypervisor(final Hypervisor hypervisor, final Jedis redis)
{
final TransactionBlockList blocks = new TransactionBlockList();
// Delete associated subscriptions
Set<Subscription> subscriptions = subscriptionDao.findByHypervisor(hypervisor, redis);
for (Subscription subscription : subscriptions)
{
blocks.addAll(deleteSubscription(subscription, redis));
}
// Delete the hypervisor
blocks.add(hypervisorDao.delete(hypervisor, redis).get());
return blocks;
}
private TransactionBlockList deleteSubscription(final Subscription subscription,
final Jedis redis)
{
final TransactionBlockList blocks = new TransactionBlockList();
blocks.add(subscriptionDao.delete(subscription, redis).get());
final VirtualMachineIdentifier vmId = new VirtualMachineIdentifier(subscription.getName());
final VirtualMachineDefinition definition = findVirtualMachineDefinition(vmId);
if (definition != null)
{
blocks.add(virtualMachineDefinitionDao.delete(definition, redis).get());
}
return blocks;
}
public Hypervisor findHypervisor(final Long id)
{
return execute(new Function<Jedis, Optional<Hypervisor>>()
{
@Override
public Optional<Hypervisor> apply(final Jedis redis)
{
return hypervisorDao.find(valueOf(id), redis);
}
});
}
public Hypervisor findHypervisor(final String endPoint, final String ip, final Integer port,
final String user, final String password, final String managerIp,
final Integer managerPort, final String managerUser, final String managerPassword,
final String agentIp, final Integer agentPort, final String agentUser,
final String agentPassword)
{
return execute(new Function<Jedis, Optional<Hypervisor>>()
{
@Override
public Optional<Hypervisor> apply(final Jedis redis)
{
return hypervisorDao.find(endPoint, ip, port, user, password, managerIp,
managerPort, managerUser, managerPassword, agentIp, agentPort, agentUser,
agentPassword, redis);
}
});
}
public Hypervisor findHypervisor(final String uid)
{
return execute(new Function<Jedis, Optional<Hypervisor>>()
{
@Override
public Optional<Hypervisor> apply(final Jedis redis)
{
return hypervisorDao.findByUID(uid, redis);
}
});
}
public Set<Hypervisor> findAllHypervisors()
{
return execute(new Function<Jedis, Optional<Set<Hypervisor>>>()
{
@Override
public Optional<Set<Hypervisor>> apply(final Jedis redis)
{
return Optional.of(hypervisorDao.findAll(redis));
}
});
}
public Subscription save(final Subscription subscription)
{
checkNotNull(subscription.getName());
executeTransactionBlock(new Function<Jedis, Optional<TransactionBlock2>>()
{
@Override
public Optional<TransactionBlock2> apply(final Jedis redis)
{
return subscriptionDao.insert(subscription, redis);
}
});
return subscription;
}
public void delete(final Subscription subscription)
{
executeTransactionBlockList(new Function<Jedis, Optional<TransactionBlockList>>()
{
@Override
public Optional<TransactionBlockList> apply(final Jedis redis)
{
return Optional.fromNullable(deleteSubscription(subscription, redis));
}
});
}
public Subscription findSubscription(final Long id)
{
return execute(new Function<Jedis, Optional<Subscription>>()
{
@Override
public Optional<Subscription> apply(final Jedis redis)
{
return subscriptionDao.find(valueOf(id), redis);
}
});
}
public Subscription findSubscriptionByName(final String name)
{
return execute(new Function<Jedis, Optional<Subscription>>()
{
@Override
public Optional<Subscription> apply(final Jedis redis)
{
return subscriptionDao.findByName(name, redis);
}
});
}
public Set<Subscription> findSubscriptions(final Hypervisor hypervisor)
{
return execute(new Function<Jedis, Optional<Set<Subscription>>>()
{
@Override
public Optional<Set<Subscription>> apply(final Jedis redis)
{
return Optional.of(subscriptionDao.findByHypervisor(hypervisor, redis));
}
});
}
public Set<Subscription> findAllSubscriptions()
{
return execute(new Function<Jedis, Optional<Set<Subscription>>>()
{
@Override
public Optional<Set<Subscription>> apply(final Jedis redis)
{
return Optional.of(subscriptionDao.findAll(redis));
}
});
}
public void save(final VirtualMachineDefinition definition)
{
executeTransactionBlock(new Function<Jedis, Optional<TransactionBlock2>>()
{
@Override
public Optional<TransactionBlock2> apply(final Jedis redis)
{
return virtualMachineDefinitionDao.insert(definition, redis);
}
});
}
public void delete(final VirtualMachineDefinition definition)
{
executeTransactionBlock(new Function<Jedis, Optional<TransactionBlock2>>()
{
@Override
public Optional<TransactionBlock2> apply(final Jedis redis)
{
return virtualMachineDefinitionDao.delete(definition, redis);
}
});
}
public VirtualMachineDefinition findVirtualMachineDefinition(
final VirtualMachineIdentifier identifier)
{
return execute(new Function<Jedis, Optional<VirtualMachineDefinition>>()
{
@Override
public Optional<VirtualMachineDefinition> apply(final Jedis redis)
{
return virtualMachineDefinitionDao.find(identifier, redis);
}
});
}
}