/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package br.uff.ic.oceano.view;
import br.uff.ic.oceano.peixeespada.contexto.ContextoAmbiente;
import br.uff.ic.oceano.core.exception.ServiceException;
import br.uff.ic.oceano.core.factory.ObjectFactory;
import br.uff.ic.oceano.core.model.ConfigurationItem;
import br.uff.ic.oceano.core.model.Revision;
import br.uff.ic.oceano.util.file.PathUtil;
import br.uff.ic.oceano.peixeespada.model.Agent;
import br.uff.ic.oceano.peixeespada.model.Knowledge;
import br.uff.ic.oceano.peixeespada.model.Refactoring;
import br.uff.ic.oceano.peixeespada.service.AgentService;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
*
* @author Heliomar
*/
public class DecoratedOrchestratorAgent {
private String name;
private Revision revision;
private List<Revision> dericRevisions;
private List<Agent> workAgents;
private Agent orchestrator;
private Long serialBranch = 0l;
private Long serialWorkerAgent = 0l;
private AgentService agentService = ObjectFactory.getObjectWithDataBaseDependencies(AgentService.class);
public DecoratedOrchestratorAgent(Agent agente) {
workAgents = new ArrayList<Agent>();
orchestrator = agente;
}
private synchronized Long getNextSerialWorkerAgent() {
return ++serialWorkerAgent;
}
private synchronized void alterCyclesOfOrchestratorAgent(int improve) {
orchestrator.setCycles(orchestrator.getCycles() + 1);
if (improve == 1) {
orchestrator.setSuccessCycles(orchestrator.getSuccessCycles() + 1);
}else if (improve == -1) {
orchestrator.setWorsenCycles(orchestrator.getWorsenCycles() + 1);
}else if (improve == 0) {
orchestrator.setNotImproveNorWorsenCycles(orchestrator.getNotImproveNorWorsenCycles() + 1);
}
try {
agentService.updateAgent(orchestrator);
} catch (ServiceException ex) {
throw new RuntimeException(ex);
}
}
private synchronized Long getNextSerialBranch() {
return ++serialBranch;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the revision
*/
public Revision getRevision() {
return revision;
}
/**
* @param revision the revision to set
*/
public void setRevision(Revision revision) {
this.revision = revision;
}
/**
* @return the dericRevisions
*/
public List<Revision> getDericRevisions() {
return dericRevisions;
}
/**
* @param dericRevisions the dericRevisions to set
*/
public void setDericRevisions(List<Revision> dericRevisions) {
this.dericRevisions = dericRevisions;
}
/**
* @return the workAgents
*/
public List<Agent> getWorkAgents() {
return workAgents;
}
/**
* @param workAgents the workAgents to set
*/
public void setWorkAgents(List<Agent> workAgents) {
this.workAgents = workAgents;
}
/**
* @return the orchestrator
*/
public Agent getOrchestrator() {
return orchestrator;
}
/**
* @param orchestrator the orchestrator to set
*/
public void setOrchestrator(Agent orchestrator) {
this.orchestrator = orchestrator;
}
public Agent registraAgenteTrabalhador(Agent agenteTrabalhador) {
agenteTrabalhador.setIdAgent(getNextSerialWorkerAgent());
workAgents.add(agenteTrabalhador);
return agenteTrabalhador;
}
public void desregistraAgenteTrabalhador(Long idAgenteTrabalhador) {
Agent agenteTrabalhador = new Agent();
agenteTrabalhador.setIdAgent(idAgenteTrabalhador);
workAgents.remove(agenteTrabalhador);
}
public void alteraStatusAgenteTrabalhador(Long idAgenteTrabalhador, String status) {
for (Agent agenteTrabalhador : workAgents) {
if (agenteTrabalhador.getIdAgent().equals(idAgenteTrabalhador)) {
agenteTrabalhador.setStatus(status);
break;
}
}
}
public synchronized String getNextBranch(Long idAgenteTrabalhador) {
Agent agenteTrabalhador = null;
for (Agent agenteCorrente : workAgents) {
if (agenteCorrente.getIdAgent().equals(idAgenteTrabalhador)) {
agenteTrabalhador = agenteCorrente;
break;
}
}
ConfigurationItem ci = orchestrator.getProject().getConfigurationItem();
return PathUtil.getWellFormedURL(ci.getBaseUrl(),
ci.getBranchPath(),
orchestrator.getQualityAttribute().getName().toLowerCase() + "_" + orchestrator.getIdAgent(),
"workagent_" + agenteTrabalhador.getIdAgent() + "_" + System.currentTimeMillis());
}
public synchronized void alteraCiclosFailAgenteTrabalhador(long idAgenteTrabalhador, String refactoring) {
alterCyclesOfOrchestratorAgent(-1);
for (Agent agenteTrabalhador : workAgents) {
if (agenteTrabalhador.getIdAgent().equals(idAgenteTrabalhador)) {
agenteTrabalhador.setCycles(agenteTrabalhador.getCycles() + 1);
agenteTrabalhador.setWorsenCycles(agenteTrabalhador.getWorsenCycles() + 1);
break;
}
}
}
public synchronized void alteraCiclosSuccessAgenteTrabalhador(long idAgenteTrabalhador, String refactoring) {
alterCyclesOfOrchestratorAgent(1);
for (Agent agenteTrabalhador : workAgents) {
if (agenteTrabalhador.getIdAgent().equals(idAgenteTrabalhador)) {
agenteTrabalhador.setCycles(agenteTrabalhador.getCycles() + 1);
agenteTrabalhador.setSuccessCycles(agenteTrabalhador.getSuccessCycles() + 1);
break;
}
}
}
public synchronized void alteraCiclosNaoMelhorouNemPiorouAgenteTrabalhador(long idAgenteTrabalhador, String refactoring) {
alterCyclesOfOrchestratorAgent(0);
for (Agent agenteTrabalhador : workAgents) {
if (agenteTrabalhador.getIdAgent().equals(idAgenteTrabalhador)) {
agenteTrabalhador.setCycles(agenteTrabalhador.getCycles() + 1);
agenteTrabalhador.setNotImproveNorWorsenCycles(agenteTrabalhador.getNotImproveNorWorsenCycles() + 1);
break;
}
}
}
public String getRefactoring(long idAgenteTrabalhador) {
return "um_refactoringAindaNaoUtilizado";
}
public List<String> getRefactorings(long idAgenteTrabalhador) {
List<Refactoring> refactorings = ContextoAmbiente.getInstance().getRefactorings();
List<String> strRefactorings = new ArrayList(refactorings.size());
int[] sorteio = sorteio(refactorings.size());
for (int i : sorteio) {
strRefactorings.add(refactorings.get(sorteio[i]).getName());
}
return strRefactorings;
}
public int[] sorteio(int size){
Random random = new Random();
int[] retorno = new int[size];
List<Integer> aSerSorteado = new ArrayList(size);
for (int i = 0; i < retorno.length; i++) {
aSerSorteado.add(i);
}
for (int i = retorno.length; i > 0 ; i--) {
int r = random.nextInt(i);
retorno[i-1] = aSerSorteado.remove(r);
}
return retorno;
}
}