_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168000 | TemplateUtils.permissions | validation | public static String[] permissions(final Permission... permissions)
{
final List<String> values = new ArrayList<>(permissions.length);
for (Permission permission : permissions)
{
values.add(permission.getValue());
}
return values.toArray(new String[values.size()]);
} | java | {
"resource": ""
} |
q168001 | TemplateUtils.allOfGroup | validation | public static List<String[]> allOfGroup(final String... args)
{
return Collections.singletonList(args == null ? new String[0] : args);
} | java | {
"resource": ""
} |
q168002 | ViewSupport.viewRestrict | validation | public boolean viewRestrict(final List<String[]> roles,
final DeadboltHandler handler,
final Optional<String> content,
final long timeoutInMillis,
final Http.RequestHeader requestHeader) throws Throwable
{
boolean allowed;
try
{
allowed = constraintLogic.restrict(requestHeader,
handler(handler),
content,
() -> roles,
rh -> CompletableFuture.completedFuture(Boolean.TRUE),
(rh, dh, cnt) -> CompletableFuture.completedFuture(Boolean.FALSE),
ConstraintPoint.TEMPLATE)
.toCompletableFuture()
.get(timeoutInMillis,
TimeUnit.MILLISECONDS);
}
catch (TimeoutException e)
{
allowed = timeoutHandler.apply(timeoutInMillis,
e);
}
return allowed;
} | java | {
"resource": ""
} |
q168003 | Encoder.overflow | validation | static CoderResult overflow(CharBuffer input, int i, CharBuffer output, int j) {
input.position(i - input.arrayOffset());
output.position(j - output.arrayOffset());
return CoderResult.OVERFLOW;
} | java | {
"resource": ""
} |
q168004 | Encoder.underflow | validation | static CoderResult underflow(CharBuffer input, int i, CharBuffer output, int j) {
input.position(i - input.arrayOffset());
output.position(j - output.arrayOffset());
return CoderResult.UNDERFLOW;
} | java | {
"resource": ""
} |
q168005 | ASCIIBits.set | validation | ASCIIBits set(int min, int max) {
// There are faster bit-twiddling tricks to accomplish the same
// thing as below. Minor optimization for later.
int i=min;
for (int n = Math.min(max,63) ; i<=n ; ++i) {
_lowerMask |= (1L << i);
}
for ( ; i<=max ; ++i) {
_upperMask |= (1L << i);
}
return this;
} | java | {
"resource": ""
} |
q168006 | Encode.encode | validation | static String encode(Encoder encoder, String str) {
if (str == null) {
// consistent with String.valueOf(...) use "null" for null.
str = "null";
}
// quick pass--see if we need to actually encode anything, if not
// return the value unchanged.
final int n = str.length();
int j = encoder.firstEncodedOffset(str, 0, n);
if (j == n) {
return str;
}
// otherwise, we need to encode. We use a buffer to avoid
// excessive memory allocation for these calls. Note: this means that
// an encoder implementation must NEVER call this method internally.
return new Buffer().encode(encoder, str, j);
} | java | {
"resource": ""
} |
q168007 | Encode.encode | validation | static void encode(Encoder encoder, Writer out, String str)
throws IOException
{
if (str == null) {
// consistent with String.valueOf(...) use "null" for null.
str = "null";
}
// quick pass--see if we need to actually encode anything, if not
// return the value unchanged.
final int n = str.length();
int j = encoder.firstEncodedOffset(str, 0, n);
if (j == n) {
out.write(str);
return;
}
// otherwise, we need to encode. We use a buffer to avoid
// excessive memory allocation for these calls. Note: this means that
// an encoder implementation must NEVER call this method internally.
new Buffer().encode(encoder, out, str, j);
} | java | {
"resource": ""
} |
q168008 | Encoders.map | validation | private static <T extends Encoder> T map(String name, T encoder) {
Encoder old = ENCODERS_MAP.put(name, encoder);
assert old == null;
return encoder;
} | java | {
"resource": ""
} |
q168009 | Encoders.forName | validation | public static Encoder forName(String contextName) throws NullPointerException, UnsupportedContextException {
if (contextName == null) {
throw new NullPointerException();
}
Encoder encoder = ENCODERS_MAP.get(contextName);
if (encoder == null) {
throw new UnsupportedContextException(contextName);
}
return encoder;
} | java | {
"resource": ""
} |
q168010 | HTMLEncoder.append | validation | static int append(char[] src, char[] out, int j) {
System.arraycopy(src, 0, out, j, src.length);
return j + src.length;
} | java | {
"resource": ""
} |
q168011 | ChainedEncoder.encode | validation | public String encode(String str) {
if (str == null) {
str = "null";
}
int n = str.length();
int j = _first.firstEncodedOffset(str, 0, n);
if (j == n) {
// string is unchanged after encoding with the first encoder
return Encode.encode(_last, str);
}
final int remaining = n - j;
final int m = j + _first.maxEncodedLength(n);
CharBuffer input = CharBuffer.allocate(m);
str.getChars(0, j, input.array(), 0);
str.getChars(j, n, input.array(), m - remaining);
input.limit(m).position(m - remaining);
CharBuffer tmp = input.duplicate();
tmp.position(j);
CoderResult cr = _first.encode(input, tmp, true);
assert cr.isUnderflow() : "maxEncodedLength was incorrect";
CharBuffer output = CharBuffer.allocate(_last.maxEncodedLength(tmp.position()));
tmp.flip();
cr = _last.encode(tmp, output, true);
assert cr.isUnderflow() : "maxEncodedLength was incorrect";
return new String(output.array(), 0, output.position());
} | java | {
"resource": ""
} |
q168012 | EncodedWriter.flushBufferToWriter | validation | private void flushBufferToWriter() throws IOException {
_out.write(_buffer.array(), 0, _buffer.position());
_buffer.clear();
} | java | {
"resource": ""
} |
q168013 | EncodedWriter.flushLeftOver | validation | private void flushLeftOver(CharBuffer input) throws IOException {
if (!_hasLeftOver) {
return;
}
for (;;) {
if (input != null && input.hasRemaining()) {
_leftOverBuffer.put(input.get());
}
_leftOverBuffer.flip();
CoderResult cr = _encoder.encode(_leftOverBuffer, _buffer, input == null);
if (cr.isUnderflow()) {
if (_leftOverBuffer.hasRemaining()) {
_leftOverBuffer.compact();
} else {
break;
}
}
if (cr.isOverflow()) {
flushBufferToWriter();
}
}
_hasLeftOver = false;
_leftOverBuffer.clear();
} | java | {
"resource": ""
} |
q168014 | ReactiveSensors.observeSensor | validation | public Flowable<ReactiveSensorEvent> observeSensor(int sensorType, final int samplingPeriodInUs,
final Handler handler, final BackpressureStrategy strategy) {
if (!hasSensor(sensorType)) {
String format = "Sensor with id = %d is not available on this device";
String message = String.format(Locale.getDefault(), format, sensorType);
return Flowable.error(new SensorNotFoundException(message));
}
final Sensor sensor = sensorManager.getDefaultSensor(sensorType);
final SensorEventListenerWrapper wrapper = new SensorEventListenerWrapper();
final SensorEventListener listener = wrapper.create();
return Flowable.create(new FlowableOnSubscribe<ReactiveSensorEvent>() {
@Override public void subscribe(final FlowableEmitter<ReactiveSensorEvent> emitter)
throws Exception {
wrapper.setEmitter(emitter);
if (handler == null) {
sensorManager.registerListener(listener, sensor, samplingPeriodInUs);
} else {
sensorManager.registerListener(listener, sensor, samplingPeriodInUs, handler);
}
}
}, strategy).doOnCancel(new Action() {
@Override public void run() throws Exception {
sensorManager.unregisterListener(listener);
}
});
} | java | {
"resource": ""
} |
q168015 | ResultDeserializer.getText | validation | private String getText(JsonNode node, String propertyName) {
JsonNode childNode = node.get(propertyName);
if (childNode == null) {
return null;
}
return childNode.asText();
} | java | {
"resource": ""
} |
q168016 | QueryExecutor.execute | validation | public Result execute(Query query) throws SonarBreakException, IOException {
URL queryURL = buildURL(sonarURL, query);
log.debug("Built a sonar query url of: " + queryURL.toString());
if (!isURLAvailable(sonarURL, SONAR_CONNECTION_RETRIES)) {
throw new SonarBreakException(String.format("Unable to get a valid response after %d tries", SONAR_CONNECTION_RETRIES));
}
return fetchSonarStatusWithRetries(queryURL, query.getVersion());
} | java | {
"resource": ""
} |
q168017 | QueryExecutor.buildURL | validation | protected static URL buildURL(URL sonarURL, Query query) throws MalformedURLException, IllegalArgumentException {
if (query.getSonarKey() == null || query.getSonarKey().length() == 0) {
throw new IllegalArgumentException("No resource specified in the Query");
}
String sonarPathWithResource = String.format(SONAR_FORMAT_PATH, query.getSonarKey());
return new URL(sonarURL, sonarPathWithResource);
} | java | {
"resource": ""
} |
q168018 | QueryExecutor.fetchSonarStatusWithRetries | validation | private Result fetchSonarStatusWithRetries(URL queryURL, String version) throws IOException, SonarBreakException {
DateTime oneMinuteAgo = DateTime.now().minusSeconds(sonarLookBackSeconds);
DateTime waitUntil = DateTime.now().plusSeconds(waitForProcessingSeconds);
do {
// If this is the first time the job is running on sonar the URL might not be available. Return null and wait.
if (isURLAvailable(queryURL, 1)) {
Result result = fetchSonarStatus(queryURL);
if (result.getVersion().equals(version) && result.getDatetime().isAfter(oneMinuteAgo)) {
log.debug("Found a sonar job run that matches version and in the correct time frame");
return result;
}
String message = String.format("Sleeping while waiting for sonar to process job. Target Version: %s. " +
"Sonar reporting Version: %s. Looking back until: %s Last result time: %s", version,
result.getVersion(), oneMinuteAgo.toString(), result.getDatetime().toString());
log.debug(message);
} else {
log.debug(String.format("Query url not available yet: %s", queryURL));
}
try {
Thread.sleep(SONAR_PROCESSING_WAIT_TIME);
} catch (InterruptedException e) {
// Do nothing
}
} while (!waitUntil.isBeforeNow());
String message = String.format("Timed out while waiting for Sonar. Waited %d seconds. This time can be extended " +
"using the \"waitForProcessingSeconds\" configuration parameter.", waitForProcessingSeconds);
throw new SonarBreakException(message);
} | java | {
"resource": ""
} |
q168019 | QueryExecutor.fetchSonarStatus | validation | private Result fetchSonarStatus(URL queryURL) throws IOException, SonarBreakException {
InputStream in = null;
try {
URLConnection connection = queryURL.openConnection();
connection.setRequestProperty("Accept", "application/json");
in = connection.getInputStream();
String response = IOUtils.toString(in);
return parseResponse(response);
} finally {
IOUtils.closeQuietly(in);
}
} | java | {
"resource": ""
} |
q168020 | QueryExecutor.parseResponse | validation | protected static Result parseResponse(String response) throws SonarBreakException {
ObjectMapper mapper = new ObjectMapper();
final DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
mapper.setDateFormat(df);
List<Result> results;
try {
results = mapper.readValue(response, new TypeReference<List<Result>>() {
});
} catch (IOException e) {
throw new SonarBreakException("Unable to parse the json into a List of QualityGateResults. Json is: " + response, e);
}
if (results == null || results.size() != 1) {
throw new SonarBreakException("Unable to deserialize JSON response: " + response);
}
return results.get(0);
} | java | {
"resource": ""
} |
q168021 | IndyRepositorySession.extractBuildArtifacts | validation | @Override
public RepositoryManagerResult extractBuildArtifacts() throws RepositoryManagerException {
TrackedContentDTO report;
try {
IndyFoloAdminClientModule foloAdmin = indy.module(IndyFoloAdminClientModule.class);
boolean sealed = foloAdmin.sealTrackingRecord(buildContentId);
if (!sealed) {
throw new RepositoryManagerException("Failed to seal content-tracking record for: %s.", buildContentId);
}
report = foloAdmin.getTrackingReport(buildContentId);
} catch (IndyClientException e) {
throw new RepositoryManagerException("Failed to retrieve tracking report for: %s. Reason: %s", e, buildContentId,
e.getMessage());
}
if (report == null) {
throw new RepositoryManagerException("Failed to retrieve tracking report for: %s.", buildContentId);
}
Comparator<Artifact> comp = (one, two) -> one.getIdentifier().compareTo(two.getIdentifier());
List<Artifact> uploads = processUploads(report);
Collections.sort(uploads, comp);
List<Artifact> downloads = processDownloads(report);
Collections.sort(downloads, comp);
try {
StoreKey key = new StoreKey(packageType, StoreType.group, buildContentId);
serviceAccountIndy.stores().delete(key, "[Post-Build] Removing build aggregation group: " + buildContentId);
} catch (IndyClientException e) {
throw new RepositoryManagerException("Failed to retrieve Indy stores module. Reason: %s", e, e.getMessage());
}
Logger logger = LoggerFactory.getLogger(getClass());
logger.info("Returning built artifacts / dependencies:\nUploads:\n {}\n\nDownloads:\n {}\n\n",
StringUtils.join(uploads, "\n "), StringUtils.join(downloads, "\n "));
String log = "";
CompletionStatus status = CompletionStatus.SUCCESS;
try {
promoteToBuildContentSet(uploads);
} catch (RepositoryManagerException rme) {
status = CompletionStatus.FAILED;
log = rme.getMessage();
logger.error("Promotion validation error(s): \n" + log);
userLog.error("Artifact promotion failed. Promotion validation error(s): {}", log);
// prevent saving artifacts and dependencies to a failed build
downloads = Collections.emptyList();
uploads = Collections.emptyList();
}
return new IndyRepositoryManagerResult(uploads, downloads, buildContentId, log, status);
} | java | {
"resource": ""
} |
q168022 | IndyRepositorySession.processUploads | validation | private List<Artifact> processUploads(TrackedContentDTO report)
throws RepositoryManagerException {
Logger logger = LoggerFactory.getLogger(getClass());
Set<TrackedContentEntryDTO> uploads = report.getUploads();
if (uploads != null) {
List<Artifact> builds = new ArrayList<>();
for (TrackedContentEntryDTO upload : uploads) {
String path = upload.getPath();
StoreKey storeKey = upload.getStoreKey();
if (ignoreContent(storeKey.getPackageType(), path)) {
logger.debug("Ignoring upload (matched in ignored-suffixes): {} (From: {})", path, storeKey);
continue;
}
String identifier = computeIdentifier(upload);
logger.info("Recording upload: {}", identifier);
IndyContentClientModule content;
try {
content = indy.content();
} catch (IndyClientException e) {
throw new RepositoryManagerException("Failed to retrieve Indy content module. Reason: %s", e, e.getMessage());
}
RepositoryType repoType = toRepoType(storeKey.getPackageType());
TargetRepository targetRepository = getUploadsTargetRepository(repoType, content);
ArtifactQuality artifactQuality = getArtifactQuality(isTempBuild);
Artifact.Builder artifactBuilder = Artifact.Builder.newBuilder()
.md5(upload.getMd5())
.sha1(upload.getSha1())
.sha256(upload.getSha256())
.size(upload.getSize())
.deployPath(upload.getPath())
.filename(new File(path).getName())
.identifier(identifier)
.targetRepository(targetRepository)
.artifactQuality(artifactQuality);
Artifact artifact = validateArtifact(artifactBuilder.build());
builds.add(artifact);
}
return builds;
}
return Collections.emptyList();
} | java | {
"resource": ""
} |
q168023 | IndyRepositorySession.computeIdentifier | validation | private String computeIdentifier(final TrackedContentEntryDTO transfer) {
String identifier = null;
switch (transfer.getStoreKey().getPackageType()) {
case MAVEN_PKG_KEY:
ArtifactPathInfo pathInfo = ArtifactPathInfo.parse(transfer.getPath());
if (pathInfo != null) {
ArtifactRef aref = new SimpleArtifactRef(pathInfo.getProjectId(), pathInfo.getType(), pathInfo.getClassifier());
identifier = aref.toString();
}
break;
case NPM_PKG_KEY:
NpmPackagePathInfo npmPathInfo = NpmPackagePathInfo.parse(transfer.getPath());
if (npmPathInfo != null) {
NpmPackageRef packageRef = new NpmPackageRef(npmPathInfo.getName(), npmPathInfo.getVersion());
identifier = packageRef.toString();
}
break;
case GENERIC_PKG_KEY:
// handle generic downloads along with other invalid download paths for other package types
break;
default:
// do not do anything by default
logger.warn("Package type {} is not handled by Indy repository session.", transfer.getStoreKey().getPackageType());
break;
}
if (identifier == null) {
identifier = computeGenericIdentifier(transfer.getOriginUrl(), transfer.getLocalUrl(), transfer.getSha256());
}
return identifier;
} | java | {
"resource": ""
} |
q168024 | IndyRepositorySession.computeGenericIdentifier | validation | private String computeGenericIdentifier(String originUrl, String localUrl, String sha256) {
String identifier = originUrl;
if (identifier == null) {
// this is from/to a hosted repository, either the build repo or something like that.
identifier = localUrl;
}
identifier += '|' + sha256;
return identifier;
} | java | {
"resource": ""
} |
q168025 | IndyRepositorySession.validateArtifact | validation | private Artifact validateArtifact(Artifact artifact) throws RepositoryManagerException {
Set<ConstraintViolation<Artifact>> violations = validator.validate(artifact);
if (!violations.isEmpty()) {
throw new RepositoryManagerException("Repository manager returned invalid artifact: " + artifact.toString() + " Constraint Violations: %s", violations);
}
return artifact;
} | java | {
"resource": ""
} |
q168026 | BuildTask.hasConfigDependencyOn | validation | public boolean hasConfigDependencyOn(BuildTask buildTask) {
if (buildTask == null || this.equals(buildTask)) {
return false;
}
BuildConfiguration buildConfiguration = buildConfigurationAudited.getBuildConfiguration();
if (buildConfiguration == null || buildConfiguration.getAllDependencies() == null) {
return false;
}
return buildConfiguration.dependsOn(buildTask.getBuildConfigurationAudited().getBuildConfiguration());
} | java | {
"resource": ""
} |
q168027 | BuildTask.hasDirectConfigDependencyOn | validation | public boolean hasDirectConfigDependencyOn(BuildTask buildTask) {
if (buildTask == null || this.equals(buildTask)) {
return false;
}
BuildConfiguration buildConfiguration = buildConfigurationAudited.getBuildConfiguration();
if (buildConfiguration == null || buildConfiguration.getDependencies() == null) {
return false;
}
return buildConfiguration.getDependencies().contains(buildTask.getBuildConfigurationAudited().getBuildConfiguration());
} | java | {
"resource": ""
} |
q168028 | ConfigurationJSONParser.parseJSONPNCConfig | validation | public <T extends AbstractModuleConfig> T parseJSONPNCConfig(
String configContent, ConfigProvider<T> provider) throws ConfigurationParseException {
try {
ObjectMapper mapper = new ObjectMapper();
provider.registerProvider(mapper);
PNCModuleGroup pncGroup = getModuleGroup(mapper, configContent,
PNCModuleGroup.class);
for (AbstractModuleConfig config : pncGroup.getConfigs()) {
if (config.getClass().isAssignableFrom(provider.getType())) {
return (T) config;
}
}
throw new ConfigurationParseException("Did not find config for provider " + provider.getType().getSimpleName() + ".");
} catch (IOException | RuntimeException e) {
log.error(e.getMessage());
throw new ConfigurationParseException("Config could not be parsed", e);
}
} | java | {
"resource": ""
} |
q168029 | IndyRunningDeletion.monitor | validation | @Override
public void monitor(Consumer<CompletedRepositoryDeletion> onComplete, Consumer<Exception> onError) {
try {
StoreKey fromKey = new StoreKey(pakageType, fromType, fromId);
if (indy.stores().exists(fromKey)) {
indy.stores().delete(fromKey, "Deleting artifacts for PNC build");
}
onComplete.accept(new IndyCompletedDeletion(true));
} catch (IndyClientException e) {
onError.accept(e);
}
} | java | {
"resource": ""
} |
q168030 | BuildSetTask.taskStatusUpdatedToFinalState | validation | public void taskStatusUpdatedToFinalState() {
// If any of the build tasks have failed or all are complete, then the build set is done
if(buildTasks.stream().anyMatch(bt -> bt.getStatus().equals(BuildCoordinationStatus.CANCELLED))) {
log.debug("Marking build set as CANCELLED as one or more tasks were cancelled. BuildSetTask: {}", this);
if (log.isDebugEnabled()) {
logTasksStatus(buildTasks);
}
buildConfigSetRecord.ifPresent(r -> r.setStatus(BuildStatus.CANCELLED));
finishBuildSetTask();
} else if(buildTasks.stream().anyMatch(bt -> bt.getStatus().hasFailed())) {
log.debug("Marking build set as FAILED as one or more tasks failed. BuildSetTask: {}", this);
if (log.isDebugEnabled()) {
logTasksStatus(buildTasks);
}
buildConfigSetRecord.ifPresent(r -> r.setStatus(BuildStatus.FAILED));
finishBuildSetTask();
} else if (buildTasks.stream().allMatch(bt -> bt.getStatus().isCompleted())) {
log.debug("Marking build set as SUCCESS. BuildSetTask: {}", this);
buildConfigSetRecord.ifPresent(r -> r.setStatus(BuildStatus.SUCCESS));
finishBuildSetTask();
} else {
if (log.isTraceEnabled()) {
List<Integer> running = buildTasks.stream()
.filter(bt -> !bt.getStatus().isCompleted())
.filter(bt -> !bt.getStatus().hasFailed())
.map(BuildTask::getId)
.collect(Collectors.toList());
log.trace("There are still running or waiting builds [{}].", running);
}
}
} | java | {
"resource": ""
} |
q168031 | BuildSetTask.getBuildTask | validation | public BuildTask getBuildTask(BuildConfigurationAudited buildConfigurationAudited) {
return buildTasks.stream().filter((bt) -> bt.getBuildConfigurationAudited().equals(buildConfigurationAudited)).findFirst().orElse(null);
} | java | {
"resource": ""
} |
q168032 | IndyRunningPromotion.monitor | validation | @Override
public void monitor(Consumer<CompletedRepositoryPromotion> onComplete, Consumer<Exception> onError) {
try {
StoreKey fromKey = new StoreKey(pakageType, fromType, fromId);
if (!indy.stores().exists(fromKey)) {
throw new RepositoryManagerException("No such %s repository: %s", fromType.singularEndpointName(), fromId);
}
StoreKey toKey = new StoreKey(pakageType, StoreType.group, toId);
Group recordSetGroup = indy.stores().load(toKey, Group.class);
if (recordSetGroup == null) {
throw new RepositoryManagerException("No such group: %s", toId);
}
recordSetGroup.addConstituent(fromKey);
boolean result = indy.stores().update(recordSetGroup,
"Promoting " + fromType.singularEndpointName() + " repository : " + fromId + " to group: " + toId);
onComplete.accept(new IndyCompletedPromotion(result));
} catch (IndyClientException | RepositoryManagerException e) {
onError.accept(e);
}
} | java | {
"resource": ""
} |
q168033 | GraphUtils.merge | validation | public static <T> void merge(Graph<T> target, Graph<T> toMerge) {
for (Vertex<T> vertex : toMerge.getVerticies()) {
target.addVertex(vertex);
}
// merge edges
List<Edge<T>> edges = target.getEdges();
for (Edge newEdge : toMerge.getEdges()) {
Optional<Edge<T>> any = edges.stream()
.filter(existing ->
existing.getFrom().getName().equals(newEdge.getFrom().getName())
&& existing.getTo().getName().equals(newEdge.getTo().getName())
).findAny();
if (!any.isPresent()) {
edges.add(newEdge);
}
}
} | java | {
"resource": ""
} |
q168034 | IoUtils.readFileAsString | validation | public static String readFileAsString(File fileName) throws IOException {
try (Scanner sc = new Scanner(fileName, Charset.defaultCharset().name())) {
sc.useDelimiter("\\A");
return sc.next();
}
} | java | {
"resource": ""
} |
q168035 | IoUtils.readStreamAsString | validation | public static String readStreamAsString(InputStream stream) throws IOException {
try (Scanner sc = new Scanner(stream, Charset.defaultCharset().name())) {
sc.useDelimiter("\\A");
return sc.next();
}
} | java | {
"resource": ""
} |
q168036 | ProductMilestoneReleaseManager.startRelease | validation | public void startRelease(ProductMilestone milestone, String accessToken) {
ProductMilestoneRelease release = triggerRelease(milestone, accessToken);
productMilestoneReleaseRepository.save(release);
} | java | {
"resource": ""
} |
q168037 | BpmManager.cleanup | validation | public void cleanup() { //TODO remove tasks immediately after the completion, see: BuildTaskEndpoint.buildTaskCompleted
log.debug("Bpm manager tasks cleanup started");
if (session == null) {
log.error("Kie session not available.");
}
Map<Integer, BpmTask> clonedTaskMap = new HashMap<>(this.tasks);
Set<Integer> toBeRemoved = clonedTaskMap.values().stream()
.filter(bpmTask -> {
if (bpmTask == null) {
log.warn("Listing invalid entry for removal from the tasks list.");
return true;
}
log.debug("Attempting to fetch process instance for bpmTask: {}.", bpmTask.getTaskId());
Long processInstanceId = bpmTask.getProcessInstanceId();
ProcessInstance processInstance = session.getProcessInstance(processInstanceId);
log.debug("fetched: {}", processInstance);
if (processInstance == null) // instance has been terminated from outside
return true;
int state = processInstance.getState();
return state == STATE_COMPLETED || state == STATE_ABORTED;
})
.map(BpmTask::getTaskId)
.collect(Collectors.toSet());
toBeRemoved.forEach(id -> {
BpmTask removed = tasks.remove(id);
if (removed != null) {
log.debug("Removed bpmTask.id: {}.", removed.getTaskId());
} else {
log.warn("Unable to remove bpmTask.id: {}.", id);
}
});
log.debug("Bpm manager tasks cleanup finished");
} | java | {
"resource": ""
} |
q168038 | BpmManager.getTaskIdByBuildId | validation | @Deprecated
public Integer getTaskIdByBuildId(int buildId) {
List<Integer> result = tasks.values().stream()
.filter(t -> t instanceof BpmBuildTask)
.filter(t -> ((BpmBuildTask) t).getBuildTask().getId() == buildId)
.map(BpmTask::getTaskId)
.collect(Collectors.toList());
if (result.size() > 1)
throw new IllegalStateException("More that one task with the same build id: " + result);
return result.size() == 1 ? result.get(0) : null;
} | java | {
"resource": ""
} |
q168039 | StreamCollectors.toFlatList | validation | public static <T> Collector<Collection<T>, List<T>, List<T>> toFlatList() {
return Collector.of(
ArrayList::new,
List::addAll,
(left, right) -> {
left.addAll(right);
return left;
});
} | java | {
"resource": ""
} |
q168040 | TemporaryBuildsCleanupScheduler.cleanupExpiredTemporaryBuilds | validation | @Schedule
public void cleanupExpiredTemporaryBuilds() throws ValidationException {
log.info("Regular cleanup of expired temporary builds started. Removing builds older than " + TEMPORARY_BUILD_LIFESPAN
+ " days.");
Date expirationThreshold = TimeUtils.getDateXDaysAgo(TEMPORARY_BUILD_LIFESPAN);
String authToken = serviceClient.getAuthToken();
deleteExpiredBuildConfigSetRecords(expirationThreshold, authToken);
deleteExpiredBuildRecords(expirationThreshold, authToken);
log.info("Regular cleanup of expired temporary builds finished.");
} | java | {
"resource": ""
} |
q168041 | RepositoryManagerDriver.setupBuildRepos | validation | private void setupBuildRepos(BuildExecution execution, String packageType, Indy indy, Map<String, String> genericParameters) throws IndyClientException {
String buildContentId = execution.getBuildContentId();
int id = execution.getId();
// if the build-level group doesn't exist, create it.
StoreKey groupKey = new StoreKey(packageType, StoreType.group, buildContentId);
if (!indy.stores().exists(groupKey)) {
// if the product-level storage repo (for in-progress product builds) doesn't exist, create it.
StoreKey hostedKey = new StoreKey(packageType, StoreType.hosted, buildContentId);
boolean tempBuild = execution.isTempBuild();
if (!indy.stores().exists(hostedKey)) {
HostedRepository buildArtifacts = new HostedRepository(packageType, buildContentId);
buildArtifacts.setAllowSnapshots(tempBuild);
buildArtifacts.setAllowReleases(true);
buildArtifacts.setDescription(String.format("Build output for PNC %s build #%s", packageType, id));
indy.stores().create(buildArtifacts, "Creating hosted repository for " + packageType + " build: " + id
+ " (repo: " + buildContentId + ")", HostedRepository.class);
}
Group buildGroup = new Group(packageType, buildContentId);
String adjective = tempBuild ? "temporary " : "";
buildGroup.setDescription(String.format("Aggregation group for PNC %sbuild #%s", adjective, id));
// build-local artifacts
buildGroup.addConstituent(hostedKey);
// Global-level repos, for captured/shared artifacts and access to the outside world
addGlobalConstituents(packageType, buildGroup, tempBuild);
// add extra repositories removed from poms by the adjust process and set in BC by user
List<ArtifactRepository> extraDependencyRepositories = extractExtraRepositoriesFromGenericParameters(genericParameters);
if (execution.getArtifactRepositories() != null) {
extraDependencyRepositories.addAll(execution.getArtifactRepositories());
}
addExtraConstituents(packageType, extraDependencyRepositories, id, buildContentId, indy, buildGroup);
indy.stores().create(buildGroup, "Creating repository group for resolving artifacts in build: " + id
+ " (repo: " + buildContentId + ")", Group.class);
}
} | java | {
"resource": ""
} |
q168042 | BpmEndpoint.onRCCreationSuccess | validation | private void onRCCreationSuccess(BpmNotificationRest notification, BuildConfigurationRest buildConfigurationRest) {
LOG.debug("Received BPM event RC_CREATION_SUCCESS: " + notification);
BpmStringMapNotificationRest repositoryCreationTaskResult = (BpmStringMapNotificationRest) notification;
int repositoryConfigurationId = -1;
int buildConfigurationSavedId = -1;
try {
repositoryConfigurationId = Integer.valueOf(repositoryCreationTaskResult.getData().get("repositoryConfigurationId"));
} catch (NumberFormatException ex) {
String errorMessage = "Receive notification about successful BC creation '" + repositoryCreationTaskResult
+ "' but the ID of the newly created RC '" + repositoryCreationTaskResult.getData()
.get("repositoryConfigurationId")
+ "' is not a number. It should be present under 'repositoryConfigurationId' key.";
LOG.error(errorMessage, ex);
sendErrorMessage(repositoryConfigurationId, buildConfigurationSavedId, errorMessage);
return;
}
RepositoryConfiguration repositoryConfiguration = repositoryConfigurationRepository.queryById(repositoryConfigurationId);
if (repositoryConfiguration == null) {
String errorMessage = "Repository Configuration was not found in database.";
LOG.error(errorMessage);
sendErrorMessage(repositoryConfigurationId, buildConfigurationSavedId, errorMessage);
return;
}
if (buildConfigurationRest != null) { //TODO test me
BuildConfiguration buildConfiguration = buildConfigurationRest.toDBEntityBuilder()
.repositoryConfiguration(repositoryConfiguration)
.build();
BuildConfiguration buildConfigurationSaved = buildConfigurationRepository.save(buildConfiguration);
buildConfigurationSavedId = buildConfigurationSaved.getId();
Set<Integer> bcSetIds = buildConfigurationRest.getBuildConfigurationSetIds();
try {
if (bcSetIds != null) {
addBuildConfigurationToSet(buildConfigurationSaved, bcSetIds);
}
} catch (Exception e) {
LOG.error(e.getMessage());
sendErrorMessage(repositoryConfigurationId, buildConfigurationSavedId, e.getMessage());
return;
}
}
RepositoryCreationResultRest repositoryCreationResultRest
= new RepositoryCreationResultRest(
repositoryConfigurationId,
buildConfigurationSavedId,
RepositoryCreationResultRest.EventType.RC_CREATION_SUCCESS,
null);
wsNotifier.sendMessage(repositoryCreationResultRest); //TODO test me!
} | java | {
"resource": ""
} |
q168043 | BpmEndpoint.addWebsocketForwardingListeners | validation | private void addWebsocketForwardingListeners(RepositoryCreationTask task) {
Consumer<? extends BpmNotificationRest> doNotify = (e) -> wsNotifier.sendMessage(e);
task.addListener(BpmEventType.RC_REPO_CREATION_SUCCESS, doNotify);
task.addListener(BpmEventType.RC_REPO_CREATION_ERROR, doNotify);
task.addListener(BpmEventType.RC_REPO_CLONE_SUCCESS, doNotify);
task.addListener(BpmEventType.RC_REPO_CLONE_ERROR, doNotify);
//clients are notified from callback in startRCreationTask
//task.addListener(BpmEventType.RC_CREATION_SUCCESS, doNotify);
task.addListener(BpmEventType.RC_CREATION_ERROR, doNotify);
} | java | {
"resource": ""
} |
q168044 | ArtifactBuilder.mockImportedArtifact | validation | public static Artifact mockImportedArtifact(int id) {
return getArtifactBuilder(id)
.importDate(Date.from(Instant.now()))
.originUrl("http://central.maven.org/org/jboss/mock/artifactFile" + id + ".jar")
.build();
} | java | {
"resource": ""
} |
q168045 | HttpUtil.setSslRequired | validation | public static void setSslRequired(boolean sslRequired) {
if (HttpUtil.sslRequired != sslRequired) {
HttpUtil.sslRequired = sslRequired;
HttpUtil.httpClient = null;
}
} | java | {
"resource": ""
} |
q168046 | TemporaryBuildsCleaner.deleteTemporaryBuild | validation | public Result deleteTemporaryBuild(Integer buildRecordId, String authToken) throws ValidationException {
BuildRecord buildRecord = buildRecordRepository.findByIdFetchAllProperties(buildRecordId);
if (!buildRecord.isTemporaryBuild()) {
throw new ValidationException("Only deletion of the temporary builds is allowed");
}
log.info("Starting deletion of a temporary build " + buildRecord + "; Built artifacts: " + buildRecord.getBuiltArtifacts()
+ "; Dependencies: " + buildRecord.getDependencies());
Result result = remoteBuildsCleaner.deleteRemoteBuilds(buildRecord, authToken);
if (!result.isSuccess()) {
log.error("Failed to delete remote temporary builds for BR.id:{}.", buildRecord.getId());
return new Result(buildRecordId.toString(), Result.Status.FAILED, "Failed to delete remote temporary builds.");
}
/** Delete relation between BuildRecord and Artifact */
Set<Artifact> artifactsToBeDeleted = new HashSet<>();
removeRelationBuildRecordArtifact(buildRecord, artifactsToBeDeleted);
/**
* Delete artifacts, if the artifacts are not used in other builds
*/
deleteArtifacts(artifactsToBeDeleted);
deleteDependencies(buildRecord);
buildRecordRepository.delete(buildRecord.getId());
log.info("Deletion of the temporary build {} finished successfully.", buildRecord);
return new Result(buildRecordId.toString(), Result.Status.SUCCESS);
} | java | {
"resource": ""
} |
q168047 | TemporaryBuildsCleaner.deleteTemporaryBuildConfigSetRecord | validation | public Result deleteTemporaryBuildConfigSetRecord(Integer buildConfigSetRecordId, String authToken)
throws ValidationException {
BuildConfigSetRecord buildConfigSetRecord = buildConfigSetRecordRepository.queryById(buildConfigSetRecordId);
if (!buildConfigSetRecord.isTemporaryBuild()) {
throw new ValidationException("Only deletion of the temporary builds is allowed");
}
log.info("Starting deletion of a temporary build record set " + buildConfigSetRecord);
for (BuildRecord br : buildConfigSetRecord.getBuildRecords()) {
Result result = deleteTemporaryBuild(br.getId(), authToken);
if (!result.isSuccess()) {
return result;
}
}
buildConfigSetRecordRepository.delete(buildConfigSetRecord.getId());
log.info("Deletion of a temporary build record set {} finished successfully.", buildConfigSetRecord);
return new Result(buildConfigSetRecordId.toString(), Result.Status.SUCCESS);
} | java | {
"resource": ""
} |
q168048 | DefaultBuildCoordinator.build | validation | @Override
public BuildSetTask build(BuildConfigurationAudited buildConfigurationAudited,
User user,
BuildOptions buildOptions) throws BuildConflictException {
return build0(user, buildOptions, buildConfigurationAudited);
} | java | {
"resource": ""
} |
q168049 | DefaultBuildCoordinator.checkForEmptyBuildSetTask | validation | private void checkForEmptyBuildSetTask(BuildSetTask buildSetTask) {
if (buildSetTask.getBuildTasks() == null || buildSetTask.getBuildTasks().isEmpty()) {
updateBuildSetTaskStatus(buildSetTask, BuildSetStatus.REJECTED, "Build config set is empty");
}
} | java | {
"resource": ""
} |
q168050 | EnvironmentDriverFactory.getDriver | validation | public EnvironmentDriver getDriver(SystemImageType systemImageType) throws ExecutorException {
for (EnvironmentDriver driver : availableDrivers) {
if (driver.canRunImageType(systemImageType))
return driver;
}
throw new ExecutorException("No environment driver available for " + systemImageType + " system image type.");
} | java | {
"resource": ""
} |
q168051 | BuildConfigurationPredicates.isNotArchived | validation | public static Predicate<BuildConfiguration> isNotArchived() {
return (root, query, cb) -> cb.isTrue(root.get(BuildConfiguration_.active));
} | java | {
"resource": ""
} |
q168052 | DatastoreAdapter.loadBuildConfigurations | validation | private void loadBuildConfigurations(BuildConfigurationAudited buildConfigAudited) {
Project project = buildConfigAudited.getProject();
project.getBuildConfigurations().forEach(BuildConfiguration::getId);
} | java | {
"resource": ""
} |
q168053 | DatastoreAdapter.storeResult | validation | public BuildRecord storeResult(BuildTask buildTask, Optional<BuildResult> buildResult, Throwable e) throws DatastoreException {
BuildRecord.Builder buildRecordBuilder = initBuildRecordBuilder(buildTask);
buildRecordBuilder.status(SYSTEM_ERROR);
StringBuilder errorLog = new StringBuilder();
buildResult.ifPresent(result -> {
result.getRepourResult().ifPresent(repourResult -> {
buildRecordBuilder.executionRootName(repourResult.getExecutionRootName());
buildRecordBuilder.executionRootVersion(repourResult.getExecutionRootVersion());
buildRecordBuilder.repourLog(repourResult.getLog());
});
result.getBuildDriverResult().ifPresent(
buildDriverResult -> {
errorLog.append(buildDriverResult.getBuildLog());
errorLog.append("\n---- End Build Log ----\n");
});
result.getRepositoryManagerResult().ifPresent(
rmr -> {
errorLog.append(rmr.getLog());
errorLog.append("\n---- End Repository Manager Log ----\n");
});
result.getEnvironmentDriverResult().ifPresent(
r -> {
if (r.getLog() != null && !r.getLog().equals(""))
errorLog.append(r.getLog());
errorLog.append("\n---- End Environment Driver Log ----\n");
});
});
errorLog.append("Build status: ").append(getBuildStatus(buildResult)).append("\n");
errorLog.append("Caught exception: ").append(e.toString()).append("\n");
StringWriter stackTraceWriter = new StringWriter();
e.printStackTrace(new PrintWriter(stackTraceWriter));
errorLog.append(stackTraceWriter.getBuffer());
buildRecordBuilder.buildLog(errorLog.toString());
userLog.error("Build status: {}.", getBuildStatus(buildResult));
log.debug("Storing ERROR result of buildTask.getBuildConfigurationAudited().getName() to datastore.", e);
return datastore.storeCompletedBuild(buildRecordBuilder);
} | java | {
"resource": ""
} |
q168054 | DatastoreAdapter.initBuildRecordBuilder | validation | private BuildRecord.Builder initBuildRecordBuilder(BuildTask buildTask) {
BuildOptions buildOptions = buildTask.getBuildOptions();
BuildRecord.Builder builder = BuildRecord.Builder.newBuilder()
.id(buildTask.getId())
.buildConfigurationAudited(buildTask.getBuildConfigurationAudited())
.user(buildTask.getUser())
.submitTime(buildTask.getSubmitTime())
.startTime(buildTask.getStartTime())
.productMilestone(buildTask.getProductMilestone())
.temporaryBuild(buildOptions.isTemporaryBuild());
if (buildTask.getEndTime() == null) {
buildTask.setEndTime(Date.from(Instant.now()));
}
builder.endTime(buildTask.getEndTime());
if (buildTask.getBuildConfigSetRecordId() != null) {
BuildConfigSetRecord buildConfigSetRecord = datastore.getBuildConfigSetRecordById(buildTask.getBuildConfigSetRecordId());
builder.buildConfigSetRecord(buildConfigSetRecord);
}
List<Integer> dependencies = buildTask.getDependencies().stream().map(t -> t.getId()).collect(Collectors.toList());
builder.dependencyBuildRecordIds(dependencies.toArray(new Integer[dependencies.size()]));
List<Integer> dependants = buildTask.getDependants().stream().map(t -> t.getId()).collect(Collectors.toList());
builder.dependentBuildRecordIds(dependants.toArray(new Integer[dependants.size()]));
return builder;
} | java | {
"resource": ""
} |
q168055 | ProductVersionPredicates.withBuildConfigurationId | validation | public static Predicate<ProductVersion> withBuildConfigurationId(Integer buildConfigurationId) {
return (root, query, cb) -> {
SetJoin<ProductVersion, BuildConfiguration> buildConfigurationJoin = root.join(ProductVersion_.buildConfigurations);
return cb.equal(buildConfigurationJoin.get(BuildConfiguration_.id), buildConfigurationId);
};
} | java | {
"resource": ""
} |
q168056 | JenkinsServerFactory.isJenkinsServerSecuredWithCSRF | validation | boolean isJenkinsServerSecuredWithCSRF(String url) throws BuildDriverException {
try {
JenkinsBuildDriverModuleConfig config = configuration
.getModuleConfig(new PncConfigProvider<JenkinsBuildDriverModuleConfig>(JenkinsBuildDriverModuleConfig.class));
String username = config.getUsername();
String password = config.getPassword();
if (url == null || username == null || password == null) {
throw new BuildDriverException("Missing config to instantiate " + JenkinsBuildDriver.DRIVER_ID + ".");
}
try {
JenkinsHttpClient jenkinsHttpClient = new JenkinsHttpClient(new URI(url), username, password);
try {
jenkinsHttpClient.get("/crumbIssuer/api/xml");
return true ;
} catch (IOException e) {
return false;
}
} catch (URISyntaxException e) {
throw new BuildDriverException("Cannot instantiate " + JenkinsBuildDriver.DRIVER_ID + ". Make sure you are using valid url: " + url, e);
}
} catch (ConfigurationParseException e) {
throw new BuildDriverException("Cannot read configuration for " + JenkinsBuildDriver.DRIVER_ID + ".", e); }
} | java | {
"resource": ""
} |
q168057 | DefaultDatastore.saveArtifacts | validation | private Set<Artifact> saveArtifacts(Collection<Artifact> artifacts,
Map<String, TargetRepository> repositoriesCache,
Map<Artifact.IdentifierSha256, Artifact> artifactCache) {
logger.debug("Saving {} artifacts.", artifacts.size());
Set<Artifact> savedArtifacts = new HashSet<>();
Set<Artifact.IdentifierSha256> artifactConstraints = new HashSet<>();
for (Artifact artifact : artifacts) {
artifactConstraints.add(new Artifact.IdentifierSha256(artifact.getIdentifier(), artifact.getSha256()));
}
Set<Artifact> artifactsInDb = null;
if (artifactConstraints.size() > 0) {
artifactsInDb = artifactRepository.withIdentifierAndSha256s(artifactConstraints);
}
if (artifactsInDb != null) {
for (Artifact artifact : artifactsInDb) {
logger.trace("Found in DB, adding to cache. Artifact {}", artifact);
artifactCache.put(artifact.getIdentifierSha256(), artifact);
}
}
for (Artifact artifact : artifacts) {
TargetRepository targetRepository = artifact.getTargetRepository();
linkTargetRepository(repositoriesCache, artifact, targetRepository);
Artifact artifactFromDb;
if (RepositoryType.GENERIC_PROXY.equals(targetRepository.getRepositoryType())) {
artifactFromDb = saveHttpArtifact(artifact);
} else {
artifactFromDb = getOrSaveRepositoryArtifact(artifact, artifactCache);
}
savedArtifacts.add(artifactFromDb);
}
logger.debug("Artifacts saved: {}.", artifacts);
return savedArtifacts;
} | java | {
"resource": ""
} |
q168058 | DefaultDatastore.saveBuildConfigSetRecord | validation | @Override
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public BuildConfigSetRecord saveBuildConfigSetRecord(BuildConfigSetRecord buildConfigSetRecord) {
return buildConfigSetRecordRepository.save(buildConfigSetRecord);
} | java | {
"resource": ""
} |
q168059 | DefaultDatastore.getBuildConfigurations | validation | @Override
public Set<BuildConfiguration> getBuildConfigurations(BuildConfigurationSet buildConfigurationSet) {
return new HashSet<>(buildConfigurationRepository.queryWithPredicates(withBuildConfigurationSetId(buildConfigurationSet.getId())));
} | java | {
"resource": ""
} |
q168060 | DefaultDatastore.hasARebuiltImplicitDependency | validation | private boolean hasARebuiltImplicitDependency(BuildRecord latestSuccessfulBuildRecord, boolean temporaryBuild) {
Collection<BuildRecord> lastBuiltFrom = getRecordsUsedFor(latestSuccessfulBuildRecord);
return lastBuiltFrom.stream()
.anyMatch(br -> hasNewerVersion(br, temporaryBuild));
} | java | {
"resource": ""
} |
q168061 | DefaultDatastore.hasARebuiltExplicitDependency | validation | private boolean hasARebuiltExplicitDependency(BuildRecord latestSuccessfulBuildRecord, Set<BuildConfiguration> dependencies, boolean temporaryBuild) {
for (BuildConfiguration dependencyBuildConfiguration : dependencies) {
BuildRecord dependencyLatestSuccessfulBuildRecord = buildRecordRepository.getLatestSuccessfulBuildRecord(dependencyBuildConfiguration.getId(), temporaryBuild);
if (dependencyLatestSuccessfulBuildRecord == null) {
return true;
}
boolean newer = dependencyLatestSuccessfulBuildRecord.getEndTime().after(latestSuccessfulBuildRecord.getEndTime());
if (newer) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q168062 | BpmTask.addListener | validation | public <T extends BpmNotificationRest> void addListener(BpmEventType eventType, Consumer<T> listener) {
List<Consumer<?>> consumers = listeners.computeIfAbsent(eventType, (k) -> new ArrayList<>());
consumers.add(listener);
} | java | {
"resource": ""
} |
q168063 | BpmTask.getExtendedProcessParameters | validation | Map<String, Object> getExtendedProcessParameters() throws CoreException {
Serializable processParameters = getProcessParameters();
requireNonNull(processParameters);
Map<String, Object> actualParameters = new HashMap<>();
try {
actualParameters.put("processParameters", MAPPER.writeValueAsString(processParameters));
} catch (JsonProcessingException e) {
throw new CoreException("Could not serialize process processParameters '" +
processParameters + "'.", e);
}
//global not process related parameters
actualParameters.put("taskId", taskId);
actualParameters.put("usersAuthToken", accessToken);
return actualParameters;
} | java | {
"resource": ""
} |
q168064 | BuildTasksInitializer.collectDependentConfigurations | validation | private boolean collectDependentConfigurations(BuildConfiguration buildConfiguration,
BuildConfigurationAudited buildConfigurationAudited,
Set<BuildConfigurationAudited> toBuild,
Set<BuildConfiguration> visited,
boolean checkImplicitDependencies,
boolean forceRebuild,
boolean temporaryBuild) {
if (visited.contains(buildConfiguration)) {
return toBuild.contains(buildConfigurationAudited);
}
visited.add(buildConfiguration);
boolean requiresRebuild = forceRebuild || datastoreAdapter.requiresRebuild(buildConfigurationAudited, checkImplicitDependencies, temporaryBuild);
for (BuildConfiguration dependency : buildConfiguration.getDependencies()) {
boolean dependencyRequiresRebuild = collectDependentConfigurations(dependency,
datastoreAdapter.getLatestBuildConfigurationAuditedInitializeBCDependencies(dependency.getId()),
toBuild,
visited,
checkImplicitDependencies,
forceRebuild,
temporaryBuild);
requiresRebuild = requiresRebuild || dependencyRequiresRebuild;
}
log.debug("Configuration {} requires rebuild: ", buildConfiguration.getId(), requiresRebuild);
if (requiresRebuild) {
toBuild.add(buildConfigurationAudited);
}
return requiresRebuild;
} | java | {
"resource": ""
} |
q168065 | BuildTasksInitializer.createBuildSetTask | validation | public BuildSetTask createBuildSetTask(
BuildConfigurationSet buildConfigurationSet,
User user,
BuildOptions buildOptions,
Supplier<Integer> buildTaskIdProvider,
Set<BuildTask> submittedBuildTasks) throws CoreException {
return createBuildSetTask(buildConfigurationSet, Collections.emptyMap(), user, buildOptions,
buildTaskIdProvider, submittedBuildTasks);
} | java | {
"resource": ""
} |
q168066 | BuildTasksInitializer.createBuildSetTask | validation | public BuildSetTask createBuildSetTask(
BuildConfigurationSet buildConfigurationSet,
Map<Integer, BuildConfigurationAudited> buildConfigurationAuditedsMap,
User user,
BuildOptions buildOptions,
Supplier<Integer> buildTaskIdProvider,
Set<BuildTask> submittedBuildTasks) throws CoreException {
BuildSetTask buildSetTask = initBuildSetTask(buildConfigurationSet, user, buildOptions);
Set<BuildConfigurationAudited> buildConfigurationAuditeds = new HashSet<>();
for (BuildConfiguration buildConfiguration : datastoreAdapter.getBuildConfigurations(buildConfigurationSet)) {
BuildConfigurationAudited buildConfigurationAudited = buildConfigurationAuditedsMap.get(buildConfiguration.getId());
if(buildConfigurationAudited == null) {
buildConfigurationAudited = datastoreAdapter.getLatestBuildConfigurationAuditedInitializeBCDependencies(buildConfiguration.getId());
}
buildConfigurationAuditeds.add(buildConfigurationAudited);
}
// initializeBuildTasksInSet
log.debug("Initializing BuildTasks In Set for BuildConfigurationAuditeds: {}.",
buildConfigurationAuditeds.stream().map(bc ->bc.toString()).collect(Collectors.joining("; ")));
fillBuildTaskSet(
buildSetTask,
user,
buildTaskIdProvider,
buildConfigurationSet.getCurrentProductMilestone(),
buildConfigurationAuditeds,
submittedBuildTasks,
buildOptions);
return buildSetTask;
} | java | {
"resource": ""
} |
q168067 | BuildTasksInitializer.fillBuildTaskSet | validation | private void fillBuildTaskSet(
BuildSetTask buildSetTask,
User user,
Supplier<Integer> buildTaskIdProvider,
ProductMilestone productMilestone,
Set<BuildConfigurationAudited> toBuild,
Set<BuildTask> alreadySubmittedBuildTasks,
BuildOptions buildOptions) {
for (BuildConfigurationAudited buildConfigAudited : toBuild) {
Optional<BuildTask> taskOptional = alreadySubmittedBuildTasks.stream()
.filter(bt -> bt.getBuildConfigurationAudited().equals(buildConfigAudited))
.findAny();
BuildTask buildTask;
if (taskOptional.isPresent()) {
buildTask = taskOptional.get();
log.debug("Linking BuildConfigurationAudited {} to existing task {}.", buildConfigAudited, buildTask);
} else {
int buildId = buildTaskIdProvider.get();
String buildContentId = ContentIdentityManager.getBuildContentId(buildId);
MDCUtils.addBuildContext(buildContentId, buildOptions.isTemporaryBuild(), temporaryBuildExpireDate);
buildTask = BuildTask.build(
buildConfigAudited,
buildSetTask.getBuildOptions(),
user,
buildId,
buildSetTask,
buildSetTask.getStartTime(),
productMilestone,
buildContentId);
log.debug("Created new buildTask {} for BuildConfigurationAudited {}.", buildTask, buildConfigAudited);
}
buildSetTask.addBuildTask(buildTask);
}
// Loop again to set dependencies
for (BuildTask buildTask : buildSetTask.getBuildTasks()) {
for (BuildTask checkDepBuildTask : buildSetTask.getBuildTasks()) {
if (buildTask.hasDirectConfigDependencyOn(checkDepBuildTask)) {
buildTask.addDependency(checkDepBuildTask);
}
}
}
} | java | {
"resource": ""
} |
q168068 | ArtifactProvider.getBuiltArtifactsForBuildRecord | validation | public CollectionInfo<ArtifactRest> getBuiltArtifactsForBuildRecord(int pageIndex, int pageSize, String sortingRsql, String query,
int buildRecordId) {
return queryForCollection(pageIndex, pageSize, sortingRsql, query, withBuildRecordId(buildRecordId));
} | java | {
"resource": ""
} |
q168069 | StringUtils.addEndingSlash | validation | public static String addEndingSlash(String string) {
if (string == null) {
return null;
}
if (!string.endsWith("/")) {
string += "/";
}
return string;
} | java | {
"resource": ""
} |
q168070 | StringUtils.deserializeInt | validation | public static Integer[] deserializeInt(String string) {
if (string == null) {
return new Integer[0];
}
return Arrays.stream(string.split(","))
.filter(s -> !s.equals(""))
.map(Integer::parseInt).toArray(Integer[]::new);
} | java | {
"resource": ""
} |
q168071 | StringUtils.serializeInt | validation | public static String serializeInt(Integer[] integers) {
if (integers == null) {
return "";
}
return Arrays.stream(integers)
.map(i -> Integer.toString(i)).collect(Collectors.joining(","));
} | java | {
"resource": ""
} |
q168072 | BuildQueue.addReadyTask | validation | public synchronized boolean addReadyTask(BuildTask task) {
if (!task.readyToBuild()) {
throw new IllegalArgumentException("a not ready task added to the queue: " + task);
}
unfinishedTasks.add(task);
log.debug("adding task: {}", task);
readyTasks.add(task);
return true;
} | java | {
"resource": ""
} |
q168073 | BuildQueue.addWaitingTask | validation | public synchronized void addWaitingTask(BuildTask task, Runnable taskReadyCallback) {
unfinishedTasks.add(task);
log.debug("adding waiting task: {}", task);
waitingTasksWithCallbacks.put(task, taskReadyCallback);
} | java | {
"resource": ""
} |
q168074 | BuildQueue.executeNewReadyTasks | validation | public synchronized void executeNewReadyTasks() {
List<BuildTask> newReadyTasks = extractReadyTasks();
log.debug("starting new ready tasks. New ready tasks: {}", newReadyTasks);
readyTasks.addAll(newReadyTasks);
} | java | {
"resource": ""
} |
q168075 | BuildQueue.getTask | validation | public synchronized Optional<BuildTask> getTask(BuildConfigurationAudited buildConfigAudited) {
Optional<BuildTask> ready = readyTasks.stream().filter(bt -> bt.getBuildConfigurationAudited().equals(buildConfigAudited)).findAny();
Optional<BuildTask> waiting = waitingTasksWithCallbacks.keySet().stream().filter(bt -> bt.getBuildConfigurationAudited().equals(buildConfigAudited)).findAny();
Optional<BuildTask> inProgress = tasksInProgress.stream().filter(bt -> bt.getBuildConfigurationAudited().equals(buildConfigAudited)).findAny();
return ready.isPresent() ? ready : waiting.isPresent() ? waiting : inProgress;
} | java | {
"resource": ""
} |
q168076 | TargetRepository.isTrusted | validation | static boolean isTrusted(String artifactOriginUrl, TargetRepository targetRepository) {
if (targetRepository.temporaryRepo) {
return false;
}
if (artifactOriginUrl == null || artifactOriginUrl.isEmpty()) {
return false;
}
for (String trustedRepoUrl : TRUSTED_REPOSITORY_URLS) {
if (artifactOriginUrl.startsWith(trustedRepoUrl)) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q168077 | User.addBuildRecord | validation | public BuildRecord addBuildRecord(BuildRecord buildRecord) {
getBuildRecords().add(buildRecord);
buildRecord.setUser(this);
return buildRecord;
} | java | {
"resource": ""
} |
q168078 | User.removeBuildRecord | validation | public BuildRecord removeBuildRecord(BuildRecord buildRecord) {
getBuildRecords().remove(buildRecord);
buildRecord.setUser(null);
return buildRecord;
} | java | {
"resource": ""
} |
q168079 | TemporaryBuildsCleanerAsyncInvoker.deleteTemporaryBuild | validation | public boolean deleteTemporaryBuild(Integer buildRecordId, String authToken, Consumer<Result> onComplete) throws ValidationException {
BuildRecord buildRecord = buildRecordRepository.findByIdFetchAllProperties(buildRecordId);
if (buildRecord == null) {
return false;
}
if (!buildRecord.isTemporaryBuild()) {
throw new ValidationException("Only deletion of the temporary builds is allowed");
}
executorService.submit(() -> {
try {
Result result = temporaryBuildsCleaner.deleteTemporaryBuild(buildRecordId, authToken);
onComplete.accept(result);
} catch (ValidationException e) {
logger.error("Failed to delete temporary buildRecord.id: " + buildRecordId + ".", e);
onComplete.accept(new Result(buildRecordId.toString(), Result.Status.FAILED, "Failed to delete temporary buildRecord."));
}
});
return true;
} | java | {
"resource": ""
} |
q168080 | BuildConfiguration.getAllDependencies | validation | public Set<BuildConfiguration> getAllDependencies() {
Set<BuildConfiguration> allDependencies = new HashSet<BuildConfiguration>();
allDependencies.addAll(getDependencies());
allDependencies.addAll(getIndirectDependencies());
return allDependencies;
} | java | {
"resource": ""
} |
q168081 | BuildConfiguration.addDependant | validation | private boolean addDependant(BuildConfiguration dependant) {
boolean result = dependants.add(dependant);
if (!dependant.getDependencies().contains(this)) {
dependant.addDependency(this);
}
return result;
} | java | {
"resource": ""
} |
q168082 | BuildConfiguration.removeDependant | validation | private boolean removeDependant(BuildConfiguration dependant) {
boolean result = dependants.remove(dependant);
if (dependant.getDependencies().contains(this)) {
dependant.removeDependency(this);
}
return result;
} | java | {
"resource": ""
} |
q168083 | BuildConfiguration.retrieveCloneName | validation | public static String retrieveCloneName(String bcName, Date now) {
String bcNameToAppend = "";
int index = bcName.indexOf("_");
if (index == -1) {
// No '_' was found, need to append date prefix to whole bcName
bcNameToAppend = bcName;
} else {
// A '_' char was found, need to analyze if the prefix is a date (to
// be replaced with new one)
String prefix = bcName.substring(0, index);
if (prefix.length() == CLONE_PREFIX_DATE_FORMAT.length()) {
try {
new SimpleDateFormat(CLONE_PREFIX_DATE_FORMAT).parse(prefix);
// The prefix was a date, need to append new date to a substring
// of original bcName
bcNameToAppend = bcName.substring(index + 1);
} catch (ParseException ex) {
// The prefix was not a date, need to append date prefix to
// whole bcName
bcNameToAppend = bcName;
}
} else {
bcNameToAppend = bcName;
}
}
StringBuilder sb = new StringBuilder();
sb.append(new SimpleDateFormat(CLONE_PREFIX_DATE_FORMAT).format(now)).append("_").append(bcNameToAppend);
return sb.toString();
} | java | {
"resource": ""
} |
q168084 | Configuration.getModuleConfig | validation | @SuppressWarnings("unchecked")
public <T extends AbstractModuleConfig> T getModuleConfig(ConfigProvider<T> provider) throws ConfigurationParseException {
Class<T> moduleClass = provider.getType();
if(configCache.containsKey(moduleClass))
return (T) configCache.get(moduleClass);
synchronized(this) {
if(configCache.containsKey(moduleClass)) {
return (T) configCache.get(moduleClass);
}
T config = configurationJsonParser.parseJSONPNCConfig(CONFIG_STRING, provider);
configCache.put(moduleClass, config);
return config;
}
} | java | {
"resource": ""
} |
q168085 | TomcatServerJunit4Runner.instantiate | validation | private static EmbeddedTomcat instantiate(Class<?> klass) {
EmbeddedTomcatConfiguration configuration = extractConfiguration(klass);
return configuration == null ? new EmbeddedTomcat() : new EmbeddedTomcat(configuration);
} | java | {
"resource": ""
} |
q168086 | JunitServerExtension.registerEmbeddedServer | validation | private EmbeddedServerRunner registerEmbeddedServer(ExtensionContext context, boolean staticMode) {
Class<?> testClass = context.getRequiredTestClass();
EmbeddedServer<?> server = this.server == null ? instantiateServer(testClass, configuration) : this.server;
EmbeddedServerRunner serverAdapter = new EmbeddedServerRunner(server);
serverAdapter.beforeAll();
putEmbeddedServerAdapterInStore(context, serverAdapter, staticMode);
return serverAdapter;
} | java | {
"resource": ""
} |
q168087 | JunitServerExtension.unregisterEmbeddedServer | validation | private void unregisterEmbeddedServer(ExtensionContext context, boolean staticMode) {
boolean registeredAsStatic = findInStore(context, SERVER_RUNNER_STATIC_MODE);
if (registeredAsStatic == staticMode) {
try {
EmbeddedServerRunner serverAdapter = findEmbeddedServerAdapterInStore(context);
serverAdapter.afterAll();
}
finally {
removeEmbeddedServerAdapterFromStore(context);
}
}
} | java | {
"resource": ""
} |
q168088 | JunitServerExtension.putInStore | validation | @SuppressWarnings("unchecked")
private static <T> void putInStore(ExtensionContext context, String name, T value) {
getStore(context).put(name, value);
} | java | {
"resource": ""
} |
q168089 | JunitServerExtension.findInStore | validation | @SuppressWarnings("unchecked")
private static <T> T findInStore(ExtensionContext context, String name) {
return (T) getStore(context).get(name);
} | java | {
"resource": ""
} |
q168090 | UrlUtils.concatenatePath | validation | public static String concatenatePath(String path, String endpoint) {
String firstSegment = ensureAbsolutePath(path);
if (endpoint == null || endpoint.isEmpty()) {
return firstSegment;
}
StringBuilder sb = new StringBuilder(firstSegment);
if (path.charAt(path.length() - 1) != PATH_SEPARATOR) {
sb.append(PATH_SEPARATOR);
}
if (endpoint.charAt(0) == PATH_SEPARATOR) {
sb.append(endpoint.substring(1));
}
else {
sb.append(endpoint);
}
return sb.toString();
} | java | {
"resource": ""
} |
q168091 | EmbeddedTomcat.createContext | validation | @Deprecated
protected Context createContext() throws Exception {
Context context = null;
final String webapp = configuration.getWebapp();
final String path = configuration.getPath();
final String classpath = configuration.getClasspath();
final boolean forceMetaInf = configuration.isForceMetaInf();
final ClassLoader parentClassLoader = configuration.getParentClasspath();
final String descriptor = configuration.getOverrideDescriptor();
File webappDirectory = new File(webapp);
if (webappDirectory.exists()) {
String webappAbsolutePath = webappDirectory.getAbsolutePath();
tomcat.getHost().setAppBase(webappAbsolutePath);
context = tomcat.addWebapp(path, webappAbsolutePath);
// Add additional classpath entry
if (isNotBlank(classpath)) {
File file = new File(classpath);
if (file.exists()) {
// Check that additional classpath entry contains META-INF directory
File metaInf = new File(file, "META-INF");
if (!metaInf.exists() && forceMetaInf) {
metaInf.mkdir();
}
// == Tomcat 8
String absolutePath = file.getAbsolutePath();
StandardRoot root = new StandardRoot(context);
root.createWebResourceSet(
WebResourceRoot.ResourceSetType.PRE,
"/WEB-INF/classes",
absolutePath,
null,
path
);
context.setResources(root);
// == Tomcat 8
// == Tomcat 7
// String s = file.toURI().toString();
// loader.addRepository(s);
// == Tomcat 7
// Used to scan additional classpath directory
// https://issues.apache.org/bugzilla/show_bug.cgi?id=52853
((StandardJarScanner) context.getJarScanner()).setScanAllDirectories(true);
}
}
// Custom parent classloader.
final ClassLoader threadCl = Thread.currentThread().getContextClassLoader();
final ClassLoader tomcatParentClassLoader;
if (parentClassLoader != null) {
tomcatParentClassLoader = new CompositeClassLoader(parentClassLoader, threadCl);
}
else {
tomcatParentClassLoader = threadCl;
}
// Set the parent class loader that will be given
// to the created loader.
//
// Setting the parent class loader here is a shortcut for (code in previous versions):
//
// Loader loader = context.getLoader();
// if (loader == null) {
// loader = new WebappLoader(parentClassLoader);
// }
//
context.setParentClassLoader(tomcatParentClassLoader);
// Override web.xml path
if (descriptor != null) {
context.setAltDDName(descriptor);
}
}
return context;
} | java | {
"resource": ""
} |
q168092 | Cookies.read | validation | public static Cookie read(String rawValue) {
notBlank(rawValue, "Cookie value");
final String[] parts = rawValue.split(FIELD_SEPARATOR);
// Extract name and value
final String[] nameAndValue = parts[0].split(NAME_VALUE_SEPARATOR);
if (nameAndValue.length != 2) {
throw new IllegalArgumentException("Cookie must have a valid name and a valid value");
}
final String name = nameAndValue[0].trim();
final String value = nameAndValue[1].trim();
if (name.isEmpty()) {
throw new IllegalArgumentException("Cookie must have a valid name");
}
// Extract other parts
Map<String, String> params = new HashMap<>();
if (parts.length > 1) {
for (String part : parts) {
String[] param = part.split(NAME_VALUE_SEPARATOR);
String paramName = param[0].toLowerCase().trim();
String paramValue = param.length == 2 ? param[1].trim() : "";
params.put(paramName, paramValue);
}
}
final String domain = params.get("domain");
final String path = params.get("path");
final boolean secure = params.containsKey("secure");
final boolean httpOnly = params.containsKey("httponly");
final String maxAgeTt = params.get("max-age");
final String expiresDate = params.get("expires");
Long expires;
Long maxAge = maxAgeTt == null ? null : Long.valueOf(maxAgeTt);
if (expiresDate != null) {
expires = getTime(expiresDate, "EEE, d MMM yyyy HH:mm:ss Z", "EEE, d-MMM-yyyy HH:mm:ss Z", "EEE, d/MMM/yyyy HH:mm:ss Z");
}
else {
expires = null;
}
if (maxAge == null && expires == null) {
maxAge = 0L;
}
else if (maxAge == null) {
maxAge = expires - System.currentTimeMillis();
}
return Cookies.cookie(name, value, domain, path, expires, maxAge, secure, httpOnly);
} | java | {
"resource": ""
} |
q168093 | HttpHeader.header | validation | public static HttpHeader header(String name, String value) {
return new HttpHeader(name, singletonList(value));
} | java | {
"resource": ""
} |
q168094 | HttpHeader.header | validation | public static HttpHeader header(String name, Collection<String> values) {
return new HttpHeader(name, values);
} | java | {
"resource": ""
} |
q168095 | EmbeddedJetty.createdWebAppContext | validation | private WebAppContext createdWebAppContext() throws Exception {
final String path = configuration.getPath();
final String webapp = configuration.getWebapp();
final String classpath = configuration.getClasspath();
final ClassLoader parentClassLoader = configuration.getParentClassLoader();
final String overrideDescriptor = configuration.getOverrideDescriptor();
final Resource baseResource = configuration.getBaseResource();
final String containerJarPattern = configuration.getContainerJarPattern();
final String webInfJarPattern = configuration.getWebInfJarPattern();
WebAppContext ctx = new WebAppContext();
if (containerJarPattern != null) {
ctx.setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, containerJarPattern);
}
else if (JavaUtils.isPostJdk9()) {
// Fix to make TLD scanning works with Java >= 9
ctx.setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, ".*\\.jar");
}
if (webInfJarPattern != null) {
ctx.setAttribute(WebInfConfiguration.WEBINF_JAR_PATTERN, webInfJarPattern);
}
final ClassLoader systemClassLoader = Thread.currentThread().getContextClassLoader();
final ClassLoader classLoader;
if (parentClassLoader != null) {
classLoader = new CompositeClassLoader(parentClassLoader, systemClassLoader);
}
else {
classLoader = systemClassLoader;
}
ctx.setClassLoader(classLoader);
ctx.setContextPath(path);
if (baseResource == null) {
// use default base resource
ctx.setBaseResource(newResource(webapp));
}
else {
ctx.setBaseResource(baseResource);
}
if (overrideDescriptor != null) {
ctx.setOverrideDescriptor(overrideDescriptor);
}
ctx.setConfigurations(new Configuration[] {
new WebInfConfiguration(),
new WebXmlConfiguration(),
new AnnotationConfiguration(),
new JettyWebXmlConfiguration(),
new MetaInfConfiguration(),
new FragmentConfiguration()
});
if (isNotBlank(classpath)) {
// Fix to scan Spring WebApplicationInitializer
// This will add compiled classes to jetty classpath
// See: http://stackoverflow.com/questions/13222071/spring-3-1-webapplicationinitializer-embedded-jetty-8-annotationconfiguration
// And more precisely: http://stackoverflow.com/a/18449506/1215828
File classes = new File(classpath);
PathResource containerResources = new PathResource(classes.toURI());
ctx.getMetaData().addContainerResource(containerResources);
}
ctx.setParentLoaderPriority(true);
ctx.setWar(webapp);
ctx.setServer(server);
// Add server context
server.setHandler(ctx);
return ctx;
} | java | {
"resource": ""
} |
q168096 | AbstractEmbeddedServer.execHooks | validation | private void execHooks(boolean pre) {
for (Hook hook : configuration.getHooks()) {
if (pre) {
hook.pre(this);
}
else {
hook.post(this);
}
}
} | java | {
"resource": ""
} |
q168097 | AnnotationsHandlerRunner.process | validation | private void process(Object target, boolean before) {
List<Field> fields = findAllFields(target.getClass());
for (Field field : fields) {
for (AnnotationHandler handler : handlers) {
processField(target, handler, field, before);
}
}
} | java | {
"resource": ""
} |
q168098 | AnnotationsHandlerRunner.processField | validation | private void processField(Object target, AnnotationHandler handler, Field field, boolean before) {
for (Annotation annotation : field.getAnnotations()) {
if (handler.support(annotation)) {
if (before) {
handler.before(target, field);
}
else {
handler.after(target, field);
}
}
}
} | java | {
"resource": ""
} |
q168099 | ApacheHttpClient.newApacheHttpClient | validation | @Deprecated
public static ApacheHttpClient newApacheHttpClient(EmbeddedServer<?> server, CloseableHttpClient client) {
return new ApacheHttpClient(HttpClientConfiguration.defaultConfiguration(), server, client);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.