EPKBSynchronization.java

package main; 
 
import java.util.ArrayList; 
import java.util.Collection; 
import java.util.List; 
 
import javax.persistence.Persistence; 
 
import ro.utcn.dsrl.contextManagementModule.contextModel.api.EACMInstance; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.CPU; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.ITComputingContextPolicy; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.MEM; 
import ro.utcn.dsrl.contextManagementModule.contextModel.concepts.ServiceCenterServer; 
import ro.utcn.dsrl.serviceCenterManagement.ServicesPoolManagement; 
import ro.utcn.dsrl.serviceCenterManagement.impl.DefaultServicesPoolManagement; 
import ro.utcn.dsrl.utils.commonDtos.ExtendedTaskDto; 
import ro.utcn.dsrl.utils.commonDtos.TaskDiskDto; 
 
import it.polimi.games.epkb.controller.ServerJpaController; 
import it.polimi.games.epkb.controller.ServiceJpaController; 
import it.polimi.games.epkb.entityClasses.Cpu; 
import it.polimi.games.epkb.entityClasses.Memory; 
import it.polimi.games.epkb.entityClasses.NetworkInterface; 
import it.polimi.games.epkb.entityClasses.Server; 
import it.polimi.games.epkb.entityClasses.Service; 
 
public class EPKBSynchronization { 
 
    private static ServerJpaController serverJpaController; 
    private static ServiceJpaController serviceJpaController; 
    private static ServicesPoolManagement servicesPoolManagement; 
 
    static { 
        serverJpaController = new ServerJpaController( 
                Persistence.createEntityManagerFactory("GAMES-EPKBPU")); 
        serviceJpaController = new ServiceJpaController( 
                Persistence.createEntityManagerFactory("GAMES-EPKBPU")); 
 
        servicesPoolManagement = DefaultServicesPoolManagement.getInstance(); 
    } 
 
    public static void synchronizeWithEPKB(EACMInstance instance){ 
        loadServicesFromEPKB(instance); 
        loadServersFromEPKB(instance); 
    } 
     
    public static void loadServicesFromEPKB(EACMInstance instance) { 
         
        List<Service> epkbServices = serviceJpaController.findServiceEntities(); 
 
        for (Service service : epkbServices) { 
 
            ExtendedTaskDto dto = new ExtendedTaskDto(); 
            dto.setEpkbID(service.getId()); 
 
            dto.setRequestedCPUMax(service.getMaxCPU().intValue()); 
            dto.setRequestedCPUMin(service.getMinCPU().intValue()); 
            dto.setRequestedCores(1); // TODO: Service NU ARE CORES REQUESTED in 
                                      // EPKB. 
 
            dto.setLife(-1); // ca sa nu o puna in schedule to be killed. Le 
                             // pune numa pe alea cu life > 0 
 
            dto.setRequestedMemoryMax(service.getMaxMEM().intValue()); 
            dto.setRequestedMemoryMin(service.getMinMEM().intValue()); 
 
            dto.setTaskName(service.getName()); 
 
            dto.setId(service.getId()); 
 
            TaskDiskDto taskDiskDto = new TaskDiskDto(); 
 
            taskDiskDto.setType("disk"); 
            taskDiskDto.setFormat("ext3"); 
            taskDiskDto.setSize(1024); 
            taskDiskDto 
                    .setPath("/home/oneadmin/Desktop/cuContextualizare/disk.0");// TODO: 
                                                                                // de 
                                                                                // dehardcodat 
                                                                                // asta 
 
            ArrayList<TaskDiskDto> taskDiskDtos = new ArrayList<TaskDiskDto>(); 
            taskDiskDtos.add(taskDiskDto); 
 
            dto.setDiskDtoCollection(taskDiskDtos); 
//          servicesPoolManagement.addService(dto); 
        } 
 
    } 
 
    public static void loadServersFromEPKB(EACMInstance instance) { 
 
        //reading servers definitions from EPKB 
        List<Server> epkbServers = serverJpaController.findServerEntities(); 
 
        for (Server server : epkbServers) { 
 
            //iterating through individual server definitions from EPKB 
            it.polimi.games.epkb.entityClasses.NetworkInterface networkInterface = server 
                    .getNetworkInterfaceCollection().iterator().next(); 
            it.polimi.games.epkb.entityClasses.Cpu cpu = server.getCpuCollection().iterator().next(); 
            it.polimi.games.epkb.entityClasses.Memory memory = server.getMemoryCollection().iterator().next(); 
 
            //creating corresponding servers in GAMES-CAP 
            ro.utcn.dsrl.contextManagementModule.contextModel.concepts.ServiceCenterServer serviceCenterServer = instance 
                    .createServiceCenterServer(networkInterface.getIPServer()); 
            ro.utcn.dsrl.contextManagementModule.contextModel.concepts.CPU serviceCenterServerCPU = instance.createCPU("CPU_for_" 
                    + serviceCenterServer.getName().split("#")[1]); 
            ro.utcn.dsrl.contextManagementModule.contextModel.concepts.MEM serviceCenterServerMEM = instance.createMEM("MEM_for_" 
                    + serviceCenterServer.getName().split("#")[1]); 
 
            serviceCenterServer.setEPKBId(server.getId()); 
 
            int coresNo = cpu.getCoresNumber(); 
 
            serviceCenterServerCPU.setEPKBId(cpu.getId()); 
 
            Double maxCPUWorkload =  coresNo * cpu.getTotalFrequency().doubleValue(); 
 
            serviceCenterServerCPU.setMaximumWorkLoad(maxCPUWorkload); 
            serviceCenterServerCPU.setOptimalWorkLoad(maxCPUWorkload / 2); 
            serviceCenterServerCPU.setCpuCoreCount(coresNo); 
 
            serviceCenterServer.setIpAddress(networkInterface.getIPServer()); 
            serviceCenterServer.setMacAddress(networkInterface.getMACServer()); 
 
            serviceCenterServer.setId(Integer.parseInt(server.getIdCloudSupplier())); 
 
            Double totalMemory =  Double.parseDouble(memory.getDimension()); 
 
            serviceCenterServerMEM.setMaximumWorkLoad(totalMemory); 
            serviceCenterServerMEM.setOptimalWorkLoad(totalMemory / 2); 
 
            Collection<CPU> cpus = new ArrayList<CPU>(); 
            Collection<MEM> mems = new ArrayList<MEM>(); 
 
            cpus.add(serviceCenterServerCPU); 
            mems.add(serviceCenterServerMEM); 
 
            serviceCenterServer.setCpuResources(cpus); 
            serviceCenterServer.setMemResources(mems); 
 
            ITComputingContextPolicy policy = instance 
                    .createITComputingContextPolicy(serviceCenterServer 
                            .getName().split("#")[1] + "_EnergyPolicy"); 
            policy.addPolicySubject(serviceCenterServer); 
            policy.addPolicyTarget(serviceCenterServer); 
            policy.setPolicyName(policy.getName()); 
            policy.setEvaluationCondition("Evaluation_condition"); 
 
            serviceCenterServer.setIsActive(false); 
 
        } 
 
    } 
}