Example usage for org.joda.time Duration getStandardSeconds

List of usage examples for org.joda.time Duration getStandardSeconds

Introduction

In this page you can find the example usage for org.joda.time Duration getStandardSeconds.

Prototype

public long getStandardSeconds() 

Source Link

Document

Gets the length of this duration in seconds assuming that there are the standard number of milliseconds in a second.

Usage

From source file:brickhouse.udf.date.AddISOPeriodUDF.java

License:Apache License

public String evaluate(String dateString, String dateFormat, String periodString) {
    if (dateString == null) {
        return null;
    }//from   w w w  . j  a v  a  2 s .  c  o  m

    if (dateFormat == null) {
        dateFormat = "YYYY-MM-dd HH:mm:ss";
    }

    DateTimeFormatter dateFormatter = org.joda.time.format.DateTimeFormat.forPattern(dateFormat);
    DateTime input = dateFormatter.parseDateTime(dateString);

    Duration duration = periodFormatter.parsePeriod(periodString).toStandardDuration();
    long seconds = duration.getStandardSeconds();

    DateTime output = input.plusSeconds(Long.valueOf(seconds).intValue());
    return dateFormatter.print(output);
}

From source file:com.anrisoftware.sscontrol.httpd.citadel.nginx_ubuntu_14_04.TimeoutDurationAttributeRenderer.java

License:Open Source License

private String toStringSeconds(Duration duration) {
    StringBuilder builder = new StringBuilder();
    builder.append(duration.getStandardSeconds());
    builder.append("s");
    return builder.toString();
}

From source file:com.anrisoftware.sscontrol.httpd.thin.core.DurationAttributeRenderer.java

License:Open Source License

@Override
public String toString(Object o, String formatString, Locale locale) {
    Duration duration = (Duration) o;
    return Long.toString(duration.getStandardSeconds());
}

From source file:com.application.actify.lifecycle.ActivityFragment.java

License:Apache License

private void inflateTimerRow(final ActivityInstance ai, final ActivityPause ap) {
    scroller.setBackgroundResource(android.R.color.transparent);
    int activityid = ai.getactivityid();
    ActivitySetting as = Actify.findActivitySettingById(activityid);
    final String strActivity = as.getActivity();
    final String strLocation = as.getLocation();
    final int mode = ai.getMode();
    final long oriStart = ai.getStart().getTimeInMillis();

    LayoutInflater inflater = (LayoutInflater) act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    final View rowView = inflater.inflate(R.layout.activity_row, null);

    final Chronometer mChronometer = (Chronometer) rowView.findViewById(R.id.chronometer);

    long base;//from  www  . j  a  va 2  s .com
    if (mode == Actify.MODE_RUNNING) {
        base = SystemClock.elapsedRealtime()
                - (Calendar.getInstance().getTimeInMillis() - ai.getStart().getTimeInMillis());
        mChronometer.setBase(base);
        mChronometer.start();

    } else if (mode == Actify.MODE_PAUSED) {
        base = SystemClock.elapsedRealtime() - ai.getEnd().getTimeInMillis();
        mChronometer.setBase(base);
    }

    final View idColor = (View) rowView.findViewById(R.id.idColor);
    idColor.setBackgroundColor(Color.parseColor(Actify.colorAdapter.getItem(ai.getactivityid()).toString()));

    final TextView txtActivity = (TextView) rowView.findViewById(R.id.txtActivity);

    final TextView txtStart = (TextView) rowView.findViewById(R.id.txtStart);
    txtStart.setText(Actify.datetimeFormat.format(ai.getStart().getTime()));

    if (mode == Actify.MODE_PAUSED) {
        txtActivity.setText(strActivity + getResources().getString(R.string.paused));
    } else {
        txtActivity.setText(strActivity);
    }

    final Button btnStop = (Button) rowView.findViewById(R.id.btnStop);
    btnStop.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            /*alarmManager.cancel(Actify.pendingIntents.get(ai.getId()));
            Actify.pendingIntents.remove(ai.getId());
            Actify.pendingIntentTimes.remove(ai.getId());
            Actify.printIntents();
            */
            ReminderUtil.cancelAlarm(getActivity(), ai.getId());

            mChronometer.stop();
            timer_container.removeView(rowView);

            Calendar calEnd = Calendar.getInstance();
            if (ai.getMode() == Actify.MODE_PAUSED) {
                ap.setEnd(calEnd);
                db.updateActivityPause(ap);
            }

            ai.setEnd(calEnd);
            ai.setMode(Actify.MODE_INSERT);
            db.updateActivity(ai);
            db.deleteLatestActivityLog();
            db.updateActivityPause(ai.getId(), ai.getSync(), ai.getMode());

            String query = db.activityGuestQueryBuilder(Actify.VIEW_TIMER, Actify.MODE_RUNNING, ai.getId());
            List<ActivityGuest> insertList = db.getActivityGuestList(query);
            for (ActivityGuest ag : insertList) {
                ag.setMode(Actify.MODE_INSERT);
                db.updateActivityGuest(ag);
            }
            query = db.activityGuestQueryBuilder(Actify.VIEW_TIMER, Actify.MODE_DELETE, ai.getId());
            List<ActivityGuest> deleteList = db.getActivityGuestList(query);
            for (ActivityGuest ag : deleteList) {
                db.deleteActivityGuest(ag);
            }

            Toast.makeText(act, strActivity + res.getString(R.string.toastActivitySaved), Toast.LENGTH_SHORT)
                    .show();

            if (timer_container.getChildCount() == 0) {
                //setIdleReminder();
                ReminderUtil.setIdleReminder(getActivity());
            }

        }
    });

    final Button btnPause = (Button) rowView.findViewById(R.id.btnPause);
    btnPause.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            switch (ai.getMode()) {
            case Actify.MODE_RUNNING: {
                // pausing

                Calendar calStart = Calendar.getInstance();
                ap.setStart(calStart);
                ActivityPause newap = db.addActivityPause(ap);
                ap.setId(newap.getId());

                Calendar calPaused = Calendar.getInstance();
                calPaused.setTimeInMillis(SystemClock.elapsedRealtime() - mChronometer.getBase());
                mChronometer.stop();
                ai.setMode(Actify.MODE_PAUSED);
                ai.setEnd(calPaused);
                db.updateActivity(ai);

                btnPause.setBackgroundResource(R.drawable.button_selector_resume);
                btnPause.setText(R.string.btnResume);
                txtActivity.setText(strActivity + getResources().getString(R.string.paused));
                break;
            }

            case Actify.MODE_PAUSED: {
                // resuming
                ai.setMode(Actify.MODE_RUNNING);
                db.updateActivity(ai);

                Calendar calResumed = Calendar.getInstance();
                ap.setEnd(calResumed);

                db.updateActivityPause(ap);
                db.deleteLatestActivityPauseLog();

                mChronometer.start();
                btnPause.setBackgroundResource(R.drawable.button_selector_pause);
                btnPause.setText(R.string.btnPause);
                txtActivity.setText(strActivity);

                break;
            }
            }
        }
    });
    if (mode == Actify.MODE_PAUSED) {
        btnPause.setBackgroundResource(R.drawable.button_selector_resume);
        btnPause.setText(R.string.btnResume);
    }

    final TextView txtLocation = (TextView) rowView.findViewById(R.id.txtLocation);
    txtLocation.setText(getResources().getString(R.string.txtLocation) + strLocation);

    final TextView txtGuest = (TextView) rowView.findViewById(R.id.txtGuest);
    List<String> guestList = db.getActivityGuestStringList(ai.getId());

    if (guestList.isEmpty())
        txtGuest.setText("");
    else {
        String guestNames = "";
        for (String s : guestList) {
            guestNames += s + " ";
        }
        txtGuest.setText(getResources().getString(R.string.txtGuests) + guestNames);
    }

    final LinearLayout ll = (LinearLayout) rowView.findViewById(R.id.ll);
    ll.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            /********************************* Activity Edit *************************************/

            final AlertDialog activityEditDialog = new AlertDialog.Builder(act).create();
            LayoutInflater inflater = act.getLayoutInflater();
            View dialogView = inflater.inflate(R.layout.activity_edit, null);

            final Spinner spinnerActivity = (Spinner) dialogView.findViewById(R.id.spinnerActivity);
            spinnerActivity.setAdapter(Actify.activityAdapter);
            spinnerActivity.setSelection(Actify.findActivitySettingById(ai.getactivityid()).getOrder());
            spinnerActivity.setPadding(2, 2, 2, 2);

            final Spinner spinnerLocation = (Spinner) dialogView.findViewById(R.id.spinnerLocation);
            spinnerLocation.setAdapter(Actify.locationAdapter);
            spinnerLocation.setSelection(ai.getlocationid());
            spinnerLocation.setPadding(2, 2, 2, 2);

            final Button btnStart = (Button) dialogView.findViewById(R.id.btnStart);
            btnStart.setText(Actify.datetimeFormat.format(ai.getStart().getTime()));
            btnStart.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    dateTimePicker = new DateTimePicker(act, ai.getStart(),
                            new DateTimePickerListener(btnStart, ai),
                            res.getString(R.string.editActivityHeaderStartTime));
                    dateTimePicker.set24HourFormat(true);
                    dateTimePicker.showDialog();
                }

            });

            String dtReminderString = settings.getString("reminder_" + ai.getId(), "");
            DateTime dtReminder = DateTime.parse(dtReminderString, Actify.datetimeFormatJoda);
            DateTime dtNow = new DateTime();
            Duration duration = new Duration(dtNow, dtReminder);
            int hours = (int) duration.getStandardHours();
            int minutes = (int) duration.getStandardMinutes();
            int seconds = (int) duration.getStandardSeconds();
            String durationStr;

            if (seconds > 30) {
                minutes = minutes + 1;
                if (minutes % 60 == 0) {
                    hours = minutes / 60;
                }
            }

            if (hours > 0) {
                minutes = minutes - (hours * 60);
                durationStr = hours + "h " + minutes + "m from now";
            } else {
                durationStr = minutes + "m from now";
            }
            final int oldMinutes = minutes;
            final int oldHours = hours;
            changeReminder = false;

            final Button btnReminder = (Button) dialogView.findViewById(R.id.btnReminder);
            btnReminder.setText(durationStr);
            btnReminder.setOnClickListener(new OnClickListener() {
                TimePickerDialog.OnTimeSetListener nextAlarmSettingListener = new TimePickerDialog.OnTimeSetListener() {
                    @Override
                    public void onTimeSet(TimePicker view, int hour, int minute) {
                        newHour = hour;
                        newMinute = minute;
                        String durationStr;
                        if (newHour > 0)
                            durationStr = newHour + " hours " + newMinute + " mins";
                        else
                            durationStr = newMinute + " mins";
                        btnReminder.setText(durationStr);
                        changeReminder = true;
                    }
                };

                @Override
                public void onClick(View v) {
                    TimePickerDialog tpDialog = new TimePickerDialog(ActivityFragment.this.getActivity(),
                            nextAlarmSettingListener, oldHours, oldMinutes, true);
                    tpDialog.setTitle("Reminder");
                    tpDialog.setMessage("Remind me after (HH:MM)");
                    tpDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
                        @Override
                        public void onDismiss(DialogInterface dialog) {
                            dialog.dismiss();
                        }
                    });
                    tpDialog.show();
                }
            });

            final Button btnPauses = (Button) dialogView.findViewById(R.id.btnPauses);
            btnPauses.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View arg0) {
                    /********************************* Pauses Edit *************************************/
                    String query = db.activityPauseQueryBuilder(Actify.VIEW_TIMER, ai.getId());
                    List<ActivityPause> activityPauses = db.getActivityPauseList(query);

                    if (activityPauses.isEmpty()) {
                        Toast.makeText(act, res.getString(R.string.toastActivityNoPauses), Toast.LENGTH_SHORT)
                                .show();
                    } else {

                        final AlertDialog dialogPause = new AlertDialog.Builder(act).create();

                        ScrollView sv = new ScrollView(act);

                        final LinearLayout ll = new LinearLayout(act);
                        ll.setOrientation(LinearLayout.VERTICAL);
                        for (int i = 0; i < activityPauses.size(); i++) {
                            final ActivityPause ap = activityPauses.get(i);
                            LayoutInflater inflater = (LayoutInflater) act
                                    .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                            final View pauseRowView = inflater.inflate(R.layout.activity_pause_row, null);

                            final Button btnStart = (Button) pauseRowView.findViewById(R.id.btnStart);
                            final String start = Actify.dateFormat.format(ap.getStart().getTime()) + "\n"
                                    + Actify.timeFormat.format(ap.getStart().getTime());
                            btnStart.setText(start);
                            btnStart.setId(START);
                            btnStart.setOnClickListener(new OnClickListener() {

                                public void onClick(View v) {
                                    dateTimePicker = new DateTimePicker(act, ap.getStart(),
                                            new DateTimePickerListener(btnStart, ap),
                                            res.getString(R.string.datetimePickerHeader));
                                    dateTimePicker.set24HourFormat(true);
                                    dateTimePicker.showDialog();
                                }
                            });

                            final Button btnEnd = (Button) pauseRowView.findViewById(R.id.btnEnd);
                            final String end = Actify.dateFormat.format(ap.getEnd().getTime()) + "\n"
                                    + Actify.timeFormat.format(ap.getEnd().getTime());
                            btnEnd.setText(end);
                            btnEnd.setId(END);
                            btnEnd.setOnClickListener(new OnClickListener() {

                                public void onClick(View v) {
                                    dateTimePicker = new DateTimePicker(act, ap.getEnd(),
                                            new DateTimePickerListener(btnEnd, ap),
                                            res.getString(R.string.datetimePickerHeader));
                                    dateTimePicker.set24HourFormat(true);
                                    dateTimePicker.showDialog();
                                }
                            });

                            final ImageButton btnDelete = (ImageButton) pauseRowView
                                    .findViewById(R.id.btnDelete);
                            btnDelete.setOnClickListener(new OnClickListener() {
                                public void onClick(View v) {
                                    AlertDialog alertDialog = new AlertDialog.Builder(act).create();
                                    alertDialog.setMessage(res.getString(R.string.editPauseDeleteMsg));
                                    alertDialog.setButton(AlertDialog.BUTTON_POSITIVE,
                                            res.getString(R.string.btnYes),
                                            new DialogInterface.OnClickListener() {
                                                public void onClick(DialogInterface dialog, int which) {
                                                    db.deleteActivityPause(ap);
                                                    ll.removeView(pauseRowView);
                                                    activityEditDialog.dismiss();
                                                    dialog.dismiss();
                                                }
                                            });
                                    alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE,
                                            res.getString(R.string.btnNo),
                                            new DialogInterface.OnClickListener() {
                                                public void onClick(DialogInterface dialog, int which) {
                                                    dialog.dismiss();
                                                }
                                            });
                                    alertDialog.show();
                                }
                            });

                            ll.addView(pauseRowView);
                        }
                        sv.addView(ll);

                        dialogPause.setView(sv);
                        dialogPause.setTitle(res.getString(R.string.editActivityTitlePauses));

                        dialogPause.setButton(AlertDialog.BUTTON_POSITIVE, res.getString(R.string.btnOk),
                                new DialogInterface.OnClickListener() {
                                    public void onClick(DialogInterface dialog, int which) {
                                        dialog.dismiss();
                                    }
                                });

                        dialogPause.setButton(AlertDialog.BUTTON_NEGATIVE, res.getString(R.string.btnCancel),
                                new DialogInterface.OnClickListener() {
                                    public void onClick(DialogInterface dialog, int which) {
                                        dialog.dismiss();
                                    }
                                });

                        dialogPause.show();
                    }
                }

            });

            final ArrayList<Guest> addGuests = new ArrayList<Guest>();
            final ArrayList<Guest> delGuests = new ArrayList<Guest>();
            final Button btnGuests = (Button) dialogView.findViewById(R.id.btnGuests);
            btnGuests.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    /********************************* Activity Guests Edit *************************************/
                    String query = db.guestQueryBuilder(ai, householdid);
                    final List<Guest> guests = db.getGuestList(query);
                    if (guests.isEmpty()) {
                        Toast.makeText(act, res.getString(R.string.editActivityToastNoGuest),
                                Toast.LENGTH_SHORT).show();
                    } else {
                        final AlertDialog dialogGuest = new AlertDialog.Builder(act).create();

                        ScrollView sv = new ScrollView(act);

                        final LinearLayout ll = new LinearLayout(act);
                        ll.setOrientation(LinearLayout.VERTICAL);

                        for (int i = 0; i < guests.size(); i++) {
                            Guest g = guests.get(i);
                            CheckBox ch = new CheckBox(act);
                            if (db.isActivityGuest(ai.getId(), g.getId())) {
                                ch.setChecked(true);
                            } else
                                ch.setChecked(false);
                            String start = Actify.datetimeFormat.format(g.getStart().getTime());
                            String end = "...";
                            if (g.getMode() != Actify.MODE_RUNNING)
                                end = Actify.datetimeFormat.format(g.getEnd().getTime());
                            String text = g.getName() + " (" + start + " - " + end + ")";
                            ch.setText(text);
                            ch.setTextSize(14);
                            ll.addView(ch);
                        }

                        sv.addView(ll);

                        dialogGuest.setView(sv);
                        dialogGuest.setTitle(res.getString(R.string.editActivityTitleGuest));
                        dialogGuest.setMessage(res.getString(R.string.editActivityMsgGuest));

                        dialogGuest.setButton(AlertDialog.BUTTON_POSITIVE, res.getString(R.string.btnOk),
                                new DialogInterface.OnClickListener() {
                                    public void onClick(DialogInterface dialog, int which) {
                                        for (int i = 0; i < guests.size(); i++) {
                                            CheckBox ch = (CheckBox) ll.getChildAt(i);
                                            if (ch.isChecked()) {
                                                addGuests.add(guests.get(i));
                                            } else
                                                delGuests.add(guests.get(i));
                                        }

                                        dialog.dismiss();
                                    }
                                });

                        dialogGuest.setButton(AlertDialog.BUTTON_NEGATIVE, res.getString(R.string.btnCancel),
                                new DialogInterface.OnClickListener() {
                                    public void onClick(DialogInterface dialog, int which) {
                                        dialog.dismiss();
                                    }
                                });

                        dialogGuest.show();
                    }
                }
            });

            activityEditDialog.setView(dialogView);
            activityEditDialog.setTitle(res.getString(R.string.editActivityTitleDialog));
            activityEditDialog.setButton(AlertDialog.BUTTON_POSITIVE, res.getString(R.string.btnOk),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {

                            int activityid = Actify
                                    .findActivitySettingByOrder(spinnerActivity.getSelectedItemPosition())
                                    .getId();
                            int locationid = spinnerLocation.getSelectedItemPosition();
                            ai.setactivityid(activityid);
                            ai.setlocationid(locationid);
                            db.updateActivity(ai);

                            for (Guest g : addGuests) {
                                ActivityGuest ag = new ActivityGuest(ai.getId(), g.getId());
                                ag.setMode(Actify.MODE_RUNNING);
                                db.addActivityGuest(ag);
                            }
                            for (Guest g : delGuests) {
                                ActivityGuest ag = new ActivityGuest(ai.getId(), g.getId());
                                ag.setMode(Actify.MODE_DELETE);
                                db.updateActivityGuest(ag);
                            }

                            List<String> guestList = db.getActivityGuestStringList(ai.getId());

                            if (guestList.isEmpty())
                                txtGuest.setText("");
                            else {
                                String guestNames = "";
                                for (String s : guestList) {
                                    guestNames += s + " ";
                                }
                                txtGuest.setText(getResources().getString(R.string.txtGuests) + guestNames);
                            }

                            idColor.setBackgroundColor(
                                    Color.parseColor(Actify.colorAdapter.getItem(activityid).toString()));

                            txtLocation.setText(getResources().getString(R.string.txtLocation)
                                    + Actify.locationAdapter.getItem(locationid).toString());
                            txtStart.setText(Actify.datetimeFormat.format(ai.getStart().getTime()));

                            long changeStart = ai.getStart().getTimeInMillis() - oriStart;
                            long base;
                            String activityStr = Actify.findActivitySettingById(ai.getactivityid())
                                    .getActivity();

                            if (ai.getMode() == Actify.MODE_RUNNING) {
                                txtActivity.setText(activityStr);
                                mChronometer.stop();
                                base = SystemClock.elapsedRealtime() - (Calendar.getInstance().getTimeInMillis()
                                        - ai.getStart().getTimeInMillis());
                                mChronometer.setBase(base);
                                mChronometer.start();

                            } else if (ai.getMode() == Actify.MODE_PAUSED) {
                                base = SystemClock.elapsedRealtime() - ai.getEnd().getTimeInMillis()
                                        + changeStart;
                                mChronometer.setBase(base);
                                mChronometer.stop();
                                txtActivity.setText(activityStr + res.getString(R.string.paused));
                            }

                            if (changeReminder) {
                                ReminderUtil.cancelAlarm(getActivity(), ai.getId());
                                ActivitySetting as = Actify.findActivitySettingById(activityid);
                                ReminderUtil.setActivityReminder(getActivity(), ai.getId(),
                                        newHour * 60 + newMinute, as.getActivity());

                            }

                            dialog.dismiss();
                        }
                    });

            activityEditDialog.setButton(AlertDialog.BUTTON_NEGATIVE, res.getString(R.string.btnCancel),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            dialog.dismiss();
                        }
                    });

            activityEditDialog.show();

        }
    });
    timer_container.addView(rowView, timer_container.getChildCount());
}

From source file:com.boundary.metrics.vmware.poller.VMwarePerfPoller.java

License:Apache License

/**
 * Extracts performance metrics from Managed Objects on the monitored entity
 * //from  w  ww  .ja v a2 s  .c  om
 * @throws MalformedURLException Bad URL
 * @throws RemoteException Endpoint exception
 * @throws InvalidPropertyFaultMsg Bad Property
 * @throws RuntimeFaultFaultMsg Runtime error
 * @throws SOAPFaultException WebServer error
 */
public void collectPerformanceData() throws MalformedURLException, RemoteException, InvalidPropertyFaultMsg,
        RuntimeFaultFaultMsg, SOAPFaultException {

    ManagedObjectReference root = client.getServiceContent().getRootFolder();

    // 'now' according to the server
    DateTime now = TimeUtils.toDateTime(client.getVimPort().currentTime(client.getServiceInstanceReference()));
    Duration serverSkew = new Duration(now, new DateTime());
    if (serverSkew.isLongerThan(Duration.standardSeconds(1))
            && (skew == null || skew.getStandardSeconds() != serverSkew.getStandardSeconds())) {
        LOG.warn("Server {} and local time skewed by {} seconds", client.getHost(),
                serverSkew.getStandardSeconds());
        skew = serverSkew;
    }
    if (lastPoll == null) {
        lastPoll = now.minusSeconds(20);
    }

    // Holder for all our newly found measurements
    // TODO set an upper size limit on measurements list
    List<Measurement> measurements = Lists.newArrayList();

    /*
    * A {@link PerfMetricId} consistents of the performance counter and
    * the instance it applies to.
    * 
    * In our particular case we are requesting for all of the instances
    * associated with the performance counter.
    * 
    * Will this work when we have a mix of VirtualMachine, HostSystem, and DataSource
    * managed objects.
    * 
    */
    List<PerfMetricId> perfMetricIds = Lists.newArrayList();
    for (String counterName : metrics.keySet()) {
        if (this.performanceCounterMap.containsKey(counterName)) {
            PerfMetricId metricId = new PerfMetricId();
            /* Get the ID for this counter. */
            metricId.setCounterId(this.performanceCounterMap.get(counterName));
            metricId.setInstance("*");
            perfMetricIds.add(metricId);
        }
    }

    GetMOREF getMOREFs = new GetMOREF(client);
    Map<String, ManagedObjectReference> entities = getMOREFs.inFolderByType(root, "VirtualMachine");

    for (Map.Entry<String, ManagedObjectReference> entity : entities.entrySet()) {
        ManagedObjectReference mor = entity.getValue();
        String entityName = entity.getKey();

        /*
        * Create the query specification for queryPerf().
        * Specify 5 minute rollup interval and CSV output format.
        */
        PerfQuerySpec querySpec = new PerfQuerySpec();
        querySpec.setEntity(mor);
        querySpec.setIntervalId(20);
        querySpec.setFormat("normal");
        querySpec.setStartTime(TimeUtils.toXMLGregorianCalendar(lastPoll));
        querySpec.setEndTime(TimeUtils.toXMLGregorianCalendar(now));
        querySpec.getMetricId().addAll(perfMetricIds);

        LOG.info("Entity: {}, MOR: {}-{}, Interval: {}, Format: {}, MetricIds: {}, Start: {}, End: {}",
                entityName, mor.getType(), mor.getValue(), querySpec.getIntervalId(), querySpec.getFormat(),
                FluentIterable.from(perfMetricIds).transform(toStringFunction), lastPoll, now);

        List<PerfEntityMetricBase> retrievedStats = client.getVimPort()
                .queryPerf(client.getServiceContent().getPerfManager(), ImmutableList.of(querySpec));

        /*
        * Cycle through the PerfEntityMetricBase objects. Each object contains
        * a set of statistics for a single ManagedEntity.
        */
        for (PerfEntityMetricBase singleEntityPerfStats : retrievedStats) {
            if (singleEntityPerfStats instanceof PerfEntityMetric) {
                PerfEntityMetric entityStats = (PerfEntityMetric) singleEntityPerfStats;
                List<PerfMetricSeries> metricValues = entityStats.getValue();
                List<PerfSampleInfo> sampleInfos = entityStats.getSampleInfo();

                for (int x = 0; x < metricValues.size(); x++) {
                    PerfMetricIntSeries metricReading = (PerfMetricIntSeries) metricValues.get(x);
                    PerfCounterInfo metricInfo = performanceCounterInfoMap
                            .get(metricReading.getId().getCounterId());
                    String metricFullName = toFullName.apply(metricInfo);
                    if (!sampleInfos.isEmpty()) {
                        PerfSampleInfo sampleInfo = sampleInfos.get(0);
                        DateTime sampleTime = TimeUtils.toDateTime(sampleInfo.getTimestamp());
                        Number sampleValue = metricReading.getValue().iterator().next();

                        if (skew != null) {
                            sampleTime = sampleTime.plusSeconds((int) skew.getStandardSeconds());
                        }

                        if (metricReading.getValue().size() > 1) {
                            LOG.warn("Metric {} has more than one value, only using the first", metricFullName);
                        }

                        String source = client.getName() + "-" + entityName;

                        if (metricInfo.getUnitInfo().getKey().equalsIgnoreCase("kiloBytes")) {
                            sampleValue = (long) sampleValue * 1024; // Convert KB to Bytes
                        } else if (metricInfo.getUnitInfo().getKey().equalsIgnoreCase("percent")) {
                            // Convert hundredth of a percent to a decimal percent
                            sampleValue = new Long((long) sampleValue).doubleValue() / 10000.0;
                        }
                        String name = metrics.get(metricFullName).getName();
                        if (name != null) {
                            Measurement measurement = Measurement.builder().setMetric(name).setSource(source)
                                    .setTimestamp(sampleTime).setMeasurement(sampleValue).build();
                            measurements.add(measurement);

                            LOG.info("{} @ {} = {} {}", metricFullName, sampleTime, sampleValue,
                                    metricInfo.getUnitInfo().getKey());
                        } else {
                            LOG.warn("Skipping collection of metric: {}", metricFullName);
                        }
                    } else {
                        LOG.warn("Didn't receive any samples when polling for {} on {} between {} and {}",
                                metricFullName, client.getHost(), lastPoll, now);
                    }
                }
            } else {
                LOG.error("Unrecognized performance entry type received: {}, ignoring",
                        singleEntityPerfStats.getClass().getName());
            }
        }
    }

    // Send metrics
    if (!measurements.isEmpty()) {
        metricsClient.addMeasurements(measurements);
    } else {
        LOG.warn("No measurements collected in last poll for {}", client.getHost());
    }

    // Reset lastPoll time
    lastPoll = now;
}

From source file:com.brighttag.agathon.dao.zerg.ZergDaoModule.java

License:Apache License

@Provides
@Singleton/*from   w  ww. j av a  2 s .c  om*/
CacheBuilder<Object, Object> provideZergLoadingCache(
        @Named(ZERG_CACHE_TIMEOUT_PROPERTY) Duration cacheTimeout) {
    return CacheBuilder.newBuilder().refreshAfterWrite(cacheTimeout.getStandardSeconds(), TimeUnit.SECONDS);
}

From source file:com.bytestemplar.subgeniuswatchface.BT_SubgeniusWatchface.java

License:Apache License

private String getXDayCountdown() {
    DateTime today = DateTime.now();/*from   w  w w  .  j ava  2s  .c  o  m*/
    //DateTime today = new DateTime( 1998, 7, 6, 4, 20, 32, 0 );
    DateTime xday = new DateTime(today.getYear(), 7, 5, 7, 0, 0, 0);

    if (today.isAfter(xday)) {
        xday = new DateTime(today.getYear() + 1, 7, 5, 7, 0, 0, 0);
    }

    Duration dur = new Duration(today, xday);

    StringBuilder sb = new StringBuilder();

    if (dur.getStandardDays() > 0) {
        sb.append(dur.getStandardDays());
        sb.append(" Day");
        if (dur.getStandardDays() > 1) {
            sb.append("s");
        }
        sb.append("\n");
    }

    long hours = dur.getStandardHours() % 24;
    if (hours > 0) {
        sb.append(hours);
        sb.append(" Hour");
        if (hours > 1) {
            sb.append("s");
        }
        sb.append("\n");
    }

    long mins = dur.getStandardMinutes() % 60;
    if (mins > 0) {
        sb.append(mins);
        sb.append(" Minute");
        if (mins > 1) {
            sb.append("s");
        }
        sb.append("\n");
    }

    long secs = dur.getStandardSeconds() % 60;
    if (secs > 0) {
        sb.append(secs);
        sb.append(" Second");
        if (secs > 1) {
            sb.append("s");
        }
        sb.append("\n");
    }

    sb.append("Until X-Day!");

    return sb.toString();
}

From source file:com.cimpress.puzzle.Main.java

License:Apache License

public static void main(final String... args) {

    logger.debug("tt");

    ApplicationContext cntx = new ClassPathXmlApplicationContext("classpath:spring-integration-context.xml");

    AsyncLogger asyncLogger = cntx.getBean("asyncLogger", AsyncLogger.class);

    asyncLogger.log("Container loaded", String.class, Main.class, logger);
    PuzzleAPI puzzleAPI = cntx.getBean("puzzleAPI", PuzzleAPI.class);

    DateTime dt = new DateTime();
    Puzzle puzzle = puzzleAPI.generatePuzzle();

    // new SquareFinder().solvePuzzle(Environment.getPuzzleObject());
    List<Square> squareList = new SquareFinder().solvePuzzle(puzzle);
    System.out.println("Total squares :" + squareList.size());
    puzzleAPI.postSolution(squareList, puzzle.getId());
    DateTime d2 = new DateTime();
    Duration elapsedTime = new Duration(dt, d2);
    System.out.println("\nTotal Time Taken :" + elapsedTime.getStandardSeconds());
}

From source file:com.cloud.agent.resource.virtualnetwork.VirtualRoutingResource.java

License:Apache License

private Answer execute(AggregationControlCommand cmd) {
    Action action = cmd.getAction();
    String routerName = cmd.getAccessDetail(NetworkElementCommand.ROUTER_NAME);
    assert routerName != null;
    assert cmd.getRouterAccessIp() != null;

    if (action == Action.Start) {
        assert (!_vrAggregateCommandsSet.containsKey(routerName));

        Queue<NetworkElementCommand> queue = new LinkedBlockingQueue<>();
        _vrAggregateCommandsSet.put(routerName, queue);
        return new Answer(cmd, true, "Command aggregation started");
    } else if (action == Action.Finish) {
        Queue<NetworkElementCommand> queue = _vrAggregateCommandsSet.get(routerName);
        int answerCounts = 0;
        try {//from w  w w .  ja v a  2s. c  om
            StringBuilder sb = new StringBuilder();
            sb.append("#Apache CloudStack Virtual Router Config File\n");
            sb.append("<version>\n" + _cfgVersion + "\n</version>\n");
            for (NetworkElementCommand command : queue) {
                answerCounts += command.getAnswersCount();
                List<ConfigItem> cfg = generateCommandCfg(command);
                if (cfg == null) {
                    s_logger.warn(
                            "Unknown commands for VirtualRoutingResource, but continue: " + cmd.toString());
                    continue;
                }

                for (ConfigItem c : cfg) {
                    sb.append(c.getAggregateCommand());
                }
            }

            // TODO replace with applyConfig with a stop on fail
            String cfgFileName = "VR-" + UUID.randomUUID().toString() + ".cfg";
            FileConfigItem fileConfigItem = new FileConfigItem(VRScripts.CONFIG_CACHE_LOCATION, cfgFileName,
                    sb.toString());
            ScriptConfigItem scriptConfigItem = new ScriptConfigItem(VRScripts.VR_CFG,
                    "-c " + VRScripts.CONFIG_CACHE_LOCATION + cfgFileName);
            // 120s is the minimal timeout
            Duration timeout = _eachTimeout.withDurationAdded(_eachTimeout.getStandardSeconds(), answerCounts);
            if (s_logger.isDebugEnabled()) {
                s_logger.debug("Aggregate action timeout in seconds is " + timeout.getStandardSeconds());
            }

            ExecutionResult result = applyConfigToVR(cmd.getRouterAccessIp(), fileConfigItem, timeout);
            if (!result.isSuccess()) {
                return new Answer(cmd, false, result.getDetails());
            }

            result = applyConfigToVR(cmd.getRouterAccessIp(), scriptConfigItem, timeout);
            if (!result.isSuccess()) {
                return new Answer(cmd, false, result.getDetails());
            }

            return new Answer(cmd, true, "Command aggregation finished");
        } finally {
            queue.clear();
            _vrAggregateCommandsSet.remove(routerName);
        }
    }
    return new Answer(cmd, false, "Fail to recongize aggregation action " + action.toString());
}

From source file:com.facebook.stats.EventRateImpl.java

License:Apache License

@Override
public long getValue() {
    Duration periodSize = getPeriodSize();

    if (periodSize.getStandardSeconds() == 0) {
        return 0;
    }/*from  w  w  w. j av a  2 s  . co  m*/

    return counter.getValue() / periodSize.getStandardSeconds();
}