_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4000
|
Utils.getString
|
train
|
public static String getString(Properties props, String name, String defaultValue) {
return props.containsKey(name) ? props.getProperty(name) : defaultValue;
}
|
java
|
{
"resource": ""
}
|
q4001
|
Utils.read
|
train
|
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
|
{
"resource": ""
}
|
q4002
|
Utils.writeShortString
|
train
|
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
|
{
"resource": ""
}
|
q4003
|
Utils.putUnsignedInt
|
train
|
public static void putUnsignedInt(ByteBuffer buffer, int index, long value) {
buffer.putInt(index, (int) (value & 0xffffffffL));
}
|
java
|
{
"resource": ""
}
|
q4004
|
Utils.crc32
|
train
|
public static long crc32(byte[] bytes, int offset, int size) {
CRC32 crc = new CRC32();
crc.update(bytes, offset, size);
return crc.getValue();
}
|
java
|
{
"resource": ""
}
|
q4005
|
Utils.newThread
|
train
|
public static Thread newThread(String name, Runnable runnable, boolean daemon) {
Thread thread = new Thread(runnable, name);
thread.setDaemon(daemon);
return thread;
}
|
java
|
{
"resource": ""
}
|
q4006
|
Utils.unregisterMBean
|
train
|
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
|
{
"resource": ""
}
|
q4007
|
Utils.openChannel
|
train
|
@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
|
{
"resource": ""
}
|
q4008
|
Utils.getObject
|
train
|
@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
|
{
"resource": ""
}
|
q4009
|
Utils.md5
|
train
|
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
|
{
"resource": ""
}
|
q4010
|
SegmentList.append
|
train
|
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
|
{
"resource": ""
}
|
q4011
|
SegmentList.trunc
|
train
|
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
|
{
"resource": ""
}
|
q4012
|
SegmentList.getLastView
|
train
|
public LogSegment getLastView() {
List<LogSegment> views = getView();
return views.get(views.size() - 1);
}
|
java
|
{
"resource": ""
}
|
q4013
|
LogManager.cleanupLogs
|
train
|
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
|
{
"resource": ""
}
|
q4014
|
LogManager.cleanupSegmentsToMaintainSize
|
train
|
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
|
{
"resource": ""
}
|
q4015
|
LogManager.deleteSegments
|
train
|
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
|
{
"resource": ""
}
|
q4016
|
LogManager.startup
|
train
|
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
|
{
"resource": ""
}
|
q4017
|
LogManager.flushAllLogs
|
train
|
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
|
{
"resource": ""
}
|
q4018
|
LogManager.getLog
|
train
|
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
|
{
"resource": ""
}
|
q4019
|
LogManager.getOrCreateLog
|
train
|
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
|
{
"resource": ""
}
|
q4020
|
LogManager.createLogs
|
train
|
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
|
{
"resource": ""
}
|
q4021
|
LogManager.getOffsets
|
train
|
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
|
{
"resource": ""
}
|
q4022
|
Processor.handle
|
train
|
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
|
{
"resource": ""
}
|
q4023
|
Authentication.build
|
train
|
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
|
{
"resource": ""
}
|
q4024
|
Broker.createBroker
|
train
|
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
|
{
"resource": ""
}
|
q4025
|
StringConsumers.buildConsumer
|
train
|
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
|
{
"resource": ""
}
|
q4026
|
FileMessageSet.read
|
train
|
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
|
{
"resource": ""
}
|
q4027
|
FileMessageSet.append
|
train
|
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
|
{
"resource": ""
}
|
q4028
|
FileMessageSet.flush
|
train
|
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
|
{
"resource": ""
}
|
q4029
|
FileMessageSet.recover
|
train
|
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
|
{
"resource": ""
}
|
q4030
|
FileMessageSet.validateMessage
|
train
|
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
|
{
"resource": ""
}
|
q4031
|
AdminOperation.createPartitions
|
train
|
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
|
{
"resource": ""
}
|
q4032
|
AdminOperation.deleteTopic
|
train
|
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
|
{
"resource": ""
}
|
q4033
|
Message.payload
|
train
|
public ByteBuffer payload() {
ByteBuffer payload = buffer.duplicate();
payload.position(headerSize(magic()));
payload = payload.slice();
payload.limit(payloadSize());
payload.rewind();
return payload;
}
|
java
|
{
"resource": ""
}
|
q4034
|
Log.validateSegments
|
train
|
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
|
{
"resource": ""
}
|
q4035
|
Log.read
|
train
|
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
|
{
"resource": ""
}
|
q4036
|
Log.flush
|
train
|
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
|
{
"resource": ""
}
|
q4037
|
Log.findRange
|
train
|
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
|
{
"resource": ""
}
|
q4038
|
Log.nameFromOffset
|
train
|
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
|
{
"resource": ""
}
|
q4039
|
Log.markDeletedWhile
|
train
|
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
|
{
"resource": ""
}
|
q4040
|
ByteBufferMessageSet.verifyMessageSize
|
train
|
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
|
{
"resource": ""
}
|
q4041
|
SocketServer.close
|
train
|
public void close() {
Closer.closeQuietly(acceptor);
for (Processor processor : processors) {
Closer.closeQuietly(processor);
}
}
|
java
|
{
"resource": ""
}
|
q4042
|
SocketServer.startup
|
train
|
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
|
{
"resource": ""
}
|
q4043
|
ZkUtils.getChildrenParentMayNotExist
|
train
|
public static List<String> getChildrenParentMayNotExist(ZkClient zkClient, String path) {
try {
return zkClient.getChildren(path);
} catch (ZkNoNodeException e) {
return null;
}
}
|
java
|
{
"resource": ""
}
|
q4044
|
ZkUtils.getCluster
|
train
|
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
|
{
"resource": ""
}
|
q4045
|
ZkUtils.getPartitionsForTopics
|
train
|
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
|
{
"resource": ""
}
|
q4046
|
ZkUtils.getConsumersPerTopic
|
train
|
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
|
{
"resource": ""
}
|
q4047
|
ZkUtils.createEphemeralPath
|
train
|
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
|
{
"resource": ""
}
|
q4048
|
ProducerPool.addProducer
|
train
|
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
|
{
"resource": ""
}
|
q4049
|
ProducerPool.send
|
train
|
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
|
{
"resource": ""
}
|
q4050
|
ProducerPool.close
|
train
|
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
|
{
"resource": ""
}
|
q4051
|
ProducerPool.getProducerPoolData
|
train
|
public ProducerPoolData<V> getProducerPoolData(String topic, Partition bidPid, List<V> data) {
return new ProducerPoolData<V>(topic, bidPid, data);
}
|
java
|
{
"resource": ""
}
|
q4052
|
ProducerRequest.readFrom
|
train
|
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
|
{
"resource": ""
}
|
q4053
|
CommandTemplate.getExpectedMessage
|
train
|
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
|
{
"resource": ""
}
|
q4054
|
ServerSetup.createCopy
|
train
|
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
|
{
"resource": ""
}
|
q4055
|
ServerSetup.verbose
|
train
|
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
|
{
"resource": ""
}
|
q4056
|
GreenMailStandaloneRunner.doRun
|
train
|
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
|
{
"resource": ""
}
|
q4057
|
MailAddress.decodeStr
|
train
|
private String decodeStr(String str) {
try {
return MimeUtility.decodeText(str);
} catch (UnsupportedEncodingException e) {
return str;
}
}
|
java
|
{
"resource": ""
}
|
q4058
|
GreenMailUtil.copyStream
|
train
|
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
|
{
"resource": ""
}
|
q4059
|
GreenMailUtil.getLineCount
|
train
|
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
|
{
"resource": ""
}
|
q4060
|
GreenMailUtil.sendTextEmail
|
train
|
public static void sendTextEmail(String to, String from, String subject, String msg, final ServerSetup setup) {
sendMimeMessage(createTextEmail(to, from, subject, msg, setup));
}
|
java
|
{
"resource": ""
}
|
q4061
|
GreenMailUtil.sendMimeMessage
|
train
|
public static void sendMimeMessage(MimeMessage mimeMessage) {
try {
Transport.send(mimeMessage);
} catch (MessagingException e) {
throw new IllegalStateException("Can not send message " + mimeMessage, e);
}
}
|
java
|
{
"resource": ""
}
|
q4062
|
GreenMailUtil.sendMessageBody
|
train
|
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
|
{
"resource": ""
}
|
q4063
|
GreenMailUtil.createMultipartWithAttachment
|
train
|
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
|
{
"resource": ""
}
|
q4064
|
GreenMailUtil.getSession
|
train
|
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
|
{
"resource": ""
}
|
q4065
|
GreenMailUtil.setQuota
|
train
|
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
|
{
"resource": ""
}
|
q4066
|
UserManager.hasUser
|
train
|
public boolean hasUser(String userId) {
String normalized = normalizerUserName(userId);
return loginToUser.containsKey(normalized) || emailToUser.containsKey(normalized);
}
|
java
|
{
"resource": ""
}
|
q4067
|
AbstractServer.closeServerSocket
|
train
|
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
|
{
"resource": ""
}
|
q4068
|
AbstractServer.quit
|
train
|
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
|
{
"resource": ""
}
|
q4069
|
AbstractServer.stopService
|
train
|
@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
|
{
"resource": ""
}
|
q4070
|
SimpleMessageAttributes.getSentDate
|
train
|
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
|
{
"resource": ""
}
|
q4071
|
SimpleMessageAttributes.parseEnvelope
|
train
|
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
|
{
"resource": ""
}
|
q4072
|
SimpleMessageAttributes.parseAddress
|
train
|
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
|
{
"resource": ""
}
|
q4073
|
SimpleMessageAttributes.decodeContentType
|
train
|
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
|
{
"resource": ""
}
|
q4074
|
ConfiguredGreenMail.doConfigure
|
train
|
protected void doConfigure() {
if (config != null) {
for (UserBean user : config.getUsersToCreate()) {
setUser(user.getEmail(), user.getLogin(), user.getPassword());
}
getManagers().getUserManager().setAuthRequired(!config.isAuthenticationDisabled());
}
}
|
java
|
{
"resource": ""
}
|
q4075
|
InternetPrintWriter.createForEncoding
|
train
|
public static InternetPrintWriter createForEncoding(OutputStream outputStream, boolean autoFlush, Charset charset) {
return new InternetPrintWriter(new OutputStreamWriter(outputStream, charset), autoFlush);
}
|
java
|
{
"resource": ""
}
|
q4076
|
GreenMail.createServices
|
train
|
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
|
{
"resource": ""
}
|
q4077
|
ImapResponse.okResponse
|
train
|
public void okResponse(String responseCode, String message) {
untagged();
message(OK);
responseCode(responseCode);
message(message);
end();
}
|
java
|
{
"resource": ""
}
|
q4078
|
ImapHandler.close
|
train
|
@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
|
{
"resource": ""
}
|
q4079
|
EncodingUtil.toStream
|
train
|
public static InputStream toStream(String content, Charset charset) {
byte[] bytes = content.getBytes(charset);
return new ByteArrayInputStream(bytes);
}
|
java
|
{
"resource": ""
}
|
q4080
|
PropertiesBasedGreenMailConfigurationBuilder.build
|
train
|
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
|
{
"resource": ""
}
|
q4081
|
GreenMailBean.createServerSetup
|
train
|
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
|
{
"resource": ""
}
|
q4082
|
CommandParser.tag
|
train
|
public String tag(ImapRequestLineReader request) throws ProtocolException {
CharacterValidator validator = new TagCharValidator();
return consumeWord(request, validator);
}
|
java
|
{
"resource": ""
}
|
q4083
|
CommandParser.astring
|
train
|
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
|
{
"resource": ""
}
|
q4084
|
CommandParser.nstring
|
train
|
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
|
{
"resource": ""
}
|
q4085
|
CommandParser.dateTime
|
train
|
public Date dateTime(ImapRequestLineReader request) throws ProtocolException {
char next = request.nextWordChar();
String dateString;
// From https://tools.ietf.org/html/rfc3501 :
// date-time = DQUOTE date-day-fixed "-" date-month "-" date-year
// SP time SP zone DQUOTE
// zone = ("+" / "-") 4DIGIT
if (next == '"') {
dateString = consumeQuoted(request);
} else {
throw new ProtocolException("DateTime values must be quoted.");
}
try {
// You can use Z or zzzz
return new SimpleDateFormat("dd-MMM-yyyy hh:mm:ss Z", Locale.US).parse(dateString);
} catch (ParseException e) {
throw new ProtocolException("Invalid date format <" + dateString + ">, should comply to dd-MMM-yyyy hh:mm:ss Z");
}
}
|
java
|
{
"resource": ""
}
|
q4086
|
CommandParser.consumeWord
|
train
|
protected String consumeWord(ImapRequestLineReader request,
CharacterValidator validator)
throws ProtocolException {
StringBuilder atom = new StringBuilder();
char next = request.nextWordChar();
while (!isWhitespace(next)) {
if (validator.isValid(next)) {
atom.append(next);
request.consume();
} else {
throw new ProtocolException("Invalid character: '" + next + '\'');
}
next = request.nextChar();
}
return atom.toString();
}
|
java
|
{
"resource": ""
}
|
q4087
|
CommandParser.consumeChar
|
train
|
protected void consumeChar(ImapRequestLineReader request, char expected)
throws ProtocolException {
char consumed = request.consume();
if (consumed != expected) {
throw new ProtocolException("Expected:'" + expected + "' found:'" + consumed + '\'');
}
}
|
java
|
{
"resource": ""
}
|
q4088
|
CommandParser.consumeQuoted
|
train
|
protected String consumeQuoted(ImapRequestLineReader request)
throws ProtocolException {
// The 1st character must be '"'
consumeChar(request, '"');
StringBuilder quoted = new StringBuilder();
char next = request.nextChar();
while (next != '"') {
if (next == '\\') {
request.consume();
next = request.nextChar();
if (!isQuotedSpecial(next)) {
throw new ProtocolException("Invalid escaped character in quote: '" +
next + '\'');
}
}
quoted.append(next);
request.consume();
next = request.nextChar();
}
consumeChar(request, '"');
return quoted.toString();
}
|
java
|
{
"resource": ""
}
|
q4089
|
CommandParser.flagList
|
train
|
public Flags flagList(ImapRequestLineReader request) throws ProtocolException {
Flags flags = new Flags();
request.nextWordChar();
consumeChar(request, '(');
CharacterValidator validator = new NoopCharValidator();
String nextWord = consumeWord(request, validator);
while (!nextWord.endsWith(")")) {
setFlag(nextWord, flags);
nextWord = consumeWord(request, validator);
}
// Got the closing ")", may be attached to a word.
if (nextWord.length() > 1) {
setFlag(nextWord.substring(0, nextWord.length() - 1), flags);
}
return flags;
}
|
java
|
{
"resource": ""
}
|
q4090
|
CommandParser.number
|
train
|
public long number(ImapRequestLineReader request) throws ProtocolException {
String digits = consumeWord(request, new DigitCharValidator());
return Long.parseLong(digits);
}
|
java
|
{
"resource": ""
}
|
q4091
|
CommandParser.parseIdRange
|
train
|
public IdRange[] parseIdRange(ImapRequestLineReader request)
throws ProtocolException {
CharacterValidator validator = new MessageSetCharValidator();
String nextWord = consumeWord(request, validator);
int commaPos = nextWord.indexOf(',');
if (commaPos == -1) {
return new IdRange[]{IdRange.parseRange(nextWord)};
}
List<IdRange> rangeList = new ArrayList<>();
int pos = 0;
while (commaPos != -1) {
String range = nextWord.substring(pos, commaPos);
IdRange set = IdRange.parseRange(range);
rangeList.add(set);
pos = commaPos + 1;
commaPos = nextWord.indexOf(',', pos);
}
String range = nextWord.substring(pos);
rangeList.add(IdRange.parseRange(range));
return rangeList.toArray(new IdRange[rangeList.size()]);
}
|
java
|
{
"resource": ""
}
|
q4092
|
PropertiesBasedServerSetupBuilder.build
|
train
|
public ServerSetup[] build(Properties properties) {
List<ServerSetup> serverSetups = new ArrayList<>();
String hostname = properties.getProperty("greenmail.hostname", ServerSetup.getLocalHostAddress());
long serverStartupTimeout =
Long.parseLong(properties.getProperty("greenmail.startup.timeout", "-1"));
// Default setups
addDefaultSetups(hostname, properties, serverSetups);
// Default setups for test
addTestSetups(hostname, properties, serverSetups);
// Default setups
for (String protocol : ServerSetup.PROTOCOLS) {
addSetup(hostname, protocol, properties, serverSetups);
}
for (ServerSetup setup : serverSetups) {
if (properties.containsKey(GREENMAIL_VERBOSE)) {
setup.setVerbose(true);
}
if (serverStartupTimeout >= 0L) {
setup.setServerStartupTimeout(serverStartupTimeout);
}
}
return serverSetups.toArray(new ServerSetup[serverSetups.size()]);
}
|
java
|
{
"resource": ""
}
|
q4093
|
MessageFlags.format
|
train
|
public static String format(Flags flags) {
StringBuilder buf = new StringBuilder();
buf.append('(');
if (flags.contains(Flags.Flag.ANSWERED)) {
buf.append("\\Answered ");
}
if (flags.contains(Flags.Flag.DELETED)) {
buf.append("\\Deleted ");
}
if (flags.contains(Flags.Flag.DRAFT)) {
buf.append("\\Draft ");
}
if (flags.contains(Flags.Flag.FLAGGED)) {
buf.append("\\Flagged ");
}
if (flags.contains(Flags.Flag.RECENT)) {
buf.append("\\Recent ");
}
if (flags.contains(Flags.Flag.SEEN)) {
buf.append("\\Seen ");
}
String[] userFlags = flags.getUserFlags();
if(null!=userFlags) {
for(String uf: userFlags) {
buf.append(uf).append(' ');
}
}
// Remove the trailing space, if necessary.
if (buf.length() > 1) {
buf.setLength(buf.length() - 1);
}
buf.append(')');
return buf.toString();
}
|
java
|
{
"resource": ""
}
|
q4094
|
ImapRequestLineReader.eol
|
train
|
public void eol() throws ProtocolException {
char next = nextChar();
// Ignore trailing spaces.
while (next == ' ') {
consume();
next = nextChar();
}
// handle DOS and unix end-of-lines
if (next == '\r') {
consume();
next = nextChar();
}
// Check if we found extra characters.
if (next != '\n') {
throw new ProtocolException("Expected end-of-line, found more character(s): "+next);
}
dumpLine();
}
|
java
|
{
"resource": ""
}
|
q4095
|
ImapRequestLineReader.read
|
train
|
public void read(byte[] holder) throws ProtocolException {
int readTotal = 0;
try {
while (readTotal < holder.length) {
int count = input.read(holder, readTotal, holder.length - readTotal);
if (count == -1) {
throw new ProtocolException("Unexpected end of stream.");
}
readTotal += count;
}
// Unset the next char.
nextSeen = false;
nextChar = 0;
} catch (IOException e) {
throw new ProtocolException("Error reading from stream.", e);
}
}
|
java
|
{
"resource": ""
}
|
q4096
|
ImapRequestLineReader.commandContinuationRequest
|
train
|
public void commandContinuationRequest()
throws ProtocolException {
try {
output.write('+');
output.write(' ');
output.write('O');
output.write('K');
output.write('\r');
output.write('\n');
output.flush();
} catch (IOException e) {
throw new ProtocolException("Unexpected exception in sending command continuation request.", e);
}
}
|
java
|
{
"resource": ""
}
|
q4097
|
UserUtil.createUsers
|
train
|
public static void createUsers(GreenMailOperations greenMail, InternetAddress... addresses) {
for (InternetAddress address : addresses) {
greenMail.setUser(address.getAddress(), address.getAddress());
}
}
|
java
|
{
"resource": ""
}
|
q4098
|
IdRange.containsUid
|
train
|
public static boolean containsUid(IdRange[] idRanges, long uid) {
if (null != idRanges && idRanges.length > 0) {
for (IdRange range : idRanges) {
if (range.includes(uid)) {
return true;
}
}
}
return false;
}
|
java
|
{
"resource": ""
}
|
q4099
|
SimpleJsonEncoder.appendToJSON
|
train
|
SimpleJsonEncoder appendToJSON(final String key, final Object value) {
if (closed) {
throw new IllegalStateException("Encoder already closed");
}
if (value != null) {
appendKey(key);
if (value instanceof Number) {
sb.append(value.toString());
} else {
sb.append(QUOTE).append(escapeString(value.toString())).append(QUOTE);
}
}
return this;
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.