Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.apache.hadoop.chukwa.analysis.salsa.visualization; import prefuse.data.io.sql.*; import prefuse.data.Table; import prefuse.data.expression.parser.*; import prefuse.data.expression.*; import prefuse.data.column.*; import prefuse.data.query.*; import prefuse.data.*; import prefuse.action.*; import prefuse.action.layout.*; import prefuse.action.assignment.*; import prefuse.visual.expression.*; import prefuse.visual.*; import prefuse.render.*; import prefuse.util.collections.*; import prefuse.util.*; import prefuse.*; import org.apache.hadoop.chukwa.hicc.OfflineTimeHandler; import org.apache.hadoop.chukwa.hicc.TimeHandler; import org.apache.hadoop.chukwa.util.DatabaseWriter; import org.apache.hadoop.chukwa.database.Macro; import org.apache.hadoop.chukwa.util.XssFilter; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.servlet.http.*; import javax.swing.BorderFactory; import java.sql.*; import java.util.*; import java.text.NumberFormat; import java.text.DateFormat; import java.awt.Font; import java.awt.geom.Rectangle2D; /** * Static image generation for Swimlanes visualization for scalable * rendering on front-end client (web-browser) * Handles database data retrieval, transforming data to form for * visualization elements, and initializing and calling visualization * elements */ public class Swimlanes { private static Log log = LogFactory.getLog(Swimlanes.class); int SIZE_X = 1600, SIZE_Y = 1600; final int[] BORDER = { 50, 50, 50, 50 }; final int LEGEND_X_OFFSET = 50; final int LEGEND_Y_OFFSET = 25; final int LEGEND_TEXT_OFFSET = 20; final int LEGEND_FONT_SIZE = 18; final int AXIS_NAME_FONT_SIZE = 24; protected boolean offline_use = true; protected HttpServletRequest request; protected String abc; /** * Modifier for generic Swimlanes plots to plot shuffle, sort, and reducer * states of same reduce on same line */ protected class MapReduceSwimlanes { protected Table plot_tab; protected HashMap<String, ArrayList<Tuple>> reducepart_hash; protected boolean collate_reduces = false; public MapReduceSwimlanes() { this.plot_tab = new Table(); this.plot_tab.addColumn("ycoord", float.class); this.plot_tab.addColumn("state_name", String.class); this.plot_tab.addColumn("hostname", String.class); this.plot_tab.addColumn("friendly_id", String.class); this.plot_tab.addColumn(START_FIELD_NAME, double.class); this.plot_tab.addColumn(END_FIELD_NAME, double.class); this.plot_tab.addColumn(PolygonRenderer.POLYGON, float[].class); this.reducepart_hash = new HashMap<String, ArrayList<Tuple>>(); } public void populateTable_OneLinePerState(Table orig_tab) { IntIterator rownumiter; int newrownum, origrownum; rownumiter = orig_tab.rows(); // iterate over everything while (rownumiter.hasNext()) { origrownum = ((Integer) rownumiter.next()).intValue(); newrownum = this.plot_tab.addRow(); this.plot_tab.set(newrownum, "state_name", orig_tab.getString(origrownum, "state_name")); this.plot_tab.set(newrownum, "ycoord", orig_tab.getInt(origrownum, "seqno")); this.plot_tab.set(newrownum, "hostname", orig_tab.getString(origrownum, "hostname")); this.plot_tab.set(newrownum, "friendly_id", orig_tab.getString(origrownum, "friendly_id")); this.plot_tab.set(newrownum, START_FIELD_NAME, orig_tab.getDouble(origrownum, START_FIELD_NAME)); this.plot_tab.set(newrownum, END_FIELD_NAME, orig_tab.getDouble(origrownum, END_FIELD_NAME)); } } public void populateTable_CollateReduces(Table orig_tab) { IntIterator rownumiter; int newrownum, origrownum; this.collate_reduces = true; // add maps normally rownumiter = orig_tab.rows((Predicate) ExpressionParser.parse("[state_name] == 'map' " + "OR [state_name] == 'shuffle_local' " + "OR [state_name] == 'shuffle_remote'")); while (rownumiter.hasNext()) { origrownum = ((Integer) rownumiter.next()).intValue(); newrownum = this.plot_tab.addRow(); this.plot_tab.set(newrownum, "state_name", orig_tab.getString(origrownum, "state_name")); this.plot_tab.set(newrownum, "ycoord", orig_tab.getInt(origrownum, "seqno")); this.plot_tab.set(newrownum, "hostname", orig_tab.getString(origrownum, "hostname")); this.plot_tab.set(newrownum, "friendly_id", orig_tab.getString(origrownum, "friendly_id")); this.plot_tab.set(newrownum, START_FIELD_NAME, orig_tab.getDouble(origrownum, START_FIELD_NAME)); this.plot_tab.set(newrownum, END_FIELD_NAME, orig_tab.getDouble(origrownum, END_FIELD_NAME)); } // special breakdown for reduces IntIterator rownumiter3 = orig_tab.rows((Predicate) ExpressionParser .parse("[state_name] == 'reduce_reducer' " + "OR [state_name] == 'reduce_shufflewait' " + "OR [state_name] == 'reduce_sort' " + "OR [state_name] == 'reduce'")); ArrayList<Tuple> tuple_array; while (rownumiter3.hasNext()) { origrownum = ((Integer) rownumiter3.next()).intValue(); if (orig_tab.getString(origrownum, "state_name").equals("reduce")) { continue; // do NOT add reduces } String curr_reduce = orig_tab.getString(origrownum, "friendly_id"); newrownum = this.plot_tab.addRow(); this.plot_tab.set(newrownum, "state_name", orig_tab.getString(origrownum, "state_name")); this.plot_tab.set(newrownum, "ycoord", orig_tab.getInt(origrownum, "seqno")); this.plot_tab.set(newrownum, "hostname", orig_tab.getString(origrownum, "hostname")); this.plot_tab.set(newrownum, "friendly_id", orig_tab.getString(origrownum, "friendly_id")); this.plot_tab.set(newrownum, START_FIELD_NAME, orig_tab.getDouble(origrownum, START_FIELD_NAME)); this.plot_tab.set(newrownum, END_FIELD_NAME, orig_tab.getDouble(origrownum, END_FIELD_NAME)); tuple_array = this.reducepart_hash.get(curr_reduce); if (tuple_array == null) { tuple_array = new ArrayList<Tuple>(); tuple_array.add(this.plot_tab.getTuple(newrownum)); this.reducepart_hash.put(curr_reduce, tuple_array); } else { tuple_array.add(this.plot_tab.getTuple(newrownum)); } } } public void populateTable_MapsReducesOnly(Table orig_tab) { IntIterator rownumiter; int newrownum, origrownum; rownumiter = orig_tab .rows((Predicate) ExpressionParser.parse("[state_name] == 'map' OR [state_name] == 'reduce'")); while (rownumiter.hasNext()) { origrownum = ((Integer) rownumiter.next()).intValue(); newrownum = this.plot_tab.addRow(); this.plot_tab.set(newrownum, "state_name", orig_tab.getString(origrownum, "state_name")); this.plot_tab.set(newrownum, "ycoord", orig_tab.getInt(origrownum, "seqno")); this.plot_tab.set(newrownum, "hostname", orig_tab.getString(origrownum, "hostname")); this.plot_tab.set(newrownum, "friendly_id", orig_tab.getString(origrownum, "friendly_id")); this.plot_tab.set(newrownum, START_FIELD_NAME, orig_tab.getDouble(origrownum, START_FIELD_NAME)); this.plot_tab.set(newrownum, START_FIELD_NAME, orig_tab.getDouble(origrownum, END_FIELD_NAME)); } } /** * Reassigns Y coord values to group by state */ public void groupByState() { int counter, rownum; int rowcount = this.plot_tab.getRowCount(); HashSet<String> states = new HashSet<String>(); String curr_state = null; Iterator<String> state_iter; IntIterator rownumiter; for (int i = 0; i < rowcount; i++) { states.add(this.plot_tab.getString(i, "state_name")); } state_iter = states.iterator(); counter = 1; while (state_iter.hasNext()) { curr_state = state_iter.next(); if (this.collate_reduces) { if (curr_state.equals("reduce_reducer") || curr_state.equals("reduce_sort")) { continue; } } rownumiter = this.plot_tab .rows((Predicate) ExpressionParser.parse("[state_name] == '" + curr_state + "'")); if (this.collate_reduces && curr_state.equals("reduce_shufflewait")) { while (rownumiter.hasNext()) { rownum = ((Integer) rownumiter.next()).intValue(); this.plot_tab.setFloat(rownum, "ycoord", (float) counter); ArrayList<Tuple> alt = this.reducepart_hash .get(this.plot_tab.getString(rownum, "friendly_id")); Object[] tarr = alt.toArray(); for (int i = 0; i < tarr.length; i++) ((Tuple) tarr[i]).setFloat("ycoord", (float) counter); counter++; } } else { while (rownumiter.hasNext()) { rownum = ((Integer) rownumiter.next()).intValue(); this.plot_tab.setFloat(rownum, "ycoord", (float) counter); counter++; } } } } public void groupByStartTime() { int counter, rownum; int rowcount = this.plot_tab.getRowCount(); HashSet<String> states = new HashSet<String>(); String curr_state = null; Iterator<String> state_iter; IntIterator rownumiter; rownumiter = this.plot_tab.rowsSortedBy(START_FIELD_NAME, true); counter = 1; while (rownumiter.hasNext()) { rownum = ((Integer) rownumiter.next()).intValue(); curr_state = this.plot_tab.getString(rownum, "state_name"); if (this.collate_reduces && curr_state.equals("reduce_shufflewait")) { this.plot_tab.setFloat(rownum, "ycoord", (float) counter); ArrayList<Tuple> alt = this.reducepart_hash.get(this.plot_tab.getString(rownum, "friendly_id")); Object[] tarr = alt.toArray(); for (int i = 0; i < tarr.length; i++) ((Tuple) tarr[i]).setFloat("ycoord", (float) counter); counter++; } else if (!curr_state.equals("reduce_sort") && !curr_state.equals("reduce_reducer")) { this.plot_tab.setFloat(rownum, "ycoord", (float) counter); counter++; } } } public void groupByEndTime() { int counter, rownum; int rowcount = this.plot_tab.getRowCount(); HashSet<String> states = new HashSet<String>(); String curr_state = null; Iterator<String> state_iter; IntIterator rownumiter; rownumiter = this.plot_tab.rowsSortedBy(END_FIELD_NAME, true); counter = 1; while (rownumiter.hasNext()) { rownum = ((Integer) rownumiter.next()).intValue(); curr_state = this.plot_tab.getString(rownum, "state_name"); if (this.collate_reduces && curr_state.equals("reduce_reducer")) { this.plot_tab.setFloat(rownum, "ycoord", (float) counter); ArrayList<Tuple> alt = this.reducepart_hash.get(this.plot_tab.getString(rownum, "friendly_id")); Object[] tarr = alt.toArray(); for (int i = 0; i < tarr.length; i++) ((Tuple) tarr[i]).setFloat("ycoord", (float) counter); counter++; } else if (!curr_state.equals("reduce_sort") && !curr_state.equals("reduce_shufflewait")) { this.plot_tab.setFloat(rownum, "ycoord", (float) counter); counter++; } } } public VisualTable addToVisualization(Visualization viz, String groupname) { return viz.addTable(groupname, this.plot_tab); } } /** * Provide constant mapping between state names and colours * so that even if particular states are missing, the colours are fixed * for each state */ public static class SwimlanesStatePalette { protected final String[] states = { "map", "reduce", "reduce_shufflewait", "reduce_sort", "reduce_reducer", "shuffle" }; HashMap<String, Integer> colourmap; protected int[] palette; public SwimlanesStatePalette() { palette = ColorLib.getCategoryPalette(states.length); colourmap = new HashMap<String, Integer>(); for (int i = 0; i < states.length; i++) { colourmap.put(states[i], new Integer(palette[i])); } } public int getColour(String state_name) { Integer val = colourmap.get(state_name); if (val == null) { return ColorLib.color(java.awt.Color.BLACK); } else { return val.intValue(); } } public int getNumStates() { return this.states.length; } public String[] getStates() { return this.states; } } /** * Provides convenient rescaling of raw values to be plotted to * actual pixels for plotting on image */ public static class CoordScaler { double x_pixel_size, y_pixel_size; double x_max_value, y_max_value, x_min_value, y_min_value; double x_start, y_start; public CoordScaler() { this.x_pixel_size = 0.0; this.y_pixel_size = 0.0; this.x_max_value = 1.0; this.y_max_value = 1.0; this.x_min_value = 0.0; this.y_min_value = 0.0; this.x_start = 0.0; this.y_start = 0.0; } public void set_pixel_start(double x, double y) { this.x_start = x; this.y_start = y; } public void set_pixel_size(double x, double y) { this.x_pixel_size = x; this.y_pixel_size = y; } public void set_value_ranges(double x_min, double y_min, double x_max, double y_max) { this.x_max_value = x_max; this.y_max_value = y_max; this.x_min_value = x_min; this.y_min_value = y_min; } public double get_x_coord(double x_value) { return x_start + (((x_value - x_min_value) / (x_max_value - x_min_value)) * x_pixel_size); } public double get_y_coord(double y_value) { // this does "inverting" to shift the (0,0) point from top-right to bottom-right return y_start + (y_pixel_size - ((((y_value - y_min_value) / (y_max_value - y_min_value)) * y_pixel_size))); } } /** * Prefuse action for plotting a line for each state */ public static class SwimlanesStateAction extends GroupAction { protected CoordScaler cs; public SwimlanesStateAction() { super(); } public SwimlanesStateAction(String group, CoordScaler cs) { super(group); this.cs = cs; } public void run(double frac) { VisualItem item = null; SwimlanesStatePalette pal = new SwimlanesStatePalette(); Iterator curr_group_items = this.m_vis.items(this.m_group); int i = 0; while (curr_group_items.hasNext()) { item = (VisualItem) curr_group_items.next(); double start_time = item.getDouble(START_FIELD_NAME); double finish_time = item.getDouble(END_FIELD_NAME); item.setShape(Constants.POLY_TYPE_LINE); item.setX(0.0); item.setY(0.0); float[] coords = new float[4]; coords[0] = (float) cs.get_x_coord(start_time); coords[1] = (float) cs.get_y_coord((double) item.getInt("ycoord")); coords[2] = (float) cs.get_x_coord(finish_time); coords[3] = (float) cs.get_y_coord((double) item.getInt("ycoord")); item.set(VisualItem.POLYGON, coords); item.setStrokeColor(pal.getColour(item.getString("state_name"))); i++; } } } // SwimlanesStateAction // keys that need to be filled: // period (last1/2/3/6/12/24hr,last7d,last30d), time_type (range/last), start, end protected HashMap<String, String> param_map; protected String cluster; protected String timezone; protected String shuffle_option; protected final String table = new String("mapreduce_fsm"); protected boolean plot_legend = true; protected String jobname = null; protected Display dis; protected Visualization viz; protected Rectangle2D dataBound = new Rectangle2D.Double(); protected Rectangle2D xlabBound = new Rectangle2D.Double(); protected Rectangle2D ylabBound = new Rectangle2D.Double(); protected Rectangle2D labelBottomBound = new Rectangle2D.Double(); static final String START_FIELD_NAME = "start_time_num"; static final String END_FIELD_NAME = "finish_time_num"; /* Different group names allow control of what Renderers to use */ final String maingroup = "Job"; final String othergroup = "Misc"; final String labelgroup = "Label"; final String legendgroup = "Legend"; final String legendshapegroup = "LegendShape"; public Swimlanes() { this.cluster = new String(""); this.timezone = new String(""); this.shuffle_option = new String(""); param_map = new HashMap<String, String>(); } /** * @brief Constructor for Swimlanes visualization object * @param timezone Timezone string from environment * @param cluster Cluster name from environment * @param event_type Whether to display shuffles or not * @param valmap HashMap of key/value pairs simulating parameters from a HttpRequest */ public Swimlanes(String timezone, String cluster, String event_type, HashMap<String, String> valmap) { this.cluster = new String(cluster); if (timezone != null) { this.timezone = new String(timezone); } else { this.timezone = null; } this.shuffle_option = new String(event_type); /* This should "simulate" an HttpServletRequest * Need to have "start" and "end" in seconds since Epoch */ this.param_map = valmap; } public Swimlanes(String timezone, String cluster, String event_type, HashMap<String, String> valmap, int width, int height) { this.cluster = new String(cluster); if (timezone != null) { this.timezone = new String(timezone); } else { this.timezone = null; } this.shuffle_option = new String(event_type); /* This should "simulate" an HttpServletRequest * Need to have "start" and "end" in seconds since Epoch */ this.param_map = valmap; this.SIZE_X = width; this.SIZE_Y = height; } public Swimlanes(String timezone, String cluster, String event_type, HashMap<String, String> valmap, int width, int height, String legend_opt) { this.cluster = new String(cluster); if (timezone != null) { this.timezone = new String(timezone); } else { this.timezone = null; } this.shuffle_option = new String(event_type); /* This should "simulate" an HttpServletRequest * Need to have "start" and "end" in seconds since Epoch */ this.param_map = valmap; this.SIZE_X = width; this.SIZE_Y = height; if (legend_opt.equals("nolegend")) { this.plot_legend = false; } } public Swimlanes(HttpServletRequest request) { XssFilter xf = new XssFilter(request); this.offline_use = false; this.request = request; HttpSession session = request.getSession(); this.cluster = session.getAttribute("cluster").toString(); String evt_type = xf.getParameter("event_type"); if (evt_type != null) { this.shuffle_option = new String(evt_type); } else { this.shuffle_option = new String("noshuffle"); } this.timezone = session.getAttribute("time_zone").toString(); } /** * Set job ID to filter results on * Call before calling @see #run */ public void setJobName(String s) { this.jobname = new String(s); } /** * Set dimensions of image to be generated * Call before calling @see #run */ public void setDimensions(int width, int height) { this.SIZE_X = width; this.SIZE_Y = height; } /** * Specify whether to print legend of states * Advisable to not print legend for excessively small images since * legend has fixed point size * Call before calling @see #run */ public void setLegend(boolean legendopt) { if (legendopt) { this.plot_legend = true; } else { this.plot_legend = false; } } /** * Generates image in specified format, and writes image as binary * output to supplied output stream */ public boolean getImage(java.io.OutputStream output, String img_fmt, double scale) { dis = new Display(this.viz); dis.setSize(SIZE_X, SIZE_Y); dis.setHighQuality(true); dis.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 24)); return dis.saveImage(output, img_fmt, scale); } /** * Adds a column to given table by converting timestamp to long with * seconds since epoch, and adding milliseconds from additional column * in original table * * @param origTable Table to add to * @param srcFieldName Name of column containing timestamp * @param srcMillisecondFieldName Name of column containing millisecond value of time * @param dstFieldName Name of new column to add * * @return Modified table with added column */ protected Table addTimeCol(Table origTable, String srcFieldName, String srcMillisecondFieldName, String dstFieldName) { origTable.addColumn(dstFieldName, long.class); int total_rows = origTable.getRowCount(); for (int curr_row_num = 0; curr_row_num < total_rows; curr_row_num++) { origTable.setLong(curr_row_num, dstFieldName, ((Timestamp) origTable.get(curr_row_num, srcFieldName)).getTime() + origTable.getLong(curr_row_num, srcMillisecondFieldName)); } return origTable; } /** * Adds a column with number of seconds of timestamp elapsed since lowest * start time; allows times to be plotted as a delta of the start time * * @param origTable Table to add column to * @param srcFieldName Name of column containing timestamp * @param srcMillisecondFieldName Name of column containing millisecond value of time * @param dstFieldName Name of new column to add * * @return Modified table with added column */ protected Table addTimeOffsetCol(Table origTable, String srcFieldName, String srcMillisecondFieldName, String dstFieldName, long timeOffset) { Table newtable = addTimeCol(origTable, srcFieldName, srcMillisecondFieldName, dstFieldName + "_fulltime"); ColumnMetadata dstcol = newtable.getMetadata(dstFieldName + "_fulltime"); long mintime = newtable.getLong(dstcol.getMinimumRow(), dstFieldName + "_fulltime"); if (timeOffset == 0) { newtable.addColumn(dstFieldName, "ROUND(([" + dstFieldName + "_fulltime] - " + mintime + "L) / 1000L)"); } else { newtable.addColumn(dstFieldName, "ROUND(([" + dstFieldName + "_fulltime] - " + timeOffset + "L) / 1000L)"); } return newtable; } protected void setupRenderer() { this.viz.setRendererFactory(new RendererFactory() { AbstractShapeRenderer sr = new ShapeRenderer(); ShapeRenderer sr_big = new ShapeRenderer(20); Renderer arY = new AxisRenderer(Constants.LEFT, Constants.TOP); Renderer arX = new AxisRenderer(Constants.CENTER, Constants.BOTTOM); PolygonRenderer pr = new PolygonRenderer(Constants.POLY_TYPE_LINE); LabelRenderer lr = new LabelRenderer("label"); LabelRenderer lr_legend = new LabelRenderer("label"); public Renderer getRenderer(VisualItem item) { lr.setHorizontalAlignment(Constants.CENTER); lr.setVerticalAlignment(Constants.TOP); lr_legend.setHorizontalAlignment(Constants.LEFT); lr_legend.setVerticalAlignment(Constants.CENTER); if (item.isInGroup("ylab")) { return arY; } else if (item.isInGroup("xlab")) { return arX; } else if (item.isInGroup(maingroup)) { return pr; } else if (item.isInGroup(labelgroup)) { return lr; } else if (item.isInGroup(legendgroup)) { return lr_legend; } else if (item.isInGroup(legendshapegroup)) { return sr_big; } else { return sr; } } }); } // setup columns: add additional time fields protected Table setupDataTable() { Table res_tab = this.getData(); if (res_tab == null) { return res_tab; } res_tab.addColumn("seqno", "ROW()"); res_tab = addTimeOffsetCol(res_tab, "start_time", "start_time_millis", START_FIELD_NAME, 0); ColumnMetadata dstcol = res_tab.getMetadata(START_FIELD_NAME); long mintime = ((Timestamp) res_tab.get(dstcol.getMinimumRow(), "start_time")).getTime(); res_tab = addTimeOffsetCol(res_tab, "finish_time", "finish_time_millis", END_FIELD_NAME, mintime); res_tab.addColumn(PolygonRenderer.POLYGON, float[].class); log.debug("After adding seqno: #cols: " + res_tab.getColumnCount() + "; #rows: " + res_tab.getRowCount()); return res_tab; } protected void addAxisNames() { Table textlabels_table = new Table(); textlabels_table.addColumn("label", String.class); textlabels_table.addColumn("type", String.class); textlabels_table.addRow(); textlabels_table.setString(0, "label", new String("Time/s")); textlabels_table.setString(0, "type", new String("xaxisname")); VisualTable textlabelsviz = this.viz.addTable(labelgroup, textlabels_table); textlabelsviz.setX(0, SIZE_X / 2); textlabelsviz.setY(0, SIZE_Y - BORDER[2] + (BORDER[2] * 0.1)); textlabelsviz.setTextColor(0, ColorLib.color(java.awt.Color.GRAY)); textlabelsviz.setFont(0, new Font(Font.SANS_SERIF, Font.PLAIN, AXIS_NAME_FONT_SIZE)); } protected void addLegend() { SwimlanesStatePalette ssp = new SwimlanesStatePalette(); Table shapes_table = new Table(); shapes_table.addColumn(VisualItem.X, float.class); shapes_table.addColumn(VisualItem.Y, float.class); Table legend_labels_table = new Table(); Table legend_squares_table = new Table(); legend_labels_table.addColumn("label", String.class); // add labels int num_states = ssp.getNumStates(); String[] state_names = ssp.getStates(); legend_labels_table.addRows(num_states); shapes_table.addRows(num_states); for (int i = 0; i < num_states; i++) { legend_labels_table.setString(i, "label", state_names[i]); } // add legend shapes, manipulate visualitems to set colours VisualTable shapes_table_viz = viz.addTable(legendshapegroup, shapes_table); float start_x = BORDER[0] + LEGEND_X_OFFSET; float start_y = BORDER[1] + LEGEND_Y_OFFSET; float incr = (float) 30.0; for (int i = 0; i < num_states; i++) { shapes_table_viz.setFillColor(i, ssp.getColour(state_names[i])); shapes_table_viz.setFloat(i, VisualItem.X, start_x); shapes_table_viz.setFloat(i, VisualItem.Y, start_y + (i * incr)); } // add legend labels, manipulate visualitems to set font VisualTable legend_labels_table_viz = this.viz.addTable(legendgroup, legend_labels_table); for (int i = 0; i < num_states; i++) { legend_labels_table_viz.setFloat(i, VisualItem.X, start_x + LEGEND_TEXT_OFFSET); legend_labels_table_viz.setFloat(i, VisualItem.Y, start_y + (i * incr)); legend_labels_table_viz.setTextColor(i, ColorLib.color(java.awt.Color.BLACK)); legend_labels_table_viz.setFont(i, new Font(Font.SANS_SERIF, Font.PLAIN, LEGEND_FONT_SIZE)); } } public void run() { // setup bounds this.dataBound.setRect(BORDER[0], BORDER[1], SIZE_X - BORDER[2] - BORDER[0], SIZE_Y - BORDER[3] - BORDER[1]); this.xlabBound.setRect(BORDER[0], BORDER[1], SIZE_X - BORDER[2] - BORDER[0], SIZE_Y - BORDER[3] - BORDER[1]); this.ylabBound.setRect(BORDER[0], BORDER[1], SIZE_X - BORDER[2] - BORDER[0], SIZE_Y - BORDER[3] - BORDER[1]); this.labelBottomBound.setRect(BORDER[0], SIZE_X - BORDER[2], SIZE_Y - BORDER[0] - BORDER[1], BORDER[3]); // setup visualization this.viz = new Visualization(); this.setupRenderer(); // add table to visualization Table raw_data_tab = this.setupDataTable(); MapReduceSwimlanes mrs = new MapReduceSwimlanes(); mrs.populateTable_CollateReduces(raw_data_tab); mrs.groupByState(); VisualTable maindatatable = mrs.addToVisualization(this.viz, maingroup); addAxisNames(); if (plot_legend) { addLegend(); } // plot swimlanes lines: setup axes, call custom action ActionList draw = new ActionList(); { // setup axes AxisLayout xaxis = new AxisLayout(maingroup, START_FIELD_NAME, Constants.X_AXIS, VisiblePredicate.TRUE); AxisLayout yaxis = new AxisLayout(maingroup, "ycoord", Constants.Y_AXIS, VisiblePredicate.FALSE); xaxis.setLayoutBounds(dataBound); yaxis.setLayoutBounds(dataBound); ColumnMetadata starttime_meta = maindatatable.getMetadata(START_FIELD_NAME); ColumnMetadata finishtime_meta = maindatatable.getMetadata(END_FIELD_NAME); ColumnMetadata ycoord_meta = maindatatable.getMetadata("ycoord"); long x_min = (long) ((Double) maindatatable.get(starttime_meta.getMinimumRow(), START_FIELD_NAME)) .doubleValue(); long x_max = (long) ((Double) maindatatable.get(finishtime_meta.getMaximumRow(), END_FIELD_NAME)) .doubleValue(); xaxis.setRangeModel(new NumberRangeModel(x_min, x_max, x_min, x_max)); float y_max = maindatatable.getFloat(ycoord_meta.getMaximumRow(), "ycoord"); yaxis.setRangeModel(new NumberRangeModel(0, y_max, 0, y_max)); // call custom action to plot actual swimlanes lines CoordScaler cs = new CoordScaler(); cs.set_pixel_size(SIZE_X - BORDER[0] - BORDER[2], SIZE_Y - BORDER[1] - BORDER[3]); cs.set_pixel_start(BORDER[0], BORDER[1]); cs.set_value_ranges(x_min, 0, x_max, y_max); //SwimlanesStateAction swimlaneslines = new SwimlanesStateAction(maingroup, cs); SwimlanesStateAction swimlaneslines = new SwimlanesStateAction(maingroup, cs); // add everything to the plot draw.add(xaxis); draw.add(yaxis); draw.add(swimlaneslines); AxisLabelLayout xlabels = new AxisLabelLayout("xlab", xaxis, xlabBound); this.viz.putAction("xlabels", xlabels); AxisLabelLayout ylabels = new AxisLabelLayout("ylab", yaxis, ylabBound); this.viz.putAction("ylabels", ylabels); } // add axes names { SpecifiedLayout sl = new SpecifiedLayout(labelgroup, VisualItem.X, VisualItem.Y); ActionList labeldraw = new ActionList(); labeldraw.add(sl); this.viz.putAction(labelgroup, labeldraw); } // add legend if (plot_legend) { ShapeAction legend_sa = new ShapeAction(legendshapegroup); SpecifiedLayout legendlabels_sl = new SpecifiedLayout(legendgroup, VisualItem.X, VisualItem.Y); ActionList legenddraw = new ActionList(); legenddraw.add(legend_sa); this.viz.putAction(legendshapegroup, legenddraw); ActionList legendlabelsdraw = new ActionList(); legendlabelsdraw.add(legendlabels_sl); this.viz.putAction(legendgroup, legendlabelsdraw); } // draw everything else this.viz.putAction("draw", draw); // finally draw this.viz.run("draw"); this.viz.run("xlabels"); this.viz.run("ylabels"); } public Table getData() { // preliminary setup OfflineTimeHandler time_offline; TimeHandler time_online; long start, end; if (offline_use) { time_offline = new OfflineTimeHandler(param_map, this.timezone); start = time_offline.getStartTime(); end = time_offline.getEndTime(); } else { time_online = new TimeHandler(this.request, this.timezone); start = time_online.getStartTime(); end = time_online.getEndTime(); } DatabaseWriter dbw = new DatabaseWriter(this.cluster); String query; // setup query if (this.shuffle_option != null && this.shuffle_option.equals("shuffles")) { query = "select job_id,friendly_id,start_time,finish_time,start_time_millis,finish_time_millis,status,state_name,hostname from [" + this.table + "] where finish_time between '[start]' and '[end]'"; } else { query = "select job_id,friendly_id,start_time,finish_time,start_time_millis,finish_time_millis,status,state_name,hostname from [" + this.table + "] where finish_time between '[start]' and '[end]' and not state_name like 'shuffle_local' and not state_name like 'shuffle_remote'"; } if (this.jobname != null) { query = query + " and job_id like '" + this.jobname + "'"; } Macro mp = new Macro(start, end, query); query = mp.toString() + " order by start_time"; Table rs_tab = null; DatabaseDataSource dds; DefaultSQLDataHandler dh = new DefaultSQLDataHandler(); log.debug("Query: " + query); // execute query try { dds = ConnectionFactory.getDatabaseConnection(dbw.getConnection()); rs_tab = dds.getData(query); } catch (prefuse.data.io.DataIOException e) { System.err.println("prefuse data IO error: " + e); log.warn("prefuse data IO error: " + e); return null; } catch (SQLException e) { System.err.println("Error in SQL: " + e + " in statement: " + query); log.warn("Error in SQL: " + e + " in statement: " + query); return null; } HashMap<String, Integer> state_counts = new HashMap<String, Integer>(); HashSet<String> states = new HashSet<String>(); for (int i = 0; i < rs_tab.getRowCount(); i++) { String curr_state = rs_tab.getString(i, "state_name"); states.add(curr_state); Integer cnt = state_counts.get(curr_state); if (cnt == null) { state_counts.put(curr_state, new Integer(1)); } else { state_counts.remove(curr_state); state_counts.put(curr_state, new Integer(cnt.intValue() + 1)); } } log.info("Search complete: #cols: " + rs_tab.getColumnCount() + "; #rows: " + rs_tab.getRowCount()); return rs_tab; } }