code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
protected void run(String war, String servlet, String testMethod) throws Exception {
FATServletClient.runTest(getServer(), war + "/" + servlet, testMethod);
}
|
java
|
private Context getURLContext(String name) throws NamingException {
int schemeIndex = name.indexOf(":");
if (schemeIndex != -1) {
String scheme = name.substring(0, schemeIndex);
return NamingManager.getURLContext(scheme, env);
}
return null;
}
|
java
|
private static int indexOf(Object o, Object[] elements,
int index, int fence) {
if (o == null) {
for (int i = index; i < fence; i++)
if (elements[i] == null)
return i;
} else {
for (int i = index; i < fence; i++)
if (o.equals(elements[i]))
return i;
}
return -1;
}
|
java
|
private static int lastIndexOf(Object o, Object[] elements, int index) {
if (o == null) {
for (int i = index; i >= 0; i--)
if (elements[i] == null)
return i;
} else {
for (int i = index; i >= 0; i--)
if (o.equals(elements[i]))
return i;
}
return -1;
}
|
java
|
public boolean addIfAbsent(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// Copy while checking if already present.
// This wins in the most common case where it is not present
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = new Object[len + 1];
for (int i = 0; i < len; ++i) {
if (eq(e, elements[i]))
return false; // exit, throwing away copy
else
newElements[i] = elements[i];
}
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
|
java
|
@Override
public boolean removeAll(Collection<?> c) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
if (len != 0) {
// temp array holds those elements we know we want to keep
int newlen = 0;
Object[] temp = new Object[len];
for (int i = 0; i < len; ++i) {
Object element = elements[i];
if (!c.contains(element))
temp[newlen++] = element;
}
if (newlen != len) {
setArray(Arrays.copyOf(temp, newlen));
return true;
}
}
return false;
} finally {
lock.unlock();
}
}
|
java
|
public int addAllAbsent(Collection<? extends E> c) {
Object[] cs = c.toArray();
if (cs.length == 0)
return 0;
Object[] uniq = new Object[cs.length];
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
int added = 0;
for (int i = 0; i < cs.length; ++i) { // scan for duplicates
Object e = cs[i];
if (indexOf(e, elements, 0, len) < 0 &&
indexOf(e, uniq, 0, added) < 0)
uniq[added++] = e;
}
if (added > 0) {
Object[] newElements = Arrays.copyOf(elements, len + added);
System.arraycopy(uniq, 0, newElements, len, added);
setArray(newElements);
}
return added;
} finally {
lock.unlock();
}
}
|
java
|
@Override
public boolean addAll(Collection<? extends E> c) {
Object[] cs = c.toArray();
if (cs.length == 0)
return false;
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + cs.length);
System.arraycopy(cs, 0, newElements, len, cs.length);
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
|
java
|
public Runnable discriminate(HttpInboundConnectionExtended inboundConnection) {
String requestUri = inboundConnection.getRequest().getURI();
Runnable requestHandler = null;
// Find the container that can handle this URI.
// The first to return a non-null wins
for (HttpContainerContext ctx : httpContainers) {
requestHandler = ctx.container.createRunnableHandler(inboundConnection);
if (requestHandler != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
if (!requestUri.endsWith("/")) {
// Strip the query string and append a / to help the best match
int pos = requestUri.lastIndexOf('?');
if (pos >= 0) {
requestUri = requestUri.substring(0, pos);
}
requestUri += "/";
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "Discriminate " + requestUri, ctx.container);
}
}
break;
}
}
return requestHandler;
}
|
java
|
public static void generateLocalVariables(JavaCodeWriter out, Element jspElement, String pageContextVar) throws JspCoreException {
if (hasUseBean(jspElement)) {
out.println("HttpSession session = "+pageContextVar+".getSession();");
out.println("ServletContext application = "+pageContextVar+".getServletContext();");
}
if (hasUseBean(jspElement) || hasIncludeAction(jspElement) || hasSetProperty(jspElement) || hasForwardAction(jspElement)) {
out.println("HttpServletRequest request = (HttpServletRequest)"+pageContextVar+".getRequest();");
}
if (hasIncludeAction(jspElement)) {
out.println("HttpServletResponse response = (HttpServletResponse)"+pageContextVar+".getResponse();");
}
}
|
java
|
public static String interpreterCall(
boolean isTagFile,
String expression,
Class expectedType,
String fnmapvar,
boolean XmlEscape,
String pageContextVar) { //PK65013
return JSPExtensionFactory.getGeneratorUtilsExtFactory().getGeneratorUtilsExt().interpreterCall(isTagFile,
expression,
expectedType,
fnmapvar,
XmlEscape,
pageContextVar); //PI59436
}
|
java
|
public static String attributeValue(
String valueIn,
boolean encode,
Class expectedType,
JspConfiguration jspConfig,
boolean isTagFile,
String pageContextVar) {
String value = valueIn;
value = value.replaceAll(">", ">");
value = value.replaceAll("<", "<");
value = value.replaceAll("&", "&");
value = value.replaceAll("<\\%", "<%");
value = value.replaceAll("%\\>", "%>");
if(com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable(Level.FINEST)){
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","valueIn = ["+valueIn+"]");
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","encode = ["+encode+"]");
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","expectedType = ["+expectedType+"]");
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","isTagFile = ["+isTagFile+"]");
}
if (JspTranslatorUtil.isExpression(value)) {
value = value.substring(2, value.length() - 1);
if (encode) {
value = "org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode(String.valueOf(" +
value +
"), request.getCharacterEncoding())";//PK03712
}
if(com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable(Level.FINEST)){
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","isExpression. value = ["+value+"]");
}
}
else if (JspTranslatorUtil.isELInterpreterInput(value, jspConfig)) {
if(encode){
//PK65013 - add pageContextVar parameter
value = "org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode(" +
interpreterCall(isTagFile, value, expectedType, "_jspx_fnmap", false, pageContextVar) +
", request.getCharacterEncoding())";
}
else{
//PK65013 - add pageContextVar parameter
value = interpreterCall(isTagFile, value, expectedType, "_jspx_fnmap", false, pageContextVar);
}
if(com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable(Level.FINEST)){
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","isELInterpreterInput. value = ["+value+"]");
}
}
else {
if (encode) {
value = "org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("
+ quote(value)
+ ", request.getCharacterEncoding())";
}
else {
value = quote(value);
}
if(com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable(Level.FINEST)){
logger.logp(Level.FINEST, CLASS_NAME, "attributeValue","default. value = ["+value+"]");
}
}
return (value);
}
|
java
|
Object[] getObjects(ExtendedLogEntry logEntry, boolean translatedMsg) {
ArrayList<Object> list = new ArrayList<Object>(5);
if (translatedMsg && logEntry.getMessage() != null) {
list.add(logEntry.getMessage());
}
if (!translatedMsg) {
String loggerName = logEntry.getLoggerName();
if (loggerName != null) {
list.add(String.format("LoggerName:%s", loggerName));
}
}
ServiceReference<?> sr = logEntry.getServiceReference();
if (sr != null) {
String sString = String.format("ServiceRef:%s(id=%s, pid=%s)",
java.util.Arrays.asList((String[]) sr.getProperty("objectClass")), sr.getProperty("service.id"),
sr.getProperty("service.pid"));
list.add(sString);
}
Throwable t = logEntry.getException();
if (t != null) {
list.add(t);
}
Object event = logEntry.getContext();
if (event instanceof EventObject) {
String sString = String.format("Event:%s", event.toString());
list.add(sString);
}
if (translatedMsg) {
while (list.size() < 4)
// 4 parameters in formatted message
list.add("");
}
return list.toArray();
}
|
java
|
private void addToLoggedOutTokenCache(String tokenString) {
String tokenValue = "userName";
LoggedOutTokenCacheImpl.getInstance().addTokenToDistributedMap(tokenString, tokenValue);
}
|
java
|
private void removeEntryFromAuthCache(HttpServletRequest req, HttpServletResponse res, WebAppSecurityConfig config) {
/*
* TODO: we need to optimize this method... if the authCacheService.remove() method
* return true for successfully removed the entry in the authentication cache, then we
* do not have to call the second method for token. See defect 66015
*/
removeEntryFromAuthCacheForUser(req, res);
removeEntryFromAuthCacheForToken(req, res, config);
}
|
java
|
private void removeEntryFromAuthCacheForToken(HttpServletRequest req, HttpServletResponse res, WebAppSecurityConfig config) {
getAuthCacheService();
if (authCacheService == null) {
return;
}
Cookie[] cookies = req.getCookies();
if (cookies != null) {
String cookieValues[] = null;
cookieValues = CookieHelper.getCookieValues(cookies, ssoCookieHelper.getSSOCookiename());
if ((cookieValues == null || cookieValues.length == 0) &&
!SSOAuthenticator.DEFAULT_SSO_COOKIE_NAME.equalsIgnoreCase(ssoCookieHelper.getSSOCookiename())) {
cookieValues = CookieHelper.getCookieValues(cookies, SSOAuthenticator.DEFAULT_SSO_COOKIE_NAME);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Cookie size: ", cookieValues == null ? "<null>" : cookieValues.length);
if (cookieValues != null && cookieValues.length > 0) {
for (int n = 0; n < cookieValues.length; n++) {
String val = cookieValues[n];
if (val != null && val.length() > 0) {
try {
authCacheService.remove(val);
//Add token to the logged out cache if enabled
if (config.isTrackLoggedOutSSOCookiesEnabled())
addToLoggedOutTokenCache(val);
} catch (Exception e) {
String user = req.getRemoteUser();
if (user == null) {
Principal p = req.getUserPrincipal();
if (p != null)
user = p.getName();
}
Tr.warning(tc, "AUTHENTICATE_CACHE_REMOVAL_EXCEPTION", user, e.toString());
}
}
}
}
}
}
|
java
|
private void removeEntryFromAuthCacheForUser(HttpServletRequest req, HttpServletResponse res) {
getAuthCacheService();
if (authCacheService == null) {
return;
}
String user = req.getRemoteUser();
if (user == null) {
Principal p = req.getUserPrincipal();
if (p != null)
user = p.getName();
}
if (user != null) {
if (collabUtils != null) {
String realm = collabUtils.getUserRegistryRealm(securityServiceRef);
if (!user.contains(realm + ":")) {
user = realm + ":" + user;
}
}
authCacheService.remove(user);
}
}
|
java
|
public void throwExceptionIfAlreadyAuthenticate(HttpServletRequest req, HttpServletResponse resp, WebAppSecurityConfig config, String username) throws ServletException {
Subject callerSubject = subjectManager.getCallerSubject();
if (subjectHelper.isUnauthenticated(callerSubject))
return;
if (!config.getWebAlwaysLogin()) {
AuthenticationResult authResult = new AuthenticationResult(AuthResult.FAILURE, username);
authResult.setAuditCredType(req.getAuthType());
authResult.setAuditCredValue(username);
authResult.setAuditOutcome(AuditEvent.OUTCOME_FAILURE);
Audit.audit(Audit.EventID.SECURITY_API_AUTHN_01, req, authResult, Integer.valueOf(HttpServletResponse.SC_UNAUTHORIZED));
throw new ServletException("Authentication had been already established");
}
logout(req, resp, config);
}
|
java
|
private void invalidateSession(HttpServletRequest req) {
HttpSession session = req.getSession(false);
if (session != null) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "invalidating existing HTTP Session");
session.invalidate();
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Existing HTTP Session does not exist, nothing to invalidate");
}
}
|
java
|
private void createSubjectAndPushItOnThreadAsNeeded(HttpServletRequest req, HttpServletResponse res) {
// We got a new instance of FormLogoutExtensionProcess every request.
logoutSubject = null;
Subject subject = subjectManager.getCallerSubject();
if (subject == null || subjectHelper.isUnauthenticated(subject)) {
if (authService == null && securityServiceRef != null) {
authService = securityServiceRef.getService().getAuthenticationService();
}
SSOAuthenticator ssoAuthenticator = new SSOAuthenticator(authService, null, null, ssoCookieHelper);
//TODO: We can not call ssoAuthenticator.authenticate because it can not handle multiple tokens.
//In the next release, authenticate need to handle multiple authentication data. See story
AuthenticationResult authResult = ssoAuthenticator.handleSSO(req, res);
if (authResult != null && authResult.getStatus() == AuthResult.SUCCESS) {
subjectManager.setCallerSubject(authResult.getSubject());
logoutSubject = authResult.getSubject();
}
}
}
|
java
|
String debugGetAllHttpHdrs(HttpServletRequest req) {
if (req == null)
return null;
StringBuffer sb = new StringBuffer(512);
Enumeration<String> headerNames = req.getHeaderNames();
while (headerNames != null && headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
sb.append(headerName).append("=");
sb.append("[").append(SRTServletRequestUtils.getHeader(req, headerName)).append("]\n");
}
return sb.toString();
}
|
java
|
public void processException(Class sourceClass,
String methodName,
Throwable throwable,
String probe) {
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(cclass,
"processException",
new Object[] { sourceClass,
methodName,
throwable,
probe });
print(null,
sourceClass,
methodName,
throwable,
probe,
null,
null);
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.exit(cclass,
"processException");
}
|
java
|
public static Properties loadRepoProperties() throws InstallException {
Properties repoProperties = null;
// Retrieves the Repository Properties file
File repoPropertiesFile = new File(getRepoPropertiesFileLocation());
//Check if default repository properties file location is overridden
boolean isPropsLocationOverridden = System.getProperty(InstallConstants.OVERRIDE_PROPS_LOCATION_ENV_VAR) != null ? true : false;
if (repoPropertiesFile.exists() && repoPropertiesFile.isFile()) {
//Load repository properties
repoProperties = new Properties();
FileInputStream repoPropertiesInput = null;
try {
repoPropertiesInput = new FileInputStream(repoPropertiesFile);
repoProperties.load(repoPropertiesInput);
} catch (Exception e) {
throw new InstallException(Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("ERROR_TOOL_REPOSITORY_PROPS_NOT_LOADED",
getRepoPropertiesFileLocation()), InstallException.IO_FAILURE);
} finally {
InstallUtils.close(repoPropertiesInput);
}
} else if (isPropsLocationOverridden) {
//Checks if the override location is a directory
throw new InstallException(Messages.INSTALL_KERNEL_MESSAGES.getLogMessage(repoPropertiesFile.isDirectory() ? "ERROR_TOOL_REPOSITORY_PROPS_NOT_FILE" : "ERROR_TOOL_REPOSITORY_PROPS_NOT_EXISTS",
getRepoPropertiesFileLocation()), InstallException.IO_FAILURE);
}
return repoProperties;
}
|
java
|
public static String getRepoPropertiesFileLocation() {
String installDirPath = Utils.getInstallDir().getAbsolutePath();
String overrideLocation = System.getProperty(InstallConstants.OVERRIDE_PROPS_LOCATION_ENV_VAR);
//Gets the repository properties file path from the default location
if (overrideLocation == null) {
return installDirPath + InstallConstants.DEFAULT_REPO_PROPERTIES_LOCATION;
} else {
//Gets the repository properties file from user specified location
return overrideLocation;
}
}
|
java
|
public static void setProxyAuthenticator(final String proxyHost, final String proxyPort, final String proxyUser, final String decodedPwd) {
if (proxyUser == null || proxyUser.isEmpty() || decodedPwd == null || decodedPwd.isEmpty()) {
return;
}
//Authenticate proxy credentials
Authenticator.setDefault(new Authenticator() {
@Override
public PasswordAuthentication getPasswordAuthentication() {
if (getRequestorType() == RequestorType.PROXY) {
if (getRequestingHost().equals(proxyHost) && getRequestingPort() == Integer.valueOf(proxyPort)) {
return new PasswordAuthentication(proxyUser, decodedPwd.toCharArray());
}
}
return null;
}
});
}
|
java
|
public static String getProxyPwd(Properties repoProperties) {
if (repoProperties.getProperty(InstallConstants.REPO_PROPERTIES_PROXY_USERPWD) != null)
return repoProperties.getProperty(InstallConstants.REPO_PROPERTIES_PROXY_USERPWD);
else if (repoProperties.getProperty(InstallConstants.REPO_PROPERTIES_PROXY_PWD) != null)
return repoProperties.getProperty(InstallConstants.REPO_PROPERTIES_PROXY_PWD);
else
return null;
}
|
java
|
public static List<String> getOrderList(Properties repoProperties) throws InstallException {
List<String> orderList = new ArrayList<String>();
List<String> repoList = new ArrayList<String>();
// Retrieves the Repository Properties file
File repoPropertiesFile = new File(getRepoPropertiesFileLocation());
if (repoPropertiesFile.exists() && repoPropertiesFile.isFile()) {
//Load repository properties
FileInputStream repoPropertiesInput = null;
BufferedReader repoPropertiesReader = null;
try {
repoPropertiesInput = new FileInputStream(repoPropertiesFile);
repoPropertiesReader = new BufferedReader(new InputStreamReader(repoPropertiesInput));
String line;
String repoName;
while ((line = repoPropertiesReader.readLine()) != null) {
String keyValue[] = line.split(EQUALS);
if (!line.startsWith(COMMENT_PREFIX) && keyValue.length > 1 && keyValue[0].endsWith(URL_SUFFIX)) {
repoName = keyValue[0].substring(0, keyValue[0].length() - URL_SUFFIX.length());
//Ignore empty repository names
if (repoName.isEmpty()) {
continue;
}
//Remove duplicate entries
if (orderList.contains(repoName)) {
repoList.remove(orderList.indexOf(repoName));
orderList.remove(repoName);
}
orderList.add(repoName);
repoList.add(line);
// if Windows, replace \ to \\
if (InstallUtils.isWindows && keyValue.length > 1 && keyValue[1].contains("\\")) {
String url = repoProperties.getProperty(keyValue[0]);
if (url != null && !InstallUtils.isURL(url)) {
repoProperties.put(keyValue[0], keyValue[1].trim());
logger.log(Level.FINEST, "The value of " + keyValue[0] + " was replaced to " + repoProperties.getProperty(keyValue[0]));
}
}
}
}
} catch (IOException e) {
throw new InstallException(Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("ERROR_TOOL_REPOSITORY_PROPS_NOT_LOADED",
getRepoPropertiesFileLocation()), InstallException.IO_FAILURE);
} finally {
InstallUtils.close(repoPropertiesInput);
InstallUtils.close(repoPropertiesReader);
}
}
if (isWlpRepoEnabled(repoProperties)) {
orderList.add(WLP_REPO);
}
return orderList;
}
|
java
|
public static boolean isWlpRepoEnabled(Properties repoProperties) {
if (!repoPropertiesFileExists() || repoProperties == null)
return true;
String wlpEnabled = repoProperties.getProperty(USE_WLP_REPO);
if (wlpEnabled == null)
return true;
return !wlpEnabled.trim().equalsIgnoreCase("false");
}
|
java
|
public static List<RepositoryConfig> getRepositoryConfigs(Properties repoProperties) throws InstallException {
List<String> orderList = getOrderList(repoProperties);
List<RepositoryConfig> connections = new ArrayList<RepositoryConfig>(orderList.size());
if (repoProperties == null || repoProperties.isEmpty()) {
connections.add(new RepositoryConfig(WLP_REPO, null, null, null, null));
return connections;
}
for (String r : orderList) {
if (r.equalsIgnoreCase(WLP_REPO)) {
connections.add(new RepositoryConfig(WLP_REPO, null, null, null, null));
continue;
}
String url = repoProperties.getProperty(r + URL_SUFFIX);
String user = null;
String userPwd = null;
if (url != null && !url.isEmpty()) {
user = repoProperties.getProperty(r + USER_SUFFIX);
if (user != null) {
if (user.isEmpty())
user = null;
else {
userPwd = repoProperties.getProperty(r + PWD_SUFFIX);
if (userPwd == null || userPwd.isEmpty()) {
userPwd = repoProperties.getProperty(r + USERPWD_SUFFIX);
}
if (userPwd != null && userPwd.isEmpty())
userPwd = null;
}
}
String apiKey = repoProperties.getProperty(r + APIKEY_SUFFIX);
url = url.trim();
if (!InstallUtils.isURL(url)) {
File f = new File(url);
try {
url = f.toURI().toURL().toString();
} catch (MalformedURLException e1) {
logger.log(Level.FINEST, "Failed to convert " + f.getAbsolutePath() + " to url format", e1);
}
}
connections.add(new RepositoryConfig(r, url, apiKey, user, userPwd));
}
}
if (connections.isEmpty()) {
throw new InstallException(Messages.INSTALL_KERNEL_MESSAGES.getLogMessage("ERROR_NO_REPO_WAS_ENABLED"));
}
return connections;
}
|
java
|
public static String getRepoName(Properties repoProperties, RepositoryConnection repoConn) throws InstallException {
String repoName = null;
List<RepositoryConfig> configRepos = RepositoryConfigUtils.getRepositoryConfigs(repoProperties);
if (!(repoConn instanceof DirectoryRepositoryConnection || repoConn instanceof ZipRepositoryConnection)) {
if (RepositoryConfigUtils.isLibertyRepository((RestRepositoryConnection) repoConn, repoProperties))
return WLP_REPO;
}
for (RepositoryConfig rc : configRepos) {
if (rc.getUrl() != null) {
if (rc.getUrl().toLowerCase().startsWith("file:") && (repoConn instanceof DirectoryRepositoryConnection || repoConn instanceof ZipRepositoryConnection)) {
String repoDir = rc.getUrl();
try {
URL fileURL = new URL(repoDir);
File repoFile = new File(fileURL.getPath());
if (repoFile.getAbsolutePath().equalsIgnoreCase(repoConn.getRepositoryLocation())) {
repoName = rc.getId();
break;
}
} catch (Exception e) {
throw new InstallException(RepositoryUtils.getMessage("ERROR_DIRECTORY_NOT_EXISTS", repoDir));
}
} else {
if (rc.getUrl().equalsIgnoreCase(repoConn.getRepositoryLocation())) {
repoName = rc.getId();
break;
}
}
}
}
return repoName;
}
|
java
|
public static boolean isLibertyRepository(RestRepositoryConnection lie, Properties repoProperties) throws InstallException {
if (isWlpRepoEnabled(repoProperties)) {
return lie.getRepositoryLocation().startsWith(InstallConstants.REPOSITORY_LIBERTY_URL);
}
return false;
}
|
java
|
private static boolean isKeySupported(String key) {
if (Arrays.asList(SUPPORTED_KEYS).contains(key))
return true;
if (key.endsWith(URL_SUFFIX) || key.endsWith(APIKEY_SUFFIX) ||
key.endsWith(USER_SUFFIX) || key.endsWith(PWD_SUFFIX) || key.endsWith(USERPWD_SUFFIX))
return true;
return false;
}
|
java
|
private boolean isFirstRequestProcessed()
{
FacesContext context = FacesContext.getCurrentInstance();
//if firstRequestProcessed is not set, check the application map
if(!_firstRequestProcessed && context != null
&& Boolean.TRUE.equals(context.getExternalContext().getApplicationMap()
.containsKey(LifecycleImpl.FIRST_REQUEST_PROCESSED_PARAM)))
{
_firstRequestProcessed = true;
}
return _firstRequestProcessed;
}
|
java
|
public static Object claimFromJsonObject(String jsonFormattedString, String claimName) throws JoseException {
Object claim = null;
// JSONObject jobj = JSONObject.parse(jsonFormattedString);
Map<String, Object> jobj = org.jose4j.json.JsonUtil.parseJson(jsonFormattedString);
if (jobj != null) {
claim = jobj.get(claimName);
}
return claim;
}
|
java
|
public static Map claimsFromJsonObject(String jsonFormattedString) throws JoseException {
Map claimsMap = new ConcurrentHashMap<String, Object>();
// JSONObject jobj = JSONObject.parse(jsonFormattedString);
Map<String, Object> jobj = org.jose4j.json.JsonUtil.parseJson(jsonFormattedString);
Set<Entry<String, Object>> entries = jobj.entrySet();
Iterator<Entry<String, Object>> it = entries.iterator();
while (it.hasNext()) {
Entry<String, Object> entry = it.next();
String key = entry.getKey();
Object value = entry.getValue();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Key : " + key + ", Value: " + value);
}
if (!isNullEmpty(key) && value != null) {
claimsMap.put(key, value);
}
// JsonElement jsonElem = entry.getValue();
}
// claims.putAll(jobj.entrySet());
return claimsMap;
}
|
java
|
public static List<String> trimIt(String[] strings) {
if (strings == null || strings.length == 0) {
return null;
}
List<String> results = new ArrayList<String>();
for (int i = 0; i < strings.length; i++) {
String result = trimIt(strings[i]);
if (result != null) {
results.add(result);
}
}
if (results.size() > 0) {
return results;
} else {
return null;
}
}
|
java
|
protected void invokeCollectorIfPresent() {
if (collectorProxy != null) {
Serializable data = collectorProxy.collectPartitionData();
logger.finer("Got partition data: " + data + ", from collector: " + collectorProxy);
sendCollectorDataPartitionReplyMsg(data);
}
}
|
java
|
protected void sendCollectorDataPartitionReplyMsg(Serializable data) {
if (logger.isLoggable(Level.FINE)) {
logger.fine("Sending collector partition data: " + data + " to analyzer queue: " + getPartitionReplyQueue());
}
PartitionReplyMsg msg = new PartitionReplyMsg( PartitionReplyMsgType.PARTITION_COLLECTOR_DATA )
.setCollectorData(serializeToByteArray(data));
getPartitionReplyQueue().add(msg);
}
|
java
|
private void initialize(Chunk chunk)
{
final String mName = "initialize";
if(logger.isLoggable(Level.FINER))
logger.entering(className, mName);
try
{
if (chunk.getSkipLimit() != null){
_skipLimit = Integer.parseInt(chunk.getSkipLimit());
if (_skipLimit < 0) {
throw new IllegalArgumentException("The skip-limit attribute on a chunk cannot be a negative value");
}
}
}
catch (NumberFormatException nfe)
{
throw new RuntimeException("NumberFormatException reading " + SKIP_COUNT, nfe);
}
// Read the include/exclude exceptions.
_skipIncludeExceptions = new HashSet<String>();
_skipExcludeExceptions = new HashSet<String>();
if (chunk.getSkippableExceptionClasses() != null) {
if (chunk.getSkippableExceptionClasses().getIncludeList() != null) {
List<ExceptionClassFilter.Include> includes = chunk.getSkippableExceptionClasses().getIncludeList();
for (ExceptionClassFilter.Include include : includes) {
_skipIncludeExceptions.add(include.getClazz().trim());
logger.finer("SKIPHANDLE: include: " + include.getClazz().trim());
}
if (_skipIncludeExceptions.size() == 0) {
logger.finer("SKIPHANDLE: include element not present");
}
}
}
if (chunk.getSkippableExceptionClasses() != null) {
if (chunk.getSkippableExceptionClasses().getExcludeList() != null) {
List<ExceptionClassFilter.Exclude> excludes = chunk.getSkippableExceptionClasses().getExcludeList();
for (ExceptionClassFilter.Exclude exclude : excludes) {
_skipExcludeExceptions.add(exclude.getClazz().trim());
logger.finer("SKIPHANDLE: exclude: " + exclude.getClazz().trim());
}
if (_skipExcludeExceptions.size() == 0) {
logger.finer("SKIPHANDLE: exclude element not present");
}
}
}
// Create the ExceptionMatcher Object
excMatcher = new ExceptionMatcher(_skipIncludeExceptions, _skipExcludeExceptions);
if (logger.isLoggable(Level.FINE))
logger.logp(Level.FINE, className, mName, "added include exception " + _skipIncludeExceptions
+ "; added exclude exception " + _skipExcludeExceptions);
if(logger.isLoggable(Level.FINER))
logger.exiting(className, mName, this.toString());
}
|
java
|
@Trivial
public static String getSymbol(String s) {
String outputSymbol = null;
if (s != null) {
if (s.length() > 3) {
// ${} .. look for $
int pos = s.indexOf('$');
if (pos >= 0) {
// look for { after $
int pos2 = pos + 1;
if (s.length() > pos2) {
if (s.charAt(pos2) == '{') {
// look for } after {
pos2 = s.indexOf('}', pos2);
if (pos2 >= 0) {
outputSymbol = s.substring(pos, pos2 + 1);
}
}
}
}
}
}
return outputSymbol;
}
|
java
|
public static String getChildUnder(String path, String parentPath) {
int start = parentPath.length();
String local = path.substring(start, path.length());
String name = getFirstPathComponent(local);
return name;
}
|
java
|
public static boolean isNormalizedPathAbsolute(String nPath) {
boolean retval = "..".equals(nPath) || nPath.startsWith("../") || nPath.startsWith("/..");
//System.out.println("returning " + retval);
return !retval;
}
|
java
|
public static String checkAndNormalizeRootPath(String path) throws IllegalArgumentException {
path = PathUtils.normalizeUnixStylePath(path);
//check the path is not trying to go upwards.
if (!PathUtils.isNormalizedPathAbsolute(path)) {
throw new IllegalArgumentException();
}
//ZipFileContainer is always the root.
//so all relative paths requested can be made into absolute by adding /
if (!path.startsWith("/")) {
path = '/' + path;
}
//remove trailing /'s
if (path.endsWith("/")) {
path = path.substring(0, path.length() - 1);
}
if (path.equals("/") || path.equals("")) {
throw new IllegalArgumentException();
}
return path;
}
|
java
|
public static boolean checkCase(final File file, String pathToTest) {
if (pathToTest == null || pathToTest.isEmpty()) {
return true;
}
if (IS_OS_CASE_SENSITIVE) {
// It is assumed that the file exists. Therefore, its case must
// match if we know that the file system is case sensitive.
return true;
}
try {
// This will handle the case where the file system is not case sensitive, but
// doesn't support symbolic links. A canonical file path will handle this case.
if (checkCaseCanonical(file, pathToTest)) {
return true;
}
// We didn't know for sure that the file system is case sensitive and a
// canonical check didn't pass. Try to handle both symbolic links and case
// insensitive files together.
return checkCaseSymlink(file, pathToTest);
} catch (PrivilegedActionException e) {
// We couldn't access the file system to test the path so must have failed
return false;
}
}
|
java
|
private static boolean checkCaseCanonical(final File file, String pathToTest) throws PrivilegedActionException {
// The canonical path returns the actual path on the file system so get this
String onDiskCanonicalPath = AccessController.doPrivileged(new PrivilegedExceptionAction<String>() {
/** {@inheritDoc} */
@Override
public String run() throws IOException {
return file.getCanonicalPath();
}
});
onDiskCanonicalPath = onDiskCanonicalPath.replace("\\", "/");
// The trailing / on a file name is optional so add it if this is a directory
final String expectedEnding;
if (onDiskCanonicalPath.endsWith("/")) {
if (pathToTest.endsWith("/")) {
expectedEnding = pathToTest;
} else {
expectedEnding = pathToTest + "/";
}
} else {
if (pathToTest.endsWith("/")) {
expectedEnding = pathToTest.substring(0, pathToTest.length() - 1);
} else {
expectedEnding = pathToTest;
}
}
if (expectedEnding.isEmpty()) {
// Nothing to compare so case must match
return true;
}
return onDiskCanonicalPath.endsWith(expectedEnding);
}
|
java
|
private static boolean checkCaseSymlink(File file, String pathToTest) throws PrivilegedActionException {
// java.nio.Path.toRealPath(LinkOption.NOFOLLOW_LINKS) in java 7 seems to do what
// we are trying to do here
//On certain platforms, i.e. iSeries, the path starts with a slash.
//Remove this slash before continuing.
if (pathToTest.startsWith("/"))
pathToTest = pathToTest.substring(1);
String[] splitPathToTest = pathToTest.split("/");
File symLinkTestFile = file;
for (int i = splitPathToTest.length - 1; i >= 0; i--) {
File symLinkParentFile = symLinkTestFile.getParentFile();
if (symLinkParentFile == null) {
return false;
}
// If the current file isn't a symbolic link, make sure the case matches using the
// canonical file. Otherwise get the parents list of files to compare against.
if (!isSymbolicLink(symLinkTestFile, symLinkParentFile)) {
if (!getCanonicalFile(symLinkTestFile).getName().equals(splitPathToTest[i])) {
return false;
}
} else if (!contains(symLinkParentFile.list(), splitPathToTest[i])) {
return false;
}
symLinkTestFile = symLinkParentFile;
}
return true;
}
|
java
|
private static boolean isSymbolicLink(final File file, File parentFile) throws PrivilegedActionException {
File canonicalParentDir = getCanonicalFile(parentFile);
File fileInCanonicalParentDir = new File(canonicalParentDir, file.getName());
File canonicalFile = getCanonicalFile(fileInCanonicalParentDir);
return !canonicalFile.equals(fileInCanonicalParentDir.getAbsoluteFile());
}
|
java
|
protected void setVariableRegistry(ServiceReference<VariableRegistry> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setVariableRegistry", ref);
variableRegistryRef.setReference(ref);
}
|
java
|
protected void unsetVariableRegistry(ServiceReference<VariableRegistry> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "unsetVariableRegistry", ref);
variableRegistryRef.unsetReference(ref);
}
|
java
|
protected void setWsConfigurationHelper(ServiceReference<WSConfigurationHelper> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setWSConfigurationHelper", ref);
wsConfigurationHelperRef.setReference(ref);
}
|
java
|
protected void unsetWsConfigurationHelper(ServiceReference<WSConfigurationHelper> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "unsetVariableRegistry", ref);
wsConfigurationHelperRef.unsetReference(ref);
}
|
java
|
protected void setMetaTypeService(ServiceReference<MetaTypeService> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setMetaTypeService", ref);
metaTypeServiceRef.setReference(ref);
}
|
java
|
protected void unsetMetaTypeService(ServiceReference<MetaTypeService> ref) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "unsetMetaTypeService", ref);
metaTypeServiceRef.unsetReference(ref);
}
|
java
|
private static <T> T getContextualReference(Class<T> type, BeanManager beanManager, Set<Bean<?>> beans)
{
Bean<?> bean = beanManager.resolve(beans);
//logWarningIfDependent(bean);
CreationalContext<?> creationalContext = beanManager.createCreationalContext(bean);
@SuppressWarnings({ "unchecked", "UnnecessaryLocalVariable" })
T result = (T) beanManager.getReference(bean, type, creationalContext);
return result;
}
|
java
|
public static String printStatus(int status)
{
switch (status)
{
case Status.STATUS_ACTIVE:
return "Status.STATUS_ACTIVE";
case Status.STATUS_COMMITTED:
return "Status.STATUS_COMMITTED";
case Status.STATUS_COMMITTING:
return "Status.STATUS_COMMITTING";
case Status.STATUS_MARKED_ROLLBACK:
return "Status.STATUS_MARKED_ROLLBACK";
case Status.STATUS_NO_TRANSACTION:
return "Status.STATUS_NO_TRANSACTION";
case Status.STATUS_PREPARED:
return "Status.STATUS_PREPARED";
case Status.STATUS_PREPARING:
return "Status.STATUS_PREPARING";
case Status.STATUS_ROLLEDBACK:
return "Status.STATUS_ROLLEDBACK";
case Status.STATUS_ROLLING_BACK:
return "Status.STATUS_ROLLING_BACK";
default:
return "Status.STATUS_UNKNOWN";
}
}
|
java
|
public static String printFlag(int flags)
{
StringBuffer sb = new StringBuffer();
sb.append(Integer.toHexString(flags));
sb.append("=");
if (flags == XAResource.TMNOFLAGS)
{
sb.append("TMNOFLAGS");
}
else
{
if ((flags & XAResource.TMENDRSCAN) != 0) sb.append("TMENDRSCAN|");
if ((flags & XAResource.TMFAIL) != 0) sb.append("TMFAIL|");
if ((flags & XAResource.TMJOIN) != 0) sb.append("TMJOIN|");
if ((flags & XAResource.TMONEPHASE) != 0) sb.append("TMONEPHASE|");
if ((flags & XAResource.TMRESUME) != 0) sb.append("TMRESUME|");
if ((flags & XAResource.TMSTARTRSCAN) != 0) sb.append("TMSTARTRSCAN|");
if ((flags & XAResource.TMSUCCESS) != 0) sb.append("TMSUCCESS|");
if ((flags & XAResource.TMSUSPEND) != 0) sb.append("TMSUSPEND|");
sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
|
java
|
public static String identity(java.lang.Object x)
{
if (x == null) return "" + x;
return(x.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(x)));
}
|
java
|
public static byte[] duplicateByteArray(byte[] in, int offset, int length)
{
if (in == null) return null;
byte[] out = new byte[length];
System.arraycopy(in, offset, out, 0, length);
return out;
}
|
java
|
public static void setBytesFromInt(byte[] bytes,
int offset,
int byteCount,
int value)
{
long maxval = ((1L << (8 * byteCount)) - 1);
if (value > maxval)
{
final String msg = "value too large for byteCount";
IllegalArgumentException iae = new IllegalArgumentException(msg);
FFDCFilter.processException(
iae,
"com.ibm.ws.Transaction.JTA.Util.setBytesFromInt",
"579");
throw iae;
}
switch (byteCount)
{
case 4: bytes[offset++] = (byte) ((value >> 24) & 0xFF);
case 3: bytes[offset++] = (byte) ((value >> 16) & 0xFF);
case 2: bytes[offset++] = (byte) ((value >> 8 ) & 0xFF);
case 1: bytes[offset++] = (byte) ((value ) & 0xFF);
break;
default:
final String msg = "byteCount is not between 1 and 4";
IllegalArgumentException iae =
new IllegalArgumentException(msg);
FFDCFilter.processException(
iae,
"com.ibm.ws.Transaction.JTA.Util.setBytesFromInt",
"598");
throw iae;
}
}
|
java
|
public static long getLongFromBytes(byte[] bytes,
int offset)
{
if (tc.isEntryEnabled())
Tr.entry(tc, "getLongFromBytes: length = " + bytes.length + ", data = " + toHexString(bytes));
long result = -1;
if (bytes.length >= offset + 8)
{
result = ((bytes[0 + offset]&0xff) << 56) +
((bytes[1 + offset]&0xff) << 48) +
((bytes[2 + offset]&0xff) << 40) +
((bytes[3 + offset]&0xff) << 32) +
((bytes[4 + offset]&0xff) << 24) +
((bytes[5 + offset]&0xff) << 16) +
((bytes[6 + offset]&0xff) << 8) +
(bytes[7 + offset]&0xff);
}
if (tc.isEntryEnabled()) Tr.exit(tc, "getLongFromBytes " + result);
return result;
}
|
java
|
public static byte[] longToBytes(long rmid)
{
return new byte[] { (byte)(rmid>>56), (byte)(rmid>>48), (byte)(rmid>>40), (byte)(rmid>>32),
(byte)(rmid>>24), (byte)(rmid>>16), (byte)(rmid>>8), (byte)(rmid)};
}
|
java
|
public static boolean equal(byte[] a, byte[] b) {
if (a == b)
return (true);
if ((a == null) || (b == null))
return (false);
if (a.length != b.length)
return (false);
for (int i = 0; i < a.length; i++)
if (a[i] != b[i])
return (false);
return (true);
}
|
java
|
public static String byteArrayToString(byte[] b) {
final int l = b.length/2;
if (l*2 != b.length) throw new IllegalArgumentException();
StringBuffer result = new StringBuffer(l);
int o = 0;
for (int i = 0; i < l; i++)
{
int i1 = b[o++] & 0xff;
int i2 = b[o++] & 0xff;
i2 = i2 << 8;
i1 = i1 | i2;
result.append((char)i1);
}
return (result.toString());
}
|
java
|
public static String stackToDebugString(Throwable e) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
pw.close();
String text = sw.toString();
// Jump past the throwable
text = text.substring(text.indexOf("at"));
return text;
}
|
java
|
@SuppressWarnings({ "unchecked", "rawtypes" })
public static String setPropertyAsNeeded(final String propName, final String propValue) {
String previousPropValue = (String) java.security.AccessController.doPrivileged(new java.security.PrivilegedAction() {
@Override
public String run() {
String oldPropValue = System.getProperty(propName);
if (propValue == null) {
System.clearProperty(propName);
} else if (!propValue.equalsIgnoreCase(oldPropValue)) {
System.setProperty(propName, propValue);
}
return oldPropValue;
}
});
if (tc.isDebugEnabled())
Tr.debug(tc, propName + " property previous: " + ((previousPropValue != null) ? previousPropValue : "<null>") + " and now: " + propValue);
return previousPropValue;
}
|
java
|
public static void restorePropertyAsNeeded(final String propName, final String oldPropValue, final String newPropValue) {
java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<Object>() {
@Override
public Object run() {
if (oldPropValue == null) {
System.clearProperty(propName);
} else if (!oldPropValue.equalsIgnoreCase(newPropValue)) {
System.setProperty(propName, oldPropValue);
}
return null;
}
});
if (tc.isDebugEnabled())
Tr.debug(tc, "Restore property " + propName + " to previous value: " + oldPropValue);
}
|
java
|
protected void setSharedConnection(Object affinity, MCWrapper mcWrapper) {
final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();
if (isTracingEnabled && tc.isEntryEnabled()) {
Tr.entry(this, tc, "setSharedConnection");
}
/*
* Set the shared pool affinity on the mcWrapper for comparing in the
* getSharedConnection method
*/
mcWrapper.setSharedPoolCoordinator(affinity);
mcWrapper.setSharedPool(this);
synchronized (sharedLockObject) {
/*
* Add the mcWrapper to the mcWrapper array list
*/
mcWrapperList[mcWrapperListSize] = mcWrapper;
mcWrapper.setPoolState(2);
++mcWrapperListSize;
if (mcWrapperListSize >= objectArraySize) {
/*
* We need to increase our size
*/
objectArraySize = objectArraySize * 2;
mcWrapperListTemp = new MCWrapper[objectArraySize];
System.arraycopy(mcWrapperList, 0, mcWrapperListTemp, 0, mcWrapperList.length);
mcWrapperList = mcWrapperListTemp;
}
} // end synchronized (sharedLockObject)
if (isTracingEnabled && tc.isEntryEnabled()) {
Tr.exit(this, tc, "setSharedConnection");
}
}
|
java
|
protected void removeSharedConnection(MCWrapper mcWrapper) throws ResourceException {
final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();
boolean removedSharedConnection = false;
if (isTracingEnabled && tc.isEntryEnabled()) {
Tr.entry(this, tc, "removeSharedConnection");
}
//MCWrapper mcw = null;
synchronized (sharedLockObject) {
if (mcWrapperListSize == 1) {
/*
* If there is only one mcWrapper in the list, the odds of it
* being the right one are good. So, optimistically
* remove it from the mcWrapper list and compare mcWrappers.
* If we are right, we are happy and we exit the method.
* If we are wrong (This should not happen), we are sad
* and need to add back into the list
*/
if (mcWrapper == mcWrapperList[0]) {
removedSharedConnection = true;
mcWrapperListSize = 0;
mcWrapperList[mcWrapperListSize] = null;
}
} else { // Too many mcWrappers to feel optimistic
/*
* If there is more than one mcWrapper in the list, the odds of it
* being the right are not as good. So, we
* get it from the mcWrapper list and compare mcWrappers.
* If the compare is equal, we remove the mcWrapper from the list.
* If the compare is not equal, we continue to look through the list
* hoping to match mcWrappers. In the normal case we will find a
* match and remove the mcWrapper from the list and exit.
*/
for (int i = 0; i < mcWrapperListSize; ++i) {
// Look for mcWrapper and remove
if (removedSharedConnection) {
mcWrapperList[i - 1] = mcWrapperList[--mcWrapperListSize]; // shift all remain wrappers up to fill any open location.
// mcWrapperList[i - 1] = mcWrapperList[i];
mcWrapperList[mcWrapperListSize] = null; // - For safety, setting the last one to null is good.
break;
} else {
if (mcWrapper == mcWrapperList[i]) {
removedSharedConnection = true;
if (i == mcWrapperListSize) {
// last one in list, remove it.
mcWrapperList[--mcWrapperListSize] = null; // - For safety, setting the last one to null is good.
}
}
}
}
// if (removedSharedConnection) {
// --mcWrapperListSize;
// }
}
}
if (!removedSharedConnection) {
/*
* We should never throw this exception unless a resource adapter
* replace the Subject or CRI references. They are not allow to
* replace the Subject or CRI references when the connection is
* being used.
*/
Tr.error(tc, "SHAREDPOOL_REMOVESHAREDCONNECTION_ERROR_J2CA1003", mcWrapper);
ResourceException re = new ResourceException("removeSharedConnection: failed to remove MCWrapper " + mcWrapper.toString());
com.ibm.ws.ffdc.FFDCFilter.processException(
re,
"com.ibm.ejs.j2c.poolmanager.SharedPool.removeSharedConnection",
"184",
this);
_pm.activeRequest.decrementAndGet();
throw re;
} else {
mcWrapper.setPoolState(0);
}
if (isTracingEnabled && tc.isEntryEnabled()) {
if (tc.isDebugEnabled()) {
Tr.debug(this, tc, "Removed connection");
}
Tr.exit(this, tc, "removeSharedConnection");
}
}
|
java
|
public void setDelegatedUsers(ArrayList<String> delegatedUsers) {
AuditThreadContext auditThreadContext = getAuditThreadContext();
auditThreadContext.setDelegatedUsers(delegatedUsers);
}
|
java
|
public void setProvider(Object pObj) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "setProvider pre: pObj(class)=" + pObj.getClass() + " isProxy=" + Proxy.isProxyClass(pObj.getClass()) + " provider=" + (provider==null?"null":provider.getClass()) +
" oldProvider=" + (oldProvider==null?"null":oldProvider.getClass()));
}
this.oldProvider = this.provider;
this.provider = (T) pObj;
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "setProvider post: provider=" + (provider==null?"null":provider.getClass()) +
" oldProvider=" + (oldProvider==null?"null":oldProvider.getClass()));
}
}
|
java
|
protected JsonObject readJsonFromContent(Object contentToValidate) throws Exception {
if (contentToValidate == null) {
throw new Exception("Provided content is null so cannot be validated.");
}
JsonObject obj = null;
try {
String responseText = WebResponseUtils.getResponseText(contentToValidate);
obj = Json.createReader(new StringReader(responseText)).readObject();
} catch (Exception e) {
throw new Exception("Failed to read JSON data from the provided content. The exception was [" + e + "]. The content to validate was: [" + contentToValidate + "].");
}
return obj;
}
|
java
|
private void init(int max) {
if ((max != INTERNAL) && (max != PROVIDER) && (max != PRIVILEGED))
throw new IllegalArgumentException("invalid action");
if (max == NONE)
throw new IllegalArgumentException("missing action");
if (getName() == null)
throw new NullPointerException("action can't be null");
this.max = max;
}
|
java
|
private static int getMax(String action) {
int max = NONE;
if (action == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission action should not be null");
}
return max;
}
if (INTERNAL_STR.equalsIgnoreCase(action)) {
max = INTERNAL;
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission - internal");
}
} else if (PROVIDER_STR.equalsIgnoreCase(action)) {
max = PROVIDER;
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission - provider");
}
} else if (PRIVILEGED_STR.equalsIgnoreCase(action)) {
max = PRIVILEGED;
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission - privileged");
}
} else {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission invalid action " + action);
}
throw new IllegalArgumentException(
"invalid permission: " + action);
}
if (tc.isDebugEnabled()) {
Tr.debug(tc, "WebSphereSecurityPermission value = " + max);
}
return max;
}
|
java
|
public void removeAll(Transaction tran) throws MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "removeAll", tran);
while(this.removeFirstMatching(null, tran) != null);
remove(tran, NO_LOCK_ID);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "removeAll");
}
|
java
|
protected final void setStorageStrategy(int setStrategy)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "setStorageStrategy", new Integer(setStrategy));
storageStrategy = setStrategy;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "setStorageStrategy");
}
|
java
|
public int getPersistentVersion()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(tc, "getPersistentVersion");
SibTr.exit(tc, "getPersistentVersion", new Integer(DEFAULT_PERSISTENT_VERSION));
}
return DEFAULT_PERSISTENT_VERSION;
}
|
java
|
public void addUnrestoredMsgId(long msgId)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "addUnrestoredMsgId", new Long(msgId));
unrestoredMsgIds.add(new Long(msgId));
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "addUnrestoredMsgId");
}
|
java
|
public Collection clearUnrestoredMessages()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "clearUnrestoredMessages");
Collection returnCollection = unrestoredMsgIds;
// bug fix
unrestoredMsgIds = new ArrayList();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "clearUnrestoredMessages", returnCollection);
return returnCollection;
}
|
java
|
public void setBinding(String binding) throws JspException
{
if (!isValueReference(binding))
{
throw new IllegalArgumentException("not a valid binding: " + binding);
}
_binding = binding;
}
|
java
|
public static UIComponentTag getParentUIComponentTag(PageContext pageContext)
{
UIComponentClassicTagBase parentTag = getParentUIComponentClassicTagBase(pageContext);
return parentTag instanceof UIComponentTag ? (UIComponentTag)parentTag : new UIComponentTagWrapper(parentTag);
}
|
java
|
@Override
protected UIComponent createComponent(FacesContext context, String id)
{
String componentType = getComponentType();
if (componentType == null)
{
throw new NullPointerException("componentType");
}
if (_binding != null)
{
Application application = context.getApplication();
ValueBinding componentBinding = application.createValueBinding(_binding);
UIComponent component = application.createComponent(componentBinding, context, componentType);
component.setId(id);
component.setValueBinding("binding", componentBinding);
setProperties(component);
return component;
}
UIComponent component = context.getApplication().createComponent(componentType);
component.setId(id);
setProperties(component);
return component;
}
|
java
|
protected boolean isSuppressed()
{
if (_suppressed == null)
{
// we haven't called this method before, so determine the suppressed
// value and cache it for later calls to this method.
if (isFacet())
{
// facets are always rendered by their parents --> suppressed
_suppressed = Boolean.TRUE;
return true;
}
UIComponent component = getComponentInstance();
// Does any parent render its children?
// (We must determine this first, before calling any isRendered method
// because rendered properties might reference a data var of a nesting UIData,
// which is not set at this time, and would cause a VariableResolver error!)
UIComponent parent = component.getParent();
while (parent != null)
{
if (parent.getRendersChildren())
{
// Yes, parent found, that renders children --> suppressed
_suppressed = Boolean.TRUE;
return true;
}
parent = parent.getParent();
}
// does component or any parent has a false rendered attribute?
while (component != null)
{
if (!component.isRendered())
{
// Yes, component or any parent must not be rendered --> suppressed
_suppressed = Boolean.TRUE;
return true;
}
component = component.getParent();
}
// else --> not suppressed
_suppressed = Boolean.FALSE;
}
return _suppressed.booleanValue();
}
|
java
|
public void setData(List<DataSlice> dataSlices)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setData", "DataSlices="+dataSlices);
_dataSlices = dataSlices;
_estimatedLength = -1;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setData");
}
|
java
|
@JSFProperty(deferredValueType="java.lang.Object")
public Locale getLocale()
{
if (_locale != null)
{
return _locale;
}
FacesContext context = FacesContext.getCurrentInstance();
return context.getViewRoot().getLocale();
}
|
java
|
public static void useProvider(String className,String handlerName) {
_httpsProviderClass = null;
JSSE_PROVIDER_CLASS =className;
SSL_PROTOCOL_HANDLER =handlerName;
}
|
java
|
public static Class getHttpsProviderClass() throws ClassNotFoundException {
if (_httpsProviderClass == null) {
// [ 1520925 ] SSL patch
Provider[] sslProviders = Security.getProviders("SSLContext.SSLv3");
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// IBM-FIX: Prevent NPE when SSLv3 is disabled.
// Security.getProviders(String) returns
// null, not an empty array, when there
// are no providers.
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//
// if (sslProviders.length > 0) {
//
if (sslProviders != null && sslProviders.length > 0) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// END IBM-FIX
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
_httpsProviderClass = sslProviders[0].getClass();
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// IBM-FIX: Try TLS if SSLv3 does not have a
// provider.
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if (_httpsProviderClass == null) {
sslProviders = Security.getProviders("SSLContext.TLS");
if (sslProviders != null && sslProviders.length > 0) {
_httpsProviderClass = sslProviders[0].getClass();
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// END IBM-FIX
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if (_httpsProviderClass == null) {
_httpsProviderClass = Class.forName( JSSE_PROVIDER_CLASS );
}
}
return _httpsProviderClass;
}
|
java
|
private static void registerSSLProtocolHandler() {
String list = System.getProperty( PROTOCOL_HANDLER_PKGS );
if (list == null || list.length() == 0) {
System.setProperty( PROTOCOL_HANDLER_PKGS, SSL_PROTOCOL_HANDLER );
} else if (list.indexOf( SSL_PROTOCOL_HANDLER ) < 0) {
// [ 1516007 ] Default SSL provider not being used
System.setProperty( PROTOCOL_HANDLER_PKGS, list + " | " + SSL_PROTOCOL_HANDLER );
}
}
|
java
|
protected static int obtainIntConfigParameter(MessageStoreImpl msi, String parameterName, String defaultValue, int minValue, int maxValue)
{
int value = Integer.parseInt(defaultValue);
if (msi != null)
{
String strValue = msi.getProperty(parameterName, defaultValue);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, parameterName + "=" + strValue);
}; // end if
try
{
value = Integer.parseInt(strValue);
if ((value < minValue) || (value > maxValue))
{
value = Integer.parseInt(defaultValue);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, "OVERRIDE: " + parameterName + "=" + strValue);
}; // end if
}; // end if
}
catch (NumberFormatException nfexc)
{
//No FFDC Code Needed.
}
}; // end if
return value;
}
|
java
|
protected static long obtainLongConfigParameter(MessageStoreImpl msi, String parameterName, String defaultValue, long minValue, long maxValue)
{
long value = Long.parseLong(defaultValue);
if (msi != null)
{
String strValue = msi.getProperty(parameterName, defaultValue);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, parameterName + "=" + strValue);
}; // end if
try
{
value = Long.parseLong(strValue);
if ((value < minValue) || (value > maxValue))
{
value = Long.parseLong(defaultValue);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
SibTr.debug(tc, "OVERRIDE: " + parameterName + "=" + strValue);
}; // end if
}; // end if
}
catch (NumberFormatException nfexc)
{
//No FFDC Code Needed.
}
}; // end if
return value;
}
|
java
|
public int originalFrame() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "originalFrame");
int result;
synchronized (getMessageLockArtefact()) {
if ((contents == null) || reallocated) {
result = -1;
}
else {
result = length;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "originalFrame", Integer.valueOf(result));
return result;
}
|
java
|
public boolean isPresent(int accessor) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.entry(this, tc, "isPresent", new Object[]{Integer.valueOf(accessor)});
boolean result;
if (accessor < cacheSize) {
result = super.isPresent(accessor);
}
else if (accessor < firstBoxed) {
result = getCase(accessor - cacheSize) > -1;
}
else if (accessor < accessorLimit) {
// Conservative answer: a boxed value is present if its containing box is present;
// this is enough to support creation of the JSBoxedImpl for the value, which can
// then be interrogated element by element.
synchronized (getMessageLockArtefact()) {
result = super.isPresent(boxManager.getBoxAccessor(accessor - firstBoxed));
}
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "isPresent", "IndexOutOfBoundsException");
throw new IndexOutOfBoundsException();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) JmfTr.exit(this, tc, "isPresent", Boolean.valueOf(result));
return result;
}
|
java
|
public boolean setPosition(long position) {
try {
long fileSize = reader.length();
if (fileSize > position) {
reader.seek(position);
return true;
}
logger.logp(Level.SEVERE, className, "setPosition", "HPEL_OffsetBeyondFileSize", new Object[]{file, Long.valueOf(position), Long.valueOf(fileSize)});
} catch (IOException ex) {
logger.logp(Level.SEVERE, className, "setPosition", "HPEL_ErrorSettingFileOffset", new Object[]{file, Long.valueOf(position), ex.getMessage()});
// Fall through to return false.
}
return false;
}
|
java
|
public long getPosition() {
try {
return reader.getFilePointer();
} catch (IOException ex) {
logger.logp(Level.SEVERE, className, "getPosition", "HPEL_ErrorReadingFileOffset", new Object[]{file, ex.getMessage()});
}
return -1L;
}
|
java
|
public RepositoryLogRecord findNext(long refSequenceNumber) {
if (nextRecord == null) {
nextRecord = getNext(refSequenceNumber);
}
if (nextRecord == null || refSequenceNumber >= 0 && refSequenceNumber < nextRecord.getInternalSeqNumber()) {
return null;
} else {
RepositoryLogRecord result = nextRecord;
nextRecord = null;
return result;
}
}
|
java
|
public long seekToNextRecord(LogRecordSerializer formatter) throws IOException {
long fileSize = reader.length();
long position = reader.getFilePointer();
int location;
int len = 0;
int offset = 0;
byte[] buffer = new byte[2048];
do {
if (offset > 0) {
position += len - offset;
// keep the last eyeCatcherSize-1 bytes of the buffer.
for (int i=0; i<offset; i++) {
buffer[i] = buffer[buffer.length-offset+i];
}
}
if (position + formatter.getEyeCatcherSize() > fileSize) {
throw new IOException("No eyeCatcher found in the rest of the file.");
}
if (position + buffer.length <= fileSize) {
len = buffer.length;
} else {
len = (int)(fileSize - position);
}
reader.readFully(buffer, offset, len-offset);
if (offset == 0) {
offset = formatter.getEyeCatcherSize()-1;
}
} while ((location = formatter.findFirstEyeCatcher(buffer, 0, len)) < 0);
position += location - 4;
reader.seek(position);
return position;
}
|
java
|
public long seekToPrevRecord(LogRecordSerializer formatter) throws IOException {
long position = reader.getFilePointer();
byte[] buffer = new byte[2048];
int location;
int offset = 0;
int len = 0;
do {
if (position <= formatter.getEyeCatcherSize()+3) {
throw new IOException("No eyeCatcher found in the rest of the file.");
}
if (position > buffer.length) {
len = buffer.length;
} else {
len = (int)position;
}
position -= len;
if (offset > 0) {
// keep the first eyeCatcherSize-1 bytes of the buffer.
for (int i=0; i<offset; i++) {
buffer[len-offset+i] = buffer[i];
}
}
reader.seek(position);
reader.readFully(buffer, 0, len-offset);
if (offset == 0) {
offset = formatter.getEyeCatcherSize()-1;
}
} while ((location = formatter.findLastEyeCatcher(buffer, 0, len)) < 0);
position += location - 4;
reader.seek(position);
return position;
}
|
java
|
protected LogFileReader createNewReader(LogFileReader other) throws IOException {
if (other instanceof LogFileReaderImpl) {
return new LogFileReaderImpl((LogFileReaderImpl)other);
}
throw new IOException("Instance of the " + other.getClass().getName() + " is not clonable by " + OneLogFileRecordIterator.class.getName() + ".");
}
|
java
|
public final void persistLock(final Transaction transaction) throws ProtocolException, TransactionException, SevereMessageStoreException
{
Membership membership = _getMembership();
if (null == membership)
{
throw new NotInMessageStore();
}
membership.persistLock(transaction);
}
|
java
|
public void persistRedeliveredCount(int redeliveredCount) throws SevereMessageStoreException
{
Membership thisItemLink = _getMembership();
if (null == thisItemLink)
{
throw new NotInMessageStore();
}
thisItemLink.persistRedeliveredCount(redeliveredCount);
}
|
java
|
public final void requestUpdate(Transaction transaction) throws MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "requestUpdate", transaction);
Membership membership = _getMembership();
if (null == membership)
{
throw new NotInMessageStore();
}
else
{
membership.requestUpdate(transaction);
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "requestUpdate");
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.