public void map(
      Object unused,
      Text line,
      OutputCollector<LongWritable, PostingSongArrayWritable> output,
      Reporter reporter)
      throws IOException {

    StringTokenizer str = new StringTokenizer(line.toString(), " |\t");

    if (nRatings == 0) {
      userId = Long.parseLong(str.nextToken());
      nRatings = Integer.parseInt(str.nextToken());
      songsRatings.clear();
      totalRate = 0;
    } else {
      long songId = Long.parseLong(str.nextToken());
      int rate = Integer.parseInt(str.nextToken());
      songsRatings.add(new PostingSong(songId, rate));
      totalRate += rate;
      nRatings--;
      if (nRatings == 0) {
        nRatings = songsRatings.size();
        songsValue.setArray(songsRatings);
        output.collect(userIdKey, songsValue);
        nRatings = 0;
      }
    }
  }
 @Override
 public void sink(FlowProcess<JobConf> fp, SinkCall<Object[], OutputCollector> sink)
     throws IOException {
   TupleEntry tuple = sink.getOutgoingEntry();
   OutputCollector outputCollector = sink.getOutput();
   outputCollector.collect(null, tuple);
 }
Beispiel #3
0
    public void map(
        Object key, Text value, OutputCollector<IntWritable, Text> output, Reporter reporter)
        throws IOException {

      // vid neighbors_num n1 n2 ...
      // vid color 1/0 "COLOR"
      String str = value.toString();
      if (str.endsWith(COLOR)) {
        // color table
        String[] tokens = str.substring(0, str.length() - 5).split("\\s+");
        int change = Integer.parseInt(tokens[2]);
        if (change == 1) {
          IntWritable SourceId = new IntWritable(Integer.parseInt(tokens[0]));
          StringBuilder sb = new StringBuilder();
          sb.append(tokens[1]);
          sb.append(" ");
          sb.append(tokens[2]);
          sb.append(COLOR);
          output.collect(SourceId, new Text(sb.toString()));
        }
      } else {
        // edge table
        String[] tokens = value.toString().split("\\s+");
        IntWritable SourceId = new IntWritable(Integer.parseInt(tokens[0]));
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i < tokens.length; i++) {
          if (sb.length() != 0) sb.append(" ");
          sb.append(tokens[i]);
        }
        output.collect(SourceId, new Text(sb.toString()));
      }
    }
Beispiel #4
0
    public void reduce(
        IntWritable key,
        Iterator<Text> values,
        OutputCollector<IntWritable, Text> output,
        Reporter reporter)
        throws IOException {
      int color = -1;
      int newColor = Integer.MAX_VALUE;
      int change = 0;
      while (values.hasNext()) {
        String str = values.next().toString();
        if (str.endsWith(COLOR)) {
          // color table
          String[] tmp = str.substring(0, str.length() - 5).split("\\s+");
          color = Integer.parseInt(tmp[0]);

          output.collect(key, new Text(str));
        } else {
          // messages table
          String[] tmp = str.split("\\s+");
          for (String i : tmp) {
            int tmpColor = Integer.parseInt(i);
            if (tmpColor < newColor) newColor = tmpColor;
          }
        }
      }
      if (newColor < Integer.MAX_VALUE) {
        output.collect(key, new Text(Integer.toString(newColor)));
      }
    }
    public void map(
        LongWritable key,
        Text value,
        OutputCollector<JoinRecordKey, JoinRecordValue> output,
        Reporter reporter)
        throws IOException {

      // create a string from the 1-character field separator;
      // since this is a ^A, it should be a regex for itself.
      char[] fieldSepChars = new char[1];
      fieldSepChars[0] = FIELD_SEPARATOR;
      String[] parts = value.toString().split(new String(fieldSepChars));

      if (parts.length >= MINIMUM_PARTS) {
        try {
          // get the int components on this line.
          int[] asInts = getInts(parts);

          if (parts.length == IP_ONLY_LENGTH) {
            // it's just an IP address
            output.collect(new JoinRecordKey(asInts), JoinRecordValue.getLogEntryInstance());
          } else if (parts.length == CITY_ID_LENGTH) {
            // it's an ip address and also the (city, country) ids
            output.collect(new JoinRecordKey(asInts), new JoinRecordValue(asInts[3], asInts[4]));
          }
        } catch (NumberFormatException nfe) {
          // unparsible line. do nothing, since we skipped
          // the uses of asInts by throwing to here.
        }
      }
    }
Beispiel #6
0
    public void reduce(
        Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {
      String rKey = key.toString();
      String[] keyTokens = rKey.split("\\$\\$");
      String reduceType = keyTokens[0];

      // Main reduce
      if (AccessReduceTypeEnum.MAIN.toString().equals(reduceType)) {
        long useTime = 0l;
        long pv = 0l;
        while (values.hasNext()) {
          pv++;
          Text rValue = values.next();
          useTime += Long.parseLong(rValue.toString());
        }
        Text outKey = new Text(rKey);
        Text outValue = new Text(pv + spliter + useTime);
        output.collect(outKey, outValue);
      } else {
        long num = 0l;
        while (values.hasNext()) {
          values.next();
          num++;
        }
        Text outKey = new Text(rKey);
        Text outValue = new Text(String.valueOf(num));
        output.collect(outKey, outValue);
      }
    }
Beispiel #7
0
    @Override
    public void reduce(
        Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {

      String line = "";
      String header = "";
      TreeMap<String, String> ciudades = new TreeMap<String, String>();

      // Obtenemos los datos y los metemos a un treemap para que los ordene por ciudad
      while (values.hasNext()) {
        String[] tmp = values.next().toString().split(",");
        String ciudad = tmp[0];
        String mes = tmp[1];
        String temperatura = tmp[2];
        String fecha = tmp[3];

        ciudades.put(ciudad, tmp[1] + "," + tmp[2] + "," + tmp[3]);
      }

      // Recorremos las ciudades y vamos imprimiendo
      for (String ciudad : ciudades.keySet()) {
        header += ciudad + ",,";
        String[] temporal = ciudades.get(ciudad).split(",");
        line += temporal[2] + "," + temporal[1] + ",";
      }

      if (c == 0) { // Imprimimos cabezera
        output.collect(new Text("Año,"), new Text(header));
        c++;
      }

      output.collect(new Text(key.toString() + ","), new Text(line));
    }
Beispiel #8
0
    public void map(
        LongWritable lineid, Text nodetxt, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {
      Node node = new Node();
      node.fromNodeMsg(nodetxt.toString());

      List<String> bubbles = node.getBubbles();
      if (bubbles != null) {
        for (String bubble : bubbles) {
          String[] vals = bubble.split("\\|");
          String minor = vals[0];
          String minord = vals[1];
          String dead = vals[2];
          String newd = vals[3];
          String newid = vals[4];
          String extracov = vals[5];

          output.collect(
              new Text(minor),
              new Text(
                  Node.KILLLINKMSG + "\t" + minord + "\t" + dead + "\t" + newd + "\t" + newid));

          output.collect(new Text(dead), new Text(Node.KILLMSG));
          output.collect(new Text(newid), new Text(Node.EXTRACOV + "\t" + extracov));

          reporter.incrCounter("Contrail", "bubblespopped", 1);
        }

        node.clearBubbles();
      }

      output.collect(new Text(node.getNodeId()), new Text(node.toNodeMsg()));
      reporter.incrCounter("Contrail", "nodes", 1);
    }
    public void map(
        LongWritable lineid, Text nodetxt, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {
      Node node = new Node();
      node.fromNodeMsg(nodetxt.toString());

      for (String adj : Node.dirs) {
        node.setCanCompress(adj, false);

        TailInfo next = node.gettail(adj);

        if (next != null /*&& node.getBlackEdges() == null*/) {
          if (next.id.equals(node.getNodeId())) {
            continue;
          }

          reporter.incrCounter("Brush", "remotemark", 1);

          output.collect(
              new Text(next.id), new Text(Node.HASUNIQUEP + "\t" + node.getNodeId() + "\t" + adj));
        }
      }

      output.collect(new Text(node.getNodeId()), new Text(node.toNodeMsg()));

      reporter.incrCounter("Brush", "nodes", 1);
    }
    void search(
        Vector<Star> v1,
        Vector<Star> v2,
        BlockIDWritable key,
        OutputCollector<BlockIDWritable, PairWritable> output)
        throws IOException {
      for (int i = 0; i < v1.size(); i++) {
        for (int j = 0; j < v2.size(); j++) {
          Star star1 = v1.get(i);
          Star star2 = v2.get(j);
          // what is this margin about
          if (star1.margin && star2.margin) continue;

          double dist = star1.x * star2.x + star1.y * star2.y + star1.z * star2.z;
          if (dist > costheta) {
            p.set(star1, star2, dist);
            output.collect(key, p);
            p.set(star2, star1, dist);
            output.collect(key, p);
            //		num += 2;

          }
        }
      } // end for i,j
    }
Beispiel #11
0
    /**
     * Map method.
     *
     * @param offset samples starting from the (offset+1)th sample.
     * @param size the number of samples for this map
     * @param out output {ture->numInside, false->numOutside}
     * @param reporter
     */
    public void map(
        LongWritable offset,
        LongWritable size,
        OutputCollector<BooleanWritable, LongWritable> out,
        Reporter reporter)
        throws IOException {

      final HaltonSequence haltonsequence = new HaltonSequence(offset.get());
      long numInside = 0L;
      long numOutside = 0L;

      for (long i = 0; i < size.get(); ) {
        // generate points in a unit square
        final double[] point = haltonsequence.nextPoint();

        // count points inside/outside of the inscribed circle of the square
        final double x = point[0] - 0.5;
        final double y = point[1] - 0.5;
        if (x * x + y * y > 0.25) {
          numOutside++;
        } else {
          numInside++;
        }

        // report status
        i++;
        if (i % 1000 == 0) {
          reporter.setStatus("Generated " + i + " samples.");
        }
      }

      // output map results
      out.collect(new BooleanWritable(true), new LongWritable(numInside));
      out.collect(new BooleanWritable(false), new LongWritable(numOutside));
    }
Beispiel #12
0
    public void map(
        WritableComparable key,
        Writable value,
        OutputCollector<WritableComparable, Writable> collector,
        Reporter reporter)
        throws IOException {
      LOG.info("Start Map");
      if (err != null) {
        throw err;
      }

      DecimalFormat df = new DecimalFormat("00000000000000000000");

      collector.collect(new Text(tableName), new Text(""));

      for (long i = 0; i < 50000; i++) {
        long randNum = rand.nextLong();
        Row.Key rowKey = new Row.Key(df.format(randNum));
        Row row = new Row(rowKey);
        row.addCell("Col1", new Cell(Cell.Key.EMPTY_KEY, this.data));
        ctable.put(row);
        if (i % 1000 == 0) {
          reporter.progress();
        }

        if (i % 10000 == 0) {
          LOG.info("uploaded: " + i);
        }
        collector.collect(new Text(df.format(randNum)), new Text(""));
      }

      LOG.info("End Map");
    }
 @Override
 public void reduce(
     GenericKey key,
     Iterator<GenericValue> values,
     OutputCollector<GenericKey, GenericValue> output,
     Reporter reporter)
     throws IOException {
   if (key.getSecondary() < Preprocesser.MINIMUM_ID) { // vector
     output.collect(key, values.next());
     if (values.hasNext()) assert false : "Vectors should not get grouped by combiner: " + key;
   } else { // addend
     reporter.progress();
     int counter = 0;
     float sim = 0;
     HalfPair hp = null;
     while (values.hasNext()) {
       hp = (HalfPair) values.next().get();
       sim += hp.getSimilarity();
       if (counter++ % REPORTER_INTERVAL == 0) reporter.progress();
     }
     if (hp != null) {
       payload.set(hp.getID(), sim);
       outValue.set(payload);
       output.collect(key, outValue);
     } else {
       assert false : "There is nothing to combine!";
     }
   }
 }
 /*
  * (non-Javadoc)
  *
  * @see org.apache.hadoop.mapred.Reducer#reduce(java.lang.Object,
  * java.util.Iterator, org.apache.hadoop.mapred.OutputCollector,
  * org.apache.hadoop.mapred.Reporter)
  *
  * So the first key that the reducer receives is taken as the source
  * node.The paper says any arbitrary node can be chosen as the source
  * node.
  *
  * There is only one reducer so all the keys come to the same reducer.
  * The first key is the source.
  *
  * For source node the output is
  * <Key>\t<neighbor1>,<neighbor2>,<neighbor3>,<neighbor4>|distance|GRAY|source|1
  * The distance is the distance from
  * the parent node. If the distance is modified then it means the parent
  * of the node changedThey source node is GRAY indicating that this is
  * the node from which the processing should startThe 'source' indicates
  * that this is the parent node.
  *
  * For other nodes the output is
  *
  * <Key>\t<neighbor1>,<neighbor2>,<neighbor3>,<neighbor4>|Integer.MAX_VALUE
  * |WHITE|null|0
  *
  * The color of these nodes is white since they are ready to be
  * processed first or they are in the search frontier.The distance is
  * set to some arbitrary number since the node is not yet reached.
  *
  * The null indicates that there is no parent for this node.
  */
 public void reduce(
     Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter reporter)
     throws IOException {
   // TODO Auto-generated method stub
   StringBuffer b = new StringBuffer();
   while (values.hasNext()) b.append(values.next().toString());
   if (!source) {
     output.collect(key, new Text(b.toString() + "|0|GRAY|source|1"));
     source = true;
   } else output.collect(key, new Text(b.toString() + "|Integer.MAX_VALUE|WHITE|null|0"));
 }
    /**
     * MAPPING FUNCTION.
     *
     * @param key Text which is the document link.
     * @param value MapReduceNode which represents a document
     * @param output Map from each link URL or a special key (Text) and final page rank.
     *     (DoubleWritable)
     */
    @Override
    public void map(
        Text key,
        MapReduceNode value,
        OutputCollector<Text, DoubleWritable> output,
        Reporter reporter)
        throws IOException {

      DoubleWritable pageRank = value.getCurrentPageRank();
      output.collect(key, pageRank);
      output.collect(special_key, pageRank);
    }
    /**
     * @param key the input file
     * @param value population of candiates
     * @param output output to reducer
     * @param reporter for reporting purposes
     * @throws IOException
     */
    @Override
    public void map(
        Text key,
        Population value,
        OutputCollector<Text, BooleanWritable> output,
        Reporter reporter)
        throws IOException {
      try {

        try {

          /**
           * evolve the population of candidates of size (popsize) untill there is a match to the
           * key (problem)
           */
          solution =
              Population.evolveSolution(key.toString(), popsize, Population.generatedpopulation);

          /** return the result of the best solution found */
          result = EvolutionStalker.populationUpdates(EvolutionStalker.output);

          /** if solution found, output the best solution to reducer */
          if (solution.contentEquals(key.toString())) {
            found = true; // set found to true
            result = EvolutionStalker.populationUpdates(EvolutionStalker.output);
            output.collect(
                new Text(result), new BooleanWritable(found)); // emit best solution to reducer

          } else {

            result = EvolutionStalker.populationUpdates(EvolutionStalker.output);
            output.collect(new Text(result), new BooleanWritable(found));
          }
        } catch (NumberFormatException e) {
          log.warning("Unable to parse key," + key + " " + value + "" + e);

          // return;

        }

      } catch (Throwable e) {
        log.severe(
            "unexpected exception in mapper for key," + "value " + key + "," + value + "" + e);

        if (e instanceof IOException) {
          throw (IOException) e;
        }
        if (e instanceof RuntimeException) {
          throw (RuntimeException) e;
        }
        throw new IOException("unknown Exception occured", e);
      }
    }
Beispiel #17
0
    public void map(
        LongWritable arg0,
        Text value,
        OutputCollector<LongWritable, LongWritable> output,
        Reporter arg3)
        throws IOException {
      String v = value.toString();
      int edgeCount = v.trim().split(" |,").length;

      // This is corresponding to the edges
      output.collect(new LongWritable(-1), new LongWritable(edgeCount));
      // This is corresponding to the vertices. FOr each vertex we emit <-2,1> KV pair
      output.collect(new LongWritable(-2), new LongWritable(1));
    }
    @SuppressWarnings("unchecked")
    public void reduce(
        Text key,
        Iterator<Text> values,
        OutputCollector<NullWritable, Text> output,
        Reporter reporter)
        throws IOException {

      OutputCollector collector =
          multipleOutputs.getCollector("station", key.toString().replace("-", ""), reporter);
      while (values.hasNext()) {
        collector.collect(NullWritable.get(), values.next());
      }
    }
Beispiel #19
0
    public void reduce(
        IntWritable key,
        Iterator<HITSNode> values,
        OutputCollector<IntWritable, HITSNode> output,
        Reporter reporter)
        throws IOException {
      // ArrayListOfIntsWritable adjList = new ArrayListOfIntsWritable();
      adjList.clear();

      // System.out.println(key.toString());
      // System.out.println(adjList.toString());
      while (values.hasNext()) {
        valIn = values.next();
        ArrayListOfIntsWritable adjListIn = valIn.getAdjacencyList();
        adjListIn.trimToSize();
        adjList.addAll(adjListIn.getArray());
        // System.out.println(adjList.toString());
      }

      valOut.setType(HITSNode.TYPE_AUTH_COMPLETE);
      valOut.setHARank((float) 0.0);
      valOut.setAdjacencyList(adjList);
      valOut.setNodeId(key.get());

      output.collect(key, valOut);
    }
 @Override
 public void reduce(
     Text moviePair, Iterator<Text> ratings, OutputCollector<Text, Text> output, Reporter reporter)
     throws IOException {
   ArrayList<Double> ratings1 = new ArrayList<Double>();
   ArrayList<Double> ratings2 = new ArrayList<Double>();
   double numRatings = 0;
   double totRating1 = 0, totrating2 = 0;
   while (ratings.hasNext()) {
     String[] rating = ratings.next().toString().split(",");
     ratings1.add(Double.parseDouble(rating[0]));
     ratings2.add(Double.parseDouble(rating[1]));
     totRating1 += Double.parseDouble(rating[0]);
     totrating2 += Double.parseDouble(rating[1]);
     numRatings += 1;
   }
   double avgRating1 = totRating1 / numRatings;
   double avgRating2 = totrating2 / numRatings;
   double sum1 = 0.0, sum2 = 0.0, sumProduct = 0.0;
   for (int i = 0; i < numRatings; i++) {
     sum1 += Math.pow((ratings1.get(i) - avgRating1), 2);
     sum2 += Math.pow((ratings2.get(i) - avgRating2), 2);
     sumProduct += (ratings1.get(i) - avgRating1) * (ratings2.get(i) - avgRating2);
   }
   double corr = sumProduct / (Math.sqrt(sum1) * Math.sqrt(sum2));
   System.out.println(sum1 + "," + sum2 + "," + sumProduct + "," + corr);
   if (Double.isNaN(corr)) {
     corr = 0;
   }
   output.collect(moviePair, new Text(corr + ""));
 }
  public void reduce(
      Text key,
      Iterator<NutchWritable> values,
      OutputCollector<Text, Text> output,
      Reporter reporter)
      throws IOException {
    StringBuffer dump = new StringBuffer();

    dump.append("\nRecno:: ").append(recNo++).append("\n");
    dump.append("URL:: " + key.toString() + "\n");
    while (values.hasNext()) {
      Writable value = values.next().get(); // unwrap
      if (value instanceof CrawlDatum) {
        dump.append("\nCrawlDatum::\n").append(((CrawlDatum) value).toString());
      } else if (value instanceof Content) {
        dump.append("\nContent::\n").append(((Content) value).toString());
      } else if (value instanceof ParseData) {
        dump.append("\nParseData::\n").append(((ParseData) value).toString());
      } else if (value instanceof ParseText) {
        dump.append("\nParseText::\n").append(((ParseText) value).toString());
      } else if (LOG.isWarnEnabled()) {
        LOG.warn("Unrecognized type: " + value.getClass());
      }
    }
    output.collect(key, new Text(dump.toString()));
  }
    @Override
    public void reduce(
        IntWritable key,
        Iterator<Text> values,
        OutputCollector<IntWritable, Text> output,
        Reporter reporter)
        throws IOException {
      List<Text> list = new ArrayList<Text>();
      while (values.hasNext()) {
        // Iteratorの要素は参照が再利用される実装であるため、別途Textをnewする必要がある。
        list.add(new Text(values.next()));
      }
      // ageでソート
      Collections.sort(
          list,
          new Comparator<Text>() {

            private EmployeeRecordParser parser1 = new EmployeeRecordParser();
            private EmployeeRecordParser parser2 = new EmployeeRecordParser();

            @Override
            public int compare(Text o1, Text o2) {
              parser1.parse(o1);
              parser2.parse(o2);
              return Integer.valueOf(parser1.getEmployeeAge()).compareTo(parser2.getEmployeeAge());
            }
          });
      for (Text value : list) {
        output.collect(key, value);
      }
    }
 @Override
 public void map(
     Object key, Text value, OutputCollector<IntWritable, Text> output, Reporter reporter)
     throws IOException {
   parser.parse(value);
   output.collect(new IntWritable(parser.getDepartmentId()), value);
 }
Beispiel #24
0
 public void reduce(
     MyType key, Iterator<Text> iter, OutputCollector<MyType, Text> oc, Reporter reporter)
     throws IOException {
   while (iter.hasNext()) {
     oc.collect(null, iter.next());
   }
 }
Beispiel #25
0
    // specify input and out keys
    public void map(
        LongWritable key, Text value, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {
      String line = value.toString(); // define new variable to be string

      ArrayList<Integer> range = new ArrayList<Integer>();
      for (int i = 2000; i <= 2010; i++) {
        range.add(i);
      }

      // String[] inputs = line.split(",(?=([^\"]*\"[^\"]*\")*[^\"]*$)");
      String[] inputs = line.split(",");

      try {

        int year = Integer.parseInt(inputs[165]);

        if (range.contains(year)) {
          String dur = inputs[3];
          String artist_name = inputs[2];
          String song_title = inputs[1];
          String final_input = artist_name + ',' + dur + ',' + song_title;
          Final_Value.set(final_input);
          output.collect(Final_Value, dummy);
        }
      } catch (NumberFormatException e) {
        // do nothing
      }
    }
    /**
     * {@inheritDoc}
     *
     * @see org.apache.hadoop.mapred.Mapper#map(java.lang.Object, java.lang.Object,
     *     org.apache.hadoop.mapred.OutputCollector, org.apache.hadoop.mapred.Reporter)
     */
    @Override
    public void map(
        LongWritable key, Text value, OutputCollector<Text, IntWritable> output, Reporter reporter)
        throws IOException {
      String line = m_caseSensitive ? value.toString() : value.toString().toLowerCase();

      for (String pattern : m_patternsToSkip) {
        line = line.replaceAll(pattern, "");
      }

      StringTokenizer tokenizer = new StringTokenizer(line);
      while (tokenizer.hasMoreTokens()) {
        m_word.set(tokenizer.nextToken());
        output.collect(m_word, ONE);
        reporter.incrCounter(Counters.INPUT_WORDS, 1);
      }

      if ((++m_numRecords % 100) == 0) {
        reporter.setStatus(
            "Finished processing "
                + m_numRecords
                + " records "
                + "from the input file: "
                + m_inputFile);
      }
    }
Beispiel #27
0
    /** Run a FileOperation */
    public void map(
        Text key,
        PolicyInfo policy,
        OutputCollector<WritableComparable, Text> out,
        Reporter reporter)
        throws IOException {
      this.reporter = reporter;
      try {
        LOG.info("Raiding file=" + key.toString() + " policy=" + policy);
        Path p = new Path(key.toString());
        FileStatus fs = p.getFileSystem(jobconf).getFileStatus(p);
        st.clear();
        RaidNode.doRaid(jobconf, policy, fs, st, reporter);

        ++succeedcount;

        reporter.incrCounter(Counter.PROCESSED_BLOCKS, st.numProcessedBlocks);
        reporter.incrCounter(Counter.PROCESSED_SIZE, st.processedSize);
        reporter.incrCounter(Counter.META_BLOCKS, st.numMetaBlocks);
        reporter.incrCounter(Counter.META_SIZE, st.metaSize);

        reporter.incrCounter(Counter.FILES_SUCCEEDED, 1);
      } catch (IOException e) {
        ++failcount;
        reporter.incrCounter(Counter.FILES_FAILED, 1);

        String s = "FAIL: " + policy + ", " + key + " " + StringUtils.stringifyException(e);
        out.collect(null, new Text(s));
        LOG.info(s);
      } finally {
        reporter.setStatus(getCountString());
      }
    }
    public void map(
        LongWritable key,
        Text t,
        OutputCollector<IntWritable, PageRankNode> output,
        Reporter reporter)
        throws IOException {

      String[] arr = t.toString().trim().split("\\s+");

      nid.set(Integer.parseInt(arr[0]));
      if (arr.length == 1) {
        node.setNodeId(Integer.parseInt(arr[0]));
        node.setAdjacencyList(new ArrayListOfIntsWritable());

      } else {
        node.setNodeId(Integer.parseInt(arr[0]));

        int[] neighbors = new int[arr.length - 1];
        for (int i = 1; i < arr.length; i++) {
          neighbors[i - 1] = Integer.parseInt(arr[i]);
        }

        node.setAdjacencyList(new ArrayListOfIntsWritable(neighbors));
      }

      reporter.incrCounter("graph", "numNodes", 1);
      reporter.incrCounter("graph", "numEdges", arr.length - 1);

      if (arr.length > 1) {
        reporter.incrCounter("graph", "numActiveNodes", 1);
      }

      output.collect(nid, node);
    }
Beispiel #29
0
    public void map(
        LongWritable key,
        Text value,
        OutputCollector<IntWritable, HITSNode> output,
        Reporter reporter)
        throws IOException {

      ArrayListOfIntsWritable links = new ArrayListOfIntsWritable();
      String line = ((Text) value).toString();
      StringTokenizer itr = new StringTokenizer(line);
      if (itr.hasMoreTokens()) {
        int curr = Integer.parseInt(itr.nextToken());
        if (stopList.contains(curr)) {
          return;
        }
        valOut.setAdjacencyList(links);
        valOut.setHARank((float) 1.0);
        valOut.setType(HITSNode.TYPE_AUTH_COMPLETE);
      }
      while (itr.hasMoreTokens()) {
        keyOut.set(Integer.parseInt(itr.nextToken()));
        valOut.setNodeId(keyOut.get());
        // System.out.println(keyOut.toString() + ", " +
        // valOut.toString());
        if (!(stopList.contains(keyOut.get()))) {
          output.collect(keyOut, valOut);
        }
      }
      // emit mentioned mentioner -> mentioned (mentioners) in links
      // emit mentioner mentioned -> mentioner (mentions) outlinks
      // emit mentioned a
      // emit mentioner 1
    }
  public void reduce(
      CompositeKey key,
      Iterator<PairOfLongInt> values,
      OutputCollector<Text, Text> output,
      Reporter reporter)
      throws IOException {

    // note that values are sorted (by using MR's secondary sort)
    // below, builder will generate:
    //    CustoerID,Date1,Amount1,Date2,Amount2,...,DateN,AmountN
    // where Date1 <= Date2 <= ... <= DateN
    StringBuilder builder = new StringBuilder();
    builder.append(key.toString());
    while (values.hasNext()) {
      builder.append(",");
      PairOfLongInt pair = values.next();
      long timestamp = pair.getLeftElement(); // date as milliseconds
      String date = DateUtil.getDateAsString(timestamp);
      builder.append(date); // date as String		
      builder.append(",");
      builder.append(pair.getRightElement()); // amount
    }

    output.collect(null, new Text(builder.toString()));
  } // reduce