/**
* test DST start with offset not fitting interval, e.g. Asia/Kathmandu adding 15min on
* 1986-01-01T00:00:00 the interval from 1986-01-01T00:15:00+05:45 to 1986-01-01T00:20:00+05:45 to
* only be 5min long
*/
public void testTimeInterval_Kathmandu_DST_Start() {
long interval = TimeUnit.MINUTES.toMillis(20);
DateTimeZone tz = DateTimeZone.forID("Asia/Kathmandu");
Rounding rounding = new TimeIntervalRounding(interval, tz);
assertThat(
rounding.round(time("1985-12-31T23:55:00+05:30")),
isDate(time("1985-12-31T23:40:00+05:30"), tz));
assertThat(
rounding.round(time("1986-01-01T00:16:00+05:45")),
isDate(time("1986-01-01T00:15:00+05:45"), tz));
assertThat(
time("1986-01-01T00:15:00+05:45") - time("1985-12-31T23:40:00+05:30"),
equalTo(TimeUnit.MINUTES.toMillis(20)));
assertThat(
rounding.round(time("1986-01-01T00:26:00+05:45")),
isDate(time("1986-01-01T00:20:00+05:45"), tz));
assertThat(
time("1986-01-01T00:20:00+05:45") - time("1986-01-01T00:15:00+05:45"),
equalTo(TimeUnit.MINUTES.toMillis(5)));
assertThat(
rounding.round(time("1986-01-01T00:46:00+05:45")),
isDate(time("1986-01-01T00:40:00+05:45"), tz));
assertThat(
time("1986-01-01T00:40:00+05:45") - time("1986-01-01T00:20:00+05:45"),
equalTo(TimeUnit.MINUTES.toMillis(20)));
}
public void run() {
if (isMediaPlayerBound) {
int totalDuration = getDuration();
int currentProgression = getCurrentPosition();
seekbar.setMax(totalDuration);
seekbar.setProgress(currentProgression);
String timeElapsed =
String.format(
"%d:%d",
TimeUnit.MILLISECONDS.toMinutes(currentProgression),
TimeUnit.MILLISECONDS.toSeconds(currentProgression)
- TimeUnit.MINUTES.toSeconds(
TimeUnit.MILLISECONDS.toMinutes(currentProgression)));
String totalTimeFormatted =
String.format(
"%d:%d",
TimeUnit.MILLISECONDS.toMinutes(totalDuration),
TimeUnit.MILLISECONDS.toSeconds(totalDuration)
- TimeUnit.MINUTES.toSeconds(
TimeUnit.MILLISECONDS.toMinutes(totalDuration)));
tvTotalTime.setText(totalTimeFormatted);
tvCurrentTime.setText(timeElapsed);
updateMediaPlayerViews();
}
// repeat yourself again in 100 miliseconds
seekHandler.postDelayed(this, 100);
}
private String getAvgTimePerTick(SortedMap<Long, Record> records) {
long sum = 0;
for (Map.Entry<Long, Record> en : records.entrySet()) {
sum += en.getValue().getLastCallDiff();
}
long globalavg = sum / records.size();
sum = 0;
Set<Map.Entry<Long, Record>> subset =
records.tailMap(System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(15)).entrySet();
for (Map.Entry<Long, Record> en : subset) {
sum += en.getValue().getLastCallDiff();
}
long min15avg = sum / subset.size();
sum = 0;
subset = records.tailMap(System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(10)).entrySet();
for (Map.Entry<Long, Record> en : subset) {
sum += en.getValue().getLastCallDiff();
}
long min10avg = sum / subset.size();
sum = 0;
subset = records.tailMap(System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(5)).entrySet();
for (Map.Entry<Long, Record> en : subset) {
sum += en.getValue().getLastCallDiff();
}
long min5avg = sum / subset.size();
sum = 0;
subset = records.tailMap(System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(1)).entrySet();
for (Map.Entry<Long, Record> en : subset) {
sum += en.getValue().getLastCallDiff();
}
long min1avg = sum / subset.size();
return globalavg
+ " "
+ ChatColor.GRAY
+ min15avg
+ " "
+ ChatColor.YELLOW
+ min10avg
+ " "
+ ChatColor.GOLD
+ min5avg
+ " "
+ ChatColor.GREEN
+ min1avg;
}
// Default config
static {
config.setMaxTotal(100);
config.setMaxTotalPerKey(100);
config.setMaxIdlePerKey(100);
config.setMinIdlePerKey(100);
config.setTestOnBorrow(true);
config.setMinEvictableIdleTimeMillis(TimeUnit.MINUTES.toMillis(5));
config.setSoftMinEvictableIdleTimeMillis(TimeUnit.MINUTES.toMillis(5));
config.setJmxEnabled(false);
}
private static String formatInterval(final long l) {
final long hr = TimeUnit.MILLISECONDS.toHours(l);
final long min = TimeUnit.MILLISECONDS.toMinutes(l - TimeUnit.HOURS.toMillis(hr));
final long sec =
TimeUnit.MILLISECONDS.toSeconds(
l - TimeUnit.HOURS.toMillis(hr) - TimeUnit.MINUTES.toMillis(min));
final long ms =
TimeUnit.MILLISECONDS.toMillis(
l
- TimeUnit.HOURS.toMillis(hr)
- TimeUnit.MINUTES.toMillis(min)
- TimeUnit.SECONDS.toMillis(sec));
return String.format("%02dh:%02dm:%02d.%03ds", hr, min, sec, ms);
}
/*
* Returns TTL value of ElasticSearch index in milliseconds when TTL
* specifier is "ms" / "s" / "m" / "h" / "d" / "w". In case of unknown
* specifier TTL is not set. When specifier is not provided it defaults to
* days in milliseconds where the number of days is parsed integer from TTL
* string provided by user. <p> Elasticsearch supports ttl values being
* provided in the format: 1d / 1w / 1ms / 1s / 1h / 1m specify a time unit
* like d (days), m (minutes), h (hours), ms (milliseconds) or w (weeks),
* milliseconds is used as default unit.
* http://www.elasticsearch.org/guide/reference/mapping/ttl-field/.
*
* @param ttl TTL value provided by user in flume configuration file for the
* sink
*
* @return the ttl value in milliseconds
*/
private long parseTTL(String ttl) {
matcher = matcher.reset(ttl);
while (matcher.find()) {
if (matcher.group(2).equals("ms")) {
return Long.parseLong(matcher.group(1));
} else if (matcher.group(2).equals("s")) {
return TimeUnit.SECONDS.toMillis(Integer.parseInt(matcher.group(1)));
} else if (matcher.group(2).equals("m")) {
return TimeUnit.MINUTES.toMillis(Integer.parseInt(matcher.group(1)));
} else if (matcher.group(2).equals("h")) {
return TimeUnit.HOURS.toMillis(Integer.parseInt(matcher.group(1)));
} else if (matcher.group(2).equals("d")) {
return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
} else if (matcher.group(2).equals("w")) {
return TimeUnit.DAYS.toMillis(7 * Integer.parseInt(matcher.group(1)));
} else if (matcher.group(2).equals("")) {
logger.info("TTL qualifier is empty. Defaulting to day qualifier.");
return TimeUnit.DAYS.toMillis(Integer.parseInt(matcher.group(1)));
} else {
logger.debug("Unknown TTL qualifier provided. Setting TTL to 0.");
return 0;
}
}
logger.info("TTL not provided. Skipping the TTL config by returning 0.");
return 0;
}
@Provides
@Singleton
@Named(TIMEOUT_NAME)
long getTimeoutMillis(@GerritServerConfig final Config cfg) {
return ConfigUtil.getTimeUnit(
cfg, "receive", null, "timeout", TimeUnit.MINUTES.toMillis(2), TimeUnit.MILLISECONDS);
}
private void updateRuntime(int currentTime) {
if (mRunTime == null) {
// this view can be null if the user
// does not want to use it. Don't throw
// an exception.
return;
}
if (currentTime < 0) {
throw new IllegalArgumentException(ERROR_PLAYTIME_CURRENT_NEGATIVE);
}
StringBuilder playbackStr = new StringBuilder();
// set the current time
// its ok to show 00:00 in the UI
playbackStr.append(
String.format(
"%02d:%02d",
TimeUnit.MILLISECONDS.toMinutes((long) currentTime),
TimeUnit.MILLISECONDS.toSeconds((long) currentTime)
- TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes((long) currentTime))));
mRunTime.setText(playbackStr);
// DebugLog.i(currentTime + " / " + totalDuration);
}
@Deprecated
private void updatePlaytime(int currentTime) {
StringBuilder playbackStr = new StringBuilder();
long totalDuration = 0;
if (getMediaPlayer() != null) {
try {
totalDuration = getMediaPlayer().getDuration();
} catch (Exception e) {
app2 mapp = (app2) context.getApplicationContext();
mapp.getInstance().trackException(e);
e.printStackTrace();
}
}
// set total time as the audio is being played
if (totalDuration != 0) {
playbackStr.append(
String.format(
"%02d:%02d",
TimeUnit.MILLISECONDS.toMinutes((long) totalDuration),
TimeUnit.MILLISECONDS.toSeconds((long) totalDuration)
- TimeUnit.MINUTES.toSeconds(
TimeUnit.MILLISECONDS.toMinutes((long) totalDuration))));
} else {
Log.w(TAG, "Something strage this audio track duration in zero");
}
mTotalTime.setText(playbackStr);
// DebugLog.i(currentTime + " / " + totalDuration);
}
/**
* test DST end with interval rounding CET: 25 October 2015, 03:00:00 clocks were turned backward
* 1 hour to 25 October 2015, 02:00:00 local standard time
*/
public void testTimeIntervalCET_DST_End() {
long interval = TimeUnit.MINUTES.toMillis(20);
DateTimeZone tz = DateTimeZone.forID("CET");
Rounding rounding = new TimeIntervalRounding(interval, tz);
assertThat(
rounding.round(time("2015-10-25T01:55:00+02:00")),
isDate(time("2015-10-25T01:40:00+02:00"), tz));
assertThat(
rounding.round(time("2015-10-25T02:15:00+02:00")),
isDate(time("2015-10-25T02:00:00+02:00"), tz));
assertThat(
rounding.round(time("2015-10-25T02:35:00+02:00")),
isDate(time("2015-10-25T02:20:00+02:00"), tz));
assertThat(
rounding.round(time("2015-10-25T02:55:00+02:00")),
isDate(time("2015-10-25T02:40:00+02:00"), tz));
// after DST shift
assertThat(
rounding.round(time("2015-10-25T02:15:00+01:00")),
isDate(time("2015-10-25T02:00:00+01:00"), tz));
assertThat(
rounding.round(time("2015-10-25T02:35:00+01:00")),
isDate(time("2015-10-25T02:20:00+01:00"), tz));
assertThat(
rounding.round(time("2015-10-25T02:55:00+01:00")),
isDate(time("2015-10-25T02:40:00+01:00"), tz));
assertThat(
rounding.round(time("2015-10-25T03:15:00+01:00")),
isDate(time("2015-10-25T03:00:00+01:00"), tz));
}
@Override
public List<Bulletin> findBulletinsForGroupBySource(
final String groupId, final int maxPerComponent) {
final long fiveMinutesAgo = System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(5);
final ConcurrentMap<String, RingBuffer<Bulletin>> componentMap = bulletinStoreMap.get(groupId);
if (componentMap == null) {
return Collections.<Bulletin>emptyList();
}
final List<Bulletin> allComponentBulletins = new ArrayList<>();
for (final RingBuffer<Bulletin> ringBuffer : componentMap.values()) {
allComponentBulletins.addAll(
ringBuffer.getSelectedElements(
new Filter<Bulletin>() {
@Override
public boolean select(final Bulletin bulletin) {
return bulletin.getTimestamp().getTime() >= fiveMinutesAgo;
}
},
maxPerComponent));
}
return allComponentBulletins;
}
private <T extends Source> T waitForSource(String id, Class<T> type)
throws InterruptedException, InvalidSyntaxException {
T source = null;
long timeoutLimit = System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(5);
boolean available = false;
while (!available) {
if (source == null) {
source =
serviceManager
.getServiceReferences(type, null)
.stream()
.map(serviceManager::getService)
.filter(src -> id.equals(src.getId()))
.findFirst()
.orElse(null);
}
if (source != null) {
available = source.isAvailable();
}
if (!available) {
if (System.currentTimeMillis() > timeoutLimit) {
fail("Source (" + id + ") was not created in a timely manner.");
}
Thread.sleep(100);
}
}
LOGGER.info("Source {} is available.", id);
return source;
}
/** Created by RETRO on 23/08/2015. */
public class LocationManager {
private static final int NUM_UPDATES_INTERVAL = 1;
private static final long INTERVAL = TimeUnit.MINUTES.toMillis(5);
private static final int LOCATION_TIMEOUT = 2;
public static Observable<Location> checkLocation(Context mContext) {
ReactiveLocationProvider locationProvider = new ReactiveLocationProvider(mContext);
LocationRequest locationRequest =
LocationRequest.create()
.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
.setNumUpdates(NUM_UPDATES_INTERVAL)
.setInterval(INTERVAL);
Observable<Location> locationObservable =
locationProvider
.getLastKnownLocation()
.timeout(LOCATION_TIMEOUT, TimeUnit.SECONDS, Observable.just((Location) null))
.concatWith(locationProvider.getUpdatedLocation(locationRequest))
.distinctUntilChanged()
.observeOn(AndroidSchedulers.mainThread());
return locationObservable;
}
}
@Override
public void onReceive(Context context, Intent intent) {
// Get Bundles
Bundle extras = intent.getExtras();
// Unwrap bundle object
runTemp = extras.getDouble(TempService.TEMPKEY); // Hopfully get the temp.
double runRoc = extras.getDouble(TempService.ROCKEY); // Hopfully get the RoC.
long currentTime = extras.getLong(TempService.TIMEKEY); // Hopfully get the time.
int currentPower = extras.getInt(TempService.POWERKEY); // Hopfully get the Power.
double wantedRoC = extras.getDouble(TempService.WROCKEY); // Desired RoC
if (currentPower != tempBar.getProgress()) {
tempBar.setProgress(currentPower);
sendMessage("A" + String.format("%04d", currentPower));
}
if (runTemp > maxTempValue) {
maxTempValue = runTemp;
dispMaxT.setText("Max Temp: " + String.format("%5.2f", runTemp));
}
liveGraphXYSeries.add(currentTime / 10000, runTemp);
mChartView.repaint();
dispRunTime.setText(
"Time: "
+ String.format(
"%d:%02d",
TimeUnit.MILLISECONDS.toMinutes(currentTime),
TimeUnit.MILLISECONDS.toSeconds(currentTime)
- TimeUnit.MINUTES.toSeconds(
TimeUnit.MILLISECONDS.toMinutes(currentTime))));
dispTemp.setText("Temp: " + String.format("%5.2f", runTemp));
dispRoc.setText("Roc: " + String.format("%5.2f", runRoc) + "/min");
dispWRoC.setText("Target RoC: " + String.format("%5.2f", wantedRoC));
}
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
@Override
public void onTick(long millisUntilFinished) {
// Change milliseconds into MM:SS
String timeLeft =
String.format(
"%d : %02d",
TimeUnit.MILLISECONDS.toMinutes(millisUntilFinished),
TimeUnit.MILLISECONDS.toSeconds(millisUntilFinished)
- TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millisUntilFinished)));
// Display the countdown
countdown.setText(timeLeft);
// Check to see if it's time to change the sprite
if (!sprite.omelette) {
if (((millisUntilFinished <= 0.8 * duration) && sprite.eggStatus == 1)
|| // 80% done
((millisUntilFinished <= 0.6 * duration) && sprite.eggStatus == 2)
|| // 60% done
((millisUntilFinished <= 0.4 * duration) && sprite.eggStatus == 3)
|| // 40% done
((millisUntilFinished <= 0.2 * duration) && sprite.eggStatus == 4)) { // 20% done
sprite.nextStatus();
}
}
}
/**
* Format the time the current crawl run has taken into a more readable format.
*
* @param timeCrawlCalc the time to display
* @return the formatted time in X min, X sec layout.
*/
private String formatRunningTime(long timeCrawlCalc) {
return String.format(
"%d min, %d sec",
TimeUnit.MILLISECONDS.toMinutes(timeCrawlCalc),
TimeUnit.MILLISECONDS.toSeconds(timeCrawlCalc)
- TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(timeCrawlCalc)));
}
@Test
public void executeTests() throws IOException {
String testBase = server.whereIs("/selenium-server/tests");
Path outputFile =
Paths.get(StandardSystemProperty.JAVA_IO_TMPDIR.value())
.resolve("core-test-suite" + browser.replace('*', '-') + ".html");
if (Files.exists(outputFile)) {
Files.delete(outputFile);
}
Files.createDirectories(outputFile.getParent());
String result =
new HTMLLauncher()
.runHTMLSuite(
browser,
// We need to do this because the path relativizing code in java.net.URL is
// clearly having a bad day. "/selenium-server/tests" appended to "../tests/"
// ends up as "/tests" rather than "/selenium-server/tests" as you'd expect.
testBase + "/TestSuite.html",
testBase + "/TestSuite.html",
outputFile.toFile(),
TimeUnit.MINUTES.toSeconds(5),
null);
assertEquals("PASSED", result);
}
private void initializeThreads() {
int startdelay = (int) (SettingUtil.getSettingDouble("start_delay_seconds") * 20);
int savefrequency = SettingUtil.getSettingInt("save_interval_seconds") * 20;
if (startdelay <= 0) startdelay = 1;
if (savefrequency <= 0) savefrequency = 300;
// data
getServer()
.getScheduler()
.scheduleAsyncRepeatingTask(
this,
new Runnable() {
@Override
public void run() {
DataManager.saveAllData();
}
},
startdelay,
savefrequency);
getServer()
.getScheduler()
.scheduleAsyncRepeatingTask(
this,
new AsyncIPMatcherTask(),
50,
TimeUnit.MINUTES.toMillis(getConfig().getInt("cache_interval_seconds", 10)));
}
/*
Fast but not so readable. From here: http://stackoverflow.com/questions/9027317/how-to-convert-milliseconds-to-hhmmss-format
*/
public static String msToString(final long millis) {
long seconds =
TimeUnit.MILLISECONDS.toSeconds(millis)
- TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis));
long minutes =
TimeUnit.MILLISECONDS.toMinutes(millis)
- TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis));
long hours = TimeUnit.MILLISECONDS.toHours(millis);
StringBuilder b = new StringBuilder();
if (hours > 0) {
b.append(hours < 10 ? String.valueOf("" + hours) : String.valueOf(hours));
b.append(":");
}
b.append(
minutes == 0
? "00"
: minutes < 10 ? String.valueOf("0" + minutes) : String.valueOf(minutes));
b.append(":");
b.append(
seconds == 0
? "00"
: seconds < 10 ? String.valueOf("0" + seconds) : String.valueOf(seconds));
return b.toString();
}
// DATABASE
static void DataBaseExample() {
// send cluster client and name of the bucket
CouchbaseLogger db = new CouchbaseLogger(CouchbaseCluster.create(), "logger");
// naming the fields as you like , if you not mention names they wont apper in logs
db.date("date")
.method("method")
.exception("exception")
.file("file")
.level("level")
.line("line")
.thread("thread")
.message("message")
.className("class")
.setExpire((int) TimeUnit.MINUTES.toSeconds(1));
// create handler
Handler dbHandler = new DatabaseHandler(db);
// add handler
GlobLoggerPool.getLogger("log1").addHandler(dbHandler);
// send LOG
GlobLoggerPool.getLogger("log1")
.publish(new NullPointerException(), "This is gonna do alot of problems!", "WARNING");
}
/**
* Formats time-of-day using FIX UTCTimeOnly format (HH:mm:ss or HH:mm:ss.SSS). For example,
* "23:59:59.999". This class is thread safe.
*/
public final class TimeOfDayParser {
private static final int MILLIS_PER_HOUR = (int) TimeUnit.HOURS.toMillis(1);
private static final int MILLIS_PER_MINUTE = (int) TimeUnit.MINUTES.toMillis(1);
/** @return number of milliseconds since midnight */
public static int parseTimeOfDay(byte[] buffer, int valueOffset, int valueLength) {
// HH:mm:ss.SSS
// 012345678901
int hours = NumbersParser.parsePositiveInt(buffer, valueOffset + 0, 2);
int minutes = NumbersParser.parsePositiveInt(buffer, valueOffset + 3, 2);
int seconds = NumbersParser.parsePositiveInt(buffer, valueOffset + 6, 2);
int millis = (valueLength > 8) ? NumbersParser.parsePositiveInt(buffer, valueOffset + 9, 3) : 0;
if (hours >= 24 || minutes >= 60 || seconds >= 60)
throw new FixParserException("Invalid time of day");
return hours * MILLIS_PER_HOUR + minutes * MILLIS_PER_MINUTE + seconds * 1000 + millis;
}
/** Parses HH:MM:SS into array containing H,M,S elements */
public static int[] parseTimeOfDay(byte[] buffer) {
int[] result = new int[3];
result[0] = NumbersParser.parsePositiveInt(buffer, 0, 2);
result[1] = NumbersParser.parsePositiveInt(buffer, 3, 2);
result[2] = NumbersParser.parsePositiveInt(buffer, 6, 2);
if (result[0] >= 24 || result[1] >= 60 || result[2] >= 60)
throw new FixParserException("Invalid time of day");
return result;
}
}
public SerialMain(CommandLine cmd, MoteList motelist) {
this.cmd = cmd;
this.motelist = motelist;
// get value of time, if not set, use default 15
time = TimeUnit.MINUTES.toMillis(Integer.parseInt(cmd.getOptionValue("T")));
}
@PostConstruct
private void init() {
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
client = HttpClients.createDefault();
this.url = telegramUrl + telegramToken + "/sendMessage";
TimerTask timerTask =
new TimerTask() {
@Override
public void run() {
SendMessage sendMessage = null;
try {
if (!outQueue.isEmpty()) {
sendMessage = outQueue.take();
deliverMessage(sendMessage);
}
} catch (InterruptedException e) {
logger.error("error in reading outQueue", e);
} catch (Exception e) {
logger.error("error sending message " + sendMessage, e);
}
}
};
Timer timer = new Timer();
timer.schedule(timerTask, TimeUnit.MINUTES.toMillis(1), TimeUnit.MILLISECONDS.toMillis(200));
}
@Override
public void elaborate(Configuration config, Results results, long timeTaken) {
super.elaborate(config, results, timeTaken);
// saving results
System.out.println("Saving results...");
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddhhmmss");
String dateFormatted = sdf.format(new Date());
String pathOfFile =
config.getOutputFolder().getAbsolutePath()
+ File.separator
+ "results-"
+ dateFormatted
+ ".json";
saveToJson(results, pathOfFile);
String time =
String.format(
"%d h, %d m, %d s",
TimeUnit.MILLISECONDS.toHours(timeTaken),
TimeUnit.MILLISECONDS.toMinutes(timeTaken)
- TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(timeTaken)),
TimeUnit.MILLISECONDS.toSeconds(timeTaken)
- TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(timeTaken)));
System.out.println("Time taken: " + time);
}
/** Entry point for a streaming Fizz Buzz! */
public static void main(String[] args) throws Exception {
Topology topology = new Topology();
// Declare an infinite stream of Long values
TStream<Long> counting = BeaconStreams.longBeacon(topology);
// Throttle the rate to allow the output to be seen easier
counting = counting.throttle(100, TimeUnit.MILLISECONDS);
// Print the tuples to standard output
playFizzBuzz(counting).print();
// At this point the streaming topology (streaming) is
// declared, but no data is flowing. The topology
// must be submitted to a StreamsContext to be executed.
// Since this is an streaming graph with an endless
// data source it will run for ever
Future<?> runningTopology = StreamsContextFactory.getEmbedded().submit(topology);
// Run for one minute before canceling.
Thread.sleep(TimeUnit.MINUTES.toMillis(1));
runningTopology.cancel(true);
}
/**
* Creates a new Cluster based on the specified configuration.
*
* @param stormConf the storm configuration.
* @return a new a new {@link Cluster} instance.
*/
@Override
protected Cluster make(Map<String, Object> stormConf) {
CassandraConf cassandraConf = new CassandraConf(stormConf);
Cluster.Builder cluster =
Cluster.builder()
.withoutJMXReporting()
.withoutMetrics()
.addContactPoints(cassandraConf.getNodes())
.withPort(cassandraConf.getPort())
.withRetryPolicy(DowngradingConsistencyRetryPolicy.INSTANCE)
.withReconnectionPolicy(
new ExponentialReconnectionPolicy(100L, TimeUnit.MINUTES.toMillis(1)))
.withLoadBalancingPolicy(new TokenAwarePolicy(new RoundRobinPolicy()));
final String username = cassandraConf.getUsername();
final String password = cassandraConf.getPassword();
if (StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {
cluster.withAuthProvider(new PlainTextAuthProvider(username, password));
}
QueryOptions options =
new QueryOptions().setConsistencyLevel(cassandraConf.getConsistencyLevel());
cluster.withQueryOptions(options);
return cluster.build();
}
/**
* Special test for intervals that don't fit evenly into rounding interval. In this case, when
* interval crosses DST transition point, rounding in local time can land in a DST gap which
* results in wrong UTC rounding values.
*/
public void testIntervalRounding_NotDivisibleInteval() {
DateTimeZone tz = DateTimeZone.forID("CET");
long interval = TimeUnit.MINUTES.toMillis(14);
Rounding rounding = new Rounding.TimeIntervalRounding(interval, tz);
assertThat(
rounding.round(time("2016-03-27T01:41:00+01:00")),
isDate(time("2016-03-27T01:30:00+01:00"), tz));
assertThat(
rounding.round(time("2016-03-27T01:51:00+01:00")),
isDate(time("2016-03-27T01:44:00+01:00"), tz));
assertThat(
rounding.round(time("2016-03-27T01:59:00+01:00")),
isDate(time("2016-03-27T01:58:00+01:00"), tz));
assertThat(
rounding.round(time("2016-03-27T03:05:00+02:00")),
isDate(time("2016-03-27T03:00:00+02:00"), tz));
assertThat(
rounding.round(time("2016-03-27T03:12:00+02:00")),
isDate(time("2016-03-27T03:08:00+02:00"), tz));
assertThat(
rounding.round(time("2016-03-27T03:25:00+02:00")),
isDate(time("2016-03-27T03:22:00+02:00"), tz));
assertThat(
rounding.round(time("2016-03-27T03:39:00+02:00")),
isDate(time("2016-03-27T03:36:00+02:00"), tz));
}
private Properties getDefaultProperties() {
Properties defaultProps = new Properties();
// testing params, DONT TOUCH !!!
defaultProps.setProperty("openkad.keyfactory.keysize", "50");
defaultProps.setProperty("openkad.keyfactory.hashalgo", "SHA-256");
defaultProps.setProperty("openkad.bucket.kbuckets.maxsize", "16");
defaultProps.setProperty("openkad.color.nrcolors", "19");
defaultProps.setProperty("openkad.scheme.name", "openkad.udp");
// performance params
// handling incoming messages
defaultProps.setProperty("openkad.executors.server.nrthreads", "8");
defaultProps.setProperty("openkad.executors.server.max_pending", "512");
// handling registered callback
defaultProps.setProperty("openkad.executors.client.nrthreads", "1");
defaultProps.setProperty("openkad.executors.client.max_pending", "20");
// forwarding find node requests
defaultProps.setProperty("openkad.executors.forward.nrthreads", "2");
defaultProps.setProperty("openkad.executors.forward.max_pending", "2");
// executing the long find node operations
defaultProps.setProperty("openkad.executors.op.nrthreads", "1");
defaultProps.setProperty("openkad.executors.op.max_pending", "2");
// sending back pings
defaultProps.setProperty("openkad.executors.ping.nrthreads", "1");
defaultProps.setProperty("openkad.executors.ping.max_pending", "16");
// cache settings
defaultProps.setProperty("openkad.cache.validtime", TimeUnit.HOURS.toMillis(10) + "");
defaultProps.setProperty("openkad.cache.size", "100");
defaultProps.setProperty("openkad.cache.share", "1");
// minimum time between successive pings
defaultProps.setProperty("openkad.bucket.valid_timespan", TimeUnit.MINUTES.toMillis(1) + "");
// network timeouts and concurrency level
defaultProps.setProperty("openkad.net.concurrency", "1");
defaultProps.setProperty("openkad.net.timeout", TimeUnit.SECONDS.toMillis(1000) + "");
defaultProps.setProperty("openkad.net.forwarded.timeout", TimeUnit.SECONDS.toMillis(1200) + "");
defaultProps.setProperty("openkad.color.candidates", "1");
defaultProps.setProperty("openkad.color.slack.size", "1");
defaultProps.setProperty("openkad.color.allcolors", "95");
// interval between successive find node operations for refresh buckets
defaultProps.setProperty("openkad.refresh.interval", TimeUnit.SECONDS.toMillis(30000) + "");
// local configuration, please touch
defaultProps.setProperty("openkad.net.udp.port", "-1");
defaultProps.setProperty("openkad.local.key", "");
defaultProps.setProperty("openkad.file.nodes.path", "nodes");
// misc
defaultProps.setProperty("openkad.seed", "0");
// shani Skademia
defaultProps.setProperty("skademlia.siblinglist.size", "8");
defaultProps.setProperty("dht.storage.checkInterval", "" + TimeUnit.SECONDS.toMillis(30000));
return defaultProps;
}
@Test
@Ignore
public void runCanalInstanceTest() {
ActionFactory<TableAction> actionFactory =
new SingleSchemaActionFactory<>(
Schemas.buildSchema("autoparts", TableAction.class)
.addTable(
Schemas.buildTable("db_goods_stock")
.action(
new AbstractTableAction(
new SingleThreadCurrentHandleTable<TableAction>()) {
@Override
public void onAction(List<? extends RowChangedData> changedData) {
System.out.println("currentTable: " + getCurrentTable());
System.out.println(changedData);
}
})
.columns("id", "goods_id", "goods_number")
.columnCondition(Schemas.DEFAULT_DELETE_COLUMN_CONDITION))
.create());
CANAL_EXECUTOR.addInstanceHandle(new TableSectionHandle(LOCAL_ADDRESS, "shop", actionFactory));
ActionFactory<EventTypeAction> eventTypeFactory =
new SingleSchemaActionFactory<>(
Schemas.buildSchema("autoparts", EventTypeAction.class)
.addTable(
Schemas.buildTable("db_goods")
.action(
new EventTypeAction() {
@Override
public void onUpdateAction(List<RowChangedData.Update> updatedData) {
System.out.println("db_goods.onUpdateAction: " + updatedData);
}
@Override
public void onInsertAction(List<RowChangedData.Insert> insertedData) {
System.out.println("db_goods.onInsertAction: " + insertedData);
}
@Override
public void onDeleteAction(List<RowChangedData.Delete> deletedData) {
System.out.println("db_goods.onDeleteAction: " + deletedData);
}
})
.columns("goods_id", "goods_name", "cat_id", "new_goods_sn")
.columnCondition(
Conditions.unmodifiableContainer()
.mustCondition(Conditions.equal("is_delete", false))
.mustCondition(Conditions.equal("seller_id", 1))
.create()))
.create());
CANAL_EXECUTOR.addInstanceHandle(
new EventTypeSectionHandle(LOCAL_ADDRESS, "shop_goods", eventTypeFactory));
CANAL_EXECUTOR.startAllInstance(0L);
try {
TimeUnit.MINUTES.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* Return the timeout in seconds for the given TimeoutType.
*
* <p>It doesn't make sense to pass in the DEFAULT timeout type, because that is a
* context-sensitive timeout.
*
* @param timeout - the TimeoutType (other than DEFAULT) to get the timeout in seconds for.
* @return - the timeout in seconds
*/
public int getTimeoutInSeconds(TimeoutType timeout) {
Preconditions.checkNotNull(timeout, "Cannot get timeout for null timeout.");
Preconditions.checkArgument(
timeout != TimeoutType.DEFAULT,
"Can only get the standard timeout for timeout types other than DEFAULT");
switch (timeout) {
case CLICK_TIMEOUT:
return getClickTimeoutSeconds();
case WEB_ELEMENT_PRESENCE_TIMEOUT:
return getWebElementPresenceTimeoutSeconds();
case POLLING_WITH_REFRESH_TIMEOUT:
return getPollingWithRefreshTimeoutSeconds();
case PAGE_REFRESH_TIMEOUT:
return getPageRefreshTimeoutSeconds();
case PAGE_LOAD_TIMEOUT:
return getPageLoadTimeoutSeconds();
case SHORT:
return getShortTimeoutSeconds();
case MEDIUM:
return getMediumTimeoutSeconds();
case LONG:
return getLongTimeoutSeconds();
case ONE_SECOND:
return 1;
case TWO_SECONDS:
return 2;
case FIVE_SECONDS:
return 5;
case TEN_SECONDS:
return 10;
case TWENTY_SECONDS:
return 20;
case SIXTY_SECONDS:
return 60;
case THIRTY_MINUTES:
return (int) TimeUnit.MINUTES.toSeconds(30);
case SIXTY_MINUTES:
return (int) TimeUnit.MINUTES.toSeconds(60);
case NINETY_MINUTES:
return (int) TimeUnit.MINUTES.toSeconds(90);
case TWO_HOURS:
return (int) TimeUnit.HOURS.toSeconds(2);
default:
return getWebElementPresenceTimeoutSeconds();
}
}
