/**
   * Get the behaviour for the activity specified
   *
   * @param toActivity the activity to get the activity for
   * @param <K> the type of the activity
   * @return the behaviour or null if no behaviour was found
   */
  public <K extends IActivity> Behaviour<K> getBehaviourFor(K toActivity) {
    // First check for a live behaviour
    if (m_oActivityMap != null && m_oActivityMap.containsKey(toActivity)) {
      return (Behaviour<K>) m_oActivityMap.get(toActivity);
    }

    if (m_oBehaviourMap != null && m_oBehaviourMap.containsKey(toActivity.getClass())) {
      List<Class<? extends Behaviour<? extends IActivity>>> loBehaviours =
          m_oBehaviourMap.get(toActivity.getClass());
      for (Class<? extends Behaviour<? extends IActivity>> loBehaviourClass : loBehaviours) {
        try {
          Behaviour<K> loBehaviour = (Behaviour<K>) loBehaviourClass.newInstance();
          if (loBehaviour.isValid(toActivity)) {
            if (m_oActivityMap == null) {
              m_oActivityMap = new HashMap<IActivity, Behaviour<? extends IActivity>>();
            }
            m_oActivityMap.put(toActivity, loBehaviour);
            return loBehaviour;
          }
        } catch (InstantiationException ex) {
          Application.log(ex);
        } catch (IllegalAccessException ex) {
          Application.log(ex);
        }
      }
    }
    return null;
  }
 private void checkKey(K keyObject) {
   if (keyObject == null) {
     throw new NullPointerException();
   }
   if (!keyType.isAssignableFrom(keyObject.getClass())) {
     throw new ClassCastException(
         "Invalid key type, expected : "
             + keyType.getName()
             + " but was : "
             + keyObject.getClass().getName());
   }
 }
 /**
  * Return the persistent instance of the given entity class with the given identifier, or null if
  * there is no such persistent instance. (If the instance is already associated with the session,
  * return that instance. This method never returns an uninitialized instance.)
  *
  * @param id an identifier
  * @return a persistent instance or null
  * @throws HibernateException Indicates a problem either translating the criteria to SQL,
  *     executing the SQL or processing the SQL results.
  */
 @SuppressWarnings("unchecked")
 public T getById(K id) {
   T result = null;
   Session session = null;
   // get the current session
   session = sessionFactory.getCurrentSession();
   try {
     // perform database access (query, insert, update, etc) here
     try {
       if (id.getClass().getName().startsWith(this.getClass().getPackage().getName())) {
         result = clazz.newInstance();
         result.setId(id);
         result = (T) session.get(clazz, result);
       } else {
         result = (T) session.get(clazz, id);
       }
     } catch (InstantiationException e) {
       result = (T) session.get(clazz, id);
     } catch (IllegalAccessException e) {
       result = (T) session.get(clazz, id);
     }
   } catch (HibernateException e) {
     exceptionHandling(e, session);
   }
   // return result, if needed
   return result;
 }
 /**
  * JavaPropertyManager stored data as strings at the moment, so need to convert to the correct
  * type here
  *
  * @param taPath the path of the property to get
  * @param toDefault the default value of the property
  * @param <K> the type of the value
  * @return the value or null if there was no value of this type
  */
 @SuppressWarnings("unchecked")
 @Override
 protected <K> K onGetProperty(String[] taPath, K toDefault) {
   K loReturn = onGetProperty(taPath);
   if (loReturn == null) {
     setProperty(taPath, toDefault);
     loReturn = toDefault;
   } else {
     loReturn = (K) Java.stringToPrimitive((String) loReturn, toDefault.getClass());
   }
   return loReturn;
 }
 public void initialize(InputSplit split, TaskAttemptContext context)
     throws IOException, InterruptedException {
   rr.initialize(split, context);
   conf = context.getConfiguration();
   nextKeyValue();
   if (!empty) {
     keyclass = key.getClass().asSubclass(WritableComparable.class);
     valueclass = value.getClass();
     if (cmp == null) {
       cmp = WritableComparator.get(keyclass, conf);
     }
   }
 }
  private String buildSolrId(K key) {
    JsonObject jsonKey = new JsonObject();
    if (key instanceof String) {
      jsonKey.putString("C", "S");
      jsonKey.putString("V", (String) key);
    } else {
      jsonKey.putString("C", key.getClass().getName());
      jsonKey.putString("V", JsonObject.toJson(key));
    }
    String id = _mapName + ":" + jsonKey.encode();

    return id;
  }
 /** For a given RecordReader rr, occupy position id in collector. */
 WrappedRecordReader(int id, RecordReader<K, U> rr, Class<? extends WritableComparator> cmpcl)
     throws IOException {
   this.id = id;
   this.rr = rr;
   khead = rr.createKey();
   vhead = rr.createValue();
   try {
     cmp = (null == cmpcl) ? WritableComparator.get(khead.getClass()) : cmpcl.newInstance();
   } catch (InstantiationException e) {
     throw (IOException) new IOException().initCause(e);
   } catch (IllegalAccessException e) {
     throw (IOException) new IOException().initCause(e);
   }
   vjoin = new StreamBackedIterator<U>();
   next();
 }
 Node<K, V> find(K key, boolean create) {
   Comparator<? super K> comparator = this.comparator;
   Node<K, V> nearest = this.root;
   int comparison = 0;
   if (nearest != null) {
     Comparable<Object> comparableKey = comparator == NATURAL_ORDER ? (Comparable) key : null;
     while (true) {
       comparison =
           comparableKey != null
               ? comparableKey.compareTo(nearest.key)
               : comparator.compare(key, nearest.key);
       if (comparison == 0) {
         return nearest;
       }
       Node<K, V> child = comparison < 0 ? nearest.left : nearest.right;
       if (child == null) {
         break;
       }
       nearest = child;
     }
   }
   if (!create) {
     return null;
   }
   Node<K, V> created;
   Node<K, V> header = this.header;
   if (nearest != null) {
     created = new Node(nearest, key, header, header.prev);
     if (comparison < 0) {
       nearest.left = created;
     } else {
       nearest.right = created;
     }
     rebalance(nearest, true);
   } else if (comparator != NATURAL_ORDER || (key instanceof Comparable)) {
     created = new Node(nearest, key, header, header.prev);
     this.root = created;
   } else {
     throw new ClassCastException(key.getClass().getName() + " is not Comparable");
   }
   this.size++;
   this.modCount++;
   return created;
 }
    @SuppressWarnings("unchecked")
    public synchronized void collect(K key, V value) throws IOException {
      reporter.progress();
      if (key.getClass() != keyClass) {
        throw new IOException(
            "Type mismatch in key from map: expected "
                + keyClass.getName()
                + ", recieved "
                + key.getClass().getName());
      }
      if (value.getClass() != valClass) {
        throw new IOException(
            "Type mismatch in value from map: expected "
                + valClass.getName()
                + ", recieved "
                + value.getClass().getName());
      }
      if (sortSpillException != null) {
        throw (IOException) new IOException("Spill failed").initCause(sortSpillException);
      }
      try {
        // serialize key bytes into buffer
        int keystart = bufindex;
        keySerializer.serialize(key);
        if (bufindex < keystart) {
          // wrapped the key; reset required
          bb.reset();
          keystart = 0;
        }
        // serialize value bytes into buffer
        int valstart = bufindex;
        valSerializer.serialize(value);
        int valend = bb.markRecord();
        mapOutputByteCounter.increment(
            valend >= keystart ? valend - keystart : (bufvoid - keystart) + valend);

        if (keystart == bufindex) {
          // if emitted records make no writes, it's possible to wrap
          // accounting space without notice
          bb.write(new byte[0], 0, 0);
        }

        int partition = partitioner.getPartition(key, value, partitions);
        if (partition < 0 || partition >= partitions) {
          throw new IOException("Illegal partition for " + key + " (" + partition + ")");
        }
        mapOutputRecordCounter.increment(1);

        // update accounting info
        int ind = kvindex * ACCTSIZE;
        kvoffsets[kvindex] = ind;
        kvindices[ind + PARTITION] = partition;
        kvindices[ind + KEYSTART] = keystart;
        kvindices[ind + VALSTART] = valstart;
        kvindex = (kvindex + 1) % kvoffsets.length;
      } catch (MapBufferTooSmallException e) {
        LOG.info("Record too large for in-memory buffer: " + e.getMessage());
        spillSingleRecord(key, value);
        mapOutputRecordCounter.increment(1);
        return;
      }
    }
Exemple #10
0
  @Override
  public MutableFudgeMsg buildMessage(FudgeSerializer serializer, final T auto) {
    MutableFudgeMsg outerMsg = serializer.newMessage();
    outerMsg.add(
        null,
        FudgeSerializer.TYPES_HEADER_ORDINAL,
        FudgeWireType.STRING,
        AutoFudgable.class.getName());
    final K inner = auto.object();
    assertValid(inner.getClass());
    try {
      MutableFudgeMsg msg = outerMsg.addSubMessage("inner", null);
      // save the internal class name
      msg.add(
          null,
          FudgeSerializer.TYPES_HEADER_ORDINAL,
          FudgeWireType.STRING,
          inner.getClass().getName());

      // save the ctor parameters
      List<Object> parameters =
          AccessController.doPrivileged(
              new PrivilegedAction<List<Object>>() {
                @Override
                public List<Object> run() {
                  try {
                    final Constructor<?>[] ctors = inner.getClass().getDeclaredConstructors();
                    // We require that inner classes got only one ctor (anonymous inner classes will
                    // do)
                    // in order to avoid disambiguity
                    if (ctors.length == 1) {
                      final Constructor<?> ctor = ctors[0];
                      // types of parameters of ctor
                      final Class<?>[] parameterTypes = ctor.getParameterTypes();
                      // all declared parameters of the inner class
                      final Field[] fs = inner.getClass().getDeclaredFields();
                      // extracting copiler synthetized fields of inner class
                      // first are the not sinthetized fields (regular ones) we need to skip
                      // then there are compiler synthetized fields with corresponds to ctor
                      // parameters
                      // the last field is the reference to enclosing object so we need to skipp it
                      // as well
                      final Field[] paramFields =
                          Arrays.copyOfRange(fs, fs.length - parameterTypes.length, fs.length - 1);
                      final List<Object> parameters = newArrayList();
                      for (Field paramField : paramFields) {
                        paramField.setAccessible(true);
                        parameters.add(paramField.get(inner));
                      }
                      return parameters;
                    }
                  } catch (IllegalAccessException e) {
                    // Ignore
                  }
                  return null;
                }
              });

      for (Object parameter : parameters) {
        // save the ctor parameter
        serializer.addToMessageWithClassHeaders(msg, null, 1, parameter);
      }
      return outerMsg;

    } catch (RuntimeException ex) {
      throw new FudgeRuntimeException("Unable to serialize: " + inner.getClass().getName(), ex);
    }
  }
 public V resolve(K key) {
   return resolve((Class<? extends K>) key.getClass());
 }
    @Override
    public void map(K key, V value, OutputCollector<K, V> output, Reporter reporter)
        throws IOException {
      // TODO Auto-generated method stub
      // doing the filter

      // <key,value>
      // <[AttemptID/PhaseStack/PhaseAlias],
      // [ThreadName,ThreadId,starttime,endtime,funlist,funcountlist,statelist,statecountlist,funStateMatric]>
      HiTuneRecord valproxy = new HiTuneRecord(value);
      String hostname = valproxy.getHost();
      String status = valproxy.getValue("ThreadState");
      String stack = valproxy.getValue("CallStack");
      String attemptID = valproxy.getValue("TaskID");
      log.debug(
          "hostname:"
              + hostname
              + " ThreadState:"
              + status
              + " stack:"
              + stack
              + " attemptID:"
              + attemptID);
      if (isMatched(this.nodelist, hostname)) {
        for (String s : phasealias.keySet()) {
          log.debug("phasealias:" + s);
          if (s == null || s.length() == 0) s = "";
          Pattern p = Pattern.compile(s);
          if (stack != null && stack.length() != 0) stack = stack.replace(" ", "");
          else stack = "";
          Matcher matcher = p.matcher(stack);
          if (matcher.find()) {
            try {
              log.debug("find pattern");
              K newkey = (K) key.getClass().getConstructor().newInstance();
              V newval = (V) value.getClass().getConstructor().newInstance();

              HiTuneKey newkeyproxy = new HiTuneKey(newkey);
              HiTuneRecord newvalproxy = new HiTuneRecord(newval);

              newkeyproxy.setKey(attemptID + "/" + s + "/" + phasealias.get(s));
              newkeyproxy.setDataType(new HiTuneKey(key).getDataType());
              newvalproxy.copyCommonFields(value);

              newvalproxy.add("thread_id", valproxy.getValue("ThreadID"));
              newvalproxy.add("thread_name", valproxy.getValue("ThreadName"));
              newvalproxy.add("attempt_id", attemptID);
              newvalproxy.add("phase_stack", s);
              newvalproxy.add("phase_name", phasealias.get(s));
              newvalproxy.add("start", "" + newvalproxy.getTime());
              newvalproxy.add("count", "1");
              log.debug("status:" + conf.get("status"));
              newvalproxy.add("statusList", conf.get("status"));
              newvalproxy.add("statusCount", count(status, this.statuslist));

              log.debug("funList:" + this.phases.get(s));
              newvalproxy.add("funList", List2String(this.phases.get(s), SEPERATOR_COMMA));
              newvalproxy.add("funCount", count(stack, this.phases.get(s)));
              newvalproxy.add(
                  AnalysisProcessorConfiguration.jobid,
                  conf.get(AnalysisProcessorConfiguration.jobid));

              log.debug("Key:" + newkeyproxy.toString() + " Record" + newkeyproxy.toString());
              output.collect((K) newkeyproxy.getObject(), (V) newvalproxy.getObject());
            } catch (IllegalArgumentException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            } catch (SecurityException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            } catch (InstantiationException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            } catch (IllegalAccessException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            } catch (InvocationTargetException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            } catch (NoSuchMethodException e) {
              // TODO Auto-generated catch block
              log.warn(e);
              e.printStackTrace();
            }
          }
        }
      }
    }