_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q163500 | AuthRequestHelper.validateTokenRequest | train | public static boolean validateTokenRequest(TokenRequestDto tokenRequestDto, OAuthApplicationDto oAuthApplicationDto) {
// basic check
try {
String decodedRedirectUri = java.net.URLDecoder.decode(tokenRequestDto.getRedirectUri(), "UTF-8");
if (StringUtils.isNotBlank(oAuthApplicationDto.getRedirectUri()) && oAuthApplicationDto.getRedirectUri().equals(decodedRedirectUri)) {
if (StringUtils.isNotBlank(tokenRequestDto.getGrantType())) {
if (OAuthFields.AUTHORIZATION_CODE.equals(tokenRequestDto.getGrantType())) {
return true;
} else {
_logger.info("Grant Type '" + tokenRequestDto.getGrantType() + "' is not supported");
throw new OAuthException(ResponseCodes.GRANT_TYPE_NOT_SUPPORTED, HttpResponseStatus.BAD_REQUEST);
}
} else {
_logger.info("Grant Type '" + tokenRequestDto.getGrantType() + "' mismatch");
throw new OAuthException(ResponseCodes.INVALID_OR_MISSING_GRANT_TYPE, HttpResponseStatus.BAD_REQUEST);
}
} else {
_logger.info("Request Redirect URI '" + tokenRequestDto.getRedirectUri() + "' mismatch");
throw new OAuthException(ResponseCodes.INVALID_OR_MISSING_REDIRECT_URI, HttpResponseStatus.BAD_REQUEST);
}
} catch (UnsupportedEncodingException e) {
_logger.info("Request Redirect URI '" + tokenRequestDto.getRedirectUri() + "' mismatch");
throw new OAuthException(ResponseCodes.INVALID_OR_MISSING_REDIRECT_URI, HttpResponseStatus.BAD_REQUEST);
}
} | java | {
"resource": ""
} |
q163501 | MetricZipperTransform.zip | train | public List<Metric> zip(List<Metric> metrics, Metric baseMetric) {
SystemAssert.requireArgument(baseMetric != null, "Zipper transform requires base metric as second param!");
List<Metric> zippedMetrics = new ArrayList<Metric>();
Map<Long, Double> baseDatapoints = baseMetric.getDatapoints();
for (Metric metric : metrics) {
Map<Long, Double> originalDatapoints = metric.getDatapoints();
Map<Long, Double> zippedDatadpoints = this.zip(originalDatapoints, baseDatapoints);
metric.setDatapoints(zippedDatadpoints);
zippedMetrics.add(metric);
}
return zippedMetrics;
} | java | {
"resource": ""
} |
q163502 | MetricZipperTransform.zip | train | public Map<Long, Double> zip(Map<Long, Double> originalDatapoints, Map<Long, Double> baseDatapoints) {
SystemAssert.requireArgument(baseDatapoints != null && !baseDatapoints.isEmpty(),
"Zipper transform requires valid baseDatapoints from base metric!");
Map<Long, Double> zippedDP = new HashMap<>();
for (Map.Entry<Long, Double> originalDP : originalDatapoints.entrySet()) {
Long originalKey = originalDP.getKey();
Double originalVal = originalDP.getValue();
// if base datapoints doesn't have the key, give it null
Double baseVal = baseDatapoints.containsKey(originalKey) ? baseDatapoints.get(originalKey) : null;
zippedDP.put(originalKey, this.valueZipper.zip(originalVal, baseVal));
}
// if a point exists in the baseDP but does not exist in the original set,
// then only add it to the result when fullJoinIndicator is true.
if(fulljoinIndicator) {
for (Map.Entry<Long, Double> baseDP : baseDatapoints.entrySet()) {
Long baseDPKey = baseDP.getKey();
if(!zippedDP.containsKey(baseDPKey)) {
zippedDP.put(baseDPKey, this.valueZipper.zip(null, baseDP.getValue()));
}
}
}
return zippedDP;
} | java | {
"resource": ""
} |
q163503 | MethodHelpDto.fromMethodClass | train | public static MethodHelpDto fromMethodClass(String parentPath, Method method) {
String methodName = _getHttpMethod(method);
Path path = method.getAnnotation(Path.class);
Description description = method.getAnnotation(Description.class);
Produces produces = method.getAnnotation(Produces.class);
Consumes consumes = method.getAnnotation(Consumes.class);
if ((path == null || !path.value().contains("help")) && description != null) {
String relativePath = path == null ? "" : path.value();
String fullPath = parentPath == null ? relativePath : parentPath + relativePath;
MethodHelpDto result = new MethodHelpDto();
result.setDescription(description.value());
result.setMethod(methodName);
result.setPath(fullPath);
if (produces != null) {
result.setProduces(produces.value());
}
if (consumes != null) {
result.setConsumes(consumes.value());
}
List<MethodParameterDto> params = _getMethodParams(method);
result.setParams(params);
return result;
} else {
return null;
}
} | java | {
"resource": ""
} |
q163504 | InterpolateTransform.putDataPoint | train | private void putDataPoint(int i, Entry<Long, Double> datapoint) {
timestamps[i] = datapoint.getKey();
values[i] = datapoint.getValue();
} | java | {
"resource": ""
} |
q163505 | InterpolateTransform.doesAnyTimeSeriesHaveData | train | private boolean doesAnyTimeSeriesHaveData() {
for (int i = 0; i < iterators.length; i++) {
if ((timestamps[iterators.length + i]) != MARK_END_TIME_SERIES) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q163506 | InterpolateTransform.updateBufferChronologically | train | private long updateBufferChronologically() {
long minTimestamp = Long.MAX_VALUE;
long timestamp = 0;
// Mark the internal timestamp buffer as done, when we have reached the end of that time series
for (int i = current; i < iterators.length; i++) {
if (timestamps[i] != 0L && timestamps[i + iterators.length] == MARK_END_TIME_SERIES) {
timestamps[i] = 0L;
}
}
current = -1;
boolean isMultipleSeriesWithMinimum = false;
for (int i = 0; i < iterators.length; i++) {
timestamp = timestamps[iterators.length + i];
if (timestamp < minTimestamp) {
minTimestamp = timestamp;
current = i;
isMultipleSeriesWithMinimum = false;
} else if (timestamp == minTimestamp) {
isMultipleSeriesWithMinimum = true;
}
}
updateCurrentAndNextSectionOfBuffer(current);
if (isMultipleSeriesWithMinimum) {
for (int i = current + 1; i < iterators.length; i++) {
timestamp = timestamps[iterators.length + i];
if (timestamp == minTimestamp) {
updateCurrentAndNextSectionOfBuffer(i);
}
}
}
return minTimestamp;
} | java | {
"resource": ""
} |
q163507 | InterpolateTransform.updateCurrentAndNextSectionOfBuffer | train | private void updateCurrentAndNextSectionOfBuffer(int i) {
int next = iterators.length + i;
timestamps[i] = timestamps[next];
values[i] = values[next];
if (iterators[i].hasNext()) {
putDataPoint(next, (Entry<Long, Double>) iterators[i].next());
} else {
markEndTimeSeries(i);
}
} | java | {
"resource": ""
} |
q163508 | InterpolateTransform.markEndTimeSeries | train | private void markEndTimeSeries(int i) {
timestamps[iterators.length + i] = MARK_END_TIME_SERIES;
iterators[i] = null;
} | java | {
"resource": ""
} |
q163509 | AnomalyDetectionGaussianZScoreTransform.calculateAnomalyScore | train | @Override
public double calculateAnomalyScore(double value) {
double zScore = (value - mean) / Math.sqrt(variance);
//Taking absolute value for a more human-readable anomaly score
return Math.abs(zScore);
} | java | {
"resource": ""
} |
q163510 | ArgusService.getInstance | train | public static ArgusService getInstance(String endpoint, int maxConn, int connTimeout, int connRequestTimeout) throws IOException {
ArgusHttpClient client = new ArgusHttpClient(endpoint, maxConn, connTimeout, connRequestTimeout);
return new ArgusService(client);
} | java | {
"resource": ""
} |
q163511 | AbstractResource.describeEndpoints | train | protected static List<EndpointHelpDto> describeEndpoints(List<Class<? extends AbstractResource>> resourceClasses) {
List<EndpointHelpDto> result = new LinkedList<>();
if (resourceClasses != null && !resourceClasses.isEmpty()) {
for (Class<? extends AbstractResource> resourceClass : resourceClasses) {
EndpointHelpDto dto = EndpointHelpDto.fromResourceClass(resourceClass);
if (dto != null) {
result.add(dto);
}
}
}
return result;
} | java | {
"resource": ""
} |
q163512 | AbstractResource.getRemoteUser | train | public PrincipalUser getRemoteUser(HttpServletRequest req) {
requireArgument(req != null, "Request cannot be null.");
if(req.getHeader(HttpHeaders.AUTHORIZATION) != null) {
PrincipalUser result = null;
Object username = req.getAttribute(AuthFilter.USER_ATTRIBUTE_NAME);
if (username != null) {
result = userService.findUserByUsername(String.class.cast(username));
}
return result;
}
return null;
} | java | {
"resource": ""
} |
q163513 | AbstractResource.help | train | @GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/help")
public Map<String, List<? extends Object>> help() {
Map<String, List<?>> result = new LinkedHashMap<>();
List<EndpointHelpDto> endpoints = describeEndpoints(getEndpoints());
if (endpoints != null && !endpoints.isEmpty()) {
result.put("endpoints", endpoints);
}
List<MethodHelpDto> methods = describeMethods();
if (methods != null && !methods.isEmpty()) {
result.put("methods", methods);
}
return result;
} | java | {
"resource": ""
} |
q163514 | AbstractResource.describeMethods | train | protected List<MethodHelpDto> describeMethods() {
List<MethodHelpDto> result = new LinkedList<>();
Path endpointPath = getClass().getAnnotation(Path.class);
for (Method method : getClass().getDeclaredMethods()) {
String parentPath = endpointPath == null ? null : endpointPath.value();
MethodHelpDto methodHelpDto = MethodHelpDto.fromMethodClass(parentPath, method);
if (methodHelpDto != null) {
result.add(methodHelpDto);
}
}
Collections.sort(result);
return result;
} | java | {
"resource": ""
} |
q163515 | AbstractResource.validateAndGetOwner | train | protected PrincipalUser validateAndGetOwner(HttpServletRequest req, String ownerName) {
PrincipalUser remoteUser = getRemoteUser(req);
if (ownerName == null || ownerName.isEmpty() || ownerName.equalsIgnoreCase(remoteUser.getUserName())) {
//If ownerName is not present or if it is present and equal to remote username, then return remoteUser.
return remoteUser;
} else if (remoteUser.isPrivileged()) {
PrincipalUser owner;
owner = userService.findUserByUsername(ownerName);
if (owner == null) {
throw new WebApplicationException(ownerName + ": User does not exist.", Status.NOT_FOUND);
} else {
return owner;
}
}
throw new WebApplicationException(Status.FORBIDDEN.getReasonPhrase(), Status.FORBIDDEN);
} | java | {
"resource": ""
} |
q163516 | AbstractResource.validateResourceAuthorization | train | protected void validateResourceAuthorization(HttpServletRequest req, PrincipalUser actualOwner, PrincipalUser currentOwner) {
if (!getRemoteUser(req).isPrivileged() && !actualOwner.equals(currentOwner)) {
throw new WebApplicationException(Status.FORBIDDEN.getReasonPhrase(), Status.FORBIDDEN);
}
} | java | {
"resource": ""
} |
q163517 | AbstractResource.validatePrivilegedUser | train | protected void validatePrivilegedUser(HttpServletRequest req) {
if (!getRemoteUser(req).isPrivileged()) {
throw new WebApplicationException(Status.FORBIDDEN.getReasonPhrase(), Status.FORBIDDEN);
}
} | java | {
"resource": ""
} |
q163518 | AbstractResource.copyProperties | train | protected void copyProperties(Object dest, Object source) {
try {
BeanUtils.copyProperties(dest, source);
} catch (Exception e) {
String errorMessage = MessageFormat.format("M:{0};;E:{1}",
e.getCause().getMessage(), e.toString());
throw new WebApplicationException(errorMessage, Status.BAD_REQUEST);
}
} | java | {
"resource": ""
} |
q163519 | Metric.setDatapoints | train | public void setDatapoints(Map<Long, Double> datapoints) {
_datapoints.clear();
if (datapoints != null) {
_datapoints.putAll(datapoints);
}
} | java | {
"resource": ""
} |
q163520 | Metric.addDatapoints | train | public void addDatapoints(Map<Long, Double> datapoints) {
if (datapoints != null) {
_datapoints.putAll(datapoints);
}
} | java | {
"resource": ""
} |
q163521 | Metric.minimumExistingDatapoints | train | public void minimumExistingDatapoints(Map<Long, Double> datapoints) {
if (datapoints != null) {
for(Entry<Long, Double> entry : datapoints.entrySet()){
Double existingValue = _datapoints.get(entry.getKey());
if(existingValue == null){
_datapoints.put(entry.getKey(), entry.getValue());
} else if (existingValue > entry.getValue()) {
_datapoints.put(entry.getKey(), entry.getValue());
}
}
}
} | java | {
"resource": ""
} |
q163522 | Metric.averageExistingDatapoints | train | public void averageExistingDatapoints(Map<Long, Double> datapoints) {
if (datapoints != null) {
for(Entry<Long, Double> entry : datapoints.entrySet()){
_datapoints.put(entry.getKey(), entry.getValue());
}
}
} | java | {
"resource": ""
} |
q163523 | ArgusWebServletListener.getSystem | train | public static SystemMain getSystem() {
try {
_gate.await();
return _system;
} catch (InterruptedException ex) {
_logger.warn("Interrupted while waiting for startup to complete.");
return null;
}
} | java | {
"resource": ""
} |
q163524 | AnomalyDetectionKMeansTransform.setMeanDistancesToCentroids | train | private void setMeanDistancesToCentroids() {
meanDistancesToCentroids = new HashMap<>();
for (int i = 0; i < clusterCentroids.numInstances(); i++) { //For each centroid
int countAssignedInstances = 0;
double sumDistancesToCentroid = 0.0;
Instance centroidInstance = clusterCentroids.instance(i);
for (int j = 0; j < trainingData.numInstances(); j++) { //For each data point
if (i == centroidAssignments[j]) {
Instance valueInstance = trainingData.instance(j);
double distanceToCentroid = Math.abs(valueInstance.value(0) -
centroidInstance.value(0));
sumDistancesToCentroid += distanceToCentroid;
countAssignedInstances++;
}
}
double meanDistanceToCentroid = sumDistancesToCentroid / countAssignedInstances;
meanDistancesToCentroids.put(centroidInstance, meanDistanceToCentroid);
}
} | java | {
"resource": ""
} |
q163525 | AnomalyDetectionKMeansTransform.calculateAnomalyScore | train | @Override
public double calculateAnomalyScore(double value) {
int instanceIndex = metricDataValues.indexOf(value);
Instance valueInstance = trainingData.instance(instanceIndex);
//Centroid that is assigned to valueInstance
Instance centroidInstance = clusterCentroids.instance(centroidAssignments[instanceIndex]);
if (meanDistancesToCentroids.get(centroidInstance) == 0.0) {
throw new ArithmeticException("Cannot divide by 0");
}
double distanceToCentroid = Math.abs(valueInstance.value(0) - centroidInstance.value(0));
double relativeDistanceToCentroid = distanceToCentroid / meanDistancesToCentroids.get(centroidInstance);
return relativeDistanceToCentroid;
} | java | {
"resource": ""
} |
q163526 | CachedTSDBService.fractureMetricIntoDayBoundary | train | private Map<String, List<Metric>> fractureMetricIntoDayBoundary(List<Metric> metrics, MetricQuery query) {
Map<String, List<Metric>> cacheMap = new TreeMap<String, List<Metric>>();
String cacheKey;
Long nextTimeStampDay;
Long previousTimeStampDay;
Long startTimeStampDay = query.getStartTimestamp();
Long endTimeStampDay = query.getEndTimestamp();
for (Metric metric : metrics) {
previousTimeStampDay = startTimeStampDay;
nextTimeStampDay = getNextDayBoundaryTimeStamp(startTimeStampDay);
Metric tempMetric = new Metric(metric);
Map<Long, Double> dataPoints = new LinkedHashMap<>();
for (Map.Entry<Long, Double> dataPoint : metric.getDatapoints().entrySet()) {
if (dataPoint.getKey() < nextTimeStampDay) {
dataPoints.put(dataPoint.getKey(), dataPoint.getValue());
} else {
while (dataPoint.getKey() >= nextTimeStampDay) {
tempMetric.setDatapoints(dataPoints);
cacheKey = constructMetricQueryKey(previousTimeStampDay, metric, query);
cacheMap.put(cacheKey, new ArrayList<Metric>(Arrays.asList(tempMetric)));
cacheKey = constructMetricQueryKey(previousTimeStampDay, query);
if (cacheMap.containsKey(cacheKey)) {
cacheMap.get(cacheKey).addAll(Arrays.asList(tempMetric));
} else {
cacheMap.put(cacheKey, new ArrayList<Metric>(Arrays.asList(tempMetric)));
}
tempMetric = new Metric(metric);
dataPoints = new LinkedHashMap<>();
previousTimeStampDay = nextTimeStampDay;
nextTimeStampDay = getNextDayBoundaryTimeStamp(nextTimeStampDay);
}
dataPoints.put(dataPoint.getKey(), dataPoint.getValue());
}
}
while (nextTimeStampDay < getNextDayBoundaryTimeStamp(endTimeStampDay)) {
tempMetric.setDatapoints(dataPoints);
cacheKey = constructMetricQueryKey(previousTimeStampDay, metric, query);
cacheMap.put(cacheKey, new ArrayList<Metric>(Arrays.asList(tempMetric)));
cacheKey = constructMetricQueryKey(previousTimeStampDay, query);
if (cacheMap.containsKey(cacheKey)) {
cacheMap.get(cacheKey).addAll(Arrays.asList(tempMetric));
} else {
cacheMap.put(cacheKey, new ArrayList<Metric>(Arrays.asList(tempMetric)));
}
tempMetric = new Metric(metric);
dataPoints = new LinkedHashMap<>();
previousTimeStampDay = nextTimeStampDay;
nextTimeStampDay = getNextDayBoundaryTimeStamp(nextTimeStampDay);
}
}
return cacheMap;
} | java | {
"resource": ""
} |
q163527 | CachedTSDBService.constructMetricQueryKey | train | private String constructMetricQueryKey(Long startTimeStampBoundary, Metric metric, MetricQuery query) {
StringBuilder sb = new StringBuilder();
sb.append(startTimeStampBoundary).append(":");
sb.append(query.getNamespace()).append(":");
sb.append(query.getScope()).append(":");
sb.append(query.getMetric()).append(":");
Map<String, String> treeMap = new TreeMap<>();
treeMap.putAll(metric.getTags());
sb.append(treeMap).append(":");
sb.append(query.getAggregator()).append(":");
sb.append(query.getDownsampler()).append(":");
sb.append(query.getDownsamplingPeriod());
return sb.toString();
} | java | {
"resource": ""
} |
q163528 | AlertService.getAlertsMeta | train | public List<Alert> getAlertsMeta(boolean includeSharedAlerts) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/meta?shared=" + includeSharedAlerts;
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<Alert>>() { });
} | java | {
"resource": ""
} |
q163529 | AlertService.getAlert | train | public Alert getAlert(BigInteger alertId) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Alert.class);
} | java | {
"resource": ""
} |
q163530 | AlertService.getNotifications | train | public List<Notification> getNotifications(BigInteger alertId) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString() + "/notifications";
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<Notification>>() { });
} | java | {
"resource": ""
} |
q163531 | AlertService.updateAlert | train | public Alert updateAlert(BigInteger alertId, Alert alert) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.PUT, requestUrl, alert);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Alert.class);
} | java | {
"resource": ""
} |
q163532 | AlertService.updateNotification | train | public Notification updateNotification(BigInteger alertId, BigInteger notificationId, Notification notification) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString() + "/notifications/" + notificationId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.PUT, requestUrl, notification);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Notification.class);
} | java | {
"resource": ""
} |
q163533 | AlertService.updateTrigger | train | public Trigger updateTrigger(BigInteger alertId, BigInteger triggerId, Trigger trigger) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString() + "/triggers/" + triggerId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.PUT, requestUrl, trigger);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Trigger.class);
} | java | {
"resource": ""
} |
q163534 | AlertService.createNotification | train | public List<Notification> createNotification(BigInteger alertId, Notification notification) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString() + "/notifications";
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.POST, requestUrl, notification);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<Notification>>() { });
} | java | {
"resource": ""
} |
q163535 | AlertService.createTrigger | train | public List<Trigger> createTrigger(BigInteger alertId, Trigger trigger) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString() + "/triggers";
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.POST, requestUrl, trigger);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<Trigger>>() { });
} | java | {
"resource": ""
} |
q163536 | AlertService.deleteAlert | train | public void deleteAlert(BigInteger alertId) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + alertId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.DELETE, requestUrl, null);
assertValidResponse(response, requestUrl);
} | java | {
"resource": ""
} |
q163537 | QueryFederation.join | train | public Map<MetricQuery, List<Metric>> join(Map<MetricQuery, List<MetricQuery>> mapQuerySubQueries, Map<MetricQuery, List<Metric>> subQueryMetricsMap) {
Map<MetricQuery, List<Metric>> queryMetricsMap = new HashMap<>();
String metricIdentifier = null;
for (Map.Entry<MetricQuery, List<MetricQuery>> entry : mapQuerySubQueries.entrySet()) {
Map<String, Metric> metricMergeMap = new HashMap<>();
List<Metric> metrics = new ArrayList<>();
MetricQuery query = entry.getKey();
List<MetricQuery> subQueries = entry.getValue();
for (MetricQuery subQuery : subQueries) {
List<Metric> metricsFromSubQuery = subQueryMetricsMap.get(subQuery);
if (metricsFromSubQuery != null) {
for (Metric metric : metricsFromSubQuery) {
if (metric != null) {
metricIdentifier = metric.getIdentifier();
Metric finalMetric = metricMergeMap.get(metricIdentifier);
if (finalMetric == null) {
metric.setQuery(query);
metricMergeMap.put(metricIdentifier, metric);
} else {
if(query.getDownsampler() !=null){
switch(query.getDownsampler()){
case SUM:
finalMetric.sumExistingDatapoints(metric.getDatapoints());
break;
case MIN:
finalMetric.minimumExistingDatapoints(metric.getDatapoints());
break;
case MAX:
finalMetric.maximumExistingDatapoints(metric.getDatapoints());
break;
case COUNT:
finalMetric.sumExistingDatapoints(metric.getDatapoints());
break;
case ZIMSUM:
finalMetric.sumExistingDatapoints(metric.getDatapoints());
break;
case AVG:
finalMetric.averageExistingDatapoints(metric.getDatapoints());
break;
default:
finalMetric.addDatapoints(metric.getDatapoints());
}
} else{
finalMetric.addDatapoints(metric.getDatapoints());
}
}
}
}
}
}
metrics.addAll(metricMergeMap.values());
queryMetricsMap.put(query, metrics);
}
return queryMetricsMap;
} | java | {
"resource": ""
} |
q163538 | AuditNotifier.getTriggerDetails | train | protected String getTriggerDetails(Trigger trigger, NotificationContext context) {
if (trigger != null) {
String triggerString = trigger.toString();
triggerString = TemplateReplacer.applyTemplateChanges(context, triggerString);
return triggerString.substring(triggerString.indexOf("{") + 1, triggerString.indexOf("}"));
} else {
return "";
}
} | java | {
"resource": ""
} |
q163539 | AuditNotifier.getMetricUrl | train | protected String getMetricUrl(String metricToAnnotate, long triggerFiredTime) {
long start = triggerFiredTime - (6L * DateTimeConstants.MILLIS_PER_HOUR);
long end = Math.min(System.currentTimeMillis(), triggerFiredTime + (6L * DateTimeConstants.MILLIS_PER_HOUR));
String expression = MessageFormat.format("{0,number,#}:{1,number,#}:{2}", start, end, metricToAnnotate);
return getExpressionUrl(expression);
} | java | {
"resource": ""
} |
q163540 | AuditNotifier.getExpressionUrl | train | @SuppressWarnings("deprecation")
protected String getExpressionUrl(String expression) {
String template = _config.getValue(Property.AUDIT_METRIC_URL_TEMPLATE.getName(), Property.AUDIT_METRIC_URL_TEMPLATE.getDefaultValue());
try {
expression = URLEncoder.encode(expression, "UTF-8");
} catch (Exception ex) {
expression = URLEncoder.encode(expression);
}
return template.replaceAll("\\$expression\\$", expression);
} | java | {
"resource": ""
} |
q163541 | AuditNotifier.getAlertUrl | train | protected String getAlertUrl(BigInteger id) {
String template = _config.getValue(Property.AUDIT_ALERT_URL_TEMPLATE.getName(), Property.AUDIT_ALERT_URL_TEMPLATE.getDefaultValue());
return template.replaceAll("\\$alertid\\$", String.valueOf(id));
} | java | {
"resource": ""
} |
q163542 | AuditNotifier.getAllNotifications | train | public List<Audit> getAllNotifications(JPAEntity entity) {
return _auditService.findByEntityHostnameMessage(entity.getId(), null, "Triggering event value:");
} | java | {
"resource": ""
} |
q163543 | NamespaceService.updateNamespace | train | public Namespace updateNamespace(BigInteger id, Namespace namespace) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + id.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.PUT, requestUrl, namespace);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Namespace.class);
} | java | {
"resource": ""
} |
q163544 | NamespaceService.updateNamespaceMembers | train | public Namespace updateNamespaceMembers(BigInteger id, Set<String> users) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/" + id.toString() + "/users";
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.PUT, requestUrl, users);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), Namespace.class);
} | java | {
"resource": ""
} |
q163545 | WardenNotifier.sendWardenEmailToUser | train | protected void sendWardenEmailToUser(NotificationContext context, SubSystem subSystem) {
EntityManager em = emf.get();
PrincipalUser user = getWardenUser(context.getAlert().getName());
SuspensionRecord record = SuspensionRecord.findByUserAndSubsystem(em, user, subSystem);
Set<String> to = new HashSet<>();
to.add(user.getEmail());
String subject = "Warden Email Notification";
StringBuilder message = new StringBuilder();
message.append(MessageFormat.format("<p>{0} has been suspended from the Argus system for violating the following policy</p>",
user.getUserName()));
message.append(MessageFormat.format("Subsystem: {0}", subSystem.toString()));
message.append(MessageFormat.format("<br>Policy: {0}",
context.getAlert().getName().replace(WARDEN_ALERT_NAME_PREFIX + user.getUserName() + "-", "")));
message.append(MessageFormat.format("<br>Threshold: {0}", context.getAlert().getTriggers().get(0).getThreshold()));
message.append(MessageFormat.format("<br>Triggering Value: {0}", context.getTriggerEventValue()));
if (record.getSuspendedUntil() == -1) {
message.append("<br> You have been suspended indefinitely");
} else {
message.append(MessageFormat.format("<br>Reinstatement Time: {0}", DATE_FORMATTER.get().format(new Date(record.getSuspendedUntil()))));
}
_mailService.sendMessage(to, subject, message.toString(), "text/html; charset=utf-8", MailService.Priority.HIGH);
to.clear();
to.add("argus-admin@salesforce.com");
message.append("<p><a href='").append(getAlertUrl(context.getAlert().getId())).append("'>Click here to view alert definition.</a><br/>");
_mailService.sendMessage(to, subject, message.toString(), "text/html; charset=utf-8", MailService.Priority.HIGH);
} | java | {
"resource": ""
} |
q163546 | WardenNotifier.getWardenUser | train | protected PrincipalUser getWardenUser(String wardenAlertName) {
assert (wardenAlertName != null) : "Warden alert name cannot be null.";
int beginIndex = wardenAlertName.indexOf("-") + 1;
int endIndex = wardenAlertName.lastIndexOf("-");
return PrincipalUser.findByUserName(emf.get(), wardenAlertName.substring(beginIndex, endIndex));
} | java | {
"resource": ""
} |
q163547 | PrincipalUser.findUniqueUserCount | train | public static long findUniqueUserCount(EntityManager em) {
TypedQuery<Long> query = em.createNamedQuery("PrincipalUser.findUniqueUserCount", Long.class);
return query.getSingleResult();
} | java | {
"resource": ""
} |
q163548 | PrincipalUser.findByUserName | train | public static PrincipalUser findByUserName(EntityManager em, String userName) {
Class<PrincipalUser> type = PrincipalUser.class;
TypedQuery<PrincipalUser> query = em.createNamedQuery("PrincipalUser.findByUserName", type);
try {
return query.setParameter("userName", userName).getSingleResult();
} catch (NoResultException ex) {
return null;
}
} | java | {
"resource": ""
} |
q163549 | PrincipalUser.setEmail | train | public void setEmail(String email) {
SystemAssert.requireArgument(email != null && !email.isEmpty(), "Email cannot be null or empty.");
this.email = email;
} | java | {
"resource": ""
} |
q163550 | PrincipalUser.setUserName | train | public void setUserName(String userName) {
SystemAssert.requireArgument(userName != null && !userName.isEmpty(), "Username cannot be null or empty.");
this.userName = userName;
} | java | {
"resource": ""
} |
q163551 | AuthService.login | train | public void login(String username, String password) throws IOException {
String requestUrl = RESOURCE + "/login";
Credentials creds = new Credentials();
creds.setPassword(password);
creds.setUsername(username);
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.POST, requestUrl, creds);
try {
assertValidResponse(response, requestUrl);
} catch (TokenExpiredException e) {
//This should never happen
throw new RuntimeException("This should never happen. login() method should never throw a TokenExpiredException", e);
}
Map<String, String> tokens = fromJson(response.getResult(), new TypeReference<Map<String, String>>() {});
getClient().accessToken = tokens.get("accessToken");
getClient().refreshToken = tokens.get("refreshToken");
} | java | {
"resource": ""
} |
q163552 | DashboardDto.transformToDto | train | public static DashboardDto transformToDto(Dashboard dashboard) {
if (dashboard == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
DashboardDto result = createDtoObject(DashboardDto.class, dashboard);
result.setOwnerName(dashboard.getOwner().getUserName());
return result;
} | java | {
"resource": ""
} |
q163553 | DashboardDto.transformToDto | train | public static List<DashboardDto> transformToDto(List<Dashboard> dashboards) {
if (dashboards == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
List<DashboardDto> result = new ArrayList<DashboardDto>();
for (Dashboard dashboard : dashboards) {
result.add(transformToDto(dashboard));
}
return result;
} | java | {
"resource": ""
} |
q163554 | DashboardDto.setTemplateVars | train | public void setTemplateVars(List<TemplateVar> templateVars) {
this.templateVars.clear();
if(templateVars != null && !templateVars.isEmpty()) {
this.templateVars.addAll(templateVars);
}
} | java | {
"resource": ""
} |
q163555 | EndpointHelpDto.fromResourceClass | train | public static EndpointHelpDto fromResourceClass(Class<? extends AbstractResource> resourceClass) {
Path path = resourceClass.getAnnotation(Path.class);
Description description = resourceClass.getAnnotation(Description.class);
if (path != null && description != null) {
EndpointHelpDto result = new EndpointHelpDto();
result.setDescription(description.value());
result.setEndpoint(path.value());
return result;
} else {
return null;
}
} | java | {
"resource": ""
} |
q163556 | JWTUtils.getUsername | train | public static String getUsername(String token) {
String accessTokenPayload = token.substring(token.indexOf(".") + 1, token.lastIndexOf(".") );
byte[] decoded = Base64.getMimeDecoder().decode(accessTokenPayload);
String output = new String(decoded);
Map<String,Object> myMap = new HashMap<String, Object>();
String result = "unknown";
ObjectMapper objectMapper = new ObjectMapper();
try {
myMap = objectMapper.readValue(output, HashMap.class);
if(myMap.get("sub") instanceof String) {
result = (String) myMap.get("sub");
}
} catch (IOException e) {
e.printStackTrace();
}
return result;
} | java | {
"resource": ""
} |
q163557 | QueueBasedDistributedSchedulingService._setServiceEnabled | train | @Transactional
protected void _setServiceEnabled(boolean enabled) {
synchronized (_serviceManagementRecordService) {
ServiceManagementRecord record = _serviceManagementRecordService.findServiceManagementRecord(Service.SCHEDULING);
if (record == null) {
record = new ServiceManagementRecord(_userService.findAdminUser(), Service.SCHEDULING, enabled);
}
record.setEnabled(enabled);
_serviceManagementRecordService.updateServiceManagementRecord(record);
}
} | java | {
"resource": ""
} |
q163558 | PrincipalUserDto.transformToDto | train | public static PrincipalUserDto transformToDto(PrincipalUser user) {
if (user == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
PrincipalUserDto result = createDtoObject(PrincipalUserDto.class, user);
for (Dashboard dashboard : user.getOwnedDashboards()) {
result.addOwnedDashboardId(dashboard.getId());
}
return result;
} | java | {
"resource": ""
} |
q163559 | MetricSchemaRecord.getStringValueForType | train | @Nullable
public String getStringValueForType(SchemaService.RecordType type) {
switch (type) {
case NAMESPACE:
return getNamespace();
case SCOPE:
return getScope();
case METRIC:
return getMetric();
case TAGK:
return getTagKey();
case TAGV:
return getTagValue();
case RETENTION_DISCOVERY:
return getRetentionDiscovery()==null?null:getRetentionDiscovery().toString();
default:
return null;
}
} | java | {
"resource": ""
} |
q163560 | AsyncHbaseSchemaService._canSkipWhileScanning | train | private boolean _canSkipWhileScanning(MetricSchemaRecordQuery query, RecordType type) {
if( (RecordType.METRIC.equals(type) || RecordType.SCOPE.equals(type))
&& !SchemaService.containsFilter(query.getTagKey())
&& !SchemaService.containsFilter(query.getTagValue())
&& !SchemaService.containsFilter(query.getNamespace())) {
if(RecordType.METRIC.equals(type) && !SchemaService.containsFilter(query.getMetric())) {
return false;
}
if(RecordType.SCOPE.equals(type) && !SchemaService.containsFilter(query.getScope())) {
return false;
}
return true;
}
return false;
} | java | {
"resource": ""
} |
q163561 | AsyncHbaseSchemaService._constructScanMetadata | train | private ScanMetadata _constructScanMetadata(MetricSchemaRecordQuery query) {
ScanMetadata metadata = new ScanMetadata();
char[] scopeTableRowKey = _constructRowKey(query.getNamespace(), query.getScope(), query.getMetric(), query.getTagKey(), query.getTagValue(),
SCOPE_SCHEMA_TABLENAME).toCharArray();
char[] metricTableRowKey = _constructRowKey(query.getNamespace(), query.getScope(), query.getMetric(), query.getTagKey(), query.getTagValue(),
METRIC_SCHEMA_TABLENAME).toCharArray();
// Find first occurrence of any wildcard character in both rowKeys.
// Everything until this character will represent our entry point into the table.
// We will therefore use the corresponding table where the index of wildcard in the rowKey is higher.
int i = 0, j = 0;
for (; (i < scopeTableRowKey.length && j < metricTableRowKey.length); i++, j++) {
if (SchemaService.isWildcardCharacter(scopeTableRowKey[i]) || SchemaService.isWildcardCharacter(metricTableRowKey[j])) {
break;
}
}
while (i < scopeTableRowKey.length && !SchemaService.isWildcardCharacter(scopeTableRowKey[i])) {
i++;
}
while (j < metricTableRowKey.length && !SchemaService.isWildcardCharacter(metricTableRowKey[j])) {
j++;
}
// If the first wildcard character is OR, then we have to backtrack until the last ROW_SEPARATOR occurrence.
if (i < scopeTableRowKey.length && scopeTableRowKey[i] == '|') {
while (i >= 0 && scopeTableRowKey[i] != ROWKEY_SEPARATOR) {
i--;
}
i++;
}
if (j < metricTableRowKey.length && metricTableRowKey[j] == '|') {
while (j >= 0 && metricTableRowKey[j] != ROWKEY_SEPARATOR) {
j--;
}
j++;
}
int indexOfWildcard;
String rowKey;
if (i < j) {
metadata.tableName = METRIC_SCHEMA_TABLENAME;
indexOfWildcard = j;
rowKey = new String(metricTableRowKey);
} else {
metadata.tableName = SCOPE_SCHEMA_TABLENAME;
indexOfWildcard = i;
rowKey = new String(scopeTableRowKey);
}
String start = rowKey.substring(0, indexOfWildcard);
metadata.startRow = start.getBytes(Charset.forName("UTF-8"));
String end = "";
if (indexOfWildcard > 0) {
// Also determine the character before the wildcard and increment it by 1.
// This will represent the stopping condition for our scan.
char prev = rowKey.charAt(indexOfWildcard - 1);
char prevPlusOne = (char) (prev + 1);
end = rowKey.substring(0, indexOfWildcard - 1) + prevPlusOne;
}
metadata.stopRow = end.getBytes(Charset.forName("UTF-8"));
return metadata;
} | java | {
"resource": ""
} |
q163562 | DiscoveryService.getMatchingRecords | train | public List<MetricSchemaRecord> getMatchingRecords(String namespaceRegex, String scopeRegex, String metricRegex, String tagKeyRegex,
String tagValueRegex, int limit) throws IOException, TokenExpiredException {
StringBuilder urlBuilder = _buildBaseUrl(namespaceRegex, scopeRegex, metricRegex, tagKeyRegex, tagValueRegex, limit);
String requestUrl = urlBuilder.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<MetricSchemaRecord>>() { });
} | java | {
"resource": ""
} |
q163563 | DiscoveryService.getMatchingRecordFields | train | public List<String> getMatchingRecordFields(String namespaceRegex, String scopeRegex, String metricRegex, String tagKeyRegex,
String tagValueRegex, FieldSelector type, int limit) throws IOException, TokenExpiredException {
StringBuilder urlBuilder = _buildBaseUrl(namespaceRegex, scopeRegex, metricRegex, tagKeyRegex, tagValueRegex, limit);
urlBuilder.append("&type=").append(type.name().toLowerCase(Locale.ENGLISH));
String requestUrl = urlBuilder.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<String>>() { });
} | java | {
"resource": ""
} |
q163564 | ClientNode.calculateAllNodesResult | train | public ClientsResult calculateAllNodesResult() {
final List<String> childNodePaths = getChildren(electionRootPath, false);
_logger.info("Total peers = {} ", childNodePaths.size());
Collections.sort(childNodePaths);
int index = childNodePaths.indexOf(clientNodePath.substring(clientNodePath.lastIndexOf('/') + 1));
return new ClientsResult(index, childNodePaths.size());
} | java | {
"resource": ""
} |
q163565 | ClientNode.createNode | train | public String createNode(final String path, final boolean watch, final boolean ephimeral) {
String createdNodePath = null;
try {
final Stat nodeStat = zooKeeper.exists(path, watch);
if(nodeStat == null) {
createdNodePath = zooKeeper.create(path, new byte[0], Ids.OPEN_ACL_UNSAFE, (ephimeral ? CreateMode.EPHEMERAL_SEQUENTIAL : CreateMode.PERSISTENT));
} else {
createdNodePath = path;
}
} catch (KeeperException | InterruptedException e) {
throw new IllegalStateException(e);
}
return createdNodePath;
} | java | {
"resource": ""
} |
q163566 | ClientNode.getChildren | train | public List<String> getChildren(final String path, final boolean watch) {
List<String> childNodes = null;
try {
childNodes = zooKeeper.getChildren(path, watch);
} catch (KeeperException | InterruptedException e) {
throw new IllegalStateException(e);
}
return childNodes;
} | java | {
"resource": ""
} |
q163567 | Namespace.findByQualifier | train | public static Namespace findByQualifier(EntityManager em, String qualifier) {
SystemAssert.requireArgument(em != null, "EntityManager cannot be null.");
SystemAssert.requireArgument(qualifier != null && !qualifier.isEmpty(), "Namespace qualifier cannot be null or empty.");
TypedQuery<Namespace> query = em.createNamedQuery("Namespace.findByQualifier", Namespace.class);
try {
return query.setParameter("qualifier", qualifier).getSingleResult();
} catch (NoResultException ex) {
return null;
}
} | java | {
"resource": ""
} |
q163568 | Namespace.findByOwner | train | public static List<Namespace> findByOwner(EntityManager em, PrincipalUser owner) {
SystemAssert.requireArgument(em != null, "EntityManager cannot be null.");
SystemAssert.requireArgument(owner != null, "Owner cannot be null or empty.");
TypedQuery<Namespace> query = em.createNamedQuery("Namespace.findByOwner", Namespace.class);
try {
return query.setParameter("owner", owner).getResultList();
} catch (NoResultException ex) {
return new ArrayList<>(0);
}
} | java | {
"resource": ""
} |
q163569 | Namespace.setQualifier | train | public void setQualifier(String qualifier) {
SystemAssert.requireArgument(qualifier != null && !qualifier.isEmpty(), "Namespace qualifier cannot be null or empty.");
this.qualifier = qualifier;
} | java | {
"resource": ""
} |
q163570 | Namespace.addUser | train | public void addUser(PrincipalUser user) {
SystemAssert.requireArgument(user != null, "Null user can not be added.");
users.add(user);
} | java | {
"resource": ""
} |
q163571 | History.findHistoryByJob | train | public static List<History> findHistoryByJob(EntityManager em, BigInteger jobId, int limit) {
requireArgument(em != null, "Entity manager cannot be null.");
requireArgument(jobId != null, "The jobId cannot be null.");
requireArgument(limit > 0, "Limit must be a positive integer.");
TypedQuery<History> query = em.createNamedQuery("History.findByJob", History.class);
query.setMaxResults(limit);
try {
query.setParameter("entityId", jobId);
return query.getResultList();
} catch (NoResultException ex) {
return new ArrayList<History>(0);
}
} | java | {
"resource": ""
} |
q163572 | History.deleteExpiredHistory | train | public static int deleteExpiredHistory(EntityManager em) {
requireArgument(em != null, "Entity manager cannot be null.");
Query query = em.createNamedQuery("History.cullExpired");
query.setParameter("expiryTime", System.currentTimeMillis() - (2 * MILLIS_PER_WEEK));
return query.executeUpdate();
} | java | {
"resource": ""
} |
q163573 | History.setMessage | train | public void setMessage(String message) {
requireArgument(message != null && !message.isEmpty(), "Message cannot be null or empty.");
this.message = message;
} | java | {
"resource": ""
} |
q163574 | History.setHostName | train | public void setHostName(String hostName) {
requireArgument(hostName != null && !hostName.isEmpty(), "Hostname cannot be null or empty.");
this.hostName = hostName;
} | java | {
"resource": ""
} |
q163575 | AnnotationDto.transformToDto | train | public static AnnotationDto transformToDto(Annotation annotation) {
if (annotation == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
AnnotationDto result = createDtoObject(AnnotationDto.class, annotation);
return result;
} | java | {
"resource": ""
} |
q163576 | AlertDto.transformToDto | train | public static AlertDto transformToDto(Alert alert) {
if (alert == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
AlertDto result = createDtoObject(AlertDto.class, alert);
result.setOwnerName(alert.getOwner().getUserName());
for (Trigger trigger : alert.getTriggers()) {
result.addTriggersIds(trigger);
}
for (Notification notification : alert.getNotifications()) {
result.addNotificationsIds(notification);
}
return result;
} | java | {
"resource": ""
} |
q163577 | Audit.findByHostName | train | public static List<Audit> findByHostName(EntityManager em, String hostName) {
requireArgument(em != null, "Entity manager cannot be null.");
requireArgument(hostName != null && !hostName.isEmpty(), "Host name cannot be null or empty.");
TypedQuery<Audit> query = em.createNamedQuery("Audit.findByHostName", Audit.class);
try {
query.setParameter("hostName", hostName);
return query.getResultList();
} catch (NoResultException ex) {
return new ArrayList<Audit>(0);
}
} | java | {
"resource": ""
} |
q163578 | Audit.findByEntityHostnameMessage | train | @SuppressWarnings("unchecked")
public static List<Audit> findByEntityHostnameMessage(EntityManager em, JPAEntity entity, String hostName, String message) {
boolean isAndrequired = false;
StringBuilder queryString = new StringBuilder("SELECT a FROM Audit a ");
if (entity != null) {
isAndrequired = true;
queryString.append(" WHERE a.entityId=:entityId ");
}
if (hostName != null && !hostName.isEmpty()) {
if (isAndrequired) {
queryString.append(" AND ");
} else {
isAndrequired = true;
queryString.append(" WHERE ");
}
queryString.append(" a.hostName = :hostName ");
}
if (message != null && !message.isEmpty()) {
if (isAndrequired) {
queryString.append(" AND ");
} else {
isAndrequired = true;
queryString.append(" WHERE ");
}
queryString.append(" a.message LIKE :message ");
}
Query query = em.createQuery(queryString.toString(), Audit.class);
if (entity != null) {
query.setParameter("entityId", entity.getId());
}
if (hostName != null && !hostName.isEmpty()) {
query.setParameter("hostName", hostName);
}
if (message != null && !message.isEmpty()) {
query.setParameter("message", "%" + message + "%");
}
return query.getResultList();
} | java | {
"resource": ""
} |
q163579 | Audit.findByMessage | train | public static List<Audit> findByMessage(EntityManager em, String message) {
requireArgument(em != null, "Entity manager cannot be null.");
requireArgument(message != null && !message.isEmpty(), "Message cannot be null or empty.");
TypedQuery<Audit> query = em.createNamedQuery("Audit.findByMessage", Audit.class);
try {
query.setParameter("message", "%" + message + "%");
return query.getResultList();
} catch (Exception ex) {
return new ArrayList<Audit>(0);
}
} | java | {
"resource": ""
} |
q163580 | Dashboard.findByNameAndOwner | train | public static Dashboard findByNameAndOwner(EntityManager em, String dashboardName, PrincipalUser owner) {
TypedQuery<Dashboard> query = em.createNamedQuery("Dashboard.findByNameAndOwner", Dashboard.class);
try {
query.setParameter("name", dashboardName);
query.setParameter("owner", owner);
return query.getSingleResult();
} catch (NoResultException ex) {
return null;
}
} | java | {
"resource": ""
} |
q163581 | Dashboard.findSharedDashboards | train | public static List<Dashboard> findSharedDashboards(EntityManager em, PrincipalUser owner, Integer limit, String version) {
requireArgument(em != null, "Entity manager can not be null.");
TypedQuery<Dashboard> query;
if(owner == null){
if (version==null) {
query = em.createNamedQuery("Dashboard.getSharedDashboards", Dashboard.class);
}
else {
query = em.createNamedQuery("Dashboard.getSharedDashboardsByVersion", Dashboard.class);
query.setParameter("version",version);
}
} else {
if(version==null) {
query = em.createNamedQuery("Dashboard.getSharedDashboardsByOwner", Dashboard.class);
query.setParameter("owner", owner);
}
else {
query = em.createNamedQuery("Dashboard.getSharedDashboardsByOwnerAndByVersion", Dashboard.class);
query.setParameter("owner", owner);
query.setParameter("version",version);
}
}
query.setHint("javax.persistence.cache.storeMode", "REFRESH");
if(limit!= null){
query.setMaxResults(limit);
}
try {
return query.getResultList();
} catch (NoResultException ex) {
return new ArrayList<>(0);
}
} | java | {
"resource": ""
} |
q163582 | Dashboard.findSharedDashboardsMeta | train | public static List<Dashboard> findSharedDashboardsMeta(EntityManager em, PrincipalUser owner, Integer limit, String version) {
requireArgument(em != null, "Entity manager can not be null.");
try {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Tuple> cq = cb.createTupleQuery();
Root<Dashboard> e = cq.from(Dashboard.class);
List<Selection<?>> fieldsToSelect = new ArrayList<>();
for(Field field : FieldUtils.getFieldsListWithAnnotation(Dashboard.class, Metadata.class)) {
fieldsToSelect.add(e.get(field.getName()).alias(field.getName()));
}
cq.multiselect(fieldsToSelect);
if(owner != null){
cq.where(cb.equal(e.get("shared"), true), cb.equal(e.get("owner"), owner), version==null?cb.isNull(e.get("version")):cb.equal(e.get("version"), version));
} else{
cq.where(cb.equal(e.get("shared"), true),version==null?cb.isNull(e.get("version")):cb.equal(e.get("version"), version));
}
return _readDashboards(em, cq, limit);
} catch (NoResultException ex) {
return new ArrayList<>(0);
}
} | java | {
"resource": ""
} |
q163583 | Dashboard.findDashboards | train | public static List<Dashboard> findDashboards(EntityManager em, Integer limit, String version) {
requireArgument(em != null, "Entity manager can not be null.");
TypedQuery<Dashboard> query;
if(version==null) {
query= em.createNamedQuery("Dashboard.getDashboards", Dashboard.class);
}
else
{
query = em.createNamedQuery("Dashboard.getDashboardsByVersion", Dashboard.class);
query.setParameter("version",version);
}
try {
if (limit != null) {
query.setMaxResults(limit);
}
return query.getResultList();
} catch (NoResultException ex) {
return new ArrayList<>(0);
}
} | java | {
"resource": ""
} |
q163584 | Dashboard.setName | train | public void setName(String name) {
SystemAssert.requireArgument(name != null && !name.isEmpty(), "Dashboard Name cannot be null or empty");
this.name = name;
} | java | {
"resource": ""
} |
q163585 | MetricUnionTransform.union | train | public List<Metric> union(List<Metric> metrics) {
SystemAssert.requireArgument(metrics != null, "Cannot transform empty metric/metrics");
if (metrics.isEmpty()) {
return metrics;
}
Metric newMetric = reduce(metrics);
Map<Long, Double> reducedDatapoints = newMetric.getDatapoints();
Set<Long> sharedTimestamps = reducedDatapoints.keySet();
Map<Long, Double> unionDatapoints = new TreeMap<>();
for (Metric metric : metrics) {
for (Map.Entry<Long, Double> entry : metric.getDatapoints().entrySet()) {
if (!sharedTimestamps.contains(entry.getKey())) {
unionDatapoints.put(entry.getKey(), entry.getValue());
}
}
}
newMetric.addDatapoints(unionDatapoints);
return Arrays.asList(newMetric);
} | java | {
"resource": ""
} |
q163586 | Trigger.setInertia | train | public void setInertia(Long inertiaMillis) {
if (this.alert == null) { // Only during deserialization.
this.inertia = inertiaMillis;
} else {
requireArgument(inertiaMillis != null && inertiaMillis >= 0, "Inertia cannot be negative.");
Long longestIntervalLength = AlertUtils.getMaximumIntervalLength(this.alert.getExpression());
if (inertiaMillis > longestIntervalLength)
throw new IllegalArgumentException(String.format("Inertia %d cannot be more than width of the longest interval %d.", inertiaMillis, longestIntervalLength));
this.inertia = inertiaMillis;
}
} | java | {
"resource": ""
} |
q163587 | MetatagsRecord.getMetatags | train | public Map<String, String> getMetatags() {
Map<String, String> result = new HashMap<>();
for (Map.Entry<String, String> entry : _metatags.entrySet()) {
String key = entry.getKey();
if (!ReservedField.isReservedField(key)) {
result.put(key, entry.getValue());
}
}
return Collections.unmodifiableMap(result);
} | java | {
"resource": ""
} |
q163588 | MetatagsRecord.setMetatags | train | public void setMetatags(Map<String, String> metatags, String key) {
if (metatags != null) {
TSDBEntity.validateTags(metatags);
_metatags.clear();
_metatags.putAll(metatags);
_key = key;
}
} | java | {
"resource": ""
} |
q163589 | TSDBEntityDto.createDtoObject | train | public static <D extends TSDBEntityDto, E extends TSDBEntity> D createDtoObject(Class<D> clazz, E tsdbEntity) {
D result = null;
try {
result = clazz.newInstance();
BeanUtils.copyProperties(result, tsdbEntity);
} catch (Exception ex) {
throw new WebApplicationException("DTO transformation failed.", Status.INTERNAL_SERVER_ERROR);
}
return result;
} | java | {
"resource": ""
} |
q163590 | GusNotifier.getHttpClient | train | public HttpClient getHttpClient(SystemConfiguration config) {
HttpClient httpclient = new HttpClient(theConnectionManager);
// Wait for 2 seconds to get a connection from pool
httpclient.getParams().setParameter("http.connection-manager.timeout", 2000L);
String host = config.getValue(Property.GUS_PROXY_HOST.getName(), Property.GUS_PROXY_HOST.getDefaultValue());
if (host != null && host.length() > 0) {
httpclient.getHostConfiguration().setProxy(host,
Integer.parseInt(config.getValue(Property.GUS_PROXY_PORT.getName(), Property.GUS_PROXY_PORT.getDefaultValue())));
}
return httpclient;
} | java | {
"resource": ""
} |
q163591 | MetricQuery.getTSDBMetricName | train | @JsonIgnore
public String getTSDBMetricName() {
StringBuilder sb = new StringBuilder();
sb.append(getMetric()).append(DefaultTSDBService.DELIMITER).append(getScope());
if (_namespace != null && !_namespace.isEmpty()) {
sb.append(DefaultTSDBService.DELIMITER).append(getNamespace());
}
return sb.toString();
} | java | {
"resource": ""
} |
q163592 | ItemsCountDto.transformToDto | train | public static ItemsCountDto transformToDto(int value) {
if (value < 0) {
throw new WebApplicationException("Items count cannot be negative", Status.INTERNAL_SERVER_ERROR);
}
ItemsCountDto result = new ItemsCountDto();
result.setValue(value);
return result;
} | java | {
"resource": ""
} |
q163593 | Consumer.initializeTopic | train | public void initializeTopic(String topic) {
if (_topics.get(topic) == null) {
synchronized (this) {
if (_topics.get(topic) == null) {
_logger.info("Initializing streams for topic: {}", topic);
Properties props = new Properties();
props.setProperty("zookeeper.connect",
_configuration.getValue(Property.ZOOKEEPER_CONNECT.getName(), Property.ZOOKEEPER_CONNECT.getDefaultValue()));
props.setProperty("group.id",
_configuration.getValue(Property.KAFKA_CONSUMER_GROUPID.getName(), Property.KAFKA_CONSUMER_GROUPID.getDefaultValue()));
props.setProperty("auto.offset.reset", _configuration.getValue(Property.KAFKA_CONSUMER_OFFSET_RESET.getName(), Property.KAFKA_CONSUMER_OFFSET_RESET.getDefaultValue()));
props.setProperty("auto.commit.interval.ms", "60000");
props.setProperty("fetch.message.max.bytes", "2000000");
ConsumerConnector consumer = kafka.consumer.Consumer.createJavaConsumerConnector(new ConsumerConfig(props));
List<KafkaStream<byte[], byte[]>> streams = _createStreams(consumer, topic);
Topic t = new Topic(topic, consumer, streams.size());
_topics.put(topic, t);
_startStreamingMessages(topic, streams);
}
}
}
} | java | {
"resource": ""
} |
q163594 | Consumer._startStreamingMessages | train | private void _startStreamingMessages(String topic, List<KafkaStream<byte[], byte[]>> streams) {
ExecutorService executorService = _topics.get(topic).getStreamExecutorService();
for (final KafkaStream<byte[], byte[]> stream : streams) {
executorService.submit(new KafkaConsumer(stream));
}
} | java | {
"resource": ""
} |
q163595 | Consumer.dequeueFromBuffer | train | public <T extends Serializable> List<T> dequeueFromBuffer(String topic, Class<T> type, int timeout, int limit) {
List<T> result = new ArrayList<T>();
long cutoff = System.currentTimeMillis() + timeout;
BlockingQueue<String> queue = _topics.get(topic).getMessages();
while (System.currentTimeMillis() < cutoff && (limit < 0 || result.size() < limit)) {
if (Thread.currentThread().isInterrupted()) {
break;
}
try {
String message = queue.poll(timeout, TimeUnit.MILLISECONDS);
if (message != null && !message.isEmpty()) {
if (String.class.isAssignableFrom(type)) {
result.add(type.cast(message));
} else {
result.add(_mapper.readValue(message, type));
}
if (result.size() % 1000 == 0) {
_logger.debug("Dequeued {} messages from local buffer.", result.size());
}
}
} catch (InterruptedException e) {
_logger.warn("Interrupted while waiting for poll() to return a message.");
Thread.currentThread().interrupt();
} catch (IOException e) {
_logger.warn("Exception while deserializing message to type: " + type + ". Skipping this message.", e);
}
}
return result;
} | java | {
"resource": ""
} |
q163596 | Consumer.shutdown | train | public void shutdown() {
for (Topic topic : _topics.values()) {
if (topic.getConsumerConnector() != null) {
topic.getConsumerConnector().shutdown();
}
topic.getStreamExecutorService().shutdownNow();
try {
topic.getStreamExecutorService().awaitTermination(60, TimeUnit.SECONDS);
} catch (InterruptedException e) {
_logger.warn("Stream executor service was interrupted while awaiting termination. This should never happen.");
}
}
_logger.debug("Pushing unflushed messages back to Kafka.");
Producer producer = new Producer(_configuration);
for (Map.Entry<String, Topic> entry : _topics.entrySet()) {
String topicName = entry.getKey();
Topic topic = entry.getValue();
List<String> unflushedMessages = new ArrayList<String>();
if (!topic.getMessages().isEmpty()) {
topic.getMessages().drainTo(unflushedMessages);
producer.enqueue(topicName, unflushedMessages);
}
_logger.debug("{} messages for topic {} enqueued on Kafka queue", unflushedMessages.size(), topicName);
}
producer.shutdown();
} | java | {
"resource": ""
} |
q163597 | Cron.shouldRun | train | public static boolean shouldRun(String entry, Date atTime) {
entry = entry.trim().toUpperCase();
if (ANNUALLY.equals(entry) || (YEARLY.equals(entry))) {
entry = "0 0 1 1 *";
} else if (MONTHLY.equals(entry)) {
entry = "0 0 1 * *";
} else if (WEEKLY.equals(entry)) {
entry = "0 0 * * 0";
} else if (DAILY.equals(entry) || (MIDNIGHT.equals(entry))) {
entry = "0 0 * * *";
} else if (HOURLY.equals(entry)) {
entry = "0 * * * *";
}
return new CronTabEntry(entry).isRunnable(atTime);
} | java | {
"resource": ""
} |
q163598 | Cron.isValid | train | public static boolean isValid(String entry) {
boolean result = true;
try {
shouldRun(entry);
} catch (Exception ex) {
result = false;
}
return result;
} | java | {
"resource": ""
} |
q163599 | AuditService.getAuditsForEntity | train | public List<Audit> getAuditsForEntity(BigInteger entityId) throws IOException, TokenExpiredException {
String requestUrl = RESOURCE + "/entity/" + entityId.toString();
ArgusResponse response = getClient().executeHttpRequest(ArgusHttpClient.RequestType.GET, requestUrl, null);
assertValidResponse(response, requestUrl);
return fromJson(response.getResult(), new TypeReference<List<Audit>>() { });
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.