code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public String generateTaskId() {
final String uuid = UUID.randomUUID().toString().substring(0, 12);
int size = this.targetHostMeta == null ? 0 : this.targetHostMeta
.getHosts().size();
return "PT_" + size + "_"
+ PcDateUtils.getNowDateTimeStrConciseNoZone() + "_" + uuid;
} | java |
public Double getProgress() {
if (state.equals(ParallelTaskState.IN_PROGRESS)) {
if (requestNum != 0) {
return 100.0 * ((double) responsedNum / (double) requestNumActual);
} else {
return 0.0;
}
}
if (state.equals(ParallelTaskState.WAITING)) {
return 0.0;
}
// fix task if fail validation, still try to poll progress 0901
if (state.equals(ParallelTaskState.COMPLETED_WITH_ERROR)
|| state.equals(ParallelTaskState.COMPLETED_WITHOUT_ERROR)) {
return 100.0;
}
return 0.0;
} | java |
public Map<String, SetAndCount> getAggregateResultFullSummary() {
Map<String, SetAndCount> summaryMap = new ConcurrentHashMap<String, SetAndCount>();
for (Entry<String, LinkedHashSet<String>> entry : aggregateResultMap
.entrySet()) {
summaryMap.put(entry.getKey(), new SetAndCount(entry.getValue()));
}
return summaryMap;
} | java |
public Map<String, Integer> getAggregateResultCountSummary() {
Map<String, Integer> summaryMap = new LinkedHashMap<String, Integer>();
for (Entry<String, LinkedHashSet<String>> entry : aggregateResultMap
.entrySet()) {
summaryMap.put(entry.getKey(), entry.getValue().size());
}
return summaryMap;
} | java |
public PerformUsage getJVMMemoryUsage() {
int mb = 1024 * 1024;
Runtime rt = Runtime.getRuntime();
PerformUsage usage = new PerformUsage();
usage.totalMemory = (double) rt.totalMemory() / mb;
usage.freeMemory = (double) rt.freeMemory() / mb;
usage.usedMemory = (double) rt.totalMemory() / mb - rt.freeMemory()
/ mb;
usage.maxMemory = (double) rt.maxMemory() / mb;
usage.memoryUsagePercent = usage.usedMemory / usage.maxMemory * 100.0;
// update current
currentJvmPerformUsage = usage;
return usage;
} | java |
public ThreadInfo[] getThreadDump() {
ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
return threadMxBean.dumpAllThreads(true, true);
} | java |
public ThreadUsage getThreadUsage() {
ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
ThreadUsage threadUsage = new ThreadUsage();
long[] threadIds = threadMxBean.getAllThreadIds();
threadUsage.liveThreadCount = threadIds.length;
for (long tId : threadIds) {
ThreadInfo threadInfo = threadMxBean.getThreadInfo(tId);
threadUsage.threadData.put(Long.toString(tId), new ThreadData(
threadInfo.getThreadName(), threadInfo.getThreadState()
.name(), threadMxBean.getThreadCpuTime(tId)));
}
return threadUsage;
} | java |
public String getHealthMemory() {
StringBuilder sb = new StringBuilder();
sb.append("Logging JVM Stats\n");
MonitorProvider mp = MonitorProvider.getInstance();
PerformUsage perf = mp.getJVMMemoryUsage();
sb.append(perf.toString());
if (perf.memoryUsagePercent >= THRESHOLD_PERCENT) {
sb.append("========= WARNING: MEM USAGE > " + THRESHOLD_PERCENT
+ "!!");
sb.append(" !! Live Threads List=============\n");
sb.append(mp.getThreadUsage().toString());
sb.append("========================================\n");
sb.append("========================JVM Thread Dump====================\n");
ThreadInfo[] threadDump = mp.getThreadDump();
for (ThreadInfo threadInfo : threadDump) {
sb.append(threadInfo.toString() + "\n");
}
sb.append("===========================================================\n");
}
sb.append("Logged JVM Stats\n");
return sb.toString();
} | java |
public void shutdown() {
for (Entry<HttpClientType, AsyncHttpClient> entry : map.entrySet()) {
AsyncHttpClient client = entry.getValue();
if (client != null)
client.close();
}
} | java |
private String getContentFromPath(String sourcePath,
HostsSourceType sourceType) throws IOException {
String res = "";
if (sourceType == HostsSourceType.LOCAL_FILE) {
res = PcFileNetworkIoUtils.readFileContentToString(sourcePath);
} else if (sourceType == HostsSourceType.URL) {
res = PcFileNetworkIoUtils.readStringFromUrlGeneric(sourcePath);
}
return res;
} | java |
@Override
public List<String> setTargetHostsFromLineByLineText(String sourcePath,
HostsSourceType sourceType) throws TargetHostsLoadException {
List<String> targetHosts = new ArrayList<String>();
try {
String content = getContentFromPath(sourcePath, sourceType);
targetHosts = setTargetHostsFromString(content);
} catch (IOException e) {
throw new TargetHostsLoadException("IEException when reading "
+ sourcePath, e);
}
return targetHosts;
} | java |
public ConnectionlessBootstrap bootStrapUdpClient()
throws HttpRequestCreateException {
ConnectionlessBootstrap udpClient = null;
try {
// Configure the client.
udpClient = new ConnectionlessBootstrap(udpMeta.getChannelFactory());
udpClient.setPipeline(new UdpPipelineFactory(
TcpUdpSshPingResourceStore.getInstance().getTimer(), this)
.getPipeline());
} catch (Exception t) {
throw new TcpUdpRequestCreateException(
"Error in creating request in udp worker. "
+ " If udpClient is null. Then fail to create.", t);
}
return udpClient;
} | java |
public void initialize() {
if (isClosed.get()) {
logger.info("Initialing Parallel Client Resources: actor system, HttpClientStore, Task Manager ....");
ActorConfig.createAndGetActorSystem();
httpClientStore.init();
tcpSshPingResourceStore.init();
isClosed.set(false);
logger.info("Parallel Client Resources has been initialized.");
} else {
logger.debug("NO OP. Parallel Client Resources has already been initialized.");
}
} | java |
public void reinitIfClosed() {
if (isClosed.get()) {
logger.info("External Resource was released. Now Re-initializing resources ...");
ActorConfig.createAndGetActorSystem();
httpClientStore.reinit();
tcpSshPingResourceStore.reinit();
try {
Thread.sleep(1000l);
} catch (InterruptedException e) {
logger.error("error reinit httpClientStore", e);
}
isClosed.set(false);
logger.info("Parallel Client Resources has been reinitialized.");
} else {
logger.debug("NO OP. Resource was not released.");
}
} | java |
public ParallelTaskBuilder prepareSsh() {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.setProtocol(RequestProtocol.SSH);
return cb;
} | java |
public ParallelTaskBuilder preparePing() {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.setProtocol(RequestProtocol.PING);
return cb;
} | java |
public ParallelTaskBuilder prepareTcp(String command) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.setProtocol(RequestProtocol.TCP);
cb.getTcpMeta().setCommand(command);
return cb;
} | java |
public ParallelTaskBuilder prepareUdp(String command) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.setProtocol(RequestProtocol.UDP);
cb.getUdpMeta().setCommand(command);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpGet(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.GET);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpPost(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.POST);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpDelete(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.DELETE);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpPut(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.PUT);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpHead(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.HEAD);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
public ParallelTaskBuilder prepareHttpOptions(String url) {
reinitIfClosed();
ParallelTaskBuilder cb = new ParallelTaskBuilder();
cb.getHttpMeta().setHttpMethod(HttpMethod.OPTIONS);
cb.getHttpMeta().setRequestUrlPostfix(url);
return cb;
} | java |
@SuppressWarnings("deprecation")
private void cancelRequestAndWorkers() {
for (ActorRef worker : workers.values()) {
if (worker != null && !worker.isTerminated()) {
worker.tell(OperationWorkerMsgType.CANCEL, getSelf());
}
}
logger.info("ExecutionManager sending cancelPendingRequest at time: "
+ PcDateUtils.getNowDateTimeStr());
} | java |
@SuppressWarnings("deprecation")
private void cancelRequestAndWorkerOnHost(List<String> targetHosts) {
List<String> validTargetHosts = new ArrayList<String>(workers.keySet());
validTargetHosts.retainAll(targetHosts);
logger.info("targetHosts for cancel: Total: {}"
+ " Valid in current manager with worker threads: {}",
targetHosts.size(), validTargetHosts.size());
for (String targetHost : validTargetHosts) {
ActorRef worker = workers.get(targetHost);
if (worker != null && !worker.isTerminated()) {
worker.tell(OperationWorkerMsgType.CANCEL, getSelf());
logger.info("Submitted CANCEL request on Host {}", targetHost);
} else {
logger.info(
"Did NOT Submitted "
+ "CANCEL request on Host {} as worker on this host is null or already killed",
targetHost);
}
}
} | java |
public Session startSshSessionAndObtainSession() {
Session session = null;
try {
JSch jsch = new JSch();
if (sshMeta.getSshLoginType() == SshLoginType.KEY) {
String workingDir = System.getProperty("user.dir");
String privKeyAbsPath = workingDir + "/"
+ sshMeta.getPrivKeyRelativePath();
logger.debug("use privkey: path: " + privKeyAbsPath);
if (!PcFileNetworkIoUtils.isFileExist(privKeyAbsPath)) {
throw new RuntimeException("file not found at "
+ privKeyAbsPath);
}
if (sshMeta.isPrivKeyUsePassphrase()
&& sshMeta.getPassphrase() != null) {
jsch.addIdentity(privKeyAbsPath, sshMeta.getPassphrase());
} else {
jsch.addIdentity(privKeyAbsPath);
}
}
session = jsch.getSession(sshMeta.getUserName(), targetHost,
sshMeta.getSshPort());
if (sshMeta.getSshLoginType() == SshLoginType.PASSWORD) {
session.setPassword(sshMeta.getPassword());
}
session.setConfig("StrictHostKeyChecking", "no");
} catch (Exception t) {
throw new RuntimeException(t);
}
return session;
} | java |
public Channel sessionConnectGenerateChannel(Session session)
throws JSchException {
// set timeout
session.connect(sshMeta.getSshConnectionTimeoutMillis());
ChannelExec channel = (ChannelExec) session.openChannel("exec");
channel.setCommand(sshMeta.getCommandLine());
// if run as super user, assuming the input stream expecting a password
if (sshMeta.isRunAsSuperUser()) {
try {
channel.setInputStream(null, true);
OutputStream out = channel.getOutputStream();
channel.setOutputStream(System.out, true);
channel.setExtOutputStream(System.err, true);
channel.setPty(true);
channel.connect();
out.write((sshMeta.getPassword()+"\n").getBytes());
out.flush();
} catch (IOException e) {
logger.error("error in sessionConnectGenerateChannel for super user", e);
}
} else {
channel.setInputStream(null);
channel.connect();
}
return channel;
} | java |
public ResponseOnSingeRequest genErrorResponse(Exception t) {
ResponseOnSingeRequest sshResponse = new ResponseOnSingeRequest();
String displayError = PcErrorMsgUtils.replaceErrorMsg(t.toString());
sshResponse.setStackTrace(PcStringUtils.printStackTrace(t));
sshResponse.setErrorMessage(displayError);
sshResponse.setFailObtainResponse(true);
logger.error("error in exec SSH. \nIf exection is JSchException: "
+ "Auth cancel and using public key. "
+ "\nMake sure 1. private key full path is right (try sshMeta.getPrivKeyAbsPath()). "
+ "\n2. the user name and key matches " + t);
return sshResponse;
} | java |
public void genNodeDataMap(ParallelTask task) {
TargetHostMeta targetHostMeta = task.getTargetHostMeta();
HttpMeta httpMeta = task.getHttpMeta();
String entityBody = httpMeta.getEntityBody();
String requestContent = HttpMeta
.replaceDefaultFullRequestContent(entityBody);
Map<String, NodeReqResponse> parallelTaskResult = task
.getParallelTaskResult();
for (String fqdn : targetHostMeta.getHosts()) {
NodeReqResponse nodeReqResponse = new NodeReqResponse(fqdn);
nodeReqResponse.setDefaultReqestContent(requestContent);
parallelTaskResult.put(fqdn, nodeReqResponse);
}
} | java |
public void filterUnsafeOrUnnecessaryRequest(
Map<String, NodeReqResponse> nodeDataMapValidSource,
Map<String, NodeReqResponse> nodeDataMapValidSafe) {
for (Entry<String, NodeReqResponse> entry : nodeDataMapValidSource
.entrySet()) {
String hostName = entry.getKey();
NodeReqResponse nrr = entry.getValue();
Map<String, String> map = nrr.getRequestParameters();
/**
* 20130507: will generally apply to all requests: if have this
* field and this field is false
*/
if (map.containsKey(PcConstants.NODE_REQUEST_WILL_EXECUTE)) {
Boolean willExecute = Boolean.parseBoolean(map
.get(PcConstants.NODE_REQUEST_WILL_EXECUTE));
if (!willExecute) {
logger.info("NOT_EXECUTE_COMMAND " + " on target: "
+ hostName + " at "
+ PcDateUtils.getNowDateTimeStrStandard());
continue;
}
}
// now safely to add this node in.
nodeDataMapValidSafe.put(hostName, nrr);
}// end for loop
} | java |
public ClientBootstrap bootStrapTcpClient()
throws HttpRequestCreateException {
ClientBootstrap tcpClient = null;
try {
// Configure the client.
tcpClient = new ClientBootstrap(tcpMeta.getChannelFactory());
// Configure the pipeline factory.
tcpClient.setPipelineFactory(new MyPipelineFactory(TcpUdpSshPingResourceStore.getInstance().getTimer(),
this, tcpMeta.getTcpIdleTimeoutSec())
);
tcpClient.setOption("connectTimeoutMillis",
tcpMeta.getTcpConnectTimeoutMillis());
tcpClient.setOption("tcpNoDelay", true);
// tcpClient.setOption("keepAlive", true);
} catch (Exception t) {
throw new TcpUdpRequestCreateException(
"Error in creating request in Tcpworker. "
+ " If tcpClient is null. Then fail to create.", t);
}
return tcpClient;
} | java |
private void reply(final String response, final boolean error,
final String errorMessage, final String stackTrace,
final String statusCode, final int statusCodeInt) {
if (!sentReply) {
//must update sentReply first to avoid duplicated msg.
sentReply = true;
// Close the connection. Make sure the close operation ends because
// all I/O operations are asynchronous in Netty.
if(channel!=null && channel.isOpen())
channel.close().awaitUninterruptibly();
final ResponseOnSingeRequest res = new ResponseOnSingeRequest(
response, error, errorMessage, stackTrace, statusCode,
statusCodeInt, PcDateUtils.getNowDateTimeStrStandard(), null);
if (!getContext().system().deadLetters().equals(sender)) {
sender.tell(res, getSelf());
}
if (getContext() != null) {
getContext().stop(getSelf());
}
}
} | java |
public static String stringMatcherByPattern(String input, String patternStr) {
String output = PcConstants.SYSTEM_FAIL_MATCH_REGEX;
// 20140105: fix the NPE issue
if (patternStr == null) {
logger.error("patternStr is NULL! (Expected when the aggregation rule is not defined at "
+ PcDateUtils.getNowDateTimeStrStandard());
return output;
}
if (input == null) {
logger.error("input (Expected when the response is null and now try to match on response) is NULL in stringMatcherByPattern() at "
+ PcDateUtils.getNowDateTimeStrStandard());
return output;
} else {
input = input.replace("\n", "").replace("\r", "");
}
logger.debug("input: " + input);
logger.debug("patternStr: " + patternStr);
Pattern patternMetric = Pattern.compile(patternStr, Pattern.MULTILINE);
final Matcher matcher = patternMetric.matcher(input);
if (matcher.matches()) {
output = matcher.group(1);
}
return output;
} | java |
public synchronized void initTaskSchedulerIfNot() {
if (scheduler == null) {
scheduler = Executors
.newSingleThreadScheduledExecutor(DaemonThreadFactory
.getInstance());
CapacityAwareTaskScheduler runner = new CapacityAwareTaskScheduler();
scheduler.scheduleAtFixedRate(runner,
ParallecGlobalConfig.schedulerInitDelay,
ParallecGlobalConfig.schedulerCheckInterval,
TimeUnit.MILLISECONDS);
logger.info("initialized daemon task scheduler to evaluate waitQ tasks.");
}
} | java |
public synchronized void shutdownTaskScheduler(){
if (scheduler != null && !scheduler.isShutdown()) {
scheduler.shutdown();
logger.info("shutdowned the task scheduler. No longer accepting new tasks");
scheduler = null;
}
} | java |
public ParallelTask getTaskFromInProgressMap(String jobId) {
if (!inprogressTaskMap.containsKey(jobId))
return null;
return inprogressTaskMap.get(jobId);
} | java |
public int getTotalUsedCapacity() {
int totalCapacity = 0;
for (Entry<String, ParallelTask> entry : inprogressTaskMap.entrySet()) {
ParallelTask task = entry.getValue();
if (task != null)
totalCapacity += task.capacityUsed();
}
return totalCapacity;
} | java |
public synchronized void cleanWaitTaskQueue() {
for (ParallelTask task : waitQ) {
task.setState(ParallelTaskState.COMPLETED_WITH_ERROR);
task.getTaskErrorMetas().add(
new TaskErrorMeta(TaskErrorType.USER_CANCELED, "NA"));
logger.info(
"task {} removed from wait q. This task has been marked as USER CANCELED.",
task.getTaskId());
}
waitQ.clear();
} | java |
public synchronized boolean removeTaskFromWaitQ(ParallelTask taskTobeRemoved) {
boolean removed = false;
for (ParallelTask task : waitQ) {
if (task.getTaskId() == taskTobeRemoved.getTaskId()) {
task.setState(ParallelTaskState.COMPLETED_WITH_ERROR);
task.getTaskErrorMetas().add(
new TaskErrorMeta(TaskErrorType.USER_CANCELED, "NA"));
logger.info(
"task {} removed from wait q. This task has been marked as USER CANCELED.",
task.getTaskId());
removed = true;
}
}
return removed;
} | java |
public ResponseFromManager generateUpdateExecuteTask(ParallelTask task) {
// add to map now; as can only pass final
ParallelTaskManager.getInstance().addTaskToInProgressMap(
task.getTaskId(), task);
logger.info("Added task {} to the running inprogress map...",
task.getTaskId());
boolean useReplacementVarMap = false;
boolean useReplacementVarMapNodeSpecific = false;
Map<String, StrStrMap> replacementVarMapNodeSpecific = null;
Map<String, String> replacementVarMap = null;
ResponseFromManager batchResponseFromManager = null;
switch (task.getRequestReplacementType()) {
case UNIFORM_VAR_REPLACEMENT:
useReplacementVarMap = true;
useReplacementVarMapNodeSpecific = false;
replacementVarMap = task.getReplacementVarMap();
break;
case TARGET_HOST_SPECIFIC_VAR_REPLACEMENT:
useReplacementVarMap = false;
useReplacementVarMapNodeSpecific = true;
replacementVarMapNodeSpecific = task
.getReplacementVarMapNodeSpecific();
break;
case NO_REPLACEMENT:
useReplacementVarMap = false;
useReplacementVarMapNodeSpecific = false;
break;
default:
logger.error("error request replacement type. default as no replacement");
}// end switch
// generate content in nodedata
InternalDataProvider dp = InternalDataProvider.getInstance();
dp.genNodeDataMap(task);
VarReplacementProvider.getInstance()
.updateRequestWithReplacement(task, useReplacementVarMap,
replacementVarMap, useReplacementVarMapNodeSpecific,
replacementVarMapNodeSpecific);
batchResponseFromManager =
sendTaskToExecutionManager(task);
removeTaskFromInProgressMap(task.getTaskId());
logger.info(
"Removed task {} from the running inprogress map... "
+ ". This task should be garbage collected if there are no other pointers.",
task.getTaskId());
return batchResponseFromManager;
} | java |
@SuppressWarnings("deprecation")
public ResponseFromManager sendTaskToExecutionManager(ParallelTask task) {
ResponseFromManager commandResponseFromManager = null;
ActorRef executionManager = null;
try {
// Start new job
logger.info("!!STARTED sendAgentCommandToManager : "
+ task.getTaskId() + " at "
+ PcDateUtils.getNowDateTimeStr());
executionManager = ActorConfig.createAndGetActorSystem().actorOf(
Props.create(ExecutionManager.class, task),
"ExecutionManager-" + task.getTaskId());
final FiniteDuration duration = Duration.create(task.getConfig()
.getTimeoutAskManagerSec(), TimeUnit.SECONDS);
// Timeout timeout = new
// Timeout(FiniteDuration.parse("300 seconds"));
Future<Object> future = Patterns.ask(executionManager,
new InitialRequestToManager(task), new Timeout(duration));
// set ref
task.executionManager = executionManager;
commandResponseFromManager = (ResponseFromManager) Await.result(
future, duration);
logger.info("!!COMPLETED sendTaskToExecutionManager : "
+ task.getTaskId() + " at "
+ PcDateUtils.getNowDateTimeStr()
+ " \t\t GenericResponseMap in future size: "
+ commandResponseFromManager.getResponseCount());
} catch (Exception ex) {
logger.error("Exception in sendTaskToExecutionManager {} details {}: ",
ex, ex);
} finally {
// stop the manager
if (executionManager != null && !executionManager.isTerminated()) {
ActorConfig.createAndGetActorSystem().stop(executionManager);
}
if (task.getConfig().isAutoSaveLogToLocal()) {
task.saveLogToLocal();
}
}
return commandResponseFromManager;
} | java |
public static boolean isFileExist(String filePath) {
File f = new File(filePath);
return f.exists() && !f.isDirectory();
} | java |
public static String readFileContentToString(String filePath)
throws IOException {
String content = "";
content = Files.toString(new File(filePath), Charsets.UTF_8);
return content;
} | java |
public static String readStringFromUrlGeneric(String url)
throws IOException {
InputStream is = null;
URL urlObj = null;
String responseString = PcConstants.NA;
try {
urlObj = new URL(url);
URLConnection con = urlObj.openConnection();
con.setConnectTimeout(ParallecGlobalConfig.urlConnectionConnectTimeoutMillis);
con.setReadTimeout(ParallecGlobalConfig.urlConnectionReadTimeoutMillis);
is = con.getInputStream();
BufferedReader rd = new BufferedReader(new InputStreamReader(is,
Charset.forName("UTF-8")));
responseString = PcFileNetworkIoUtils.readAll(rd);
} finally {
if (is != null) {
is.close();
}
}
return responseString;
} | java |
public void updateRequestByAddingReplaceVarPair(
ParallelTask task, String replaceVarKey, String replaceVarValue) {
Map<String, NodeReqResponse> taskResult = task.getParallelTaskResult();
for (Entry<String, NodeReqResponse> entry : taskResult.entrySet()) {
NodeReqResponse nodeReqResponse = entry.getValue();
nodeReqResponse.getRequestParameters()
.put(PcConstants.NODE_REQUEST_PREFIX_REPLACE_VAR
+ replaceVarKey, replaceVarValue);
nodeReqResponse.getRequestParameters().put(
PcConstants.NODE_REQUEST_WILL_EXECUTE,
Boolean.toString(true));
}// end for loop
} | java |
public static ActorSystem createAndGetActorSystem() {
if (actorSystem == null || actorSystem.isTerminated()) {
actorSystem = ActorSystem.create(PcConstants.ACTOR_SYSTEM, conf);
}
return actorSystem;
} | java |
public static void shutDownActorSystemForce() {
if (!actorSystem.isTerminated()) {
logger.info("shutting down actor system...");
actorSystem.shutdown();
actorSystem.awaitTermination(timeOutDuration);
logger.info("Actor system has been shut down.");
} else {
logger.info("Actor system has been terminated already. NO OP.");
}
} | java |
public synchronized void init() {
channelFactory = new NioClientSocketChannelFactory(
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool());
datagramChannelFactory = new NioDatagramChannelFactory(
Executors.newCachedThreadPool());
timer = new HashedWheelTimer();
} | java |
public static String replaceErrorMsg(String origMsg) {
String replaceMsg = origMsg;
for (ERROR_TYPE errorType : ERROR_TYPE.values()) {
if (origMsg == null) {
replaceMsg = PcConstants.NA;
return replaceMsg;
}
if (origMsg.contains(errorMapOrig.get(errorType))) {
replaceMsg = errorMapReplace.get(errorType);
break;
}
}
return replaceMsg;
} | java |
private void disableCertificateVerification()
throws KeyManagementException, NoSuchAlgorithmException {
// Create a trust manager that does not validate certificate chains
final TrustManager[] trustAllCerts = new TrustManager[] { new CustomTrustManager() };
// Install the all-trusting trust manager
final SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, trustAllCerts, new SecureRandom());
final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
HttpsURLConnection.setDefaultSSLSocketFactory(sslSocketFactory);
final HostnameVerifier verifier = new HostnameVerifier() {
@Override
public boolean verify(final String hostname,
final SSLSession session) {
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(verifier);
} | java |
public static String replaceFullRequestContent(
String requestContentTemplate, String replacementString) {
return (requestContentTemplate.replace(
PcConstants.COMMAND_VAR_DEFAULT_REQUEST_CONTENT,
replacementString));
} | java |
public void addFile(String description, FileModel fileModel)
{
Map<FileModel, ProblemFileSummary> files = addDescription(description);
if (files.containsKey(fileModel))
{
files.get(fileModel).addOccurrence();
} else {
files.put(fileModel, new ProblemFileSummary(fileModel, 1));
}
} | java |
private boolean shouldIgnore(String typeReference)
{
typeReference = typeReference.replace('/', '.').replace('\\', '.');
return JavaClassIgnoreResolver.singletonInstance().matches(typeReference);
} | java |
@Override
public FileModel resolvePayload(GraphRewrite event, EvaluationContext context, WindupVertexFrame payload)
{
checkVariableName(event, context);
if (payload instanceof FileReferenceModel)
{
return ((FileReferenceModel) payload).getFile();
}
if (payload instanceof FileModel)
{
return (FileModel) payload;
}
return null;
} | java |
public static FreeMarkerOperation create(Furnace furnace, String templatePath, String outputFilename,
String... varNames)
{
return new FreeMarkerOperation(furnace, templatePath, outputFilename, varNames);
} | java |
private void recurseAndAddFiles(GraphRewrite event, EvaluationContext context,
Path tempFolder,
FileService fileService, ArchiveModel archiveModel,
FileModel parentFileModel, boolean subArchivesOnly)
{
checkCancelled(event);
int numberAdded = 0;
FileFilter filter = TrueFileFilter.TRUE;
if (archiveModel instanceof IdentifiedArchiveModel)
{
filter = new IdentifiedArchiveFileFilter(archiveModel);
}
File fileReference;
if (parentFileModel instanceof ArchiveModel)
fileReference = new File(((ArchiveModel) parentFileModel).getUnzippedDirectory());
else
fileReference = parentFileModel.asFile();
WindupJavaConfigurationService windupJavaConfigurationService = new WindupJavaConfigurationService(event.getGraphContext());
File[] subFiles = fileReference.listFiles();
if (subFiles == null)
return;
for (File subFile : subFiles)
{
if (!filter.accept(subFile))
continue;
if (subArchivesOnly && !ZipUtil.endsWithZipExtension(subFile.getAbsolutePath()))
continue;
FileModel subFileModel = fileService.createByFilePath(parentFileModel, subFile.getAbsolutePath());
// check if this file should be ignored
if (windupJavaConfigurationService.checkIfIgnored(event, subFileModel))
continue;
numberAdded++;
if (numberAdded % 250 == 0)
event.getGraphContext().commit();
if (subFile.isFile() && ZipUtil.endsWithZipExtension(subFileModel.getFilePath()))
{
File newZipFile = subFileModel.asFile();
ArchiveModel newArchiveModel = GraphService.addTypeToModel(event.getGraphContext(), subFileModel, ArchiveModel.class);
newArchiveModel.setParentArchive(archiveModel);
newArchiveModel.setArchiveName(newZipFile.getName());
/*
* New archive must be reloaded in case the archive should be ignored
*/
newArchiveModel = GraphService.refresh(event.getGraphContext(), newArchiveModel);
ArchiveModel canonicalArchiveModel = null;
for (FileModel otherMatches : fileService.findAllByProperty(FileModel.SHA1_HASH, newArchiveModel.getSHA1Hash()))
{
if (otherMatches instanceof ArchiveModel && !otherMatches.equals(newArchiveModel) && !(otherMatches instanceof DuplicateArchiveModel))
{
canonicalArchiveModel = (ArchiveModel)otherMatches;
break;
}
}
if (canonicalArchiveModel != null)
{
// handle as duplicate
DuplicateArchiveModel duplicateArchive = GraphService.addTypeToModel(event.getGraphContext(), newArchiveModel, DuplicateArchiveModel.class);
duplicateArchive.setCanonicalArchive(canonicalArchiveModel);
// create dupes for child archives
unzipToTempDirectory(event, context, tempFolder, newZipFile, duplicateArchive, true);
} else
{
unzipToTempDirectory(event, context, tempFolder, newZipFile, newArchiveModel, false);
}
} else if (subFile.isDirectory())
{
recurseAndAddFiles(event, context, tempFolder, fileService, archiveModel, subFileModel, false);
}
}
} | java |
private void renderAsLI(Writer writer, ProjectModel project, Iterator<Link> links, boolean wrap) throws IOException
{
if (!links.hasNext())
return;
if (wrap)
writer.append("<ul>");
while (links.hasNext())
{
Link link = links.next();
writer.append("<li>");
renderLink(writer, project, link);
writer.append("</li>");
}
if (wrap)
writer.append("</ul>");
} | java |
private ApplicationReportIndexModel createApplicationReportIndex(GraphContext context,
ProjectModel applicationProjectModel)
{
ApplicationReportIndexService applicationReportIndexService = new ApplicationReportIndexService(context);
ApplicationReportIndexModel index = applicationReportIndexService.create();
addAllProjectModels(index, applicationProjectModel);
return index;
} | java |
private void addAllProjectModels(ApplicationReportIndexModel navIdx, ProjectModel projectModel)
{
navIdx.addProjectModel(projectModel);
for (ProjectModel childProject : projectModel.getChildProjects())
{
if (!Iterators.asSet(navIdx.getProjectModels()).contains(childProject))
addAllProjectModels(navIdx, childProject);
}
} | java |
public long getTimeRemainingInMillis()
{
long batchTime = System.currentTimeMillis() - startTime;
double timePerIteration = (double) batchTime / (double) worked.get();
return (long) (timePerIteration * (total - worked.get()));
} | java |
public FileModel getChildFile(ArchiveModel archiveModel, String filePath)
{
filePath = FilenameUtils.separatorsToUnix(filePath);
StringTokenizer stk = new StringTokenizer(filePath, "/");
FileModel currentFileModel = archiveModel;
while (stk.hasMoreTokens() && currentFileModel != null)
{
String pathElement = stk.nextToken();
currentFileModel = findFileModel(currentFileModel, pathElement);
}
return currentFileModel;
} | java |
private void sort()
{
DefaultDirectedWeightedGraph<RuleProvider, DefaultEdge> graph = new DefaultDirectedWeightedGraph<>(
DefaultEdge.class);
for (RuleProvider provider : providers)
{
graph.addVertex(provider);
}
addProviderRelationships(graph);
checkForCycles(graph);
List<RuleProvider> result = new ArrayList<>(this.providers.size());
TopologicalOrderIterator<RuleProvider, DefaultEdge> iterator = new TopologicalOrderIterator<>(graph);
while (iterator.hasNext())
{
RuleProvider provider = iterator.next();
result.add(provider);
}
this.providers = Collections.unmodifiableList(result);
int index = 0;
for (RuleProvider provider : this.providers)
{
if (provider instanceof AbstractRuleProvider)
((AbstractRuleProvider) provider).setExecutionIndex(index++);
}
} | java |
private void checkForCycles(DefaultDirectedWeightedGraph<RuleProvider, DefaultEdge> graph)
{
CycleDetector<RuleProvider, DefaultEdge> cycleDetector = new CycleDetector<>(graph);
if (cycleDetector.detectCycles())
{
// if we have cycles, then try to throw an exception with some usable data
Set<RuleProvider> cycles = cycleDetector.findCycles();
StringBuilder errorSB = new StringBuilder();
for (RuleProvider cycle : cycles)
{
errorSB.append("Found dependency cycle involving: " + cycle.getMetadata().getID()).append(System.lineSeparator());
Set<RuleProvider> subCycleSet = cycleDetector.findCyclesContainingVertex(cycle);
for (RuleProvider subCycle : subCycleSet)
{
errorSB.append("\tSubcycle: " + subCycle.getMetadata().getID()).append(System.lineSeparator());
}
}
throw new RuntimeException("Dependency cycles detected: " + errorSB.toString());
}
} | java |
private void recurseAndAddFiles(GraphRewrite event, FileService fileService, WindupJavaConfigurationService javaConfigurationService, FileModel file)
{
if (javaConfigurationService.checkIfIgnored(event, file))
return;
String filePath = file.getFilePath();
File fileReference = new File(filePath);
Long directorySize = new Long(0);
if (fileReference.isDirectory())
{
File[] subFiles = fileReference.listFiles();
if (subFiles != null)
{
for (File reference : subFiles)
{
FileModel subFile = fileService.createByFilePath(file, reference.getAbsolutePath());
recurseAndAddFiles(event, fileService, javaConfigurationService, subFile);
if (subFile.isDirectory())
{
directorySize = directorySize + subFile.getDirectorySize();
}
else
{
directorySize = directorySize + subFile.getSize();
}
}
}
file.setDirectorySize(directorySize);
}
} | java |
public static void checkFileOrDirectoryToBeRead(File fileOrDir, String fileDesc)
{
if (fileOrDir == null)
throw new IllegalArgumentException(fileDesc + " must not be null.");
if (!fileOrDir.exists())
throw new IllegalArgumentException(fileDesc + " does not exist: " + fileOrDir.getAbsolutePath());
if (!(fileOrDir.isDirectory() || fileOrDir.isFile()))
throw new IllegalArgumentException(fileDesc + " must be a file or a directory: " + fileOrDir.getPath());
if (fileOrDir.isDirectory())
{
if (fileOrDir.list().length == 0)
throw new IllegalArgumentException(fileDesc + " is an empty directory: " + fileOrDir.getPath());
}
} | java |
public List<URL> scan(Predicate<String> filter)
{
List<URL> discoveredURLs = new ArrayList<>(128);
// For each Forge addon...
for (Addon addon : furnace.getAddonRegistry().getAddons(AddonFilters.allStarted()))
{
List<String> filteredResourcePaths = filterAddonResources(addon, filter);
for (String filePath : filteredResourcePaths)
{
URL ruleFile = addon.getClassLoader().getResource(filePath);
if (ruleFile != null)
discoveredURLs.add(ruleFile);
}
}
return discoveredURLs;
} | java |
public List<Class<?>> scanClasses(Predicate<String> filter)
{
List<Class<?>> discoveredClasses = new ArrayList<>(128);
// For each Forge addon...
for (Addon addon : furnace.getAddonRegistry().getAddons(AddonFilters.allStarted()))
{
List<String> discoveredFileNames = filterAddonResources(addon, filter);
// Then try to load the classes.
for (String discoveredFilename : discoveredFileNames)
{
String clsName = PathUtil.classFilePathToClassname(discoveredFilename);
try
{
Class<?> clazz = addon.getClassLoader().loadClass(clsName);
discoveredClasses.add(clazz);
}
catch (ClassNotFoundException ex)
{
LOG.log(Level.WARNING, "Failed to load class for name '" + clsName + "':\n" + ex.getMessage(), ex);
}
}
}
return discoveredClasses;
} | java |
public List<String> filterAddonResources(Addon addon, Predicate<String> filter)
{
List<String> discoveredFileNames = new ArrayList<>();
List<File> addonResources = addon.getRepository().getAddonResources(addon.getId());
for (File addonFile : addonResources)
{
if (addonFile.isDirectory())
handleDirectory(filter, addonFile, discoveredFileNames);
else
handleArchiveByFile(filter, addonFile, discoveredFileNames);
}
return discoveredFileNames;
} | java |
private void handleArchiveByFile(Predicate<String> filter, File archive, List<String> discoveredFiles)
{
try
{
try (ZipFile zip = new ZipFile(archive))
{
Enumeration<? extends ZipEntry> entries = zip.entries();
while (entries.hasMoreElements())
{
ZipEntry entry = entries.nextElement();
String name = entry.getName();
if (filter.accept(name))
discoveredFiles.add(name);
}
}
}
catch (IOException e)
{
throw new RuntimeException("Error handling file " + archive, e);
}
} | java |
private void handleDirectory(final Predicate<String> filter, final File rootDir, final List<String> discoveredFiles)
{
try
{
new DirectoryWalker<String>()
{
private Path startDir;
public void walk() throws IOException
{
this.startDir = rootDir.toPath();
this.walk(rootDir, discoveredFiles);
}
@Override
protected void handleFile(File file, int depth, Collection<String> discoveredFiles) throws IOException
{
String newPath = startDir.relativize(file.toPath()).toString();
if (filter.accept(newPath))
discoveredFiles.add(newPath);
}
}.walk();
}
catch (IOException ex)
{
LOG.log(Level.SEVERE, "Error reading Furnace addon directory", ex);
}
} | java |
public static Project dependsOnArtifact(Artifact artifact)
{
Project project = new Project();
project.artifact = artifact;
return project;
} | java |
public static final <T> T getSingle( Iterable<T> it ) {
if( ! it.iterator().hasNext() )
return null;
final Iterator<T> iterator = it.iterator();
T o = iterator.next();
if(iterator.hasNext())
throw new IllegalStateException("Found multiple items in iterator over " + o.getClass().getName() );
return o;
} | java |
@Override
public void perform(GraphRewrite event, EvaluationContext context)
{
checkVariableName(event, context);
WindupVertexFrame payload = resolveVariable(event, getVariableName());
if (payload instanceof FileReferenceModel)
{
FileModel file = ((FileReferenceModel) payload).getFile();
perform(event, context, (XmlFileModel) file);
}
else
{
super.perform(event, context);
}
} | java |
public Project dependsOnArtifact(Artifact artifact)
{
Project project = new Project();
project.setArtifact(artifact);
project.setInputVariablesName(inputVarName);
return project;
} | java |
public static JmsDestinationType getTypeFromClass(String aClass)
{
if (StringUtils.equals(aClass, "javax.jms.Queue") || StringUtils.equals(aClass, "javax.jms.QueueConnectionFactory"))
{
return JmsDestinationType.QUEUE;
}
else if (StringUtils.equals(aClass, "javax.jms.Topic") || StringUtils.equals(aClass, "javax.jms.TopicConnectionFactory"))
{
return JmsDestinationType.TOPIC;
}
else
{
return null;
}
} | java |
protected void checkVariableName(GraphRewrite event, EvaluationContext context)
{
if (variableName == null)
{
setVariableName(Iteration.getPayloadVariableName(event, context));
}
} | java |
public static List<ClassReference> analyze(WildcardImportResolver importResolver, Set<String> libraryPaths, Set<String> sourcePaths,
Path sourceFile)
{
ASTParser parser = ASTParser.newParser(AST.JLS11);
parser.setEnvironment(libraryPaths.toArray(new String[libraryPaths.size()]), sourcePaths.toArray(new String[sourcePaths.size()]), null, true);
parser.setBindingsRecovery(false);
parser.setResolveBindings(true);
Map options = JavaCore.getOptions();
JavaCore.setComplianceOptions(JavaCore.VERSION_1_8, options);
parser.setCompilerOptions(options);
String fileName = sourceFile.getFileName().toString();
parser.setUnitName(fileName);
try
{
parser.setSource(FileUtils.readFileToString(sourceFile.toFile()).toCharArray());
}
catch (IOException e)
{
throw new ASTException("Failed to get source for file: " + sourceFile.toString() + " due to: " + e.getMessage(), e);
}
parser.setKind(ASTParser.K_COMPILATION_UNIT);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
ReferenceResolvingVisitor visitor = new ReferenceResolvingVisitor(importResolver, cu, sourceFile.toString());
cu.accept(visitor);
return visitor.getJavaClassReferences();
} | java |
public static final String vertexAsString(Vertex vertex, int depth, String withEdgesOfLabel)
{
StringBuilder sb = new StringBuilder();
vertexAsString(vertex, depth, withEdgesOfLabel, sb, 0, new HashSet<>());
return sb.toString();
} | java |
private static String normalizeDirName(String name)
{
if(name == null)
return null;
return name.toLowerCase().replaceAll("[^a-zA-Z0-9]", "-");
} | java |
private static String guessPackaging(ProjectModel projectModel)
{
String projectType = projectModel.getProjectType();
if (projectType != null)
return projectType;
LOG.warning("WINDUP-983 getProjectType() returned null for: " + projectModel.getRootFileModel().getPrettyPath());
String suffix = StringUtils.substringAfterLast(projectModel.getRootFileModel().getFileName(), ".");
if ("jar war ear sar har ".contains(suffix+" ")){
projectModel.setProjectType(suffix); // FIXME: Remove when WINDUP-983 is fixed.
return suffix;
}
// Should we try something more? Used APIs? What if it's a source?
return "unknown";
} | java |
public static boolean xpathExists(Node document, String xpathExpression, Map<String, String> namespaceMapping) throws XPathException,
MarshallingException
{
Boolean result = (Boolean) executeXPath(document, xpathExpression, namespaceMapping, XPathConstants.BOOLEAN);
return result != null && result;
} | java |
public static Object executeXPath(Node document, String xpathExpression, Map<String, String> namespaceMapping, QName result)
throws XPathException, MarshallingException
{
NamespaceMapContext mapContext = new NamespaceMapContext(namespaceMapping);
try
{
XPathFactory xPathfactory = XPathFactory.newInstance();
XPath xpath = xPathfactory.newXPath();
xpath.setNamespaceContext(mapContext);
XPathExpression expr = xpath.compile(xpathExpression);
return executeXPath(document, expr, result);
}
catch (XPathExpressionException e)
{
throw new XPathException("Xpath(" + xpathExpression + ") cannot be compiled", e);
}
catch (Exception e)
{
throw new MarshallingException("Exception unmarshalling XML.", e);
}
} | java |
String deriveGroupIdFromPackages(ProjectModel projectModel)
{
Map<Object, Long> pkgsMap = new HashMap<>();
Set<String> pkgs = new HashSet<>(1000);
GraphTraversal<Vertex, Vertex> pipeline = new GraphTraversalSource(graphContext.getGraph()).V(projectModel);
pkgsMap = pipeline.out(ProjectModel.PROJECT_MODEL_TO_FILE)
.has(WindupVertexFrame.TYPE_PROP, new P(new BiPredicate<String, String>() {
@Override
public boolean test(String o, String o2) {
return o.contains(o2);
}
},
GraphTypeManager.getTypeValue(JavaClassFileModel.class)))
.hasKey(JavaClassFileModel.PROPERTY_PACKAGE_NAME)
.groupCount()
.by(v -> upToThirdDot(graphContext, (Vertex)v)).toList().get(0);
Map.Entry<Object, Long> biggest = null;
for (Map.Entry<Object, Long> entry : pkgsMap.entrySet())
{
if (biggest == null || biggest.getValue() < entry.getValue())
biggest = entry;
}
// More than a half is of this package.
if (biggest != null && biggest.getValue() > pkgsMap.size() / 2)
return biggest.getKey().toString();
return null;
} | java |
@Override
public JavaClassBuilderAt at(TypeReferenceLocation... locations)
{
if (locations != null)
this.locations = Arrays.asList(locations);
return this;
} | java |
@Override
public ConditionBuilder as(String variable)
{
Assert.notNull(variable, "Variable name must not be null.");
this.setOutputVariablesName(variable);
return this;
} | java |
protected void setResults(GraphRewrite event, String variable, Iterable<? extends WindupVertexFrame> results)
{
Variables variables = Variables.instance(event);
Iterable<? extends WindupVertexFrame> existingVariables = variables.findVariable(variable, 1);
if (existingVariables != null)
{
variables.setVariable(variable, Iterables.concat(existingVariables, results));
}
else
{
variables.setVariable(variable, results);
}
} | java |
private Map<String, Class<? extends RulePhase>> loadPhases()
{
Map<String, Class<? extends RulePhase>> phases;
phases = new HashMap<>();
Furnace furnace = FurnaceHolder.getFurnace();
for (RulePhase phase : furnace.getAddonRegistry().getServices(RulePhase.class))
{
@SuppressWarnings("unchecked")
Class<? extends RulePhase> unwrappedClass = (Class<? extends RulePhase>) Proxies.unwrap(phase).getClass();
String simpleName = unwrappedClass.getSimpleName();
phases.put(classNameToMapKey(simpleName), unwrappedClass);
}
return Collections.unmodifiableMap(phases);
} | java |
private void allInput(List<FileModel> vertices, GraphRewrite event, ParameterStore store)
{
if (StringUtils.isBlank(getInputVariablesName()) && this.filenamePattern == null)
{
FileService fileModelService = new FileService(event.getGraphContext());
for (FileModel fileModel : fileModelService.findAll())
{
vertices.add(fileModel);
}
}
} | java |
@Override
public T getById(Object id)
{
return context.getFramed().getFramedVertex(this.type, id);
} | java |
public static <T extends WindupVertexFrame> T addTypeToModel(GraphContext graphContext, WindupVertexFrame frame, Class<T> type)
{
Vertex vertex = frame.getElement();
graphContext.getGraphTypeManager().addTypeToElement(type, vertex);
return graphContext.getFramed().frameElement(vertex, type);
} | java |
public static <T extends WindupVertexFrame> WindupVertexFrame removeTypeFromModel(GraphContext graphContext, WindupVertexFrame frame, Class<T> type)
{
Vertex vertex = frame.getElement();
graphContext.getGraphTypeManager().removeTypeFromElement(type, vertex);
return graphContext.getFramed().frameElement(vertex, WindupVertexFrame.class);
} | java |
@SuppressWarnings("unchecked")
private static synchronized Map<String, Boolean> getCache(GraphRewrite event)
{
Map<String, Boolean> result = (Map<String, Boolean>)event.getRewriteContext().get(ClassificationServiceCache.class);
if (result == null)
{
result = Collections.synchronizedMap(new LRUMap(30000));
event.getRewriteContext().put(ClassificationServiceCache.class, result);
}
return result;
} | java |
public static String getEffortLevelDescription(Verbosity verbosity, int points)
{
EffortLevel level = EffortLevel.forPoints(points);
switch (verbosity)
{
case ID:
return level.name();
case VERBOSE:
return level.getVerboseDescription();
case SHORT:
default:
return level.getShortDescription();
}
} | java |
public WindupConfiguration setOptionValue(String name, Object value)
{
configurationOptions.put(name, value);
return this;
} | java |
@SuppressWarnings("unchecked")
public <T> T getOptionValue(String name)
{
return (T) configurationOptions.get(name);
} | java |
private void logTimeTakenByRuleProvider(GraphContext graphContext, Context context, int ruleIndex, int timeTaken)
{
AbstractRuleProvider ruleProvider = (AbstractRuleProvider) context.get(RuleMetadataType.RULE_PROVIDER);
if (ruleProvider == null)
return;
if (!timeTakenByProvider.containsKey(ruleProvider))
{
RuleProviderExecutionStatisticsModel model = new RuleProviderExecutionStatisticsService(graphContext)
.create();
model.setRuleIndex(ruleIndex);
model.setRuleProviderID(ruleProvider.getMetadata().getID());
model.setTimeTaken(timeTaken);
timeTakenByProvider.put(ruleProvider, model.getElement().id());
}
else
{
RuleProviderExecutionStatisticsService service = new RuleProviderExecutionStatisticsService(graphContext);
RuleProviderExecutionStatisticsModel model = service.getById(timeTakenByProvider.get(ruleProvider));
int prevTimeTaken = model.getTimeTaken();
model.setTimeTaken(prevTimeTaken + timeTaken);
}
logTimeTakenByPhase(graphContext, ruleProvider.getMetadata().getPhase(), timeTaken);
} | java |
private void logTimeTakenByPhase(GraphContext graphContext, Class<? extends RulePhase> phase, int timeTaken)
{
if (!timeTakenByPhase.containsKey(phase))
{
RulePhaseExecutionStatisticsModel model = new GraphService<>(graphContext,
RulePhaseExecutionStatisticsModel.class).create();
model.setRulePhase(phase.toString());
model.setTimeTaken(timeTaken);
model.setOrderExecuted(timeTakenByPhase.size());
timeTakenByPhase.put(phase, model.getElement().id());
}
else
{
GraphService<RulePhaseExecutionStatisticsModel> service = new GraphService<>(graphContext,
RulePhaseExecutionStatisticsModel.class);
RulePhaseExecutionStatisticsModel model = service.getById(timeTakenByPhase.get(phase));
int prevTimeTaken = model.getTimeTaken();
model.setTimeTaken(prevTimeTaken + timeTaken);
}
} | java |
public static String transformXPath(String originalXPath)
{
// use a list to maintain the multiple joined xqueries (if there are multiple queries joined with the "|" operator)
List<StringBuilder> compiledXPaths = new ArrayList<>(1);
int frameIdx = -1;
boolean inQuote = false;
int conditionLevel = 0;
char startQuoteChar = 0;
StringBuilder currentXPath = new StringBuilder();
compiledXPaths.add(currentXPath);
for (int i = 0; i < originalXPath.length(); i++)
{
char curChar = originalXPath.charAt(i);
if (!inQuote && curChar == '[')
{
frameIdx++;
conditionLevel++;
currentXPath.append("[windup:startFrame(").append(frameIdx).append(") and windup:evaluate(").append(frameIdx).append(", ");
}
else if (!inQuote && curChar == ']')
{
conditionLevel--;
currentXPath.append(")]");
}
else if (!inQuote && conditionLevel == 0 && curChar == '|')
{
// joining multiple xqueries
currentXPath = new StringBuilder();
compiledXPaths.add(currentXPath);
}
else
{
if (inQuote && curChar == startQuoteChar)
{
inQuote = false;
startQuoteChar = 0;
}
else if (curChar == '"' || curChar == '\'')
{
inQuote = true;
startQuoteChar = curChar;
}
if (!inQuote && originalXPath.startsWith(WINDUP_MATCHES_FUNCTION_PREFIX, i))
{
i += (WINDUP_MATCHES_FUNCTION_PREFIX.length() - 1);
currentXPath.append("windup:matches(").append(frameIdx).append(", ");
}
else
{
currentXPath.append(curChar);
}
}
}
Pattern leadingAndTrailingWhitespace = Pattern.compile("(\\s*)(.*?)(\\s*)");
StringBuilder finalResult = new StringBuilder();
for (StringBuilder compiledXPath : compiledXPaths)
{
if (StringUtils.isNotBlank(compiledXPath))
{
Matcher whitespaceMatcher = leadingAndTrailingWhitespace.matcher(compiledXPath);
if (!whitespaceMatcher.matches())
continue;
compiledXPath = new StringBuilder();
compiledXPath.append(whitespaceMatcher.group(1));
compiledXPath.append(whitespaceMatcher.group(2));
compiledXPath.append("/self::node()[windup:persist(").append(frameIdx).append(", ").append(".)]");
compiledXPath.append(whitespaceMatcher.group(3));
if (StringUtils.isNotBlank(finalResult))
finalResult.append("|");
finalResult.append(compiledXPath);
}
}
return finalResult.toString();
} | java |
@Override
public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
if (this.options.verbose) {
this.out.println(
Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));
// new Exception("TRACE BINARY").printStackTrace(System.out);
// System.out.println();
}
LookupEnvironment env = packageBinding.environment;
env.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.