code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public String getJavaCreateString()
{
StringBuilder sb = new StringBuilder();
sb.append("new com.caucho.v5.make.DependencyList()");
for (int i = 0; i < _dependencyList.size(); i++) {
sb.append(".add(");
sb.append(_dependencyList.get(i).getJavaCreateString());
sb.append(")");
}
return sb.toString();
} | java |
protected void initRequest()
{
_hostHeader = null;
_xForwardedHostHeader = null;
_expect100Continue = false;
_cookies.clear();
_contentLengthIn = -1;
_hasReadStream = false;
_readEncoding = null;
//_request = request;
//_requestFacade = getHttp().createFacade(this);
_startTime = -1;
_expireTime = -1;
_isUpgrade = false;
_statusCode = 200;
_statusMessage = "OK";
_headerKeysOut.clear();
_headerValuesOut.clear();
_contentTypeOut = null;
_contentEncodingOut = null;
_contentLengthOut = -1;
_footerKeys.clear();
_footerValues.clear();
out().start();
_isHeaderWritten = false;
_isClosed = false;
//_serverHeader = http().serverHeader();
_isKeepalive = true;
} | java |
public void clientDisconnect()
{
try {
OutHttpApp responseStream = _responseStream;
if (responseStream != null) {
responseStream.close();
}
} catch (Exception e) {
log.log(Level.FINER, e.toString(), e);
}
ConnectionTcp conn = connTcp();
if (conn != null) {
conn.clientDisconnect();
}
killKeepalive("client disconnect");
} | java |
public int getServerPort()
{
String host = null;
CharSequence rawHost;
if ((rawHost = getHost()) != null) {
int length = rawHost.length();
int i;
for (i = length - 1; i >= 0; i--) {
if (rawHost.charAt(i) == ':') {
int port = 0;
for (i++; i < length; i++) {
char ch = rawHost.charAt(i);
if ('0' <= ch && ch <= '9') {
port = 10 * port + ch - '0';
}
}
return port;
}
}
// server/0521 vs server/052o
// because of proxies, need to use the host header,
// not the actual port
return isSecure() ? 443 : 80;
}
if (host == null) {
return connTcp().portLocal();
}
int p1 = host.lastIndexOf(':');
if (p1 < 0)
return isSecure() ? 443 : 80;
else {
int length = host.length();
int port = 0;
for (int i = p1 + 1; i < length; i++) {
char ch = host.charAt(i);
if ('0' <= ch && ch <= '9') {
port = 10 * port + ch - '0';
}
}
return port;
}
} | java |
public CharSegment getHeaderBuffer(String name)
{
String value = header(name);
if (value != null)
return new CharBuffer(value);
else
return null;
} | java |
protected boolean addHeaderInt(char []keyBuf, int keyOff, int keyLen,
CharSegment value)
{
if (keyLen < 4) {
return true;
}
int key1 = keyBuf[keyOff] | 0x20 | (keyLen << 8);
switch (key1) {
case CONNECTION_KEY:
if (match(keyBuf, keyOff, keyLen, CONNECTION)) {
char []valueBuffer = value.buffer();
int valueOffset = value.offset();
int valueLength = value.length();
int end = valueOffset + valueLength;
boolean isKeepalive = false;
while (valueOffset < end) {
char ch = Character.toLowerCase(valueBuffer[valueOffset]);
if (ch == 'k'
&& match(valueBuffer, valueOffset, KEEPALIVE.length, KEEPALIVE)) {
isKeepalive = true;
valueOffset += KEEPALIVE.length;
}
else if (ch == 'u'
&& match(valueBuffer, valueOffset, UPGRADE.length, UPGRADE)) {
_isUpgrade = true;
valueOffset += UPGRADE.length;
}
while (valueOffset < end && valueBuffer[valueOffset++] != ',') {
}
if (valueBuffer[valueOffset] == ' ') {
valueOffset++;
}
}
_isKeepalive = isKeepalive;
return true;
}
case COOKIE_KEY:
if (match(keyBuf, keyOff, keyLen, COOKIE)) {
fillCookie(_cookies, value);
}
return true;
case CONTENT_LENGTH_KEY:
if (match(keyBuf, keyOff, keyLen, CONTENT_LENGTH)) {
contentLengthIn(value);
}
return true;
case EXPECT_KEY:
if (match(keyBuf, keyOff, keyLen, EXPECT)) {
if (match(value.buffer(), value.offset(), value.length(),
CONTINUE_100)) {
_expect100Continue = true;
return false;
}
}
return true;
case HOST_KEY:
if (match(keyBuf, keyOff, keyLen, HOST)) {
_hostHeader = value;
}
return true;
case TRANSFER_ENCODING_KEY:
if (match(keyBuf, keyOff, keyLen, TRANSFER_ENCODING)) {
_isChunkedIn = true;
}
return true;
case X_FORWARDED_HOST_KEY:
if (match(keyBuf, keyOff, keyLen, X_FORWARDED_HOST)) {
_xForwardedHostHeader = value;
}
return true;
default:
return true;
}
} | java |
private boolean match(char []a, int aOff, int aLength, char []b)
{
int bLength = b.length;
if (aLength != bLength)
return false;
for (int i = aLength - 1; i >= 0; i--) {
char chA = a[aOff + i];
char chB = b[i];
if (chA != chB && chA + 'a' - 'A' != chB) {
return false;
}
}
return true;
} | java |
public Enumeration<String> getHeaders(String name)
{
String value = header(name);
if (value == null) {
return Collections.emptyEnumeration();
}
ArrayList<String> list = new ArrayList<String>();
list.add(value);
return Collections.enumeration(list);
} | java |
public void getHeaderBuffers(String name, ArrayList<CharSegment> resultList)
{
String value = header(name);
if (value != null)
resultList.add(new CharBuffer(value));
} | java |
public int getIntHeader(String key)
{
CharSegment value = getHeaderBuffer(key);
if (value == null)
return -1;
int len = value.length();
if (len == 0)
throw new NumberFormatException(value.toString());
int iValue = 0;
int i = 0;
int ch = value.charAt(i);
int sign = 1;
if (ch == '+') {
if (i + 1 < len)
ch = value.charAt(++i);
else
throw new NumberFormatException(value.toString());
} else if (ch == '-') {
sign = -1;
if (i + 1 < len)
ch = value.charAt(++i);
else
throw new NumberFormatException(value.toString());
}
for (; i < len && (ch = value.charAt(i)) >= '0' && ch <= '9'; i++)
iValue = 10 * iValue + ch - '0';
if (i < len)
throw new NumberFormatException(value.toString());
return sign * iValue;
} | java |
public String encoding()
{
if (_readEncoding != null)
return _readEncoding;
CharSegment value = getHeaderBuffer("Content-Type");
if (value == null)
return null;
int i = value.indexOf("charset");
if (i < 0)
return null;
int len = value.length();
for (i += 7; i < len && Character.isWhitespace(value.charAt(i)); i++) {
}
if (i >= len || value.charAt(i) != '=')
return null;
for (i++; i < len && Character.isWhitespace(value.charAt(i)); i++) {
}
if (i >= len)
return null;
char end = value.charAt(i);
if (end == '"') {
int tail;
for (tail = ++i; tail < len; tail++) {
if (value.charAt(tail) == end)
break;
}
_readEncoding = Encoding.getMimeName(value.substring(i, tail));
return _readEncoding;
}
int tail;
for (tail = i; tail < len; tail++) {
if (Character.isWhitespace(value.charAt(tail))
|| value.charAt(tail) == ';')
break;
}
_readEncoding = Encoding.getMimeName(value.substring(i, tail));
return _readEncoding;
} | java |
CookieWeb []fillCookies()
{
int size = _cookies.size();
if (size > 0) {
CookieWeb []cookiesIn = new WebCookie[size];
for (int i = size - 1; i >= 0; i--) {
cookiesIn[i] = _cookies.get(i);
}
return cookiesIn;
}
else {
return NULL_COOKIES;
}
} | java |
private void finishRequest()
throws IOException
{
try {
cleanup();
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
} finally {
//_requestFacade = null;
}
} | java |
public final OutHttpApp out()
{
OutHttpApp stream = _responseStream;
if (stream == null) {
stream = createOut();
_responseStream = stream;
}
return stream;
} | java |
public boolean containsHeaderOut(String name)
{
ArrayList<String> headerKeys = _headerKeysOut;
int size = headerKeys.size();
for (int i = 0; i < size; i++) {
String oldKey = headerKeys.get(i);
if (oldKey.equalsIgnoreCase(name)) {
return true;
}
}
if (name.equalsIgnoreCase("content-type")) {
return _contentTypeOut != null;
}
if (name.equalsIgnoreCase("content-length")) {
return _contentLengthOut >= 0;
}
return false;
} | java |
public String headerOut(String name)
{
ArrayList<String> keys = _headerKeysOut;
int headerSize = keys.size();
for (int i = 0; i < headerSize; i++) {
String oldKey = keys.get(i);
if (oldKey.equalsIgnoreCase(name)) {
return (String) _headerValuesOut.get(i);
}
}
/*
if (name.equalsIgnoreCase("content-type")) {
throw new UnsupportedOperationException();
//return request().getContentType();
}
*/
if (name.equalsIgnoreCase("content-length")) {
return _contentLengthOut >= 0 ? String.valueOf(_contentLengthOut) : null;
}
if (name.equalsIgnoreCase("content-type")) {
return _contentTypeOut;
}
return null;
} | java |
public void addHeaderOutImpl(String key, String value)
{
if (headerOutSpecial(key, value)) {
return;
}
ArrayList<String> keys = _headerKeysOut;
ArrayList<String> values = _headerValuesOut;
int size = keys.size();
// webapp/1k32
for (int i = 0; i < size; i++) {
if (keys.get(i).equals(key) && values.get(i).equals(value)) {
return;
}
}
keys.add(key);
values.add(value);
} | java |
private boolean headerOutSpecial(String key, String value)
{
int length = key.length();
if (length == 0) {
return false;
}
int ch = key.charAt(0);
if ('A' <= ch && ch <= 'Z') {
ch += 'a' - 'A';
}
int code = (length << 8) + ch;
switch (code) {
case 0x0d00 + 'c':
if (CACHE_CONTROL.matchesIgnoreCase(key)) {
// server/13d9, server/13dg
if (value.startsWith("max-age")) {
}
else if (value.startsWith("s-maxage")) {
}
else if (value.equals("x-anonymous")) {
}
else {
//request().setCacheControl(true);
if (true) throw new UnsupportedOperationException();
}
}
return false;
case 0x0a00 + 'c':
if (CONNECTION_CB.matchesIgnoreCase(key)) {
if ("close".equalsIgnoreCase(value))
killKeepalive("client connection: close");
return true;
}
else {
return false;
}
case 0x0c00 + 'c':
if (CONTENT_TYPE_CB.matchesIgnoreCase(key)) {
headerOutContentType(value);
return true;
}
else {
return false;
}
case 0x0e00 + 'c':
if (CONTENT_LENGTH_CB.matchesIgnoreCase(key)) {
// server/05a8
// php/164v
_contentLengthOut = parseLong(value);
return true;
}
else {
return false;
}
case 0x0400 + 'd':
if (DATE.matchesIgnoreCase(key)) {
return true;
}
else {
return false;
}
case 0x0600 + 's':
if (SERVER.matchesIgnoreCase(key)) {
_serverHeader = value;
return true;
}
else {
return false;
}
default:
return false;
}
} | java |
public void setFooter(String key, String value)
{
Objects.requireNonNull(value);
int i = 0;
boolean hasFooter = false;
for (i = _footerKeys.size() - 1; i >= 0; i--) {
String oldKey = _footerKeys.get(i);
if (oldKey.equalsIgnoreCase(key)) {
if (hasFooter) {
_footerKeys.remove(i);
_footerValues.remove(i);
}
else {
hasFooter = true;
_footerValues.set(i, value);
}
}
}
if (! hasFooter) {
_footerKeys.add(key);
_footerValues.add(value);
}
} | java |
public void addFooter(String key, String value)
{
if (headerOutSpecial(key, value)) {
return;
}
_footerKeys.add(key);
_footerValues.add(value);
} | java |
public final boolean isOutCommitted()
{
OutHttpApp stream = out();
if (stream.isCommitted()) {
return true;
}
// server/05a7
if (_contentLengthOut > 0 && _contentLengthOut <= stream.contentLength()) {
return true;
}
return false;
} | java |
public long contentLengthSent()
{
OutHttpApp stream = _responseStream;
// stream can be null for duplex (websocket)
if (stream != null) {
return stream.contentLength();
}
else {
return Math.max(_contentLengthOut, 0);
}
} | java |
private boolean enableKeepalive(PollController conn,
boolean isNew)
throws IOException
{
if (_selectMax <= _connectionCount.get()) {
throw new IllegalStateException(this + " keepalive overflow "
+ _connectionCount + " max=" + _selectMax);
/*
conn.requestDestroy();
return false;
*/
}
JniSocketImpl socket = (JniSocketImpl) conn.getSocket();
if (socket == null) {
throw new IllegalStateException(this + " socket empty for " + conn);
}
int nativeFd = socket.getNativeFd();
if (nativeFd < 0) {
throw new IllegalStateException(this + " attempted keepalive with closed file descriptor fd=" + nativeFd
+ "\n " + socket
+ "\n " + conn);
}
else if (_connections.length() <= nativeFd) {
throw new IllegalStateException(this + " select overflow for file descriptor fd=" + nativeFd + " " + conn);
}
if (! _lifecycle.isActive()) {
throw new IllegalStateException("inactive keepalive");
}
if (isNew) {
setMaxConnection(nativeFd);
_connections.set(nativeFd, conn);
_connectionCount.incrementAndGet();
}
int result = addNative(_fd, nativeFd, isNew);
// result < 0 would likely be a disconnect
return result == 0;
} | java |
private void runSelectTask()
{
if (_lifecycle.isActive() || _lifecycle.isAfterStopping()) {
log.warning(this + " cannot start because an instance is active");
return;
}
initNative(_fd);
synchronized (_thread) {
_thread.notify();
}
if (! _lifecycle.toActive()) {
log.warning(this + " invalid starting state");
return;
}
runImpl();
} | java |
@SuppressWarnings("unchecked")
private void initTypesMapping() {
if (mapping == null) {
throw new IllegalStateException("Mapping does contain any information in " +
"DeployerTypesResolver " + this);
}
if (mapping.containsKey(NODE_TYPES_MAPPING_SECTION)) {
log.debug("Mapping contains NodeTypes mapping");
nodeTypesMapping = (Map<String, String>) mapping.get(NODE_TYPES_MAPPING_SECTION);
}
if (mapping.containsKey(RELATIONSHIP_TYPES_MAPPING_SECTION)) {
log.debug("Mapping contains NodeTypes mapping");
relationshipTypesMapping = (Map<String, String>) mapping
.get(RELATIONSHIP_TYPES_MAPPING_SECTION);
}
if (mapping.containsKey(NODE_TYPES_DEFINITIONS)) {
log.debug("Mapping contains NodeTypes description");
nodeTypesDefinitions = (Map<String, Object>) mapping.get(NODE_TYPES_DEFINITIONS);
}
if (mapping.containsKey(POLICY_TYPES_MAPPING_SECTION)) {
log.debug("Mapping contains Policy mapping");
policyTypesMapping = (Map<String, String>) mapping.get(POLICY_TYPES_MAPPING_SECTION);
}
} | java |
@Override
public int addressRemote(byte []buffer, int offset, int length)
{
return _socket.getRemoteAddress(buffer, offset, length);
} | java |
@Override
public void requestWake()
{
try {
_state = _state.toWake();
requestLoop();
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
}
/*
if (_stateRef.get().toWake(_stateRef)) {
offer(getConnectionTask());
}
*/
} | java |
private StateConnection processPoll()
throws IOException
{
PortTcp port = _port;
if (port.isClosed()) {
return StateConnection.DESTROY;
}
if (readStream().available() > 0) {
return StateConnection.ACTIVE;
}
long timeout = _idleTimeout;
_idleStartTime = CurrentTime.currentTime();
_idleExpireTime = _idleStartTime + timeout;
// _state = _state.toKeepalive(this);
PollTcpManagerBase pollManager = port.pollManager();
// use poll manager if available
if (pollManager == null) {
port().stats().addLifetimeKeepaliveCount();
return threadPoll(timeout);
}
if (! _pollHandle.isKeepaliveStarted()) {
ServiceRef.flushOutbox();
if (_port.keepaliveThreadRead(readStream(), _idleTimeout) > 0) {
return StateConnection.ACTIVE;
}
else if (_idleExpireTime <= CurrentTime.currentTime()) {
return StateConnection.TIMEOUT;
}
}
/*
if (! _state.toPollRequested(_stateRef)) {
return _stateRef.get().getNextState();
}
// _state = _state.toKeepaliveSelect();
* */
// keepalive to select manager succeeds
switch (pollManager.startPoll(_pollHandle)) {
case START: {
if (log.isLoggable(Level.FINEST)) {
log.finest(dbgId() + "keepalive (poll)");
}
port().stats().addLifetimeKeepaliveCount();
port().stats().addLifetimeKeepalivePollCount();
return StateConnection.POLL;
}
case DATA: {
if (log.isLoggable(Level.FINEST)) {
log.finest("keepalive data available (poll) [" + dbgId() + "]");
}
//_state = _state.toWake();
//System.out.println("DATA: " + _state);
/*
if (_stateRef.get().toPollSleep(_stateRef)) {
throw new IllegalStateException();
}
*/
return StateConnection.ACTIVE;
}
case CLOSED: {
if (log.isLoggable(Level.FINEST)) {
log.finest(dbgId() + " keepalive close (poll)");
}
//_state = _state.toWake();
/*
if (_stateRef.get().toPollSleep(_stateRef)) {
throw new IllegalStateException();
}
*/
return StateConnection.CLOSE_READ_A;
}
default:
throw new IllegalStateException();
}
} | java |
private void initSocket()
throws IOException
{
_idleTimeout = _port.getKeepaliveTimeout();
_port.ssl(_socket);
writeStream().init(_socket.stream());
// ReadStream cannot use getWriteStream or auto-flush
// because of duplex mode
// ReadStream is = getReadStream();
_readStream.init(_socket.stream());
if (log.isLoggable(Level.FINEST)) {
log.finest(dbgId() + "starting connection " + this
+ ", total=" + _port.getConnectionCount());
}
} | java |
private void destroy()
{
if (log.isLoggable(Level.FINEST)) {
log.finest(this + " destroying connection");
}
try {
_socket.forceShutdown();
} catch (Throwable e) {
}
try {
closeConnection();
} catch (Throwable e) {
log.log(Level.FINER, e.toString(), e);
}
// XXX:
_port.removeConnection(this);
} | java |
private boolean isCacheValid()
{
long now = CurrentTime.currentTime();
if ((now - _lastTime < 100) && ! CurrentTime.isTest())
return true;
long oldLastModified = _lastModified;
long oldLength = _length;
long newLastModified = getBacking().getLastModified();
long newLength = getBacking().length();
_lastTime = now;
if (newLastModified == oldLastModified && newLength == oldLength) {
_lastTime = now;
return true;
}
else {
_changeSequence.incrementAndGet();
// If the file has changed, close the old file
clearCache();
_zipEntryCache.clear();
_lastModified = newLastModified;
_length = newLength;
_lastTime = now;
return false;
}
} | java |
@Override
public void setContextLoader(ClassLoader loader)
{
if (loader != null)
_loaderRef = new WeakReference<ClassLoader>(loader);
else
_loaderRef = null;
} | java |
public static JClassLoaderWrapper create(ClassLoader loader)
{
JClassLoaderWrapper jLoader = _localClassLoader.getLevel(loader);
if (jLoader == null) {
jLoader = new JClassLoaderWrapper(loader);
_localClassLoader.set(jLoader, loader);
}
return jLoader;
} | java |
private ByExpressionBuilder parseBy()
{
ByExpressionBuilder by = new ByExpressionBuilder();
int x = _parseIndex;
Token token = scanToken();
if (token == null)
throw new IllegalStateException(L.l("expected field name at {0} in {1}",
x,
_method.getName()));
do {
switch (token) {
case IDENTIFIER: {
StringBuilder sb = new StringBuilder();
sb.append(_lexeme);
while (peekToken() == Token.IDENTIFIER) {
token = scanToken();
sb.append(_lexeme);
}
String term = fieldTerm(sb.toString());
by.addField(term);
break;
}
case AND: {
by.addAnd();
break;
}
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
by.term(token);
break;
case GREATER: {
if (peekToken() == Token.THAN) {
scanToken();
by.term(Token.GT);
}
else if (peekToken() == Token.EQ) {
scanToken();
by.term(Token.GE);
}
else {
by.term(Token.GT);
}
break;
}
case LESS: {
if (peekToken() == Token.THAN) {
scanToken();
by.term(Token.LT);
}
else if (peekToken() == Token.EQ) {
scanToken();
by.term(Token.LE);
}
else {
by.term(Token.LT);
}
break;
}
case NOT: {
if (peekToken() == Token.EQ) {
scanToken();
by.term(Token.NE);
}
else {
by.term(Token.NE);
}
break;
}
case OR: {
by.addOr();
break;
}
default: {
throw new IllegalStateException(_method.getName());
}
}
}
while ((token = scanToken()) != Token.EOF);
return by;
} | java |
public static boolean isCaseInsensitive()
{
Boolean value = _caseInsensitive.get();
if (value == null) {
return _isCaseInsensitive;
}
else
return value.booleanValue();
} | java |
@Override
public void validate()
throws ConfigException
{
for (int i = 0; i < _jarList.size(); i++) {
_jarList.get(i).validate();
}
} | java |
@Override
public void getResources(Vector<URL> vector, String name)
{
if (_pathMap != null) {
String cleanName = name;
if (cleanName.endsWith("/"))
cleanName = cleanName.substring(0, cleanName.length() - 1);
JarMap.JarList jarEntryList = _pathMap.get(cleanName);
for (; jarEntryList != null; jarEntryList = jarEntryList.getNext()) {
JarEntry jarEntry = jarEntryList.getEntry();
PathImpl path = jarEntry.getJarPath();
path = path.lookup(name);
try {
URL url = new URL(path.getURL());
if (! vector.contains(url))
vector.add(url);
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
}
}
}
else {
for (int i = 0; i < _jarList.size(); i++) {
JarEntry jarEntry = _jarList.get(i);
PathImpl path = jarEntry.getJarPath();
path = path.lookup(name);
if (path.exists()) {
try {
URL url = new URL(path.getURL());
if (! vector.contains(url))
vector.add(url);
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
}
}
}
}
} | java |
@Override
public PathImpl getPath(String pathName)
{
if (_pathMap != null) {
String cleanPathName = pathName;
if (cleanPathName.endsWith("/"))
cleanPathName = cleanPathName.substring(0, cleanPathName.length() - 1);
JarMap.JarList jarEntryList = _pathMap.get(cleanPathName);
if (jarEntryList != null) {
return jarEntryList.getEntry().getJarPath().lookup(pathName);
}
}
else {
for (int i = 0; i < _jarList.size(); i++) {
JarEntry jarEntry = _jarList.get(i);
PathImpl path = jarEntry.getJarPath();
PathImpl filePath = path.lookup(pathName);
if (filePath.exists())
return filePath;
}
}
return null;
} | java |
protected void clearJars()
{
synchronized (this) {
ArrayList<JarEntry> jars = new ArrayList<JarEntry>(_jarList);
_jarList.clear();
if (_pathMap != null)
_pathMap.clear();
for (int i = 0; i < jars.size(); i++) {
JarEntry jarEntry = jars.get(i);
JarPath jarPath = jarEntry.getJarPath();
jarPath.closeJar();
}
}
} | java |
public final double sampleSigma(int n)
{
synchronized (_lock) {
long count = _count.get();
long lastCount = _lastStdCount;
_lastStdCount = count;
double sum = _sum.get();
double lastSum = _lastStdSum;
_lastStdSum = sum;
double sumSquare = _sumSquare;
_sumSquare = 0;
if (count == lastCount)
return 0;
double avg = (sum - lastSum) / (count - lastCount);
double part = (count - lastCount) * sumSquare - sum * sum;
if (part < 0)
part = 0;
double std = Math.sqrt(part) / (count - lastCount);
return _scale * (avg + n * std);
}
} | java |
public static int getInt(String strValue) {
int value = 0;
if (StringUtils.isNotBlank(strValue)) {
Matcher m = Pattern.compile("^(\\d+)(?:\\w+|%)?$").matcher(strValue);
if (m.find()) {
value = Integer.parseInt(m.group(1));
}
}
return value;
} | java |
boolean isKeepaliveAllowed(long connectionStartTime)
{
if (! _lifecycle.isActive()) {
return false;
}
else if (connectionStartTime + _keepaliveTimeMax < CurrentTime.currentTime()) {
return false;
}
else if (_keepaliveMax <= _keepaliveAllocateCount.get()) {
return false;
}
/*
else if (_connThreadPool.isThreadMax()
&& _connThreadPool.isIdleLow()
&& ! isKeepaliveAsyncEnabled()) {
return false;
}
*/
else {
return true;
}
} | java |
int keepaliveThreadRead(ReadStream is, long timeoutConn)
throws IOException
{
if (isClosed()) {
return -1;
}
int available = is.availableBuffer();
if (available > 0) {
return available;
}
long timeout = Math.min(getKeepaliveTimeout(), getSocketTimeout());
if (timeoutConn > 0) {
timeout = Math.min(timeout, timeoutConn);
}
// server/2l02
int keepaliveThreadCount = _keepaliveThreadCount.incrementAndGet();
// boolean isSelectManager = getServer().isSelectManagerEnabled();
try {
int result;
if (isKeepaliveAsyncEnabled() && _pollManager != null) {
timeout = Math.min(timeout, getBlockingTimeoutForPoll());
if (keepaliveThreadCount > 32) {
// throttle the thread keepalive when heavily loaded to save threads
if (isAsyncThrottle()) {
// when async throttle is active move the thread to async
// immediately
return 0;
}
else {
timeout = Math.min(timeout, 100);
}
}
}
/*
if (timeout < 0)
timeout = 0;
*/
if (timeout <= 0) {
return 0;
}
_keepaliveThreadMeter.start();
try {
/*
if (false && _keepaliveThreadCount.get() < 32) {
// benchmark perf with memcache
result = is.fillWithTimeout(-1);
}
*/
result = is.fillWithTimeout(timeout);
} finally {
_keepaliveThreadMeter.end();
}
if (isClosed()) {
return -1;
}
return result;
} catch (IOException e) {
if (isClosed()) {
log.log(Level.FINEST, e.toString(), e);
return -1;
}
throw e;
} finally {
_keepaliveThreadCount.decrementAndGet();
}
} | java |
@Friend(ConnectionTcp.class)
void freeConnection(ConnectionTcp conn)
{
if (removeConnection(conn)) {
_idleConn.free(conn);
}
else if (isActive()) {
// Thread.dumpStack();
System.out.println("Possible Double Close: " + this + " " + conn);
}
//_connThreadPool.wake();
} | java |
public void init(String dc_sync_period, String resources_keep_alive_period, String manager_ip, String manager_port) {
if (registryInitialized)
throw new RuntimeException("Registry was already initialized");
if (dc_sync_period != null) {
CONFIG_SYNC_PERIOD = Integer.parseInt(dc_sync_period);
}
if (resources_keep_alive_period != null) {
KEEP_ALIVE = Integer.parseInt(resources_keep_alive_period);
}
// Build metrics
providedMetrics = buildProvidedMetrics();
// Build the DCAgent
dcAgent = new DCAgent(new ManagerAPI(manager_ip, Integer.parseInt(manager_port)));
// Add observers of metrics to the DCAgent
for (Metric metric : providedMetrics) {
logger.debug("Added metric {} as observer of dcagent",
metric.getMonitoredMetric());
dcAgent.addObserver(metric);
}
// Build the DCDescriptor
DCDescriptor dcDescriptor = new DCDescriptor();
dcDescriptor.addMonitoredResources(getProvidedMetrics(), getResources());
dcDescriptor.addResources(getResources());
dcDescriptor
.setConfigSyncPeriod(CONFIG_SYNC_PERIOD != null ? CONFIG_SYNC_PERIOD
: DEFAULT_CONFIG_SYNC_PERIOD);
dcDescriptor.setKeepAlive(KEEP_ALIVE != null ? KEEP_ALIVE
: (DEFAULT_CONFIG_SYNC_PERIOD + 15));
dcAgent.setDCDescriptor(dcDescriptor);
registryInitialized = true;
} | java |
public static void addResource(String type, String id, String url){
//add the new resource to the list of the managed resources
logger.info("Adding the following new resource to the Data Collector Descriptor: {}, {}", type, id);
try {
resources.put(new InternalComponent(type,id), new URL(url));
} catch (MalformedURLException e) {
logger.error(e.getMessage(), e.getCause());
}
logger.info("Currently managed resources...");
for(Resource r: _INSTANCE.getResources()){
logger.info(r.getType() + " " + r.getId() + "\n");
}
// re-Build the DCDescriptor
DCDescriptor dcDescriptor = new DCDescriptor();
dcDescriptor.addMonitoredResources(_INSTANCE.getProvidedMetrics(), _INSTANCE.getResources());
dcDescriptor.addResources(_INSTANCE.getResources());
dcDescriptor
.setConfigSyncPeriod(CONFIG_SYNC_PERIOD != null ? CONFIG_SYNC_PERIOD
: DEFAULT_CONFIG_SYNC_PERIOD);
dcDescriptor.setKeepAlive(KEEP_ALIVE != null ? KEEP_ALIVE
: (DEFAULT_CONFIG_SYNC_PERIOD + 15));
logger.info("Setting the new DCDescriptor...");
_INSTANCE.dcAgent.setDCDescriptor(dcDescriptor);
//re-start the monitoring
_INSTANCE.monitoringStarted = false;
startMonitoring();
} | java |
static Throwable cause(Throwable e)
{
while (e.getCause() != null
&& (e instanceof InstantiationException
|| e instanceof InvocationTargetException
|| e.getClass().equals(RuntimeExceptionConfig.class))) {
e = e.getCause();
}
return e;
} | java |
@Override
public void alarm(DeployService2Impl<I> deploy, Result<I> result)
{
LifecycleState state = deploy.getState();
if (! state.isActive()) {
result.ok(deploy.get());
}
else if (deploy.isModifiedNow()) {
// baratine/801g
deploy.logModified(deploy.getLog());
deploy.restartImpl(result);
}
else {
result.ok(deploy.get());
}
} | java |
String parseLine(CharCursor is, LineMap lineMap)
throws IOException
{
int ch = is.read();
_buf.clear();
String filename = null;
int line = 0;
// Take 3: match /.*:\d+:/
_token.clear();
line:
for (; ch != is.DONE; ch = is.read()) {
while (ch == ':') {
line = 0;
for (ch = is.read(); ch >= '0' && ch <= '9'; ch = is.read())
line = 10 * line + ch - '0';
if (ch == ':' && line > 0) {
filename = _token.toString();
break line;
}
else {
_token.append(':');
if (line > 0)
_token.append(line);
}
}
if (ch != is.DONE)
_token.append((char) ch);
}
if (filename == null)
return null;
int column = 0;
// skip added junk like jikes extra "emacs" style columns
for (; ch != is.DONE && ch != ' '; ch = is.read()) {
}
for (; ch == ' '; ch = is.read()) {
}
// now gather the message
_buf.clear();
for (; ch != is.DONE; ch = is.read())
_buf.append((char) ch);
String message = _buf.toString();
if (lineMap != null)
return lineMap.convertError(filename, line, 0, message);
else
return filename + ":" + line + ": " + message;
} | java |
public static long generate(long crc, long value)
{
crc = next(crc, (byte) (value >> 56));
crc = next(crc, (byte) (value >> 48));
crc = next(crc, (byte) (value >> 40));
crc = next(crc, (byte) (value >> 32));
crc = next(crc, (byte) (value >> 24));
crc = next(crc, (byte) (value >> 16));
crc = next(crc, (byte) (value >> 8));
crc = next(crc, (byte) (value >> 0));
return crc;
} | java |
@Override
public String toObjectExpr(String columnName)
{
if (_value == null) {
return "null";
}
else if (_value instanceof String) {
return "'" + _value + "'";
}
else {
return String.valueOf(_value);
}
} | java |
public int copyTo(byte []buffer, int rowOffset, int blobTail)
{
byte []blockBuffer = _block.getBuffer();
System.arraycopy(blockBuffer, _rowOffset, buffer, rowOffset, _length);
return _row.copyBlobs(blockBuffer, _rowOffset, buffer, rowOffset,
blobTail);
} | java |
@Override
public PathImpl schemeWalk(String userPath,
Map<String,Object> newAttributes,
String newPath, int offset)
{
return getWrappedPath().schemeWalk(userPath, newAttributes,
newPath, offset);
} | java |
final void executorTimeout(ExecutorThrottle executor, long timeout)
{
_executor = executor;
_activeSlowExpireTime = CurrentTime.getCurrentTimeActual() + timeout;
} | java |
@Override
public void run()
{
try {
_launcher.onChildIdleBegin();
_launcher.onChildThreadLaunchBegin();
_pool.addThread(this);
runTasks();
} catch (Throwable e) {
log.log(Level.WARNING, e.toString(), e);
} finally {
_pool.removeThread(this);
_launcher.onChildIdleEnd();
_launcher.onChildThreadLaunchEnd();
}
} | java |
private void runTasks()
{
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
ThreadPoolBase pool = _pool;
Thread thread = this;
Outbox outbox = outbox();
boolean isWake = false;
setName(_name);
while (! _isClose) {
RunnableItem taskItem = pool.poll(isWake);
isWake = false;
if (taskItem != null) {
try {
_launcher.onChildIdleEnd();
outbox.open();
do {
// if the task is available, run it in the proper context
thread.setContextClassLoader(taskItem.getClassLoader());
taskItem.getTask().run();
outbox.flushAndExecuteAll();
} while ((taskItem = pool.poll(false)) != null);
} catch (Throwable e) {
log.log(Level.WARNING, e.toString(), e);
} finally {
try {
outbox.close();
} catch (Throwable e) {
e.printStackTrace();
}
_launcher.onChildIdleBegin();
thread.setContextClassLoader(systemClassLoader);
if (! thread.getName().equals(_name)) {
setName(_name);
}
}
}
else if (_launcher.isIdleExpire()) {
return;
}
else if (park()) {
//thread.onWakeThread();
isWake = true;
}
else {
return;
}
}
} | java |
private static long addDigest(long digest, long v)
{
digest = Crc64.generate(digest, (byte) (v >> 24));
digest = Crc64.generate(digest, (byte) (v >> 16));
digest = Crc64.generate(digest, (byte) (v >> 8));
digest = Crc64.generate(digest, (byte) v);
return digest;
} | java |
private int compareView(ViewRef<?> viewA,
ViewRef<?> viewB,
Class<?> type)
{
int cmp = viewB.priority() - viewA.priority();
if (cmp != 0) {
return cmp;
}
cmp = typeDepth(viewA.type(), type) - typeDepth(viewB.type(), type);
if (cmp != 0) {
return cmp;
}
// equivalent views are sorted by name to ensure consistency
String nameA = viewA.resolver().getClass().getName();
String nameB = viewB.resolver().getClass().getName();
return nameA.compareTo(nameB);
} | java |
private int typeDepth(Class<?> match, Class<?> actual)
{
if (actual == null) {
return Integer.MAX_VALUE / 2;
}
if (match.equals(Object.class)) {
return Integer.MAX_VALUE / 4;
}
if (match.equals(actual)) {
return 0;
}
int cost = 1 + typeDepth(match, actual.getSuperclass());
for (Class<?> iface : actual.getInterfaces()) {
cost = Math.min(cost, 1 + typeDepth(match, iface));
}
return cost;
} | java |
public final void configure(Object bean)
{
Objects.requireNonNull(bean);
Thread thread = Thread.currentThread();
ClassLoader loader = thread.getContextClassLoader();
/*
ContextConfig oldContext = ContextConfig.getCurrent();
try {
ContextConfig.setCurrent(new ContextConfig(new Config()));
ConfigType<?> type = TypeFactoryConfig.getType(bean);
configure(bean, type);
} finally {
ContextConfig.setCurrent(oldContext);
}
*/
} | java |
final
public void configureImpl(Object bean) // , ConfigType<?> type)
throws ConfigException
{
Objects.requireNonNull(bean);
//Objects.requireNonNull(type);
try {
//type.beforeConfigure(bean);
// ioc/23e7
InjectContext env = InjectContextImpl.CONTEXT;
injectTop(bean, env);
//type.init(bean);
} finally {
//type.afterConfigure(bean);
}
} | java |
public boolean add(String srcFilename, int srcLine, int dstLine)
{
return add(srcFilename, srcLine, dstLine, false);
} | java |
public void addLine(int startLine, String sourceFile, int repeatCount,
int outputLine, int outputIncrement)
{
_lines.add(new Line(startLine, sourceFile, repeatCount,
outputLine, outputIncrement));
} | java |
public String convertError(String filename, int line,
int column, String message)
{
String srcFilename = null;
int destLine = 0;
int srcLine = 0;
for (int i = 0; i < _lines.size(); i++) {
Line map = _lines.get(i);
if (filename != null && ! filename.endsWith(_dstFilename)) {
}
else if (map._dstLine <= line && line <= map.getLastDestinationLine()) {
srcFilename = map._srcFilename;
srcLine = map.getSourceLine(line);
}
}
if (srcFilename != null)
return srcFilename + ":" + srcLine + ": " + message;
else
return filename + ":" + line + ": " + message;
} | java |
private void convertError(CharBuffer buf, int line)
{
String srcFilename = null;
int destLine = 0;
int srcLine = 0;
int srcTailLine = Integer.MAX_VALUE;
for (int i = 0; i < _lines.size(); i++) {
Line map = (Line) _lines.get(i);
if (map._dstLine <= line && line <= map.getLastDestinationLine()) {
srcFilename = map._srcFilename;
destLine = map._dstLine;
srcLine = map.getSourceLine(line);
break;
}
}
if (srcFilename != null) {
}
else if (_lines.size() > 0)
srcFilename = ((Line) _lines.get(0))._srcFilename;
else
srcFilename = "";
buf.append(srcFilename);
if (line >= 0) {
buf.append(":");
buf.append(srcLine + (line - destLine));
}
} | java |
public void copyFrom(Invocation invocation)
{
_classLoader = invocation._classLoader;
_rawHost = invocation._rawHost;
_rawURI = invocation._rawURI;
_hostName = invocation._hostName;
_port = invocation._port;
_uri = invocation._uri;
_depend = invocation._depend;
_queryString = invocation._queryString;
} | java |
final public void print(long v)
{
Writer out = this.out;
if (out == null)
return;
if (v == 0x8000000000000000L) {
print("-9223372036854775808");
return;
}
try {
if (v < 0) {
out.write('-');
v = -v;
} else if (v == 0) {
out.write('0');
return;
}
int j = 31;
while (v > 0) {
_tempCharBuffer[--j] = (char) ((v % 10) + '0');
v /= 10;
}
out.write(_tempCharBuffer, j, 31 - j);
} catch (IOException e) {
log.log(Level.FINE, e.toString(), e);
}
} | java |
final public void println(long v)
{
Writer out = this.out;
if (out == null)
return;
print(v);
try {
out.write(_newline, 0, _newline.length);
} catch (IOException e) {
log.log(Level.FINE, e.toString(), e);
}
} | java |
public void exportCode(JavaClass source, JavaClass target)
throws Exception
{
ExportAnalyzer analyzer = new ExportAnalyzer(source, target);
CodeEnhancer visitor = new CodeEnhancer(source, this);
visitor.analyze(analyzer, false);
visitor.update();
} | java |
@Override
protected void fillChunkHeader(TempBuffer tBuf, int length)
{
if (length == 0)
throw new IllegalStateException();
byte []buffer = tBuf.buffer();
buffer[0] = (byte) '\r';
buffer[1] = (byte) '\n';
buffer[2] = hexDigit(length >> 12);
buffer[3] = hexDigit(length >> 8);
buffer[4] = hexDigit(length >> 4);
buffer[5] = hexDigit(length);
buffer[6] = (byte) '\r';
buffer[7] = (byte) '\n';
} | java |
public static <T> Key<T> of(Type type, Class<? extends Annotation> []annTypes)
{
return new Key<>(type, annTypes);
} | java |
public static <T> Key<T> of(Class<T> type,
Class<? extends Annotation> annType)
{
Objects.requireNonNull(type);
Objects.requireNonNull(annType);
return new Key<>(type, new Class[] { annType });
} | java |
public static <T> Key<T> of(Class<T> type,
Annotation ann)
{
Objects.requireNonNull(type);
Objects.requireNonNull(ann);
return new Key<>(type, new Annotation[] { ann });
} | java |
public Class<T> rawClass()
{
Type type = type();
if (type instanceof Class) {
return (Class) type;
}
else if (type instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) type;
return (Class) pType.getRawType();
}
else {
throw new UnsupportedOperationException(type + " " + type.getClass().getName());
}
} | java |
public boolean isAnnotationPresent(Class<? extends Annotation> annTypeTest)
{
for (Class<?> annType : _annTypes) {
if (annType.equals(annTypeTest)) {
return true;
}
}
return false;
} | java |
public boolean isAssignableFrom(Key<? super T> key)
{
Objects.requireNonNull(key);
for (Class<? extends Annotation> annType : _annTypes) {
if (! containsType(annType, key._annTypes)) {
return false;
}
}
if (_type instanceof ParameterizedType) {
if (! (key._type instanceof ParameterizedType)) {
return false;
}
if (! isAssignableFrom((ParameterizedType) _type,
(ParameterizedType) key._type)) {
return false;
}
}
if (_anns.length > 0 && key._anns.length > 0) {
return isAssignableFrom(_anns, key._anns);
}
return true;
} | java |
public static void syslog(int facility, int severity, String text)
{
_jniTroubleshoot.checkIsValid();
if (! _isOpen) {
_isOpen = true;
nativeOpenSyslog();
}
int priority = facility * 8 + severity;
nativeSyslog(priority, text);
} | java |
public Object removeAttribute(String name)
{
if (_attributes == null)
return null;
else
return _attributes.remove(name);
} | java |
@Override
public InputStream getResourceAsStream(String name)
{
ResourceEntry entry = _resourceCacheMap.get(name);
if (entry == null || entry.isModified()) {
URL resource = super.getResource(name);
entry = new ResourceEntry(resource);
_resourceCacheMap.put(name, entry);
}
return entry.getResourceAsStream();
} | java |
private void initListeners()
{
ClassLoader parent = getParent();
for (; parent != null; parent = parent.getParent()) {
if (parent instanceof EnvironmentClassLoader) {
EnvironmentClassLoader loader = (EnvironmentClassLoader) parent;
if (_stopListener == null)
_stopListener = new WeakStopListener(this);
loader.addListener(_stopListener);
return;
}
}
} | java |
@Override
public void addURL(URL url, boolean isScanned)
{
if (containsURL(url)) {
return;
}
super.addURL(url, isScanned);
if (isScanned)
_pendingScanRoots.add(new ScanRoot(url, null));
} | java |
@Override
public String getHash()
{
String superHash = super.getHash();
// ioc/0p61 - package needed for hash to enable scan
long crc = Crc64.generate(superHash);
for (String pkg : _packageList) {
crc = Crc64.generate(crc, pkg);
}
return Long.toHexString(Math.abs(crc));
} | java |
public void start()
{
if (! getLifecycle().toStarting()) {
startListeners();
return;
}
//sendAddLoaderEvent();
//bind();
try {
make();
} catch (Exception e) {
log().log(Level.WARNING, e.toString(), e);
e.printStackTrace();
}
startListeners();
getLifecycle().toActive();
if (isAdminEnable()) {
Thread thread = Thread.currentThread();
ClassLoader loader = thread.getContextClassLoader();
try {
thread.setContextClassLoader(this);
//_admin = new EnvironmentAdmin(this);
//_admin.register();
} finally {
thread.setContextClassLoader(loader);
}
}
} | java |
@Override
public void stop()
{
if (! getLifecycle().toStop()) {
return;
}
ArrayList<EnvLoaderListener> listeners = getEnvironmentListeners();
Thread thread = Thread.currentThread();
ClassLoader oldLoader = thread.getContextClassLoader();
thread.setContextClassLoader(this);
try {
// closing down in reverse
if (listeners != null) {
for (int i = listeners.size() - 1; i >= 0; i--) {
EnvLoaderListener listener = listeners.get(i);
try {
listener.environmentStop(this);
} catch (Throwable e) {
log().log(Level.WARNING, e.toString(), e);
}
}
}
super.stop();
} finally {
thread.setContextClassLoader(oldLoader);
// drain the thread pool for GC
// XXX: ExecutorThreadPoolBaratine.getThreadPool().stopEnvironment(this);
}
} | java |
@Override
public void destroy()
{
Thread thread = Thread.currentThread();
ClassLoader oldLoader = thread.getContextClassLoader();
try {
thread.setContextClassLoader(this);
WeakStopListener stopListener = _stopListener;
_stopListener = null;
super.destroy();
thread.setContextClassLoader(oldLoader);
ClassLoader parent = getParent();
for (; parent != null; parent = parent.getParent()) {
if (parent instanceof EnvironmentClassLoader) {
EnvironmentClassLoader loader = (EnvironmentClassLoader) parent;
loader.removeListener(stopListener);
}
}
} finally {
thread.setContextClassLoader(oldLoader);
//_owner = null;
_attributes = null;
_listeners = null;
//_scanListeners = null;
//_stopListener = null;
/*
EnvironmentAdmin admin = _admin;
_admin = null;
if (admin != null)
admin.unregister();
*/
}
} | java |
@Override
public void update(Result<Integer> result,
int nodeIndex,
String sql,
Object[] args)
{
NodePodAmp node = _podKraken.getNode(nodeIndex);
for (int i = 0; i < node.serverCount(); i++) {
ServerBartender server = node.server(i);
if (server != null && server.isUp()) {
ClusterServiceKraken proxy = _podKraken.getProxy(server);
// XXX: failover
proxy.update(result, nodeIndex, sql, args);
return;
}
}
RuntimeException exn = new ServiceException(L.l("update failed with no live servers"));
exn.fillInStackTrace();
// XXX: fail
result.fail(exn);
} | java |
@Override
protected void doAttach() throws Exception {
if (file == null) {
// Remove the "file:///"
// LocalFileName localFileName = (LocalFileName) getName();
String fileName = rootFile + getName().getPathDecoded();
// fileName = UriParser.decode(fileName);
file = new File(fileName); // NOSONAR
}
} | java |
@Override
protected FileType doGetType() throws Exception {
// JDK BUG: 6192331
// if (!file.exists())
if (!file.exists() && file.length() < 1) {
return FileType.IMAGINARY;
}
if (file.isDirectory()) {
return FileType.FOLDER;
}
// In doubt, treat an existing file as file
// if (file.isFile())
// {
return FileType.FILE;
// }
// throw new FileSystemException("vfs.provider.local/get-type.error", file);
} | java |
@Override
protected void doRename(final FileObject newfile) throws Exception {
AludraLocalFile newLocalFile = (AludraLocalFile) FileObjectUtils.getAbstractFileObject(newfile);
if (!file.renameTo(newLocalFile.getLocalFile())) {
throw new FileSystemException("vfs.provider.local/rename-file.error", new String[] { file.toString(),
newfile.toString() });
}
} | java |
@Override
//@Direct
public void openWrite(Result<OutputStream> result,
WriteOption ...options)
{
result.ok(_root.openWriteFile(_path, options));
} | java |
@Override
@Direct
public void renameTo(String relPath,
Result<Boolean> result,
WriteOption ...options)
{
_root.renameTo(_path, toAbsolute(relPath), result, options);
} | java |
@Override
public void get(byte []tableKey,
byte []key,
long version,
Result<GetStreamResult> result)
{
_tableManager.getKelpBacking().getLocal(tableKey, key, version,
result.then(gs->getImpl(gs)));
} | java |
@Override
public void put(byte []tableKey,
StreamSource rowSource,
Result<Boolean> result)
{
putImpl(tableKey, rowSource, PutType.PUT, result);
} | java |
@Override
public void remove(byte []tableKey, byte []rowKey,
long version,
Result<Boolean> result)
{
_tableManager.getKelpBacking().remove(tableKey, rowKey, version, result);
} | java |
@Override
public void find(byte []tableKey,
Object arg,
Result<byte[]> result)
{
TableKraken table = _tableManager.getTable(tableKey);
if (table == null) {
throw new QueryException(L.l("'{0}' is an unknown table.",
Hex.toShortHex(tableKey)));
}
String sql = "select_local table_key from kraken_meta_table where table_name=?";
QueryBuilderKraken builder = QueryParserKraken.parse(_tableManager, sql);
QueryKraken query = builder.build();
query.findOne(result.then(cursor->findKeyResult(cursor)), arg);
} | java |
@Override
public void requestStartupUpdates(String from,
byte []tableKey,
int podIndex,
long deltaTime,
Result<Boolean> cont)
{
if (log.isLoggable(Level.FINEST)) {
log.finest("CacheRequestUpdates " + from + " shard=" + podIndex
+ " delta=" + deltaTime);
}
// ChampCloudManager cloudManager = ChampCloudManager.create();
//ServiceManagerAmp rampManager = AmpSystem.getCurrentManager();
//String address = "champ://" + from + ClusterServiceKraken.UID;
//ClusterServiceKraken peerService = rampManager.lookup(address).as(ClusterServiceKraken.class);
// ArrayList<CacheData> entryList = null;
long accessTime = CurrentTime.currentTime() + deltaTime;
// int count = 0;
TablePod tablePod = _clientKraken.getTable(tableKey);
if (tablePod == null) {
// This server does not have any information about the table.
if (log.isLoggable(Level.FINEST)) {
log.finest(L.l("{0} is an unknown table key ({1})",
Hex.toShortHex(tableKey),
BartenderSystem.getCurrentSelfServer()));
}
cont.ok(true);
return;
}
tablePod.getUpdatesFromLocal(podIndex, accessTime, cont);
// new ResultUpdate(peerService, cont));
// start reciprocating update request
// tablePod.startRequestUpdates();
} | java |
public PathImpl fsWalk(String userPath,
Map<String,Object> attributes,
String path)
{
return new ClasspathPath(_root, userPath, path);
} | java |
@Override
public boolean exists()
{
ClassLoader loader = Thread.currentThread().getContextClassLoader();
return loader.getResource(getTrimPath()) != null;
} | java |
public char setIndex(int pos)
{
if (pos < 0) {
_pos = 0;
return DONE;
}
else if (_length <= pos) {
_pos = _length;
return DONE;
}
else {
_pos = pos;
return _string.charAt(pos);
}
} | java |
public char skip(int n)
{
_pos += n;
if (_length <= _pos) {
_pos = _string.length();
return DONE;
} else
return _string.charAt(_pos);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.