code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
protected void setInputElementValue(Node element, FormInput input) {
LOGGER.debug("INPUTFIELD: {} ({})", input.getIdentification(), input.getType());
if (element == null || input.getInputValues().isEmpty()) {
return;
}
try {
switch (input.getType()) {
case TEXT:
case TEXTAREA:
case PASSWORD:
handleText(input);
break;
case HIDDEN:
handleHidden(input);
break;
case CHECKBOX:
handleCheckBoxes(input);
break;
case RADIO:
handleRadioSwitches(input);
break;
case SELECT:
handleSelectBoxes(input);
}
} catch (ElementNotVisibleException e) {
LOGGER.warn("Element not visible, input not completed.");
} catch (BrowserConnectionException e) {
throw e;
} catch (RuntimeException e) {
LOGGER.error("Could not input element values", e);
}
} | java |
private void handleHidden(FormInput input) {
String text = input.getInputValues().iterator().next().getValue();
if (null == text || text.length() == 0) {
return;
}
WebElement inputElement = browser.getWebElement(input.getIdentification());
JavascriptExecutor js = (JavascriptExecutor) browser.getWebDriver();
js.executeScript("arguments[0].setAttribute(arguments[1], arguments[2]);", inputElement,
"value", text);
} | java |
@Override
public EmbeddedBrowser get() {
LOGGER.debug("Setting up a Browser");
// Retrieve the config values used
ImmutableSortedSet<String> filterAttributes =
configuration.getCrawlRules().getPreCrawlConfig().getFilterAttributeNames();
long crawlWaitReload = configuration.getCrawlRules().getWaitAfterReloadUrl();
long crawlWaitEvent = configuration.getCrawlRules().getWaitAfterEvent();
// Determine the requested browser type
EmbeddedBrowser browser = null;
EmbeddedBrowser.BrowserType browserType =
configuration.getBrowserConfig().getBrowserType();
try {
switch (browserType) {
case CHROME:
browser = newChromeBrowser(filterAttributes, crawlWaitReload, crawlWaitEvent,
false);
break;
case CHROME_HEADLESS:
browser = newChromeBrowser(filterAttributes, crawlWaitReload,
crawlWaitEvent, true);
break;
case FIREFOX:
browser = newFirefoxBrowser(filterAttributes, crawlWaitReload, crawlWaitEvent,
false);
break;
case FIREFOX_HEADLESS:
browser = newFirefoxBrowser(filterAttributes, crawlWaitReload, crawlWaitEvent,
true);
break;
case REMOTE:
browser = WebDriverBackedEmbeddedBrowser.withRemoteDriver(
configuration.getBrowserConfig().getRemoteHubUrl(), filterAttributes,
crawlWaitEvent, crawlWaitReload);
break;
case PHANTOMJS:
browser =
newPhantomJSDriver(filterAttributes, crawlWaitReload, crawlWaitEvent);
break;
default:
throw new IllegalStateException("Unrecognized browser type "
+ configuration.getBrowserConfig().getBrowserType());
}
} catch (IllegalStateException e) {
LOGGER.error("Crawling with {} failed: " + e.getMessage(), browserType.toString());
throw e;
}
/* for Retina display. */
if (browser instanceof WebDriverBackedEmbeddedBrowser) {
int pixelDensity =
this.configuration.getBrowserConfig().getBrowserOptions().getPixelDensity();
if (pixelDensity != -1)
((WebDriverBackedEmbeddedBrowser) browser).setPixelDensity(pixelDensity);
}
plugins.runOnBrowserCreatedPlugins(browser);
return browser;
} | java |
public StackTraceElement[] asStackTrace() {
int i = 1;
StackTraceElement[] list = new StackTraceElement[this.size()];
for (Eventable e : this) {
list[this.size() - i] =
new StackTraceElement(e.getEventType().toString(), e.getIdentification()
.toString(), e.getElement().toString(), i);
i++;
}
return list;
} | java |
public static WebDriverBackedEmbeddedBrowser withRemoteDriver(String hubUrl,
ImmutableSortedSet<String> filterAttributes, long crawlWaitEvent,
long crawlWaitReload) {
return WebDriverBackedEmbeddedBrowser.withDriver(buildRemoteWebDriver(hubUrl),
filterAttributes, crawlWaitEvent,
crawlWaitReload);
} | java |
public static WebDriverBackedEmbeddedBrowser withDriver(WebDriver driver,
ImmutableSortedSet<String> filterAttributes, long crawlWaitEvent,
long crawlWaitReload) {
return new WebDriverBackedEmbeddedBrowser(driver, filterAttributes, crawlWaitEvent,
crawlWaitReload);
} | java |
private static RemoteWebDriver buildRemoteWebDriver(String hubUrl) {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setPlatform(Platform.ANY);
URL url;
try {
url = new URL(hubUrl);
} catch (MalformedURLException e) {
LOGGER.error("The given hub url of the remote server is malformed can not continue!",
e);
return null;
}
HttpCommandExecutor executor = null;
try {
executor = new HttpCommandExecutor(url);
} catch (Exception e) {
// TODO Stefan; refactor this catch, this will definitely result in
// NullPointers, why
// not throw RuntimeException direct?
LOGGER.error(
"Received unknown exception while creating the "
+ "HttpCommandExecutor, can not continue!",
e);
return null;
}
return new RemoteWebDriver(executor, capabilities);
} | java |
@Override
public void handlePopups() {
/*
* try { executeJavaScript("window.alert = function(msg){return true;};" +
* "window.confirm = function(msg){return true;};" +
* "window.prompt = function(msg){return true;};"); } catch (CrawljaxException e) {
* LOGGER.error("Handling of PopUp windows failed", e); }
*/
/* Workaround: Popups handling currently not supported in PhantomJS. */
if (browser instanceof PhantomJSDriver) {
return;
}
if (ExpectedConditions.alertIsPresent().apply(browser) != null) {
try {
browser.switchTo().alert().accept();
LOGGER.info("Alert accepted");
} catch (Exception e) {
LOGGER.error("Handling of PopUp windows failed");
}
}
} | java |
private boolean fireEventWait(WebElement webElement, Eventable eventable)
throws ElementNotVisibleException, InterruptedException {
switch (eventable.getEventType()) {
case click:
try {
webElement.click();
} catch (ElementNotVisibleException e) {
throw e;
} catch (WebDriverException e) {
throwIfConnectionException(e);
return false;
}
break;
case hover:
LOGGER.info("EventType hover called but this isn't implemented yet");
break;
default:
LOGGER.info("EventType {} not supported in WebDriver.", eventable.getEventType());
return false;
}
Thread.sleep(this.crawlWaitEvent);
return true;
} | java |
private String filterAttributes(String html) {
String filteredHtml = html;
for (String attribute : this.filterAttributes) {
String regex = "\\s" + attribute + "=\"[^\"]*\"";
Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(html);
filteredHtml = m.replaceAll("");
}
return filteredHtml;
} | java |
@Override
public synchronized boolean fireEventAndWait(Eventable eventable)
throws ElementNotVisibleException, NoSuchElementException, InterruptedException {
try {
boolean handleChanged = false;
boolean result = false;
if (eventable.getRelatedFrame() != null && !eventable.getRelatedFrame().equals("")) {
LOGGER.debug("switching to frame: " + eventable.getRelatedFrame());
try {
switchToFrame(eventable.getRelatedFrame());
} catch (NoSuchFrameException e) {
LOGGER.debug("Frame not found, possibly while back-tracking..", e);
// TODO Stefan, This exception is caught to prevent stopping
// from working
// This was the case on the Gmail case; find out if not switching
// (catching)
// Results in good performance...
}
handleChanged = true;
}
WebElement webElement =
browser.findElement(eventable.getIdentification().getWebDriverBy());
if (webElement != null) {
result = fireEventWait(webElement, eventable);
}
if (handleChanged) {
browser.switchTo().defaultContent();
}
return result;
} catch (ElementNotVisibleException | NoSuchElementException e) {
throw e;
} catch (WebDriverException e) {
throwIfConnectionException(e);
return false;
}
} | java |
@Override
public Object executeJavaScript(String code) throws CrawljaxException {
try {
JavascriptExecutor js = (JavascriptExecutor) browser;
return js.executeScript(code);
} catch (WebDriverException e) {
throwIfConnectionException(e);
throw new CrawljaxException(e);
}
} | java |
private InputValue getInputValue(FormInput input) {
/* Get the DOM element from Selenium. */
WebElement inputElement = browser.getWebElement(input.getIdentification());
switch (input.getType()) {
case TEXT:
case PASSWORD:
case HIDDEN:
case SELECT:
case TEXTAREA:
return new InputValue(inputElement.getAttribute("value"));
case RADIO:
case CHECKBOX:
default:
String value = inputElement.getAttribute("value");
Boolean checked = inputElement.isSelected();
return new InputValue(value, checked);
}
} | java |
public static Properties loadProps(String filename) {
Properties props = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(filename);
props.load(fis);
return props;
} catch (IOException ex) {
throw new RuntimeException(ex);
} finally {
Closer.closeQuietly(fis);
}
} | java |
public static Properties getProps(Properties props, String name, Properties defaultProperties) {
final String propString = props.getProperty(name);
if (propString == null) return defaultProperties;
String[] propValues = propString.split(",");
if (propValues.length < 1) {
throw new IllegalArgumentException("Illegal format of specifying properties '" + propString + "'");
}
Properties properties = new Properties();
for (int i = 0; i < propValues.length; i++) {
String[] prop = propValues[i].split("=");
if (prop.length != 2) throw new IllegalArgumentException("Illegal format of specifying properties '" + propValues[i] + "'");
properties.put(prop[0], prop[1]);
}
return properties;
} | java |
public static String getString(Properties props, String name, String defaultValue) {
return props.containsKey(name) ? props.getProperty(name) : defaultValue;
} | java |
public static int read(ReadableByteChannel channel, ByteBuffer buffer) throws IOException {
int count = channel.read(buffer);
if (count == -1) throw new EOFException("Received -1 when reading from channel, socket has likely been closed.");
return count;
} | java |
public static void writeShortString(ByteBuffer buffer, String s) {
if (s == null) {
buffer.putShort((short) -1);
} else if (s.length() > Short.MAX_VALUE) {
throw new IllegalArgumentException("String exceeds the maximum size of " + Short.MAX_VALUE + ".");
} else {
byte[] data = getBytes(s); //topic support non-ascii character
buffer.putShort((short) data.length);
buffer.put(data);
}
} | java |
public static void putUnsignedInt(ByteBuffer buffer, int index, long value) {
buffer.putInt(index, (int) (value & 0xffffffffL));
} | java |
public static long crc32(byte[] bytes, int offset, int size) {
CRC32 crc = new CRC32();
crc.update(bytes, offset, size);
return crc.getValue();
} | java |
public static Thread newThread(String name, Runnable runnable, boolean daemon) {
Thread thread = new Thread(runnable, name);
thread.setDaemon(daemon);
return thread;
} | java |
private static void unregisterMBean(String name) {
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
try {
synchronized (mbs) {
ObjectName objName = new ObjectName(name);
if (mbs.isRegistered(objName)) {
mbs.unregisterMBean(objName);
}
}
} catch (Exception e) {
e.printStackTrace();
}
} | java |
@SuppressWarnings("resource")
public static FileChannel openChannel(File file, boolean mutable) throws IOException {
if (mutable) {
return new RandomAccessFile(file, "rw").getChannel();
}
return new FileInputStream(file).getChannel();
} | java |
@SuppressWarnings("unchecked")
public static <E> E getObject(String className) {
if (className == null) {
return (E) null;
}
try {
return (E) Class.forName(className).newInstance();
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
} | java |
public static String md5(byte[] source) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(source);
byte tmp[] = md.digest();
char str[] = new char[32];
int k = 0;
for (byte b : tmp) {
str[k++] = hexDigits[b >>> 4 & 0xf];
str[k++] = hexDigits[b & 0xf];
}
return new String(str);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
} | java |
public void append(LogSegment segment) {
while (true) {
List<LogSegment> curr = contents.get();
List<LogSegment> updated = new ArrayList<LogSegment>(curr);
updated.add(segment);
if (contents.compareAndSet(curr, updated)) {
return;
}
}
} | java |
public List<LogSegment> trunc(int newStart) {
if (newStart < 0) {
throw new IllegalArgumentException("Starting index must be positive.");
}
while (true) {
List<LogSegment> curr = contents.get();
int newLength = Math.max(curr.size() - newStart, 0);
List<LogSegment> updatedList = new ArrayList<LogSegment>(curr.subList(Math.min(newStart, curr.size() - 1),
curr.size()));
if (contents.compareAndSet(curr, updatedList)) {
return curr.subList(0, curr.size() - newLength);
}
}
} | java |
public LogSegment getLastView() {
List<LogSegment> views = getView();
return views.get(views.size() - 1);
} | java |
private void cleanupLogs() throws IOException {
logger.trace("Beginning log cleanup...");
int total = 0;
Iterator<Log> iter = getLogIterator();
long startMs = System.currentTimeMillis();
while (iter.hasNext()) {
Log log = iter.next();
total += cleanupExpiredSegments(log) + cleanupSegmentsToMaintainSize(log);
}
if (total > 0) {
logger.warn("Log cleanup completed. " + total + " files deleted in " + (System.currentTimeMillis() - startMs) / 1000 + " seconds");
} else {
logger.trace("Log cleanup completed. " + total + " files deleted in " + (System.currentTimeMillis() - startMs) / 1000 + " seconds");
}
} | java |
private int cleanupSegmentsToMaintainSize(final Log log) throws IOException {
if (logRetentionSize < 0 || log.size() < logRetentionSize) return 0;
List<LogSegment> toBeDeleted = log.markDeletedWhile(new LogSegmentFilter() {
long diff = log.size() - logRetentionSize;
public boolean filter(LogSegment segment) {
diff -= segment.size();
return diff >= 0;
}
});
return deleteSegments(log, toBeDeleted);
} | java |
private int deleteSegments(Log log, List<LogSegment> segments) {
int total = 0;
for (LogSegment segment : segments) {
boolean deleted = false;
try {
try {
segment.getMessageSet().close();
} catch (IOException e) {
logger.warn(e.getMessage(), e);
}
if (!segment.getFile().delete()) {
deleted = true;
} else {
total += 1;
}
} finally {
logger.warn(String.format("DELETE_LOG[%s] %s => %s", log.name, segment.getFile().getAbsolutePath(),
deleted));
}
}
return total;
} | java |
public void startup() {
if (config.getEnableZookeeper()) {
serverRegister.registerBrokerInZk();
for (String topic : getAllTopics()) {
serverRegister.processTask(new TopicTask(TopicTask.TaskType.CREATE, topic));
}
startupLatch.countDown();
}
logger.debug("Starting log flusher every {} ms with the following overrides {}", config.getFlushSchedulerThreadRate(), logFlushIntervalMap);
logFlusherScheduler.scheduleWithRate(new Runnable() {
public void run() {
flushAllLogs(false);
}
}, config.getFlushSchedulerThreadRate(), config.getFlushSchedulerThreadRate());
} | java |
public void flushAllLogs(final boolean force) {
Iterator<Log> iter = getLogIterator();
while (iter.hasNext()) {
Log log = iter.next();
try {
boolean needFlush = force;
if (!needFlush) {
long timeSinceLastFlush = System.currentTimeMillis() - log.getLastFlushedTime();
Integer logFlushInterval = logFlushIntervalMap.get(log.getTopicName());
if (logFlushInterval == null) {
logFlushInterval = config.getDefaultFlushIntervalMs();
}
final String flushLogFormat = "[%s] flush interval %d, last flushed %d, need flush? %s";
needFlush = timeSinceLastFlush >= logFlushInterval.intValue();
logger.trace(String.format(flushLogFormat, log.getTopicName(), logFlushInterval,
log.getLastFlushedTime(), needFlush));
}
if (needFlush) {
log.flush();
}
} catch (IOException ioe) {
logger.error("Error flushing topic " + log.getTopicName(), ioe);
logger.error("Halting due to unrecoverable I/O error while flushing logs: " + ioe.getMessage(), ioe);
Runtime.getRuntime().halt(1);
} catch (Exception e) {
logger.error("Error flushing topic " + log.getTopicName(), e);
}
}
} | java |
public ILog getLog(String topic, int partition) {
TopicNameValidator.validate(topic);
Pool<Integer, Log> p = getLogPool(topic, partition);
return p == null ? null : p.get(partition);
} | java |
public ILog getOrCreateLog(String topic, int partition) throws IOException {
final int configPartitionNumber = getPartition(topic);
if (partition >= configPartitionNumber) {
throw new IOException("partition is bigger than the number of configuration: " + configPartitionNumber);
}
boolean hasNewTopic = false;
Pool<Integer, Log> parts = getLogPool(topic, partition);
if (parts == null) {
Pool<Integer, Log> found = logs.putIfNotExists(topic, new Pool<Integer, Log>());
if (found == null) {
hasNewTopic = true;
}
parts = logs.get(topic);
}
//
Log log = parts.get(partition);
if (log == null) {
log = createLog(topic, partition);
Log found = parts.putIfNotExists(partition, log);
if (found != null) {
Closer.closeQuietly(log, logger);
log = found;
} else {
logger.info(format("Created log for [%s-%d], now create other logs if necessary", topic, partition));
final int configPartitions = getPartition(topic);
for (int i = 0; i < configPartitions; i++) {
getOrCreateLog(topic, i);
}
}
}
if (hasNewTopic && config.getEnableZookeeper()) {
topicRegisterTasks.add(new TopicTask(TopicTask.TaskType.CREATE, topic));
}
return log;
} | java |
public int createLogs(String topic, final int partitions, final boolean forceEnlarge) {
TopicNameValidator.validate(topic);
synchronized (logCreationLock) {
final int configPartitions = getPartition(topic);
if (configPartitions >= partitions || !forceEnlarge) {
return configPartitions;
}
topicPartitionsMap.put(topic, partitions);
if (config.getEnableZookeeper()) {
if (getLogPool(topic, 0) != null) {//created already
topicRegisterTasks.add(new TopicTask(TopicTask.TaskType.ENLARGE, topic));
} else {
topicRegisterTasks.add(new TopicTask(TopicTask.TaskType.CREATE, topic));
}
}
return partitions;
}
} | java |
public List<Long> getOffsets(OffsetRequest offsetRequest) {
ILog log = getLog(offsetRequest.topic, offsetRequest.partition);
if (log != null) {
return log.getOffsetsBefore(offsetRequest);
}
return ILog.EMPTY_OFFSETS;
} | java |
private Send handle(SelectionKey key, Receive request) {
final short requestTypeId = request.buffer().getShort();
final RequestKeys requestType = RequestKeys.valueOf(requestTypeId);
if (requestLogger.isTraceEnabled()) {
if (requestType == null) {
throw new InvalidRequestException("No mapping found for handler id " + requestTypeId);
}
String logFormat = "Handling %s request from %s";
requestLogger.trace(format(logFormat, requestType, channelFor(key).socket().getRemoteSocketAddress()));
}
RequestHandler handlerMapping = requesthandlerFactory.mapping(requestType, request);
if (handlerMapping == null) {
throw new InvalidRequestException("No handler found for request");
}
long start = System.nanoTime();
Send maybeSend = handlerMapping.handler(requestType, request);
stats.recordRequest(requestType, System.nanoTime() - start);
return maybeSend;
} | java |
public static Authentication build(String crypt) throws IllegalArgumentException {
if(crypt == null) {
return new PlainAuth(null);
}
String[] value = crypt.split(":");
if(value.length == 2 ) {
String type = value[0].trim();
String password = value[1].trim();
if(password!=null&&password.length()>0) {
if("plain".equals(type)) {
return new PlainAuth(password);
}
if("md5".equals(type)) {
return new Md5Auth(password);
}
if("crc32".equals(type)) {
return new Crc32Auth(Long.parseLong(password));
}
}
}
throw new IllegalArgumentException("error password: "+crypt);
} | java |
public static Broker createBroker(int id, String brokerInfoString) {
String[] brokerInfo = brokerInfoString.split(":");
String creator = brokerInfo[0].replace('#', ':');
String hostname = brokerInfo[1].replace('#', ':');
String port = brokerInfo[2];
boolean autocreated = Boolean.valueOf(brokerInfo.length > 3 ? brokerInfo[3] : "true");
return new Broker(id, creator, hostname, Integer.parseInt(port), autocreated);
} | java |
public static StringConsumers buildConsumer(
final String zookeeperConfig,//
final String topic,//
final String groupId, //
final IMessageListener<String> listener) {
return buildConsumer(zookeeperConfig, topic, groupId, listener, 2);
} | java |
public MessageSet read(long readOffset, long size) throws IOException {
return new FileMessageSet(channel, this.offset + readOffset, //
Math.min(this.offset + readOffset + size, highWaterMark()), false, new AtomicBoolean(false));
} | java |
public long[] append(MessageSet messages) throws IOException {
checkMutable();
long written = 0L;
while (written < messages.getSizeInBytes())
written += messages.writeTo(channel, 0, messages.getSizeInBytes());
long beforeOffset = setSize.getAndAdd(written);
return new long[]{written, beforeOffset};
} | java |
public void flush() throws IOException {
checkMutable();
long startTime = System.currentTimeMillis();
channel.force(true);
long elapsedTime = System.currentTimeMillis() - startTime;
LogFlushStats.recordFlushRequest(elapsedTime);
logger.debug("flush time " + elapsedTime);
setHighWaterMark.set(getSizeInBytes());
logger.debug("flush high water mark:" + highWaterMark());
} | java |
private long recover() throws IOException {
checkMutable();
long len = channel.size();
ByteBuffer buffer = ByteBuffer.allocate(4);
long validUpTo = 0;
long next = 0L;
do {
next = validateMessage(channel, validUpTo, len, buffer);
if (next >= 0) validUpTo = next;
} while (next >= 0);
channel.truncate(validUpTo);
setSize.set(validUpTo);
setHighWaterMark.set(validUpTo);
logger.info("recover high water mark:" + highWaterMark());
/* This should not be necessary, but fixes bug 6191269 on some OSs. */
channel.position(validUpTo);
needRecover.set(false);
return len - validUpTo;
} | java |
private long validateMessage(FileChannel channel, long start, long len, ByteBuffer buffer) throws IOException {
buffer.rewind();
int read = channel.read(buffer, start);
if (read < 4) return -1;
// check that we have sufficient bytes left in the file
int size = buffer.getInt(0);
if (size < Message.MinHeaderSize) return -1;
long next = start + 4 + size;
if (next > len) return -1;
// read the message
ByteBuffer messageBuffer = ByteBuffer.allocate(size);
long curr = start + 4;
while (messageBuffer.hasRemaining()) {
read = channel.read(messageBuffer, curr);
if (read < 0) throw new IllegalStateException("File size changed during recovery!");
else curr += read;
}
messageBuffer.rewind();
Message message = new Message(messageBuffer);
if (!message.isValid()) return -1;
else return next;
} | java |
public int createPartitions(String topic, int partitionNum, boolean enlarge) throws IOException {
KV<Receive, ErrorMapping> response = send(new CreaterRequest(topic, partitionNum, enlarge));
return Utils.deserializeIntArray(response.k.buffer())[0];
} | java |
public int deleteTopic(String topic, String password) throws IOException {
KV<Receive, ErrorMapping> response = send(new DeleterRequest(topic, password));
return Utils.deserializeIntArray(response.k.buffer())[0];
} | java |
public ByteBuffer payload() {
ByteBuffer payload = buffer.duplicate();
payload.position(headerSize(magic()));
payload = payload.slice();
payload.limit(payloadSize());
payload.rewind();
return payload;
} | java |
private void validateSegments(List<LogSegment> segments) {
synchronized (lock) {
for (int i = 0; i < segments.size() - 1; i++) {
LogSegment curr = segments.get(i);
LogSegment next = segments.get(i + 1);
if (curr.start() + curr.size() != next.start()) {
throw new IllegalStateException("The following segments don't validate: " + curr.getFile()
.getAbsolutePath() + ", " + next.getFile().getAbsolutePath());
}
}
}
} | java |
public MessageSet read(long offset, int length) throws IOException {
List<LogSegment> views = segments.getView();
LogSegment found = findRange(views, offset, views.size());
if (found == null) {
if (logger.isTraceEnabled()) {
logger.trace(format("NOT FOUND MessageSet from Log[%s], offset=%d, length=%d", name, offset, length));
}
return MessageSet.Empty;
}
return found.getMessageSet().read(offset - found.start(), length);
} | java |
public void flush() throws IOException {
if (unflushed.get() == 0) return;
synchronized (lock) {
if (logger.isTraceEnabled()) {
logger.debug("Flushing log '" + name + "' last flushed: " + getLastFlushedTime() + " current time: " + System
.currentTimeMillis());
}
segments.getLastView().getMessageSet().flush();
unflushed.set(0);
lastflushedTime.set(System.currentTimeMillis());
}
} | java |
public static <T extends Range> T findRange(List<T> ranges, long value, int arraySize) {
if (ranges.size() < 1) return null;
T first = ranges.get(0);
T last = ranges.get(arraySize - 1);
// check out of bounds
if (value < first.start() || value > last.start() + last.size()) {
throw new OffsetOutOfRangeException(format("offset %s is out of range (%s, %s)",//
value,first.start(),last.start()+last.size()));
}
// check at the end
if (value == last.start() + last.size()) return null;
int low = 0;
int high = arraySize - 1;
while (low <= high) {
int mid = (high + low) / 2;
T found = ranges.get(mid);
if (found.contains(value)) {
return found;
} else if (value < found.start()) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return null;
} | java |
public static String nameFromOffset(long offset) {
NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumIntegerDigits(20);
nf.setMaximumFractionDigits(0);
nf.setGroupingUsed(false);
return nf.format(offset) + Log.FileSuffix;
} | java |
List<LogSegment> markDeletedWhile(LogSegmentFilter filter) throws IOException {
synchronized (lock) {
List<LogSegment> view = segments.getView();
List<LogSegment> deletable = new ArrayList<LogSegment>();
for (LogSegment seg : view) {
if (filter.filter(seg)) {
deletable.add(seg);
}
}
for (LogSegment seg : deletable) {
seg.setDeleted(true);
}
int numToDelete = deletable.size();
//
// if we are deleting everything, create a new empty segment
if (numToDelete == view.size()) {
if (view.get(numToDelete - 1).size() > 0) {
roll();
} else {
// If the last segment to be deleted is empty and we roll the log, the new segment will have the same
// file name. So simply reuse the last segment and reset the modified time.
view.get(numToDelete - 1).getFile().setLastModified(System.currentTimeMillis());
numToDelete -= 1;
}
}
return segments.trunc(numToDelete);
}
} | java |
public void verifyMessageSize(int maxMessageSize) {
Iterator<MessageAndOffset> shallowIter = internalIterator(true);
while(shallowIter.hasNext()) {
MessageAndOffset messageAndOffset = shallowIter.next();
int payloadSize = messageAndOffset.message.payloadSize();
if(payloadSize > maxMessageSize) {
throw new MessageSizeTooLargeException("payload size of " + payloadSize + " larger than " + maxMessageSize);
}
}
} | java |
public void close() {
Closer.closeQuietly(acceptor);
for (Processor processor : processors) {
Closer.closeQuietly(processor);
}
} | java |
public void startup() throws InterruptedException {
final int maxCacheConnectionPerThread = serverConfig.getMaxConnections() / processors.length;
logger.debug("start {} Processor threads",processors.length);
for (int i = 0; i < processors.length; i++) {
processors[i] = new Processor(handlerFactory, stats, maxRequestSize, maxCacheConnectionPerThread);
Utils.newThread("jafka-processor-" + i, processors[i], false).start();
}
Utils.newThread("jafka-acceptor", acceptor, false).start();
acceptor.awaitStartup();
} | java |
public static List<String> getChildrenParentMayNotExist(ZkClient zkClient, String path) {
try {
return zkClient.getChildren(path);
} catch (ZkNoNodeException e) {
return null;
}
} | java |
public static Cluster getCluster(ZkClient zkClient) {
Cluster cluster = new Cluster();
List<String> nodes = getChildrenParentMayNotExist(zkClient, BrokerIdsPath);
for (String node : nodes) {
final String brokerInfoString = readData(zkClient, BrokerIdsPath + "/" + node);
cluster.add(Broker.createBroker(Integer.valueOf(node), brokerInfoString));
}
return cluster;
} | java |
public static Map<String, List<String>> getPartitionsForTopics(ZkClient zkClient, Collection<String> topics) {
Map<String, List<String>> ret = new HashMap<String, List<String>>();
for (String topic : topics) {
List<String> partList = new ArrayList<String>();
List<String> brokers = getChildrenParentMayNotExist(zkClient, BrokerTopicsPath + "/" + topic);
if (brokers != null) {
for (String broker : brokers) {
final String parts = readData(zkClient, BrokerTopicsPath + "/" + topic + "/" + broker);
int nParts = Integer.parseInt(parts);
for (int i = 0; i < nParts; i++) {
partList.add(broker + "-" + i);
}
}
}
Collections.sort(partList);
ret.put(topic, partList);
}
return ret;
} | java |
public static Map<String, List<String>> getConsumersPerTopic(ZkClient zkClient, String group) {
ZkGroupDirs dirs = new ZkGroupDirs(group);
List<String> consumers = getChildrenParentMayNotExist(zkClient, dirs.consumerRegistryDir);
//
Map<String, List<String>> consumersPerTopicMap = new HashMap<String, List<String>>();
for (String consumer : consumers) {
TopicCount topicCount = getTopicCount(zkClient, group, consumer);
for (Map.Entry<String, Set<String>> e : topicCount.getConsumerThreadIdsPerTopic().entrySet()) {
final String topic = e.getKey();
for (String consumerThreadId : e.getValue()) {
List<String> list = consumersPerTopicMap.get(topic);
if (list == null) {
list = new ArrayList<String>();
consumersPerTopicMap.put(topic, list);
}
//
list.add(consumerThreadId);
}
}
}
//
for (Map.Entry<String, List<String>> e : consumersPerTopicMap.entrySet()) {
Collections.sort(e.getValue());
}
return consumersPerTopicMap;
} | java |
public static void createEphemeralPath(ZkClient zkClient, String path, String data) {
try {
zkClient.createEphemeral(path, Utils.getBytes(data));
} catch (ZkNoNodeException e) {
createParentPath(zkClient, path);
zkClient.createEphemeral(path, Utils.getBytes(data));
}
} | java |
public void addProducer(Broker broker) {
Properties props = new Properties();
props.put("host", broker.host);
props.put("port", "" + broker.port);
props.putAll(config.getProperties());
if (sync) {
SyncProducer producer = new SyncProducer(new SyncProducerConfig(props));
logger.info("Creating sync producer for broker id = " + broker.id + " at " + broker.host + ":" + broker.port);
syncProducers.put(broker.id, producer);
} else {
AsyncProducer<V> producer = new AsyncProducer<V>(new AsyncProducerConfig(props),//
new SyncProducer(new SyncProducerConfig(props)),//
serializer,//
eventHandler,//
config.getEventHandlerProperties(),//
this.callbackHandler, //
config.getCbkHandlerProperties());
producer.start();
logger.info("Creating async producer for broker id = " + broker.id + " at " + broker.host + ":" + broker.port);
asyncProducers.put(broker.id, producer);
}
} | java |
public void send(ProducerPoolData<V> ppd) {
if (logger.isDebugEnabled()) {
logger.debug("send message: " + ppd);
}
if (sync) {
Message[] messages = new Message[ppd.data.size()];
int index = 0;
for (V v : ppd.data) {
messages[index] = serializer.toMessage(v);
index++;
}
ByteBufferMessageSet bbms = new ByteBufferMessageSet(config.getCompressionCodec(), messages);
ProducerRequest request = new ProducerRequest(ppd.topic, ppd.partition.partId, bbms);
SyncProducer producer = syncProducers.get(ppd.partition.brokerId);
if (producer == null) {
throw new UnavailableProducerException("Producer pool has not been initialized correctly. " + "Sync Producer for broker "
+ ppd.partition.brokerId + " does not exist in the pool");
}
producer.send(request.topic, request.partition, request.messages);
} else {
AsyncProducer<V> asyncProducer = asyncProducers.get(ppd.partition.brokerId);
for (V v : ppd.data) {
asyncProducer.send(ppd.topic, v, ppd.partition.partId);
}
}
} | java |
public void close() {
logger.info("Closing all sync producers");
if (sync) {
for (SyncProducer p : syncProducers.values()) {
p.close();
}
} else {
for (AsyncProducer<V> p : asyncProducers.values()) {
p.close();
}
}
} | java |
public ProducerPoolData<V> getProducerPoolData(String topic, Partition bidPid, List<V> data) {
return new ProducerPoolData<V>(topic, bidPid, data);
} | java |
public static ProducerRequest readFrom(ByteBuffer buffer) {
String topic = Utils.readShortString(buffer);
int partition = buffer.getInt();
int messageSetSize = buffer.getInt();
ByteBuffer messageSetBuffer = buffer.slice();
messageSetBuffer.limit(messageSetSize);
buffer.position(buffer.position() + messageSetSize);
return new ProducerRequest(topic, partition, new ByteBufferMessageSet(messageSetBuffer));
} | java |
protected String getExpectedMessage() {
StringBuilder syntax = new StringBuilder("<tag> ");
syntax.append(getName());
String args = getArgSyntax();
if (args != null && args.length() > 0) {
syntax.append(' ');
syntax.append(args);
}
return syntax.toString();
} | java |
public ServerSetup createCopy(String bindAddress) {
ServerSetup setup = new ServerSetup(getPort(), bindAddress, getProtocol());
setup.setServerStartupTimeout(getServerStartupTimeout());
setup.setConnectionTimeout(getConnectionTimeout());
setup.setReadTimeout(getReadTimeout());
setup.setWriteTimeout(getWriteTimeout());
setup.setVerbose(isVerbose());
return setup;
} | java |
public static ServerSetup[] verbose(ServerSetup[] serverSetups) {
ServerSetup[] copies = new ServerSetup[serverSetups.length];
for (int i = 0; i < serverSetups.length; i++) {
copies[i] = serverSetups[i].createCopy().setVerbose(true);
}
return copies;
} | java |
public void doRun(Properties properties) {
ServerSetup[] serverSetup = new PropertiesBasedServerSetupBuilder().build(properties);
if (serverSetup.length == 0) {
printUsage(System.out);
} else {
greenMail = new GreenMail(serverSetup);
log.info("Starting GreenMail standalone v{} using {}",
BuildInfo.INSTANCE.getProjectVersion(), Arrays.toString(serverSetup));
greenMail.withConfiguration(new PropertiesBasedGreenMailConfigurationBuilder().build(properties))
.start();
}
} | java |
private String decodeStr(String str) {
try {
return MimeUtility.decodeText(str);
} catch (UnsupportedEncodingException e) {
return str;
}
} | java |
public static void copyStream(final InputStream src, OutputStream dest) throws IOException {
byte[] buffer = new byte[1024];
int read;
while ((read = src.read(buffer)) > -1) {
dest.write(buffer, 0, read);
}
dest.flush();
} | java |
public static int getLineCount(String str) {
if (null == str || str.isEmpty()) {
return 0;
}
int count = 1;
for (char c : str.toCharArray()) {
if ('\n' == c) {
count++;
}
}
return count;
} | java |
public static void sendTextEmail(String to, String from, String subject, String msg, final ServerSetup setup) {
sendMimeMessage(createTextEmail(to, from, subject, msg, setup));
} | java |
public static void sendMimeMessage(MimeMessage mimeMessage) {
try {
Transport.send(mimeMessage);
} catch (MessagingException e) {
throw new IllegalStateException("Can not send message " + mimeMessage, e);
}
} | java |
public static void sendMessageBody(String to, String from, String subject, Object body, String contentType, ServerSetup serverSetup) {
try {
Session smtpSession = getSession(serverSetup);
MimeMessage mimeMessage = new MimeMessage(smtpSession);
mimeMessage.setRecipients(Message.RecipientType.TO, to);
mimeMessage.setFrom(from);
mimeMessage.setSubject(subject);
mimeMessage.setContent(body, contentType);
sendMimeMessage(mimeMessage);
} catch (MessagingException e) {
throw new IllegalStateException("Can not send message", e);
}
} | java |
public static MimeMultipart createMultipartWithAttachment(String msg, final byte[] attachment, final String contentType,
final String filename, String description) {
try {
MimeMultipart multiPart = new MimeMultipart();
MimeBodyPart textPart = new MimeBodyPart();
multiPart.addBodyPart(textPart);
textPart.setText(msg);
MimeBodyPart binaryPart = new MimeBodyPart();
multiPart.addBodyPart(binaryPart);
DataSource ds = new DataSource() {
@Override
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(attachment);
}
@Override
public OutputStream getOutputStream() throws IOException {
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
byteStream.write(attachment);
return byteStream;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public String getName() {
return filename;
}
};
binaryPart.setDataHandler(new DataHandler(ds));
binaryPart.setFileName(filename);
binaryPart.setDescription(description);
return multiPart;
} catch (MessagingException e) {
throw new IllegalArgumentException("Can not create multipart message with attachment", e);
}
} | java |
public static Session getSession(final ServerSetup setup, Properties mailProps) {
Properties props = setup.configureJavaMailSessionProperties(mailProps, false);
log.debug("Mail session properties are {}", props);
return Session.getInstance(props, null);
} | java |
public static void setQuota(final GreenMailUser user, final Quota quota) {
Session session = GreenMailUtil.getSession(ServerSetupTest.IMAP);
try {
Store store = session.getStore("imap");
store.connect(user.getEmail(), user.getPassword());
try {
((QuotaAwareStore) store).setQuota(quota);
} finally {
store.close();
}
} catch (Exception ex) {
throw new IllegalStateException("Can not set quota " + quota
+ " for user " + user, ex);
}
} | java |
public boolean hasUser(String userId) {
String normalized = normalizerUserName(userId);
return loginToUser.containsKey(normalized) || emailToUser.containsKey(normalized);
} | java |
protected void closeServerSocket() {
// Close server socket, we do not accept new requests anymore.
// This also terminates the server thread if blocking on socket.accept.
if (null != serverSocket) {
try {
if (!serverSocket.isClosed()) {
serverSocket.close();
if (log.isTraceEnabled()) {
log.trace("Closed server socket " + serverSocket + "/ref="
+ Integer.toHexString(System.identityHashCode(serverSocket))
+ " for " + getName());
}
}
} catch (IOException e) {
throw new IllegalStateException("Failed to successfully quit server " + getName(), e);
}
}
} | java |
protected synchronized void quit() {
log.debug("Stopping {}", getName());
closeServerSocket();
// Close all handlers. Handler threads terminate if run loop exits
synchronized (handlers) {
for (ProtocolHandler handler : handlers) {
handler.close();
}
handlers.clear();
}
log.debug("Stopped {}", getName());
} | java |
@Override
public final synchronized void stopService(long millis) {
running = false;
try {
if (keepRunning) {
keepRunning = false;
interrupt();
quit();
if (0L == millis) {
join();
} else {
join(millis);
}
}
} catch (InterruptedException e) {
//its possible that the thread exits between the lines keepRunning=false and interrupt above
log.warn("Got interrupted while stopping {}", this, e);
Thread.currentThread().interrupt();
}
} | java |
private static Date getSentDate(MimeMessage msg, Date defaultVal) {
if (msg == null) {
return defaultVal;
}
try {
Date sentDate = msg.getSentDate();
if (sentDate == null) {
return defaultVal;
} else {
return sentDate;
}
} catch (MessagingException me) {
return new Date();
}
} | java |
private String parseEnvelope() {
List<String> response = new ArrayList<>();
//1. Date ---------------
response.add(LB + Q + sentDateEnvelopeString + Q + SP);
//2. Subject ---------------
if (subject != null && (subject.length() != 0)) {
response.add(Q + escapeHeader(subject) + Q + SP);
} else {
response.add(NIL + SP);
}
//3. From ---------------
addAddressToEnvelopeIfAvailable(from, response);
response.add(SP);
//4. Sender ---------------
addAddressToEnvelopeIfAvailableWithNetscapeFeature(sender, response);
response.add(SP);
addAddressToEnvelopeIfAvailableWithNetscapeFeature(replyTo, response);
response.add(SP);
addAddressToEnvelopeIfAvailable(to, response);
response.add(SP);
addAddressToEnvelopeIfAvailable(cc, response);
response.add(SP);
addAddressToEnvelopeIfAvailable(bcc, response);
response.add(SP);
if (inReplyTo != null && inReplyTo.length > 0) {
response.add(inReplyTo[0]);
} else {
response.add(NIL);
}
response.add(SP);
if (messageID != null && messageID.length > 0) {
messageID[0] = escapeHeader(messageID[0]);
response.add(Q + messageID[0] + Q);
} else {
response.add(NIL);
}
response.add(RB);
StringBuilder buf = new StringBuilder(16 * response.size());
for (String aResponse : response) {
buf.append(aResponse);
}
return buf.toString();
} | java |
private String parseAddress(String address) {
try {
StringBuilder buf = new StringBuilder();
InternetAddress[] netAddrs = InternetAddress.parseHeader(address, false);
for (InternetAddress netAddr : netAddrs) {
if (buf.length() > 0) {
buf.append(SP);
}
buf.append(LB);
String personal = netAddr.getPersonal();
if (personal != null && (personal.length() != 0)) {
buf.append(Q).append(personal).append(Q);
} else {
buf.append(NIL);
}
buf.append(SP);
buf.append(NIL); // should add route-addr
buf.append(SP);
try {
// Remove quotes to avoid double quoting
MailAddress mailAddr = new MailAddress(netAddr.getAddress().replaceAll("\"", "\\\\\""));
buf.append(Q).append(mailAddr.getUser()).append(Q);
buf.append(SP);
buf.append(Q).append(mailAddr.getHost()).append(Q);
} catch (Exception pe) {
buf.append(NIL + SP + NIL);
}
buf.append(RB);
}
return buf.toString();
} catch (AddressException e) {
throw new RuntimeException("Failed to parse address: " + address, e);
}
} | java |
void decodeContentType(String rawLine) {
int slash = rawLine.indexOf('/');
if (slash == -1) {
// if (DEBUG) getLogger().debug("decoding ... no slash found");
return;
} else {
primaryType = rawLine.substring(0, slash).trim();
}
int semicolon = rawLine.indexOf(';');
if (semicolon == -1) {
// if (DEBUG) getLogger().debug("decoding ... no semicolon found");
secondaryType = rawLine.substring(slash + 1).trim();
return;
}
// have parameters
secondaryType = rawLine.substring(slash + 1, semicolon).trim();
Header h = new Header(rawLine);
parameters = h.getParams();
} | java |
protected void doConfigure() {
if (config != null) {
for (UserBean user : config.getUsersToCreate()) {
setUser(user.getEmail(), user.getLogin(), user.getPassword());
}
getManagers().getUserManager().setAuthRequired(!config.isAuthenticationDisabled());
}
} | java |
public static InternetPrintWriter createForEncoding(OutputStream outputStream, boolean autoFlush, Charset charset) {
return new InternetPrintWriter(new OutputStreamWriter(outputStream, charset), autoFlush);
} | java |
protected Map<String, AbstractServer> createServices(ServerSetup[] config, Managers mgr) {
Map<String, AbstractServer> srvc = new HashMap<>();
for (ServerSetup setup : config) {
if (srvc.containsKey(setup.getProtocol())) {
throw new IllegalArgumentException("Server '" + setup.getProtocol() + "' was found at least twice in the array");
}
final String protocol = setup.getProtocol();
if (protocol.startsWith(ServerSetup.PROTOCOL_SMTP)) {
srvc.put(protocol, new SmtpServer(setup, mgr));
} else if (protocol.startsWith(ServerSetup.PROTOCOL_POP3)) {
srvc.put(protocol, new Pop3Server(setup, mgr));
} else if (protocol.startsWith(ServerSetup.PROTOCOL_IMAP)) {
srvc.put(protocol, new ImapServer(setup, mgr));
}
}
return srvc;
} | java |
public void okResponse(String responseCode, String message) {
untagged();
message(OK);
responseCode(responseCode);
message(message);
end();
} | java |
@Override
public void close() {
// Use monitor to avoid race between external close and handler thread run()
synchronized (closeMonitor) {
// Close and clear streams, sockets etc.
if (socket != null) {
try {
// Terminates thread blocking on socket read
// and automatically closed depending streams
socket.close();
} catch (IOException e) {
log.warn("Can not close socket", e);
} finally {
socket = null;
}
}
// Clear user data
session = null;
response = null;
}
} | java |
public static InputStream toStream(String content, Charset charset) {
byte[] bytes = content.getBytes(charset);
return new ByteArrayInputStream(bytes);
} | java |
public GreenMailConfiguration build(Properties properties) {
GreenMailConfiguration configuration = new GreenMailConfiguration();
String usersParam = properties.getProperty(GREENMAIL_USERS);
if (null != usersParam) {
String[] usersArray = usersParam.split(",");
for (String user : usersArray) {
extractAndAddUser(configuration, user);
}
}
String disabledAuthentication = properties.getProperty(GREENMAIL_AUTH_DISABLED);
if (null != disabledAuthentication) {
configuration.withDisabledAuthentication();
}
return configuration;
} | java |
private ServerSetup[] createServerSetup() {
List<ServerSetup> setups = new ArrayList<>();
if (smtpProtocol) {
smtpServerSetup = createTestServerSetup(ServerSetup.SMTP);
setups.add(smtpServerSetup);
}
if (smtpsProtocol) {
smtpsServerSetup = createTestServerSetup(ServerSetup.SMTPS);
setups.add(smtpsServerSetup);
}
if (pop3Protocol) {
setups.add(createTestServerSetup(ServerSetup.POP3));
}
if (pop3sProtocol) {
setups.add(createTestServerSetup(ServerSetup.POP3S));
}
if (imapProtocol) {
setups.add(createTestServerSetup(ServerSetup.IMAP));
}
if (imapsProtocol) {
setups.add(createTestServerSetup(ServerSetup.IMAPS));
}
return setups.toArray(new ServerSetup[setups.size()]);
} | java |
public String tag(ImapRequestLineReader request) throws ProtocolException {
CharacterValidator validator = new TagCharValidator();
return consumeWord(request, validator);
} | java |
public String astring(ImapRequestLineReader request) throws ProtocolException {
char next = request.nextWordChar();
switch (next) {
case '"':
return consumeQuoted(request);
case '{':
return consumeLiteral(request);
default:
return atom(request);
}
} | java |
public String nstring(ImapRequestLineReader request) throws ProtocolException {
char next = request.nextWordChar();
switch (next) {
case '"':
return consumeQuoted(request);
case '{':
return consumeLiteral(request);
default:
String value = atom(request);
if ("NIL".equals(value)) {
return null;
} else {
throw new ProtocolException("Invalid nstring value: valid values are '\"...\"', '{12} CRLF *CHAR8', and 'NIL'.");
}
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.