code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private void scanAttributeForAnnotation(InputStream is)
throws IOException
{
int nameIndex = readShort(is);
// String name = _cp.getUtf8(nameIndex).getValue();
int length = readInt(is);
if (! isNameAnnotation(nameIndex)) {
is.skip(length);
return;
}
int count = readShort(is);
for (int i = 0; i < count; i++) {
int annTypeIndex = scanAnnotation(is);
if (annTypeIndex > 0 && _cpLengths[annTypeIndex] > 2) {
_matcher.addClassAnnotation(_charBuffer,
_cpData[annTypeIndex] + 1,
_cpLengths[annTypeIndex] - 2);
}
}
} | java |
public static long toPeriod(String value, long defaultUnits)
throws ConfigException
{
if (value == null)
return 0;
long sign = 1;
long period = 0;
int i = 0;
int length = value.length();
if (length > 0 && value.charAt(i) == '-') {
sign = -1;
i++;
}
while (i < length) {
long delta = 0;
char ch;
for (; i < length && (ch = value.charAt(i)) >= '0' && ch <= '9'; i++)
delta = 10 * delta + ch - '0';
if (length <= i)
period += defaultUnits * delta;
else {
ch = value.charAt(i++);
switch (ch) {
case 's':
period += 1000 * delta;
break;
case 'm':
if (i < value.length() && value.charAt(i) == 's') {
i++;
period += delta;
}
else
period += 60 * 1000 * delta;
break;
case 'h':
period += 60L * 60 * 1000 * delta;
break;
case 'D':
period += DAY * delta;
break;
case 'W':
period += 7L * DAY * delta;
break;
case 'M':
period += 30L * DAY * delta;
break;
case 'Y':
period += 365L * DAY * delta;
break;
default:
throw new ConfigException(L.l("Unknown unit `{0}' in period `{1}'. Valid units are:\n '10ms' milliseconds\n '10s' seconds\n '10m' minutes\n '10h' hours\n '10D' days\n '10W' weeks\n '10M' months\n '10Y' years",
String.valueOf(ch), value));
}
}
}
period = sign * period;
// server/137w
/*
if (period < 0)
return INFINITE;
else
return period;
*/
return period;
} | java |
static HttpStreamWrapper openRead(HttpPath path) throws IOException
{
HttpStream stream = createStream(path);
stream._isPost = false;
HttpStreamWrapper wrapper = new HttpStreamWrapper(stream);
String status = (String) wrapper.getAttribute("status");
// ioc/23p0
if ("404".equals(status)) {
throw new FileNotFoundException(L.l("'{0}' returns a HTTP 404.",
path.getURL()));
}
return wrapper;
} | java |
static HttpStreamWrapper openReadWrite(HttpPath path) throws IOException
{
HttpStream stream = createStream(path);
stream._isPost = true;
return new HttpStreamWrapper(stream);
} | java |
static private HttpStream createStream(HttpPath path) throws IOException
{
String host = path.getHost();
int port = path.getPort();
HttpStream stream = null;
long streamTime = 0;
synchronized (LOCK) {
if (_savedStream != null
&& host.equals(_savedStream.getHost())
&& port == _savedStream.getPort()) {
stream = _savedStream;
streamTime = _saveTime;
_savedStream = null;
}
}
if (stream != null) {
long now;
now = CurrentTime.currentTime();
if (now < streamTime + 5000) {
// if the stream is still valid, use it
stream.init(path);
return stream;
}
else {
// if the stream has timed out, close it
try {
stream._isKeepalive = false;
stream.close();
} catch (IOException e) {
log.log(Level.FINE, e.toString(), e);
}
}
}
Socket s;
try {
s = new Socket(host, port);
if (path instanceof HttpsPath) {
SSLContext context = SSLContext.getInstance("TLS");
javax.net.ssl.TrustManager tm =
new javax.net.ssl.X509TrustManager() {
public java.security.cert.X509Certificate[]
getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(
java.security.cert.X509Certificate[] cert, String foo) {
}
public void checkServerTrusted(
java.security.cert.X509Certificate[] cert, String foo) {
}
};
context.init(null, new javax.net.ssl.TrustManager[] { tm }, null);
SSLSocketFactory factory = context.getSocketFactory();
s = factory.createSocket(s, host, port, true);
}
} catch (ConnectException e) {
throw new ConnectException(path.getURL() + ": " + e.getMessage());
} catch (Exception e) {
throw new ConnectException(path.getURL() + ": " + e.toString());
}
int socketTimeout = 300 * 1000;
try {
s.setSoTimeout(socketTimeout);
} catch (Exception e) {
}
return new HttpStream(path, host, port, s);
} | java |
private void init(PathImpl path)
{
_contentLength = -1;
_isChunked = false;
_isRequestDone = false;
_didGet = false;
_isPost = false;
_isHead = false;
_method = null;
_attributes.clear();
//setPath(path);
if (path instanceof HttpPath)
_virtualHost = ((HttpPath) path).getVirtualHost();
} | java |
private void getConnInput() throws IOException
{
if (_didGet)
return;
try {
getConnInputImpl();
} catch (IOException e) {
_isKeepalive = false;
throw e;
} catch (RuntimeException e) {
_isKeepalive = false;
throw e;
}
} | java |
public void setPathFormat(String pathFormat)
throws ConfigException
{
_pathFormat = pathFormat;
if (pathFormat.endsWith(".zip")) {
throw new ConfigException(L.l(".zip extension to path-format is not supported."));
}
} | java |
public void setArchiveFormat(String format)
{
if (format.endsWith(".gz")) {
_archiveFormat = format.substring(0, format.length() - ".gz".length());
_archiveSuffix = ".gz";
}
else if (format.endsWith(".zip")) {
_archiveFormat = format.substring(0, format.length() - ".zip".length());
_archiveSuffix = ".zip";
}
else {
_archiveFormat = format;
_archiveSuffix = "";
}
} | java |
public void setRolloverPeriod(Duration period)
{
_rolloverPeriod = period.toMillis();
if (_rolloverPeriod > 0) {
_rolloverPeriod += 3600000L - 1;
_rolloverPeriod -= _rolloverPeriod % 3600000L;
}
else
_rolloverPeriod = Integer.MAX_VALUE; // Period.INFINITE;
} | java |
public void setRolloverCheckPeriod(long period)
{
if (period > 1000)
_rolloverCheckPeriod = period;
else if (period > 0)
_rolloverCheckPeriod = 1000;
if (DAY < _rolloverCheckPeriod) {
log.info(this + " rollover-check-period "
+ _rolloverCheckPeriod + "ms is longer than 24h");
_rolloverCheckPeriod = DAY;
}
} | java |
@Override
public void write(byte []buffer, int offset, int length)
throws IOException
{
synchronized (_logLock) {
if (_isRollingOver && getTempStreamMax() < _tempStreamSize) {
try {
_logLock.wait();
} catch (Exception e) {
}
}
if (! _isRollingOver) {
if (_os == null)
openLog();
if (_os != null)
_os.write(buffer, offset, length);
}
else {
// XXX:
throw new UnsupportedOperationException(getClass().getName());
/*
if (_tempStream == null) {
_tempStream = createTempStream();
_tempStreamSize = 0;
}
_tempStreamSize += length;
_tempStream.write(buffer, offset, length);
*/
}
}
} | java |
private void rolloverLogTask()
{
try {
if (_isInit) {
flush();
}
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
}
_isRollingOver = true;
try {
if (! _isInit)
return;
Path savedPath = null;
long now = CurrentTime.currentTime();
long lastPeriodEnd = _nextPeriodEnd;
_nextPeriodEnd = nextRolloverTime(now);
Path path = getPath();
synchronized (_logLock) {
flushTempStream();
long length = Files.size(path);
if (lastPeriodEnd <= now && lastPeriodEnd > 0) {
closeLogStream();
savedPath = getSavedPath(lastPeriodEnd - 1);
}
else if (path != null && getRolloverSize() <= length) {
closeLogStream();
savedPath = getSavedPath(now);
}
}
// archiving of path is outside of the synchronized block to
// avoid freezing during archive
if (savedPath != null) {
movePathToArchive(savedPath);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
synchronized (_logLock) {
_isRollingOver = false;
flushTempStream();
}
_rolloverListener.requeue(_rolloverAlarm);
}
} | java |
private void openLog()
{
closeLogStream();
WriteStream os = _os;
_os = null;
IoUtil.close(os);
Path path = getPath();
if (path == null) {
path = getPath(CurrentTime.currentTime());
}
Path parent = path.getParent();
try {
if (! Files.isDirectory(parent)) {
Files.createDirectory(parent);
}
} catch (Exception e) {
logWarning(L.l("Can't create log directory {0}.\n Exception={1}",
parent, e), e);
}
Exception exn = null;
for (int i = 0; i < 3 && _os == null; i++) {
try {
OutputStream out = Files.newOutputStream(path, StandardOpenOption.APPEND);
_os = new WriteStream(out);
} catch (IOException e) {
exn = e;
}
}
String pathName = path.toString();
try {
if (pathName.endsWith(".gz")) {
_zipOut = _os;
_os = new WriteStream(new GZIPOutputStream(_zipOut));
}
else if (pathName.endsWith(".zip")) {
throw new ConfigException("Can't support .zip in path-format");
}
} catch (Exception e) {
if (exn == null)
exn = e;
}
if (exn != null)
logWarning(L.l("Can't create log for {0}.\n User={1} Exception={2}",
path, System.getProperty("user.name"), exn), exn);
} | java |
private void removeOldLogs()
{
try {
Path path = getPath();
Path parent = path.getParent();
ArrayList<String> matchList = new ArrayList<String>();
Pattern archiveRegexp = getArchiveRegexp();
Files.list(parent).forEach(child->{
String subPath = child.getFileName().toString();
Matcher matcher = archiveRegexp.matcher(subPath);
if (matcher.matches())
matchList.add(subPath);
});
Collections.sort(matchList);
if (_rolloverCount <= 0 || matchList.size() < _rolloverCount)
return;
for (int i = 0; i + _rolloverCount < matchList.size(); i++) {
try {
Files.delete(parent.resolve(matchList.get(i)));
} catch (Throwable e) {
}
}
} catch (Throwable e) {
}
} | java |
protected Path getPath(long time)
{
String formatString = getPathFormat();
if (formatString == null)
throw new IllegalStateException(L.l("getPath requires a format path"));
String pathString = getFormatName(formatString, time);
return getPwd().resolve(pathString);
} | java |
public void close()
throws IOException
{
_isClosed = true;
_rolloverWorker.wake();
_rolloverWorker.close();
synchronized (_logLock) {
closeLogStream();
}
Alarm alarm = _rolloverAlarm;
_rolloverAlarm = null;
if (alarm != null)
alarm.dequeue();
} | java |
private void closeLogStream()
{
try {
WriteStream os = _os;
_os = null;
if (os != null)
os.close();
} catch (Throwable e) {
// can't log in log routines
}
try {
WriteStream zipOut = _zipOut;
_zipOut = null;
if (zipOut != null)
zipOut.close();
} catch (Throwable e) {
// can't log in log routines
}
} | java |
public ApplicationSummary getApplication(String brooklynId) throws IOException {
Invocation invocation = getJerseyClient().target(getEndpoint() + "/v1/applications/" + brooklynId).request().buildGet();
return invocation.invoke().readEntity(ApplicationSummary.class);
} | java |
public JsonNode getApplicationsTree() throws IOException {
Invocation invocation = getJerseyClient().target(getEndpoint() + "/v1/applications/fetch").request().buildGet();
return invocation.invoke().readEntity(JsonNode.class);
} | java |
public TaskSummary removeApplication(String brooklynId) throws IOException {
Invocation invocation = getJerseyClient().target(getEndpoint() + "/v1/applications/" + brooklynId).request().buildDelete();
return invocation.invoke().readEntity(TaskSummary.class);
} | java |
public TaskSummary deployApplication(String tosca) throws IOException {
Entity content = Entity.entity(tosca, "application/x-yaml");
Invocation invocation = getJerseyClient().target(getEndpoint() + "/v1/applications").request().buildPost(content);
return invocation.invoke().readEntity(TaskSummary.class);
} | java |
public List<EntitySummary> getEntitiesFromApplication(String brooklynId) throws IOException {
Invocation invocation = getJerseyClient().target(getEndpoint() + "/v1/applications/" + brooklynId + "/entities")
.request().buildGet();
return invocation.invoke().readEntity(new GenericType<List<EntitySummary>>(){});
} | java |
public PathImpl get(String scheme)
{
ConcurrentHashMap<String,SchemeRoot> map = getMap();
SchemeRoot root = map.get(scheme);
if (root == null) {
PathImpl rootPath = createLazyScheme(scheme);
if (rootPath != null) {
map.putIfAbsent(scheme, new SchemeRoot(rootPath));
root = map.get(scheme);
}
}
PathImpl path = null;
if (root != null) {
path = root.getRoot();
}
if (path != null) {
return path;
}
else {
return new NotFoundPath(this, scheme + ":");
}
} | java |
public PathImpl remove(String scheme)
{
SchemeRoot oldRoot = getUpdateMap().remove(scheme);
return oldRoot != null ? oldRoot.getRoot() : null;
} | java |
@Override
public int export(ConstantPool target)
{
int entryIndex = _entry.export(target);
return target.addMethodHandle(_type, target.getEntry(entryIndex)).getIndex();
} | java |
protected void initHttpSystem(SystemManager system,
ServerBartender selfServer)
throws IOException
{
//RootConfigBoot rootConfig = getRootConfig();
String clusterId = selfServer.getClusterId();
//ClusterConfigBoot clusterConfig = rootConfig.findCluster(clusterId);
String serverHeader = config().get("server.header");
if (serverHeader != null) {
}
else if (! CurrentTime.isTest()) {
serverHeader = getProgramName() + "/" + Version.getVersion();
}
else {
serverHeader = getProgramName() + "/1.1";
}
// XXX: need cleaner config class names (root vs cluster at minimum)
/*
ServerContainerConfig serverConfig
= new ServerContainerConfig(this, system, selfServer);
*/
// rootConfig.getProgram().configure(serverConfig);
//clusterConfig.getProgram().configure(serverConfig);
/*
ServerConfig config = new ServerConfig(serverConfig);
clusterConfig.getServerDefault().configure(config);
ServerConfigBoot serverConfigBoot
= rootConfig.findServer(selfServer.getDisplayName());
if (serverConfigBoot != null) {
serverConfigBoot.getServerProgram().configure(config);
}
*/
/*
_args.getProgram().configure(config);
*/
// _bootServerConfig.getServerProgram().configure(config);
// serverConfig.init();
//int port = getServerPort();
HttpContainerBuilder httpBuilder
= createHttpBuilder(selfServer, serverHeader);
// serverConfig.getProgram().configure(httpBuilder);
//httpBuilder.init();
//PodSystem.createAndAddSystem(httpBuilder);
HttpSystem.createAndAddSystem(httpBuilder);
//return http;
} | java |
@Override
public boolean isModified()
{
if (_isDigestModified) {
if (log.isLoggable(Level.FINE))
log.fine(_source.getNativePath() + " digest is modified.");
return true;
}
long sourceLastModified = _source.getLastModified();
long sourceLength = _source.length();
// if the source was deleted and we need the source
if (! _requireSource && sourceLastModified == 0) {
return false;
}
// if the length changed
else if (sourceLength != _length) {
if (log.isLoggable(Level.FINE)) {
log.fine(_source.getNativePath() + " length is modified (" +
_length + " -> " + sourceLength + ")");
}
return true;
}
// if the source is newer than the old value
else if (sourceLastModified != _lastModified) {
if (log.isLoggable(Level.FINE))
log.fine(_source.getNativePath() + " time is modified.");
return true;
}
else
return false;
} | java |
public boolean logModified(Logger log)
{
if (_isDigestModified) {
log.info(_source.getNativePath() + " digest is modified.");
return true;
}
long sourceLastModified = _source.getLastModified();
long sourceLength = _source.length();
// if the source was deleted and we need the source
if (! _requireSource && sourceLastModified == 0) {
return false;
}
// if the length changed
else if (sourceLength != _length) {
log.info(_source.getNativePath() + " length is modified (" +
_length + " -> " + sourceLength + ")");
return true;
}
// if the source is newer than the old value
else if (sourceLastModified != _lastModified) {
log.info(_source.getNativePath() + " time is modified.");
return true;
}
else
return false;
} | java |
public static BaseType createGenericClass(Class<?> type)
{
TypeVariable<?> []typeParam = type.getTypeParameters();
if (typeParam == null || typeParam.length == 0)
return ClassType.create(type);
BaseType []args = new BaseType[typeParam.length];
HashMap<String,BaseType> newParamMap = new HashMap<String,BaseType>();
String paramDeclName = null;
for (int i = 0; i < args.length; i++) {
args[i] = create(typeParam[i],
newParamMap, paramDeclName,
ClassFill.TARGET);
if (args[i] == null) {
throw new NullPointerException("unsupported BaseType: " + type);
}
newParamMap.put(typeParam[i].getName(), args[i]);
}
// ioc/07f2
return new GenericParamType(type, args, newParamMap);
} | java |
@Override
public int read(byte []buf, int offset, int length)
throws IOException
{
if (buf == null)
throw new NullPointerException();
else if (offset < 0 || buf.length < offset + length)
throw new ArrayIndexOutOfBoundsException();
int result = nativeRead(_fd, buf, offset, length);
if (result > 0)
_pos += result;
return result;
} | java |
public boolean lock(boolean shared, boolean block)
{
if (shared && !_canRead) {
// Invalid request for a shared "read" lock on a write only stream.
return false;
}
if (!shared && !_canWrite) {
// Invalid request for an exclusive "write" lock on a read only stream.
return false;
}
return true;
} | java |
public String getFullName()
{
StringBuilder name = new StringBuilder();
name.append(getName());
name.append("(");
JClass []params = getParameterTypes();
for (int i = 0; i < params.length; i++) {
if (i != 0)
name.append(", ");
name.append(params[i].getShortName());
}
name.append(')');
return name.toString();
} | java |
@AfterBatch
public void afterBatch()
{
if (_isGc) {
return;
}
long gcSequence = _gcSequence;
_gcSequence = 0;
if (gcSequence <= 0) {
return;
}
try {
ArrayList<SegmentHeaderGc> collectList = findCollectList(gcSequence);
if (collectList.size() < _table.database().getGcMinCollect()) {
return;
}
_gcGeneration++;
/*
while (collectList.size() > 0) {
ArrayList<SegmentHeaderGc> sublist = new ArrayList<>();
// int sublen = Math.min(_db.getGcMinCollect(), collectList.size());
int size = collectList.size();
int sublen = size;
if (size > 16) {
sublen = Math.min(16, collectList.size() / 2);
}
// System.out.println("GC: count=" + sublen + " gcSeq=" + gcSequence);
//if (_db.getGcMinCollect() <= sublist.size()) {
// sublen = Math.max(2, _db.getGcMinCollect() / 2);
//}
for (int i = 0; i < sublen; i++) {
SegmentHeaderGc header = collectList.remove(0);
header.startGc();
sublist.add(header);
}
collect(gcSequence, sublist);
}
*/
collect(gcSequence, collectList);
} catch (Throwable e) {
e.printStackTrace();
}
} | java |
public URL copyWithDevice(String deviceAddress, String attrName, String attrValue) {
return new URL(this.protocol, this.adapterAddress, deviceAddress, Collections.singletonMap(attrName, attrValue),
this.serviceUUID, this.characteristicUUID, this.fieldName);
} | java |
public URL getDeviceURL() {
return new URL(this.protocol, this.adapterAddress, this.deviceAddress, this.deviceAttributes, null, null, null);
} | java |
public URL getServiceURL() {
return new URL(this.protocol, this.adapterAddress, this.deviceAddress, this.deviceAttributes,
this.serviceUUID, null, null);
} | java |
public URL getCharacteristicURL() {
return new URL(this.protocol, this.adapterAddress, this.deviceAddress, this.deviceAttributes, this.serviceUUID,
this.characteristicUUID, null);
} | java |
public URL getParent() {
if (isField()) {
return getCharacteristicURL();
} else if (isCharacteristic()) {
return getServiceURL();
} else if (isService()) {
return getDeviceURL();
} else if (isDevice()) {
return getAdapterURL();
} else if (isAdapter()) {
return getProtocolURL();
} else {
return null;
}
} | java |
public boolean isDescendant(URL url) {
if (url.protocol != null && protocol != null && !protocol.equals(url.protocol)) {
return false;
}
if (adapterAddress != null && url.adapterAddress == null) {
return true;
}
if (adapterAddress != null && !adapterAddress.equals(url.adapterAddress)) {
return false;
}
if (deviceAddress != null && url.deviceAddress == null) {
return true;
}
if (deviceAddress != null && !deviceAddress.equals(url.deviceAddress)) {
return false;
}
if (serviceUUID != null && url.serviceUUID == null) {
return true;
}
if (serviceUUID != null ? !serviceUUID.equals(url.serviceUUID) : url.serviceUUID != null) {
return false;
}
if (characteristicUUID != null && url.characteristicUUID == null) {
return true;
}
if (characteristicUUID != null
? !characteristicUUID.equals(url.characteristicUUID) :
url.characteristicUUID != null) {
return false;
}
return fieldName != null && url.fieldName == null;
} | java |
public Object putValue(String key, Object value)
{
return _valueMap.put(key, value);
} | java |
static JavaAnnotation []parseAnnotations(InputStream is,
ConstantPool cp,
JavaClassLoader loader)
throws IOException
{
int n = readShort(is);
JavaAnnotation []annArray = new JavaAnnotation[n];
for (int i = 0; i < n; i++) {
annArray[i] = parseAnnotation(is, cp, loader);
}
return annArray;
} | java |
@Override
public void run()
{
try {
handleAlarm();
} catch (Throwable e) {
log.log(Level.WARNING, e.toString(), e);
} finally {
_isRunning = false;
_runningAlarmCount.decrementAndGet();
}
} | java |
private void handleAlarm()
{
AlarmListener listener = getListener();
if (listener == null) {
return;
}
Thread thread = Thread.currentThread();
ClassLoader loader = getContextLoader();
if (loader != null) {
thread.setContextClassLoader(loader);
}
else {
thread.setContextClassLoader(_systemLoader);
}
try {
listener.handleAlarm(this);
} finally {
thread.setContextClassLoader(_systemLoader);
}
} | java |
private IDomain createDomainIfNotExist(String domainId){
IDomain foundDomain=findDomainByID(domainId);
if(foundDomain==null){
foundDomain=user.createDomain(domainName);
}
return foundDomain;
} | java |
protected void configureEnv() {
//TODO a sensor with the custom-environment variables?
Map<String, String> envs=getEntity().getConfig(OpenShiftWebApp.ENV);
if((envs!=null)&&(envs.size()!=0)){
deployedApp.addEnvironmentVariables(envs);
deployedApp.restart();
}
} | java |
@Override
public void shutdown(DeployService2Impl<I> deploy,
ShutdownModeAmp mode,
Result<Boolean> result)
{
deploy.shutdownImpl(mode, result);
} | java |
public JavaClass readFromClassPath(String classFile)
throws IOException
{
Thread thread = Thread.currentThread();
ClassLoader loader = thread.getContextClassLoader();
InputStream is = loader.getResourceAsStream(classFile);
try {
return parse(is);
} finally {
is.close();
}
} | java |
private void updateLocalRepository() throws GitAPIException {
try {
Git.open(new File(paasifyRepositoryDirecory)).pull().call();
} catch (IOException e) {
log.error("Cannot update local Git repository");
log.error(e.getMessage());
}
} | java |
private Offering getOfferingFromJSON(JSONObject obj) throws IOException {
JSONArray infrastructures = (JSONArray) obj.get("infrastructures");
String name = (String) obj.get("name");
Offering offering = null;
if (infrastructures == null || infrastructures.size() == 0) {
String providerName = Offering.sanitizeName(name);
offering = this.parseOffering(providerName, providerName, obj);
} else {
for (Object element: infrastructures) {
JSONObject infrastructure = (JSONObject) element;
String continent = "";
String country = "";
String fullName = name;
if (infrastructure.containsKey("continent")) {
continent = infrastructure.get("continent").toString();
if (!continent.isEmpty()) {
continent = continentFullName.get(continent);
fullName = fullName + "." + continent;
}
}
if (infrastructure.containsKey("country")) {
country = infrastructure.get("country").toString();
if (!country.isEmpty())
fullName = fullName + "." + country;
}
String providerName = Offering.sanitizeName(name);
String offeringName = Offering.sanitizeName(fullName);
offering = this.parseOffering(providerName, offeringName, obj);
if (!continent.isEmpty())
offering.addProperty("continent", continent);
if (!country.isEmpty())
offering.addProperty("country", country);
}
}
return offering;
} | java |
@Override
public int acceptInitialRead(byte []buffer, int offset, int length)
{
synchronized (_readLock) {
// initialize fields from the _fd
int result = nativeAcceptInit(_socketFd, _localAddrBuffer, _remoteAddrBuffer,
buffer, offset, length);
return result;
}
} | java |
@Override
public String getRemoteHost()
{
if (_remoteName == null) {
byte []remoteAddrBuffer = _remoteAddrBuffer;
char []remoteAddrCharBuffer = _remoteAddrCharBuffer;
if (_remoteAddrLength <= 0) {
_remoteAddrLength = InetAddressUtil.createIpAddress(remoteAddrBuffer,
remoteAddrCharBuffer);
}
_remoteName = new String(remoteAddrCharBuffer, 0, _remoteAddrLength);
}
return _remoteName;
} | java |
@Override
public String getLocalHost()
{
if (_localName == null) {
byte []localAddrBuffer = _localAddrBuffer;
char []localAddrCharBuffer = _localAddrCharBuffer;
if (_localAddrLength <= 0) {
_localAddrLength = InetAddressUtil.createIpAddress(localAddrBuffer,
localAddrCharBuffer);
}
_localName = new String(localAddrCharBuffer, 0, _localAddrLength);
}
return _localName;
} | java |
public int read(byte []buffer, int offset, int length, long timeout)
throws IOException
{
if (length == 0) {
throw new IllegalArgumentException();
}
long requestExpireTime = _requestExpireTime;
if (requestExpireTime > 0 && requestExpireTime < CurrentTime.currentTime()) {
close();
throw new ClientDisconnectException(L.l("{0}: request-timeout read",
addressRemote()));
}
int result = 0;
synchronized (_readLock) {
long now = CurrentTime.getCurrentTimeActual();
long expires;
// gap is because getCurrentTimeActual() isn't exact
long gap = 20;
if (timeout >= 0)
expires = timeout + now - gap;
else
expires = _socketTimeout + now - gap;
do {
result = readNative(_socketFd, buffer, offset, length, timeout);
now = CurrentTime.getCurrentTimeActual();
timeout = expires - now;
} while (result == JniStream.TIMEOUT_EXN && timeout > 0);
}
return result;
} | java |
public int write(byte []buffer, int offset, int length, boolean isEnd)
throws IOException
{
int result;
long requestExpireTime = _requestExpireTime;
if (requestExpireTime > 0 && requestExpireTime < CurrentTime.currentTime()) {
close();
throw new ClientDisconnectException(L.l("{0}: request-timeout write exp={0}s",
addressRemote(),
CurrentTime.currentTime() - requestExpireTime));
}
synchronized (_writeLock) {
long now = CurrentTime.getCurrentTimeActual();
long expires = _socketTimeout + now;
// _isNativeFlushRequired = true;
do {
result = writeNative(_socketFd, buffer, offset, length);
//byte []tempBuffer = _byteBuffer.array();
//System.out.println("TEMP: " + tempBuffer);
//System.arraycopy(buffer, offset, tempBuffer, 0, length);
//_byteBuffer.position(0);
//_byteBuffer.put(buffer, offset, length);
//result = writeNativeNio(_fd, _byteBuffer, 0, length);
} while (result == JniStream.TIMEOUT_EXN
&& CurrentTime.getCurrentTimeActual() < expires);
}
if (isEnd) {
// websocket/1261
closeWrite();
}
return result;
} | java |
@Override
public StreamImpl stream()
throws IOException
{
if (_stream == null) {
_stream = new JniStream(this);
}
_stream.init();
return _stream;
} | java |
private boolean onLoad(Cursor cursor, T entity)
{
if (cursor == null) {
if (log.isLoggable(Level.FINEST)) {
log.finest(L.l("{0} load returned null", _entityInfo));
}
_entityInfo.loadFail(entity);
return false;
}
else {
_entityInfo.load(cursor, entity);
if (log.isLoggable(Level.FINER)) {
log.finer("loaded " + entity);
}
return true;
}
} | java |
@Override
public void findOne(String sql,
Object[] params,
Result<Cursor> result)
{
_db.findOne(sql, result, params);
} | java |
@Override
public void findAll(String sql,
Object[] params,
Result<Iterable<Cursor>> result)
{
_db.findAll(sql, result, params);
} | java |
public <V> Function<Cursor, V> cursorToBean(Class<V> api)
{
return (FindDataVault<ID,T,V>) _valueBeans.get(api);
} | java |
public static TempCharBuffer allocate()
{
TempCharBuffer next = _freeList.allocate();
if (next == null)
return new TempCharBuffer(SIZE);
next._next = null;
next._offset = 0;
next._length = 0;
next._bufferCount = 0;
return next;
} | java |
public static void free(TempCharBuffer buf)
{
buf._next = null;
if (buf._buf.length == SIZE)
_freeList.free(buf);
} | java |
@Override
public void log(int level, String message) {
switch (level) {
case LogChute.WARN_ID:
log.warn(message);
break;
case LogChute.INFO_ID:
log.info(message);
break;
case LogChute.TRACE_ID:
log.trace(message);
break;
case LogChute.ERROR_ID:
log.error(message);
break;
case LogChute.DEBUG_ID:
default:
log.debug(message);
break;
}
} | java |
@Override
public boolean isLevelEnabled(int level) {
switch (level) {
case LogChute.DEBUG_ID:
return log.isDebugEnabled();
case LogChute.INFO_ID:
return log.isInfoEnabled();
case LogChute.TRACE_ID:
return log.isTraceEnabled();
case LogChute.WARN_ID:
return log.isWarnEnabled();
case LogChute.ERROR_ID:
return log.isErrorEnabled();
default:
return true;
}
} | java |
@Override
public void onPut(byte[] key, TypePut type)
{
//_watchKey.init(key);
WatchKey watchKey = new WatchKey(key);
switch (type) {
case LOCAL:
ArrayList<WatchEntry> listLocal = _entryMapLocal.get(watchKey);
onPut(listLocal, key);
break;
case REMOTE:
{
int hash = _table.getPodHash(key);
TablePodNodeAmp node = _table.getTablePod().getNode(hash);
if (node.isSelfCopy()) {
// copies are responsible for their own local watch events
onPut(key, TypePut.LOCAL);
}
if (node.isSelfOwner()) {
// only the owner sends remote watch events
/*
System.out.println("NSO: " + BartenderSystem.getCurrentSelfServer().getDisplayName()
+ " " + node.isSelfOwner() + " " + node + " " + Hex.toHex(key));
*/
ArrayList<WatchEntry> listRemote = _entryMapRemote.get(watchKey);
onPut(listRemote, key);
}
break;
}
default:
throw new IllegalArgumentException(String.valueOf(type));
}
} | java |
private void onPut(ArrayList<WatchEntry> list, byte []key)
{
if (list != null) {
int size = list.size();
for (int i = 0; i < size; i++) {
WatchEntry entry = list.get(i);
RowCursor rowCursor = _table.cursor();
rowCursor.setKey(key, 0);
EnvKelp envKelp = null;
CursorKraken cursor = new CursorKraken(table(), envKelp, rowCursor, _results);
entry.onPut(cursor);
}
}
} | java |
@Override
public long skip(long n)
throws IOException
{
if (_is == null) {
if (_s == null)
return -1;
_is = _s.getInputStream();
}
return _is.skip(n);
} | java |
@Override
public int getAvailable() throws IOException
{
if (_is == null) {
if (_s == null)
return -1;
_is = _s.getInputStream();
}
return _is.available();
} | java |
@Override
public void flush() throws IOException
{
if (_os == null || ! _needsFlush)
return;
_needsFlush = false;
try {
_os.flush();
} catch (IOException e) {
try {
close();
} catch (IOException e1) {
}
throw ClientDisconnectException.create(e);
}
} | java |
@Override
public int available() throws IOException
{
if (_readOffset < _readLength) {
return _readLength - _readOffset;
}
StreamImpl source = _source;
if (source != null) {
return source.getAvailable();
}
else {
return -1;
}
} | java |
@Override
public synchronized boolean addLogger(Logger logger)
{
EnvironmentLogger envLogger = addLogger(logger.getName(),
logger.getResourceBundleName());
// handle custom logger
if (! logger.getClass().equals(Logger.class)) {
return envLogger.addCustomLogger(logger);
}
return false;
} | java |
private EnvironmentLogger buildParentTree(String childName)
{
if (childName == null || childName.equals(""))
return null;
int p = childName.lastIndexOf('.');
String parentName;
if (p > 0)
parentName = childName.substring(0, p);
else
parentName = "";
EnvironmentLogger parent = null;
SoftReference<EnvironmentLogger> parentRef = _envLoggers.get(parentName);
if (parentRef != null)
parent = parentRef.get();
if (parent != null)
return parent;
else {
parent = new EnvironmentLogger(parentName, null);
_envLoggers.put(parentName, new SoftReference<EnvironmentLogger>(parent));
EnvironmentLogger grandparent = buildParentTree(parentName);
if (grandparent != null)
parent.setParent(grandparent);
return parent;
}
} | java |
@Override
public synchronized Logger getLogger(String name)
{
SoftReference<EnvironmentLogger> envLoggerRef = _envLoggers.get(name);
EnvironmentLogger envLogger = null;
if (envLoggerRef != null)
envLogger = envLoggerRef.get();
if (envLogger == null)
envLogger = addLogger(name, null);
Logger customLogger = envLogger.getLogger();
if (customLogger != null)
return customLogger;
else
return envLogger;
} | java |
public static JavacConfig getLocalConfig()
{
JavacConfig config;
config = _localJavac.get();
if (config != null)
return config;
else
return new JavacConfig();
} | java |
public ArrayList<InetAddress> getLocalAddresses()
{
synchronized (_addressCache) {
ArrayList<InetAddress> localAddresses = _addressCache.get("addresses");
if (localAddresses == null) {
localAddresses = new ArrayList<InetAddress>();
try {
for (NetworkInterfaceBase iface : getNetworkInterfaces()) {
for (InetAddress addr : iface.getInetAddresses()) {
localAddresses.add(addr);
}
}
Collections.sort(localAddresses, new LocalIpCompare());
_addressCache.put("addresses", localAddresses);
} catch (Exception e) {
log.log(Level.WARNING, e.toString(), e);
} finally {
_addressCache.put("addresses", localAddresses);
}
}
return new ArrayList<>(localAddresses);
}
} | java |
public byte[] getHardwareAddress()
{
if (CurrentTime.isTest() || System.getProperty("test.mac") != null) {
return new byte[] { 10, 0, 0, 0, 0, 10 };
}
for (NetworkInterfaceBase nic : getNetworkInterfaces()) {
if (! nic.isLoopback()) {
return nic.getHardwareAddress();
}
}
try {
InetAddress localHost = InetAddress.getLocalHost();
return localHost.getAddress();
} catch (Exception e) {
log.log(Level.FINER, e.toString(), e);
}
return new byte[0];
} | java |
public void waitForExit()
throws IOException
{
Thread thread = Thread.currentThread();
ClassLoader oldLoader = thread.getContextClassLoader();
try {
thread.setContextClassLoader(_systemManager.getClassLoader());
_waitForExitService = new WaitForExitService3(this,
_systemManager);
_waitForExitService.waitForExit();
} finally {
thread.setContextClassLoader(oldLoader);
}
} | java |
public boolean compareAndPut(V testValue, K key, V value)
{
V result = compareAndPut(testValue, key, value, true);
return testValue == result;
} | java |
private void updateLru(CacheItem<K,V> item)
{
long lruCounter = _lruCounter;
long itemCounter = item._lruCounter;
long delta = (lruCounter - itemCounter) & 0x3fffffff;
if (_lruTimeout < delta || delta < 0) {
// update LRU only if not used recently
updateLruImpl(item);
}
} | java |
public boolean removeTail()
{
CacheItem<K,V> tail = null;
if (_capacity1 <= _size1)
tail = _tail1;
if (tail == null) {
tail = _tail2;
if (tail == null) {
tail = _tail1;
if (tail == null)
return false;
}
}
V oldValue = tail._value;
if (oldValue instanceof LruListener) {
((LruListener) oldValue).lruEvent();
}
V value = remove(tail._key);
return true;
} | java |
public Iterator<K> keys()
{
KeyIterator<K,V> iter = new KeyIterator<K,V>(this);
iter.init(this);
return iter;
} | java |
public Iterator<K> keys(Iterator<K> oldIter)
{
KeyIterator<K,V> iter = (KeyIterator<K,V>) oldIter;
iter.init(this);
return oldIter;
} | java |
public Iterator<V> values()
{
ValueIterator<K,V> iter = new ValueIterator<K,V>(this);
iter.init(this);
return iter;
} | java |
@Override
public void ssl(SSLFactory sslFactory)
{
try {
Objects.requireNonNull(sslFactory);
SocketChannel channel = _channel;
Objects.requireNonNull(channel);
_sslSocket = sslFactory.ssl(channel);
_sslSocket.startHandshake();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
} | java |
@Override
public int portRemote()
{
if (_channel != null) {
try {
SocketAddress addr = _channel.getRemoteAddress();
return 0;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
else
return 0;
} | java |
public Map<IGuaranteeTerm, GuaranteeTermEvaluationResult> evaluate(IAgreement agreement,
Map<IGuaranteeTerm, List<IMonitoringMetric>> metricsMap) {
checkInitialized(false);
Map<IGuaranteeTerm,GuaranteeTermEvaluationResult> result =
new HashMap<IGuaranteeTerm,GuaranteeTermEvaluationResult>();
Date now = new Date();
for (IGuaranteeTerm term : metricsMap.keySet()) {
List<IMonitoringMetric> metrics = metricsMap.get(term);
if (metrics.size() > 0) {
GuaranteeTermEvaluationResult aux = termEval.evaluate(agreement, term, metrics, now);
result.put(term, aux);
}
}
return result;
} | java |
public Map<IGuaranteeTerm, GuaranteeTermEvaluationResult> evaluateBusiness(IAgreement agreement,
Map<IGuaranteeTerm, List<IViolation>> violationsMap) {
checkInitialized(false);
Map<IGuaranteeTerm,GuaranteeTermEvaluationResult> result =
new HashMap<IGuaranteeTerm,GuaranteeTermEvaluationResult>();
Date now = new Date();
for (IGuaranteeTerm term : violationsMap.keySet()) {
List<IViolation> violations = violationsMap.get(term);
if (violations.size() > 0) {
GuaranteeTermEvaluationResult aux = termEval.evaluateBusiness(agreement, term, violations, now);
result.put(term, aux);
}
}
return result;
} | java |
@Override
public Auction createAuction(String userId,
long durationMs, long startPrice,
String title, String description)
{
ResourceManager manager = getResourceManager();
ServiceRef ref = manager.create(userId, durationMs, startPrice, title, description);
Auction auction = ref.as(Auction.class);
Auction copy = new Auction(auction);
return copy;
} | java |
public void read()
{
StateInPipe stateOld;
StateInPipe stateNew;
do {
stateOld = _stateInRef.get();
stateNew = stateOld.toActive();
} while (! _stateInRef.compareAndSet(stateOld, stateNew));
while (stateNew.isActive()) {
readPipe();
wakeOut();
do {
stateOld = _stateInRef.get();
stateNew = stateOld.toIdle();
} while (! _stateInRef.compareAndSet(stateOld, stateNew));
}
if (_stateInRef.get().isClosed()) {
StateOutPipe outStateOld = _stateOutRef.getAndSet(StateOutPipe.CLOSE);
if (! outStateOld.isClosed()) {
_outFlow.cancel();
}
}
} | java |
private void wakeIn()
{
StateInPipe stateOld;
StateInPipe stateNew;
do {
stateOld = _stateInRef.get();
if (stateOld.isActive()) {
return;
}
stateNew = stateOld.toWake();
} while (! _stateInRef.compareAndSet(stateOld, stateNew));
if (stateOld == StateInPipe.IDLE) {
try (OutboxAmp outbox = OutboxAmp.currentOrCreate(_services)) {
Objects.requireNonNull(outbox);
PipeWakeInMessage<T> msg = new PipeWakeInMessage<>(outbox, _inRef, this);
outbox.offer(msg);
}
}
} | java |
void wakeOut()
{
OnAvailable outFlow = _outFlow;
if (outFlow == null) {
return;
}
if (_creditsIn <= _queue.head()) {
return;
}
StateOutPipe stateOld;
StateOutPipe stateNew;
do {
stateOld = _stateOutRef.get();
if (! stateOld.isFull()) {
return;
}
stateNew = stateOld.toWake();
} while (! _stateOutRef.compareAndSet(stateOld, stateNew));
try (OutboxAmp outbox = OutboxAmp.currentOrCreate(_outRef.services())) {
Objects.requireNonNull(outbox);
PipeWakeOutMessage<T> msg = new PipeWakeOutMessage<>(outbox, _outRef, this, outFlow);
outbox.offer(msg);
}
} | java |
public void flush()
{
int level = getLevel().intValue();
for (int i = 0; i < _handlers.length; i++) {
Handler handler = _handlers[i];
if (level <= handler.getLevel().intValue())
handler.flush();
}
} | java |
public void checkpointStart()
{
if (_isWhileCheckpoint) {
throw new IllegalStateException();
}
_isWhileCheckpoint = true;
long sequence = ++_sequence;
setSequence(sequence);
byte []headerBuffer = _headerBuffer;
BitsUtil.writeInt16(headerBuffer, 0, CHECKPOINT_START);
writeImpl(headerBuffer, 0, 2);
_lastCheckpointStart = _index - _startAddress;
} | java |
public void checkpointEnd()
{
if (! _isWhileCheckpoint) {
throw new IllegalStateException();
}
_isWhileCheckpoint = false;
byte []headerBuffer = _headerBuffer;
BitsUtil.writeInt16(headerBuffer, 0, CHECKPOINT_END);
writeImpl(headerBuffer, 0, 2);
flush();
_lastCheckpointEnd = _index - _startAddress;
writeTail(_os);
} | java |
public void replay(ReplayCallback replayCallback)
{
TempBuffer tReadBuffer = TempBuffer.createLarge();
byte []readBuffer = tReadBuffer.buffer();
int bufferLength = readBuffer.length;
try (InStore jIn = _blockStore.openRead(_startAddress, getSegmentSize())) {
Replay replay = readReplay(jIn);
if (replay == null) {
return;
}
long address = replay.getCheckpointStart();
long next;
setSequence(replay.getSequence());
TempBuffer tBuffer = TempBuffer.create();
byte []tempBuffer = tBuffer.buffer();
jIn.read(getBlockAddress(address), readBuffer, 0, bufferLength);
ReadStream is = new ReadStream();
while (address < _tailAddress
&& (next = scanItem(jIn, address, readBuffer, tempBuffer)) > 0) {
boolean isOverflow = getBlockAddress(address) != getBlockAddress(next);
// if scanning has passed the buffer boundary, need to re-read
// the initial buffer
if (isOverflow) {
jIn.read(getBlockAddress(address), readBuffer, 0, bufferLength);
}
ReplayInputStream rIn = new ReplayInputStream(jIn, readBuffer, address);
is.init(rIn);
try {
replayCallback.onItem(is);
} catch (Exception e) {
e.printStackTrace();
log.log(Level.FINER, e.toString(), e);
}
address = next;
if (isOverflow) {
jIn.read(getBlockAddress(address), readBuffer, 0, bufferLength);
}
_index = address;
_flushIndex = address;
}
}
} | java |
private long scanItem(InStore is, long address, byte []readBuffer,
byte []tempBuffer)
{
startRead();
byte []headerBuffer = _headerBuffer;
while (address + 2 < _tailAddress) {
readImpl(is, address, readBuffer, headerBuffer, 0, 2);
address += 2;
int len = BitsUtil.readInt16(headerBuffer, 0);
if ((len & 0x8000) != 0) {
if (len == CHECKPOINT_START) {
setSequence(_sequence + 1);
}
startRead();
continue;
}
if (len == 0) {
readImpl(is, address, readBuffer, headerBuffer, 0, 4);
address += 4;
int crc = BitsUtil.readInt(headerBuffer, 0);
int digest = (int) _crc.getValue();
if (crc == digest) {
return address;
}
else {
return -1;
}
}
if (_tailAddress < address + len) {
return -1;
}
int readLen = len;
while (readLen > 0) {
int sublen = Math.min(readLen, tempBuffer.length);
readImpl(is, address, readBuffer, tempBuffer, 0, sublen);
_crc.update(tempBuffer, 0, sublen);
address += sublen;
readLen -= sublen;
}
}
return -1;
} | java |
public static void main(String []argv)
{
EnvLoader.init();
ArgsServerBase args = new ArgsServerBaratine(argv);
args.doMain();
} | java |
public int getLine()
{
if (_line >= 0)
return _line;
Attribute attr = getAttribute("LineNumberTable");
if (attr == null) {
_line = 0;
return _line;
}
_line = 0;
return _line;
} | java |
public JClass getReturnType()
{
String descriptor = getDescriptor();
int i = descriptor.lastIndexOf(')');
return getClassLoader().descriptorToClass(descriptor, i + 1);
} | java |
public Attribute removeAttribute(String name)
{
for (int i = _attributes.size() - 1; i >= 0; i--) {
Attribute attr = _attributes.get(i);
if (attr.getName().equals(name)) {
_attributes.remove(i);
return attr;
}
}
return null;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.