UpdateFromEPKBAndFCIM.java

/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package ro.utcn.dsrl.contextManagementModule.utils; 
 
import it.eng.games.esmi.fcim.controller.FcimCpuJpaController; 
import it.eng.games.esmi.fcim.controller.FcimRamJpaController; 
import it.eng.games.esmi.fcim.controller.FcimTimestampJpaController; 
import it.eng.games.esmi.fcim.entity.FcimCpu; 
import it.eng.games.esmi.fcim.entity.FcimRam; 
import it.eng.games.esmi.fcim.entity.FcimTimestamp; 
import it.eng.games.esmi.fcim.entity.FcimVmOne; 
import it.polimi.games.epkb.controller.ComponentJpaController; 
import it.polimi.games.epkb.controller.CpuCoreJpaController; 
import it.polimi.games.epkb.controller.CpuJpaController; 
import it.polimi.games.epkb.controller.MemoryJpaController; 
import it.polimi.games.epkb.controller.NetworkInterfaceJpaController; 
import it.polimi.games.epkb.controller.ServerJpaController; 
import it.polimi.games.epkb.controller.ServiceJpaController; 
import it.polimi.games.epkb.controller.VirtualMachineConfJpaController; 
import it.polimi.games.epkb.controller.VirtualMachineInstJpaController; 
import it.polimi.games.epkb.controller.exceptions.IllegalOrphanException; 
import it.polimi.games.epkb.controller.exceptions.NonexistentEntityException; 
import it.polimi.games.epkb.controller.exceptions.PreexistingEntityException; 
import it.polimi.games.epkb.entityClasses.Component; 
import it.polimi.games.epkb.entityClasses.Cpu; 
import it.polimi.games.epkb.entityClasses.CpuCore; 
import it.polimi.games.epkb.entityClasses.Memory; 
import it.polimi.games.epkb.entityClasses.NetworkInterface; 
import it.polimi.games.epkb.entityClasses.ObservedComponent; 
import it.polimi.games.epkb.entityClasses.SensorType; 
import it.polimi.games.epkb.entityClasses.Server; 
import it.polimi.games.epkb.entityClasses.Service; 
import it.polimi.games.epkb.entityClasses.ServiceInstance; 
import it.polimi.games.epkb.entityClasses.VirtualMachineConf; 
import it.polimi.games.epkb.entityClasses.VirtualMachineInst; 
import it.polimi.games.epkb.entityClasses.VirtualMachineResources; 
 
import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.Collection; 
import java.util.GregorianCalendar; 
import java.util.List; 
import javax.persistence.EntityManagerFactory; 
import javax.persistence.Persistence; 
 
import org.apache.log4j.Level; 
import org.apache.log4j.Logger; 
import org.apache.log4j.PropertyConfigurator; 
import ro.utcn.dsrl.contextManagementModule.contextAccessAndProcessing.ContextAccessAndProcessingAPI; 
import ro.utcn.dsrl.contextManagementModule.contextAccessAndProcessing.impl.ContextAccessAndProcessing; 
import ro.utcn.dsrl.contextManagementModule.contextModel.api.EACMInstance; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.ApplicationActivity; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.CPU; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.MEM; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.ServiceCenterServer; 
import ro.utcn.dsrl.utils.exceptions.ApplicationException; 
 
/** 
 * @author Administrator 
 */ 
public class UpdateFromEPKBAndFCIM { 
 
    private static ServerJpaController serverJpaController; 
    private static MemoryJpaController memoryJpaController; 
    private static NetworkInterfaceJpaController networkInterfaceJpaController; 
    private static CpuJpaController cpuJpaController; 
    private static CpuCoreJpaController cpuCoreJpaController; 
    private static ServiceJpaController serviceJpaController; 
    private static ComponentJpaController componentJpaController; 
    private static VirtualMachineConfJpaController virtualMachineConfJpaController; 
    private static Logger logger; 
    private static FcimCpuJpaController fcimCpuController; 
    private static FcimRamJpaController fcimRamController; 
    private static VirtualMachineInstJpaController virtualMachineInstJpaController; 
 
    static { 
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("GAMES-EPKBPU"); 
        serverJpaController = new ServerJpaController(entityManagerFactory); 
        memoryJpaController = new MemoryJpaController(entityManagerFactory); 
        networkInterfaceJpaController = new NetworkInterfaceJpaController(entityManagerFactory); 
        cpuJpaController = new CpuJpaController(entityManagerFactory); 
        cpuCoreJpaController = new CpuCoreJpaController(entityManagerFactory); 
        serviceJpaController = new ServiceJpaController(entityManagerFactory); 
        componentJpaController = new ComponentJpaController(entityManagerFactory); 
        virtualMachineConfJpaController = new VirtualMachineConfJpaController(entityManagerFactory); 
        virtualMachineInstJpaController = new VirtualMachineInstJpaController(entityManagerFactory); 
 
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("GAMES-ESMI-FCIMPU"); 
        fcimCpuController = new FcimCpuJpaController(emf); 
        fcimRamController = new FcimRamJpaController(emf); 
 
    } 
 
    public void updateServersData(EACMInstance eacmInstance) { 
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("GAMES-ESMI-FCIMPU"); 
 
        List<Server> servers = serverJpaController.findServerEntities(); 
        CPU ontologyCpu; 
        MEM ontologyMem; 
 
        FcimTimestampJpaController timestamps = new FcimTimestampJpaController(emf); 
        FcimTimestamp lastTimestamp  = timestamps.findFcimTimestampEntities().iterator().next(); 
 
        for (FcimTimestamp timestamp : timestamps.findFcimTimestampEntities()) { 
 
            if (timestamp.getTimestamp().after(lastTimestamp.getTimestamp())) { 
                lastTimestamp = timestamp; 
            } 
 
        } 
 
        for (Server server : servers) { 
            Collection<NetworkInterface> networkInterfaces = server.getNetworkInterfaceCollection(); 
            String ip = networkInterfaces.iterator().next().getIPServer(); 
            ServiceCenterServer serverFromOntology = eacmInstance.getServiceCenterServer(ip); 
 
            Collection<Cpu> cpus = server.getCpuCollection(); 
            for (Cpu cpu : cpus) { 
                Component cpuComponent = cpu.getComponent(); 
 
                ObservedComponent observedComponent = cpuComponent.getObservedComponentCollection().iterator().next(); 
                String sensorID = observedComponent.getSensorID(); 
 
                for (FcimCpu fcimCpu : lastTimestamp.getFcimCpuCollection()) { 
                    if (fcimCpu.getServiceId().equalsIgnoreCase(sensorID)) { 
                        float usagePerc = fcimCpu.getUsagePerc(); 
                        ontologyCpu = serverFromOntology.getCpuResources().iterator().next(); 
                        ontologyCpu.setCurrentWorkLoad(usagePerc * ontologyCpu.getMaximumWorkLoad() / 100); 
                        break; 
                    } 
                } 
 
 
            } 
 
            Collection<Memory> mems = server.getMemoryCollection(); 
 
            for (Memory memory : mems) { 
                Component memoryComponent = memory.getComponent(); 
                ObservedComponent observedComponent = memoryComponent.getObservedComponentCollection().iterator().next(); 
                String sensorID = observedComponent.getSensorID(); 
 
                for (FcimRam fcimRam : lastTimestamp.getFcimRamCollection()) { 
                    if (fcimRam.getServiceId().equalsIgnoreCase(sensorID)) { 
                        ontologyMem = serverFromOntology.getMemResources().iterator().next(); 
                        ontologyMem.setCurrentWorkLoad((double) fcimRam.getUsed()); 
                    } 
                    break; 
                } 
            } 
 
        } 
    } 
 
    public void deployVirtualMachine(ApplicationActivity applicationActivity, ServiceCenterServer serviceCenterServer, ContextAccessAndProcessingAPI contextAccessAndProcessingAPI) { 
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("GAMES-ESMI-FCIMPU"); 
        EACMInstance eacmInstance = contextAccessAndProcessingAPI.getCurrentContextInstance(); 
 
        Server server = serverJpaController.findServer(serviceCenterServer.getEPKBId()); 
        //%TODO check 
 
        VirtualMachineInst virtualMachine = new VirtualMachineInst(applicationActivity.getEPKBId()); 
        virtualMachine.setIdCloudSupplier("" + applicationActivity.getId()); 
        virtualMachine.setIdHost(server.getIdCloudSupplier()); 
        Component virtualMachineComp = new Component(); 
        virtualMachineComp.setVirtualMachineInst(virtualMachine); 
        virtualMachine.setComponent(virtualMachineComp); 
 
 
        try { 
            virtualMachineInstJpaController.create(virtualMachine); 
        } catch (IllegalOrphanException ex) { 
            java.util.logging.Logger.getLogger(UpdateFromEPKBAndFCIM.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 
        } catch (PreexistingEntityException ex) { 
            java.util.logging.Logger.getLogger(UpdateFromEPKBAndFCIM.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 
        } catch (Exception ex) { 
            java.util.logging.Logger.getLogger(UpdateFromEPKBAndFCIM.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 
        } 
 
        //TODO Add synch EPKB FCIM 
 
 
    } 
 
    public void unDeployVirtualMachine(ApplicationActivity applicationActivity, ServiceCenterServer serviceCenterServer, ContextAccessAndProcessingAPI contextAccessAndProcessingAPI) { 
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("GAMES-ESMI-FCIMPU"); 
        EACMInstance eacmInstance = contextAccessAndProcessingAPI.getCurrentContextInstance(); 
 
        Server server = serverJpaController.findServer(serviceCenterServer.getEPKBId()); 
 
        try { 
 
            virtualMachineInstJpaController.destroy(applicationActivity.getEPKBId()); 
        } catch (IllegalOrphanException ex) { 
            java.util.logging.Logger.getLogger(UpdateFromEPKBAndFCIM.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 
        } catch (NonexistentEntityException ex) { 
            java.util.logging.Logger.getLogger(UpdateFromEPKBAndFCIM.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 
        } 
    } 
 
    public void updateServicesData(ContextAccessAndProcessingAPI contextAccessAndProcessingAPI) { 
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("GAMES-ESMI-FCIMPU"); 
        EACMInstance eacmInstance = contextAccessAndProcessingAPI.getCurrentContextInstance(); 
 
        List<Service> services = serviceJpaController.findServiceEntities(); 
        FcimTimestampJpaController timestamps = new FcimTimestampJpaController(emf); 
        FcimTimestamp lastTimestamp = new FcimTimestamp(); 
        for (FcimTimestamp timestamp : timestamps.findFcimTimestampEntities()) { 
            if (timestamp.getTimestamp().after(lastTimestamp.getTimestamp())) { 
                lastTimestamp = timestamp; 
            } 
        } 
 
        VirtualMachineInst vmInstance; 
        Collection<ApplicationActivity> activities = eacmInstance.getAllApplicationActivityInstances(); 
        for (Service service : services) { 
            Collection<ServiceInstance> instances = service.getServiceInstanceCollection(); 
 
            for (ServiceInstance serviceInstance : instances) { 
                vmInstance = serviceInstance.getIdVMInstance(); 
                String sensorID = vmInstance.getComponent().getObservedComponentCollection().iterator().next().getSensorID(); 
                //TODO: something to get the application activity on name, not to iterate over the entire set 
                ApplicationActivity activity = null; 
                for (ApplicationActivity applicationActivity : activities) { 
                    if (applicationActivity.getEPKBId().equalsIgnoreCase(serviceInstance.getId())) { 
                        activity = applicationActivity; 
                        break; 
                    } 
                } 
                for (FcimVmOne fcimVmOne : lastTimestamp.getFcimVmOneCollection()) { 
                    if (fcimVmOne.getServiceId().equalsIgnoreCase(sensorID)) { 
                        float usagePerc = fcimVmOne.getCpuUsagePerc(); 
                        float memoryUsed = fcimVmOne.getMemory(); 
                        float cpuTime = fcimVmOne.getCpuTime(); 
                        float vmId = fcimVmOne.getVmId(); 
                        //activity.setCpuAllocatedValue(usagePerc*activity.); 
 
                        activity.setMemAllocatedValue(memoryUsed); 
                    } 
                } 
 
            } 
        } 
    } 
 
}