Beispiel #1
0
  /*
   * (non-Javadoc)
   * @see com.almende.eve.agent.AgentCore#onReady()
   */
  public void onReady() {
    DateTime now = DateTime.now();
    super.onReady();

    LOG.warning("OnReady called!");
    schedule("repeatTest", null, now.plusMillis(400));
    schedule("repeatTest", null, now.plusMillis(400));
    schedule("repeatTest", null, now.plusMillis(400));
    schedule("repeatTest", null, now.plusMillis(400));
  }
Beispiel #2
0
  public static String formatUTCToLocal(String datetime) {
    String returnTimeDate = "";
    DateTime dtUTC = null;
    DateTimeZone timezone = DateTimeZone.getDefault();
    DateTimeFormatter formatDT = DateTimeFormat.forPattern("MMM dd, yyyy  hh:mma");

    try {
      DateTime dateDateTime1 = formatDT.parseDateTime(datetime);
      DateTime now = new DateTime();
      DateTime nowUTC = new LocalDateTime(now).toDateTime(DateTimeZone.UTC);
      long instant = now.getMillis();
      long instantUTC = nowUTC.getMillis();
      long offset = instantUTC - instant;

      // convert to local time
      dtUTC = dateDateTime1.withZoneRetainFields(DateTimeZone.UTC);
      // dtUTC = dateDateTime1.toDateTime(timezone);
      dtUTC = dtUTC.plusMillis((int) offset);

      returnTimeDate = dtUTC.toString(formatDT);
    } catch (Exception e) {
      returnTimeDate = "null";
      e.printStackTrace();
    }
    return returnTimeDate;
  }
Beispiel #3
0
 private void logProgress(final long count, final long total, final DateTime begin) {
   DateTime current = DateTime.now();
   long duration = current.getMillis() - begin.getMillis();
   int rate = (int) (count / duration) + 1;
   int remaining = (int) ((total - count) / rate);
   DateTime done = current.plusMillis(remaining);
   System.out.printf(
       "Imported %d of %d (%.2f%%).  Estimated completion time: %s\n",
       count, total, 100.0 * count / total, done.toString("HH:mm:ss"));
 }
  private SignalTimeHolder getNextTimeForOffsetType(
      SignalTime signalTime, List<SignalTimeHolder> previousTimes, Long experimentId) {
    if (previousTimes.size() == 0) {
      return createNullSignalTimeHolder(
          signalTime); // we don't allow offset types as the first signalTime
    }

    SignalTimeHolder previousTimePair = previousTimes.get(previousTimes.size() - 1);
    DateTime basis = computeBasisTimeForOffsetType(signalTime, previousTimePair, experimentId);
    if (basis != null) {
      DateTime chosenTime = basis.plusMillis(signalTime.getOffsetTimeMillis());
      return new SignalTimeHolder(null, null, chosenTime, signalTime);
    } else {
      return createNullSignalTimeHolder(signalTime);
    }
  }
  @Test
  public void testOthersCallOutOfBounds_OtherIsMax() {
    DateTime instant = new DateTime(2013, 9, 20, 4, 40, 11);

    BigDecimal expectedResult = new BigDecimal("15.00");
    BigDecimal actualResult =
        executeGetInvoice(
                callee,
                join(
                    generateSMS("007", "008", instant, HOUR, 10),
                    generateSMS("007", "008", instant, HOUR + 20, 10),
                    generateSMS("007", "any", instant.plusMillis(HOUR * 11 + 100), 0, 1)),
                billingPeriod,
                callee,
                called)
            .getAmount();

    assertEquals(expectedResult, actualResult);
  }
 public TimelineSourceEventAccumulator(
     final TimelineDao dao,
     final TimelineCoder timelineCoder,
     final SampleCoder sampleCoder,
     final BackgroundDBChunkWriter backgroundWriter,
     final int sourceId,
     final int eventCategoryId,
     final DateTime firstSampleTime,
     final Integer timelineLengthMillis) {
   this.timelineLengthMillis = timelineLengthMillis;
   this.backgroundWriter = backgroundWriter;
   this.timelineCoder = timelineCoder;
   this.sampleCoder = sampleCoder;
   this.sourceId = sourceId;
   this.eventCategoryId = eventCategoryId;
   // Set the end-of-chunk time by tossing a random number, to evenly distribute the db writeback
   // load.
   this.chunkEndTime =
       timelineLengthMillis != null
           ? firstSampleTime.plusMillis(rand.nextInt(timelineLengthMillis))
           : null;
 }
Beispiel #7
0
  /**
   * 计算指定时间之后的日期
   *
   * @param date 待计算时间
   * @param random 待计算数
   * @param timeType 时间类型枚举
   * @see org.codingsills.modules.utils.DateKit.TimeType
   * @return Date
   */
  public static Date nextDate(Date date, int random, TimeType timeType) {
    Date nextDate = null;
    if (date == null) {
      return nextDate;
    }
    DateTime dateTime = fromDate(date);
    random = Math.abs(random);
    switch (timeType.getCode()) {
      case "Y":
        nextDate = dateTime.plusYears(random).toDate();
        break;
      case "M":
        nextDate = dateTime.plusMonths(random).toDate();
        break;
      case "W":
        nextDate = dateTime.plusWeeks(random).toDate();
        break;
      case "D":
        nextDate = dateTime.plusDays(random).toDate();
        break;
      case "H":
        nextDate = dateTime.plusHours(random).toDate();
        break;
      case "MIN":
        nextDate = dateTime.plusMinutes(random).toDate();
        break;
      case "S":
        nextDate = dateTime.plusSeconds(random).toDate();
        break;
      case "MS":
        nextDate = dateTime.plusMillis(random).toDate();
        break;
      default:
        break;
    }

    return nextDate;
  }
  @SuppressWarnings("unchecked")
  // TODO - we can probably do better than synchronize the whole method
  public synchronized void addSourceSamples(final SourceSamplesForTimestamp samples) {
    final DateTime timestamp = samples.getTimestamp();

    if (chunkEndTime != null && chunkEndTime.isBefore(timestamp)) {
      extractAndQueueTimelineChunks();
      startTime = timestamp;
      chunkEndTime = timestamp.plusMillis(timelineLengthMillis);
    }

    if (startTime == null) {
      startTime = timestamp;
    }
    if (endTime == null) {
      endTime = timestamp;
    } else if (!timestamp.isAfter(endTime)) {
      log.warn(
          "Adding samples for host {}, timestamp {} is not after the end time {}; ignored",
          new Object[] {sourceId, dateFormatter.print(timestamp), dateFormatter.print(endTime)});
      return;
    }
    sampleSequenceNumber++;
    latestSampleAddTime = new DateTime();
    for (final Map.Entry<Integer, ScalarSample> entry : samples.getSamples().entrySet()) {
      final Integer metricId = entry.getKey();
      final SampleSequenceNumber counter = metricIdCounters.get(metricId);
      if (counter != null) {
        counter.setSequenceNumber(sampleSequenceNumber);
      } else {
        metricIdCounters.put(metricId, new SampleSequenceNumber(sampleSequenceNumber));
      }
      final ScalarSample sample = entry.getValue();
      TimelineChunkAccumulator timeline = timelines.get(metricId);
      if (timeline == null) {
        timeline = new TimelineChunkAccumulator(sourceId, metricId, sampleCoder);
        if (sampleCount > 0) {
          addPlaceholders(timeline, sampleCount);
        }
        timelines.put(metricId, timeline);
      }
      final ScalarSample compressedSample = sampleCoder.compressSample(sample);
      timeline.addSample(compressedSample);
    }
    for (final Map.Entry<Integer, SampleSequenceNumber> entry : metricIdCounters.entrySet()) {
      final SampleSequenceNumber counter = entry.getValue();
      if (counter.getSequenceNumber() < sampleSequenceNumber) {
        counter.setSequenceNumber(sampleSequenceNumber);
        final int metricId = entry.getKey();
        final TimelineChunkAccumulator timeline = timelines.get(metricId);
        timeline.addSample(nullSample);
      }
    }
    // Now we can update the state
    endTime = timestamp;
    sampleCount++;
    times.add(timestamp);

    if (checkEveryAccess) {
      checkSampleCounts(sampleCount);
    }
  }
Beispiel #9
0
  private static RubyTime createTime(IRubyObject recv, IRubyObject[] args, boolean gmt) {
    Ruby runtime = recv.getRuntime();
    int len = ARG_SIZE;
    Boolean isDst = null;

    DateTimeZone dtz;
    if (gmt) {
      dtz = DateTimeZone.UTC;
    } else if (args.length == 10 && args[9] instanceof RubyString) {
      dtz = getTimeZone(runtime, ((RubyString) args[9]).toString());
    } else {
      dtz = getLocalTimeZone(runtime);
    }

    if (args.length == 10) {
      if (args[8] instanceof RubyBoolean) {
        isDst = ((RubyBoolean) args[8]).isTrue();
      }
      args =
          new IRubyObject[] {
            args[5], args[4], args[3], args[2], args[1], args[0], runtime.getNil()
          };
    } else {
      // MRI accepts additional wday argument which appears to be ignored.
      len = args.length;

      if (len < ARG_SIZE) {
        IRubyObject[] newArgs = new IRubyObject[ARG_SIZE];
        System.arraycopy(args, 0, newArgs, 0, args.length);
        for (int i = len; i < ARG_SIZE; i++) {
          newArgs[i] = runtime.getNil();
        }
        args = newArgs;
        len = ARG_SIZE;
      }
    }

    if (args[0] instanceof RubyString) {
      args[0] = RubyNumeric.str2inum(runtime, (RubyString) args[0], 10, false);
    }

    int year = (int) RubyNumeric.num2long(args[0]);
    int month = 1;

    if (len > 1) {
      if (!args[1].isNil()) {
        IRubyObject tmp = args[1].checkStringType();
        if (!tmp.isNil()) {
          String monthString = tmp.toString().toLowerCase();
          Integer monthInt = MONTHS_MAP.get(monthString);

          if (monthInt != null) {
            month = monthInt;
          } else {
            try {
              month = Integer.parseInt(monthString);
            } catch (NumberFormatException nfExcptn) {
              throw runtime.newArgumentError("Argument out of range.");
            }
          }
        } else {
          month = (int) RubyNumeric.num2long(args[1]);
        }
      }
      if (1 > month || month > 12) {
        throw runtime.newArgumentError("Argument out of range: for month: " + month);
      }
    }

    int[] int_args = {1, 0, 0, 0, 0, 0};

    for (int i = 0; int_args.length >= i + 2; i++) {
      if (!args[i + 2].isNil()) {
        if (!(args[i + 2] instanceof RubyNumeric)) {
          args[i + 2] = args[i + 2].callMethod(runtime.getCurrentContext(), "to_i");
        }

        long value = RubyNumeric.num2long(args[i + 2]);
        if (time_min[i] > value || value > time_max[i]) {
          throw runtime.newArgumentError("argument out of range.");
        }
        int_args[i] = (int) value;
      }
    }

    if (!runtime.is1_9()) {
      if (0 <= year && year < 39) {
        year += 2000;
      } else if (69 <= year && year < 139) {
        year += 1900;
      }
    }

    DateTime dt;
    // set up with min values and then add to allow rolling over
    try {
      dt = new DateTime(year, 1, 1, 0, 0, 0, 0, DateTimeZone.UTC);

      dt =
          dt.plusMonths(month - 1)
              .plusDays(int_args[0] - 1)
              .plusHours(int_args[1])
              .plusMinutes(int_args[2])
              .plusSeconds(int_args[3]);
      if (runtime.is1_9() && !args[5].isNil()) {
        double millis = RubyFloat.num2dbl(args[5]);
        int int_millis = (int) (millis * 1000) % 1000;
        dt = dt.plusMillis(int_millis);
      }

      dt = dt.withZoneRetainFields(dtz);

      // we might need to perform a DST correction
      if (isDst != null) {
        // the instant at which we will ask dtz what the difference between DST and
        // standard time is
        long offsetCalculationInstant = dt.getMillis();

        // if we might be moving this time from !DST -> DST, the offset is assumed
        // to be the same as it was just before we last moved from DST -> !DST
        if (dtz.isStandardOffset(dt.getMillis())) {
          offsetCalculationInstant = dtz.previousTransition(offsetCalculationInstant);
        }

        int offset =
            dtz.getStandardOffset(offsetCalculationInstant)
                - dtz.getOffset(offsetCalculationInstant);

        if (!isDst && !dtz.isStandardOffset(dt.getMillis())) {
          dt = dt.minusMillis(offset);
        }
        if (isDst && dtz.isStandardOffset(dt.getMillis())) {
          dt = dt.plusMillis(offset);
        }
      }
    } catch (org.joda.time.IllegalFieldValueException e) {
      throw runtime.newArgumentError("time out of range");
    }

    RubyTime time = new RubyTime(runtime, (RubyClass) recv, dt);
    // Ignores usec if 8 args (for compatibility with parsedate) or if not supplied.
    if (args.length != 8 && !args[6].isNil()) {
      int usec = int_args[4] % 1000;
      int msec = int_args[4] / 1000;

      if (int_args[4] < 0) {
        msec -= 1;
        usec += 1000;
      }
      time.dt = dt.withMillis(dt.getMillis() + msec);
      time.setUSec(usec);
    }

    time.callInit(IRubyObject.NULL_ARRAY, Block.NULL_BLOCK);
    return time;
  }
Beispiel #10
0
 private double gScore(FakeNode node) {
   return node.node.cost.getCost(
           startTime.plusMillis((int) Math.round((currentNode.g_scores * 1000.0))))
       + currentNode.g_scores;
 }
 public synchronized DateTime addmillisecond() {
   systemDate = systemDate.plusMillis(1);
   return systemDate;
 }
 public synchronized DateTime addmilliseconds(int milliseconds) {
   systemDate = systemDate.plusMillis(milliseconds);
   return systemDate;
 }