Java tutorial
/* * Copyright 2010 JBoss Inc * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.drools.planner.examples.cloudbalancing.swingui; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import javax.swing.AbstractAction; import javax.swing.GroupLayout; import javax.swing.JComboBox; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.JPanel; import org.apache.commons.lang.ObjectUtils; import org.drools.planner.core.score.director.ScoreDirector; import org.drools.planner.core.solution.Solution; import org.drools.planner.core.solver.ProblemFactChange; import org.drools.planner.examples.cloudbalancing.domain.CloudProcess; import org.drools.planner.examples.cloudbalancing.domain.CloudBalance; import org.drools.planner.examples.cloudbalancing.domain.CloudComputer; import org.drools.planner.examples.cloudbalancing.solver.move.CloudComputerChangeMove; import org.drools.planner.examples.common.swingui.SolutionPanel; public class CloudBalancingPanel extends SolutionPanel { public static final String LOGO_PATH = "/org/drools/planner/examples/cloudbalancing/swingui/cloudBalancingLogo.png"; private JPanel computersPanel; private CloudComputerPanel unassignedPanel; private Map<CloudComputer, CloudComputerPanel> computerToPanelMap; private Map<CloudProcess, CloudComputerPanel> processToPanelMap; public CloudBalancingPanel() { GroupLayout layout = new GroupLayout(this); setLayout(layout); JPanel headerPanel = createHeaderPanel(); JPanel computersPanel = createComputersPanel(); layout.setHorizontalGroup( layout.createParallelGroup().addComponent(headerPanel).addComponent(computersPanel)); layout.setVerticalGroup(layout.createSequentialGroup() .addComponent(headerPanel, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE) .addComponent(computersPanel, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE, GroupLayout.PREFERRED_SIZE)); } private JPanel createHeaderPanel() { JPanel headerPanel = new JPanel(new GridLayout(0, 5)); JLabel emptyLabel = new JLabel(""); headerPanel.add(emptyLabel); JLabel cpuPowerLabel = new JLabel("CPU power"); headerPanel.add(cpuPowerLabel); JLabel memoryLabel = new JLabel("Memory"); headerPanel.add(memoryLabel); JLabel networkBandwidthLabel = new JLabel("Network bandwidth"); headerPanel.add(networkBandwidthLabel); JLabel costLabel = new JLabel("Cost"); headerPanel.add(costLabel); return headerPanel; } private JPanel createComputersPanel() { computersPanel = new JPanel(new GridLayout(0, 1)); unassignedPanel = new CloudComputerPanel(this, null); computersPanel.add(unassignedPanel); computerToPanelMap = new LinkedHashMap<CloudComputer, CloudComputerPanel>(); computerToPanelMap.put(null, unassignedPanel); processToPanelMap = new LinkedHashMap<CloudProcess, CloudComputerPanel>(); return computersPanel; } @Override public boolean isRefreshScreenDuringSolving() { return true; } private CloudBalance getCloudBalance() { return (CloudBalance) solutionBusiness.getSolution(); } public void resetPanel(Solution solution) { for (CloudComputerPanel computerPanel : computerToPanelMap.values()) { if (computerPanel.getComputer() != null) { computersPanel.remove(computerPanel); } } computerToPanelMap.clear(); computerToPanelMap.put(null, unassignedPanel); processToPanelMap.clear(); unassignedPanel.clearProcess(); updatePanel(solution); } @Override public void updatePanel(Solution solution) { CloudBalance cloudBalance = (CloudBalance) solution; Set<CloudComputer> deadCloudComputerSet = new LinkedHashSet<CloudComputer>(computerToPanelMap.keySet()); deadCloudComputerSet.remove(null); for (CloudComputer computer : cloudBalance.getComputerList()) { deadCloudComputerSet.remove(computer); CloudComputerPanel computerPanel = computerToPanelMap.get(computer); if (computerPanel == null) { computerPanel = new CloudComputerPanel(this, computer); computersPanel.add(computerPanel); computerToPanelMap.put(computer, computerPanel); } } Set<CloudProcess> deadCloudProcessSet = new LinkedHashSet<CloudProcess>(processToPanelMap.keySet()); for (CloudProcess process : cloudBalance.getProcessList()) { deadCloudProcessSet.remove(process); CloudComputerPanel computerPanel = processToPanelMap.get(process); CloudComputer computer = process.getComputer(); if (computerPanel != null && !ObjectUtils.equals(computerPanel.getComputer(), computer)) { processToPanelMap.remove(process); computerPanel.removeProcess(process); computerPanel = null; } if (computerPanel == null) { computerPanel = computerToPanelMap.get(computer); computerPanel.addProcess(process); processToPanelMap.put(process, computerPanel); } } for (CloudProcess deadProcess : deadCloudProcessSet) { CloudComputerPanel deadComputerPanel = processToPanelMap.remove(deadProcess); deadComputerPanel.removeProcess(deadProcess); } for (CloudComputer deadComputer : deadCloudComputerSet) { CloudComputerPanel deadComputerPanel = computerToPanelMap.remove(deadComputer); computersPanel.remove(deadComputerPanel); } for (CloudComputerPanel computerPanel : computerToPanelMap.values()) { computerPanel.update(); } } public void deleteComputer(final CloudComputer computer) { logger.info("Scheduling delete of computer ({}).", computer); solutionBusiness.doProblemFactChange(new ProblemFactChange() { public void doChange(ScoreDirector scoreDirector) { CloudBalance cloudBalance = (CloudBalance) scoreDirector.getWorkingSolution(); // First remove the planning fact from all planning entities that use it for (CloudProcess process : cloudBalance.getProcessList()) { if (ObjectUtils.equals(process.getComputer(), computer)) { // TODO HACK we are removing it because it becomes uninitialized, // which means it has to be retracted // This is nonsense from a ProblemFactChange point of view, FIXME! scoreDirector.beforeEntityRemoved(process); process.setComputer(null); scoreDirector.afterEntityRemoved(process); } } // Next remove it the planning fact itself for (Iterator<CloudComputer> it = cloudBalance.getComputerList().iterator(); it.hasNext();) { CloudComputer workingComputer = it.next(); if (ObjectUtils.equals(workingComputer, computer)) { scoreDirector.beforeProblemFactRemoved(workingComputer); it.remove(); // remove from list scoreDirector.beforeProblemFactRemoved(workingComputer); break; } } } }); updatePanel(solutionBusiness.getSolution()); } private class CloudProcessAction extends AbstractAction { private CloudProcess process; public CloudProcessAction(CloudProcess process) { super("=>"); this.process = process; } public void actionPerformed(ActionEvent e) { List<CloudComputer> computerList = getCloudBalance().getComputerList(); JComboBox computerListField = new JComboBox(computerList.toArray()); computerListField.setSelectedItem(process.getComputer()); int result = JOptionPane.showConfirmDialog(CloudBalancingPanel.this.getRootPane(), computerListField, "Select computer", JOptionPane.OK_CANCEL_OPTION); if (result == JOptionPane.OK_OPTION) { CloudComputer toComputer = (CloudComputer) computerListField.getSelectedItem(); solutionBusiness.doMove(new CloudComputerChangeMove(process, toComputer)); solverAndPersistenceFrame.resetScreen(); } } } }