import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Test
public void testCalculatorWeightedAverage() throws Exception {
    VMTaskFitnessCalculator fitnessCalculator1 = mock(VMTaskFitnessCalculator.class);
    when(fitnessCalculator1.calculateFitness(any(), any(), any())).thenReturn(0.5);

    VMTaskFitnessCalculator fitnessCalculator2 = mock(VMTaskFitnessCalculator.class);
    when(fitnessCalculator2.calculateFitness(any(), any(), any())).thenReturn(1.0);

    List<WeightedFitnessCalculator> weightedFitnessCalculators = Arrays.asList(
            new WeightedFitnessCalculator(fitnessCalculator1, 0.5),
            new WeightedFitnessCalculator(fitnessCalculator2, 0.5)
    );
    WeightedAverageFitnessCalculator calculator = new WeightedAverageFitnessCalculator(weightedFitnessCalculators);
    double fitness = calculator.calculateFitness(mock(TaskRequest.class), mock(VirtualMachineCurrentState.class), mock(TaskTrackerState.class));
    Assert.assertEquals(0.75, fitness, 0.0);
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Test
public void testCalculatorWeightedAverageWithZero() throws Exception {
    VMTaskFitnessCalculator fitnessCalculator1 = mock(VMTaskFitnessCalculator.class);
    when(fitnessCalculator1.calculateFitness(any(), any(), any())).thenReturn(0.0);

    VMTaskFitnessCalculator fitnessCalculator2 = mock(VMTaskFitnessCalculator.class);
    when(fitnessCalculator2.calculateFitness(any(), any(), any())).thenReturn(1.0);

    List<WeightedFitnessCalculator> weightedFitnessCalculators = Arrays.asList(
            new WeightedFitnessCalculator(fitnessCalculator1, 0.3),
            new WeightedFitnessCalculator(fitnessCalculator2, 0.7)
    );
    WeightedAverageFitnessCalculator calculator = new WeightedAverageFitnessCalculator(weightedFitnessCalculators);
    double fitness = calculator.calculateFitness(mock(TaskRequest.class), mock(VirtualMachineCurrentState.class), mock(TaskTrackerState.class));
    Assert.assertEquals(0.0, fitness, 0.0);
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
/**
 * Returns a "soft" constraint, in the form of a {@link VMTaskFitnessCalculator}, based on a specified "hard"
 * constraint, in the form of a {@link ConstraintEvaluator}.
 *
 * @param c the "hard" constraint to convert
 * @return a "soft" constraint version of {@code c}
 */
public static VMTaskFitnessCalculator get(final ConstraintEvaluator c) {
    // This fitness calculator return 0 or 1. This can possibly be improved upon by the ConstraintEvaluator using its
    // own logic.
    return new VMTaskFitnessCalculator() {
        @Override
        public String getName() {
            return c.getName();
        }
        @Override
        public double calculateFitness(TaskRequest taskRequest, VirtualMachineCurrentState targetVM, TaskTrackerState taskTrackerState) {
            return c.evaluate(taskRequest, targetVM, taskTrackerState).isSuccessful()? 1.0 : 0.0;
        }
    };
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
public WeightedFitnessCalculator(VMTaskFitnessCalculator fitnessCalculator, double weight) {
    if (fitnessCalculator == null) {
        throw new IllegalArgumentException("Fitness Calculator cannot be null");
    }
    this.fitnessCalculator = fitnessCalculator;
    this.weight = weight;
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
/**
 * Converts this constraint into a "soft" constraint. By default, a balanced host attribute constraint is a
 * "hard" constraint, which is to say that Fenzo will guarantee that the constraint is applied and will fail
 * to place a task if the only way it can do so is to violate the constraint. This method returns a
 * {@link VMTaskFitnessCalculator} that represents this constraint as a "soft" constraint that will permit
 * Fenzo to place a task in violation of the constraint if it cannot do so otherwise.
 *
 * @return a task fitness calculator that represents the balanced host attribute constraint as a soft
 *         constraint
 */
public VMTaskFitnessCalculator asSoftConstraint() {
    return new VMTaskFitnessCalculator() {
        @Override
        public String getName() {
            return name;
        }

        @Override
        public double calculateFitness(TaskRequest taskRequest, VirtualMachineCurrentState targetVM, TaskTrackerState taskTrackerState) {
            String targetHostAttrVal = AttributeUtilities.getAttrValue(targetVM.getCurrAvailableResources(), hostAttributeName);
            if(targetHostAttrVal==null || targetHostAttrVal.isEmpty()) {
                return 0.0;
            }
            Set<String> coTasks = coTasksGetter.call(taskRequest.getId());
            Map<String, Integer> usedAttribsMap = null;
            try {
                usedAttribsMap = getUsedAttributesMap(coTasks, taskTrackerState);
            } catch (Exception e) {
                return 0.0;
            }
            final Integer integer = usedAttribsMap.get(targetHostAttrVal);
            if(integer==null)
                return 1.0;
            if(usedAttribsMap.isEmpty())
                return 1.0;
            double avg=0.0;
            for(Integer i: usedAttribsMap.values())
                avg += i;
            avg = Math.ceil(avg+1 / Math.max(expectedValues, usedAttribsMap.size()));
            if(integer<=avg)
                return (avg-(double)integer) / avg;
            return 0.0;
        }
    };
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testWeightsMustEqualOne() throws Exception {
    VMTaskFitnessCalculator fitnessCalculator = mock(VMTaskFitnessCalculator.class);
    List<WeightedFitnessCalculator> weightedFitnessCalculators = Arrays.asList(
            new WeightedFitnessCalculator(fitnessCalculator, 0.3),
            new WeightedFitnessCalculator(fitnessCalculator, 0.75)
    );
    new WeightedAverageFitnessCalculator(weightedFitnessCalculators);
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Override
public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
    return null;
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
private TaskRequest getTaskRequest() {
    final String taskId = nextTaskId();
    return new TaskRequest() {
        @Override
        public String getId() {
            return taskId;
        }

        @Override
        public String taskGroupName() {
            return frameworkName;
        }

        @Override
        public double getCPUs() {
            return taskCPU;
        }

        @Override
        public double getMemory() {
            return taskMEM;
        }

        @Override
        public double getNetworkMbps() {
            return taskNET;
        }

        @Override
        public double getDisk() {
            return taskDISK;
        }

        @Override
        public int getPorts() {
            return 1;
        }

        @Override
        public List<? extends ConstraintEvaluator> getHardConstraints() {
      	  List<ConstraintEvaluator> list = new ArrayList<ConstraintEvaluator>();
      	  list.add(new ExclusiveHostConstraint()); // Force a exclusive host as we are using HOST network
      	  if (!hostAttribute[0].equals(TASK_HOST_ATTRIBUTE_NAME_NOT_DEFINED))
      	  {
      	   list.add( new HostAttrValueConstraint(hostAttribute[0], new Func1<java.lang.String,java.lang.String>() {

				@Override
				public String call(String arg0) {
					// TODO, as we only have one framework. Otherwise need a task id to framework map and framework to attribute map
					return hostAttribute[1];
				}
            	  
			} ));
      	  }
      	  return list;
        }

        @Override
        public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
            return null;
        }
    };
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Override
public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
	return null;
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Override
public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
	return Collections.emptyList();
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
private TaskRequest getTaskRequest(final int id) {
    final String taskId = "" + id;
    final AtomicReference<TaskRequest.AssignedResources> assgndResRef = new AtomicReference<>();
    return new TaskRequest() {
        @Override
        public String getId() {
            return taskId;
        }

        @Override
        public String taskGroupName() {
            return "";
        }

        @Override
        public double getCPUs() {
            return 1.0;
        }

        @Override
        public double getMemory() {
            return 1024;
        }

        @Override
        public double getNetworkMbps() {
            return 0;
        }

        @Override
        public double getDisk() {
            return 10;
        }

        @Override
        public int getPorts() {
            return 1;
        }

        @Override
        public Map<String, Double> getScalarRequests() {
            return null;
        }

        @Override
        public List<? extends ConstraintEvaluator> getHardConstraints() {
            return null;
        }

        @Override
        public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
            return null;
        }

        @Override
        public void setAssignedResources(AssignedResources assignedResources) {
            assgndResRef.set(assignedResources);
        }

        @Override
        public AssignedResources getAssignedResources() {
            return assgndResRef.get();
        }

        @Override
        public Map<String, NamedResourceSetRequest> getCustomNamedResources() {
            return Collections.emptyMap();
        }
    };
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
public VMTaskFitnessCalculator getFitnessCalculator() {
    return fitnessCalculator;
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Override
public double calculateFitness(TaskRequest taskRequest, VirtualMachineCurrentState targetVM, TaskTrackerState taskTrackerState) {
    VMTaskFitnessCalculator cpuBinPacker = BinPackingFitnessCalculators.cpuBinPacker;
    return 1 - cpuBinPacker.calculateFitness(taskRequest, targetVM, taskTrackerState);
}
 

import com.netflix.fenzo.VMTaskFitnessCalculator; //导入依赖的package包/类
@Override
public List<? extends VMTaskFitnessCalculator> getSoftConstraints() {
    return Collections.emptyList();
}