> getInvalidSource() {
25 | return invalidSource;
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/backend/backend/src/test/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/SerializingTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import com.fasterxml.jackson.annotation.JsonInclude.Include;
4 | import com.fasterxml.jackson.core.JsonProcessingException;
5 | import com.fasterxml.jackson.databind.JsonNode;
6 | import com.fasterxml.jackson.databind.ObjectMapper;
7 | import com.fasterxml.jackson.databind.PropertyNamingStrategy;
8 | import org.assertj.core.api.Assertions;
9 | import org.junit.jupiter.api.BeforeEach;
10 |
11 | public abstract class SerializingTest {
12 |
13 | protected ObjectMapper objectMapper;
14 |
15 | @BeforeEach
16 | void setUp() {
17 | // This mapper should be configured the same as the one in ServerMain.java
18 | objectMapper =
19 | new ObjectMapper()
20 | .setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE)
21 | .setSerializationInclusion(Include.NON_NULL);
22 | }
23 |
24 | protected void serializedEquals(Object object, String json) throws JsonProcessingException {
25 | JsonNode objectTree = objectMapper.readTree(objectMapper.writeValueAsString(object));
26 | JsonNode jsonTree = objectMapper.readTree(json);
27 | Assertions.assertThat(objectTree).isEqualTo(jsonTree);
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/backend/checkstyle.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/frontend/src/util/json/RepoJsonHelper.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
2 | import { RepoBranch, Repo, Dimension, GithubBotCommand } from "@/store/types";
3 |
4 | /**
5 | * Parses a repo json to a Repo object.
6 | *
7 | * @export
8 | * @param {*} json the json object
9 | * @returns {Repo} the repo object
10 | */
11 | export function repoFromJson(json: any): Repo {
12 | let lastGithubUpdate: Date | undefined;
13 | if (json.last_github_update !== undefined) {
14 | lastGithubUpdate = new Date(json.last_github_update * 1000);
15 | }
16 | return new Repo(
17 | json.id,
18 | json.name,
19 | json.branches.map(repoBranchFromJson),
20 | json.dimensions.map((it: any) => dimensionFromJson(it)),
21 | json.remote_url,
22 | lastGithubUpdate,
23 | );
24 | }
25 |
26 | export function repoBranchFromJson(json: any): RepoBranch {
27 | return new RepoBranch(json.name, json.tracked, json.latest_commit);
28 | }
29 |
30 | export function dimensionFromJson(json: any): Dimension {
31 | return new Dimension(json.benchmark, json.metric, json.unit, json.interpretation);
32 | }
33 |
34 | export function githubCommandFromJson(json: any): GithubBotCommand {
35 | return new GithubBotCommand(json.status, json.comment_id, json.pr_number);
36 | }
37 |
--------------------------------------------------------------------------------
/frontend/src/components/misc/TextChip.vue:
--------------------------------------------------------------------------------
1 |
2 |
11 | {{ text }}
12 |
13 |
14 |
15 |
45 |
46 |
54 |
--------------------------------------------------------------------------------
/backend/shared/src/main/java/de/aaaaaaah/velcom/shared/GitProperties.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared;
2 |
3 | import java.io.IOException;
4 | import java.util.Properties;
5 |
6 | /**
7 | * Provides some build information such as the build time, commit hash or version.
8 | *
9 | * When changing this, also update the sections marked with the comment "Current commit hash
10 | * available to jars" in backend/pom.xml and runner/pom.xml.
11 | */
12 | public class GitProperties {
13 |
14 | private static final Properties PROPERTIES;
15 |
16 | static {
17 | PROPERTIES = new Properties();
18 | try {
19 | PROPERTIES.load(GitProperties.class.getResourceAsStream("/git.properties"));
20 | } catch (IOException e) {
21 | throw new RuntimeException("Could not initialize git properties", e);
22 | }
23 | }
24 |
25 | public static String getBuildTime() {
26 | return PROPERTIES.getProperty("git.build.time");
27 | }
28 |
29 | public static String getVersion() {
30 | return PROPERTIES.getProperty("git.build.version");
31 | }
32 |
33 | public static String getHash() {
34 | return PROPERTIES.getProperty("git.commit.id.full");
35 | }
36 |
37 | public static String getHashAbbrev() {
38 | return PROPERTIES.getProperty("git.commit.id.abbrev");
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/frontend/src/util/GraphVariantSelection.ts:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import EchartsDetailGraph from "@/components/graphs/graph/EchartsDetailGraph.vue";
3 | import DytailGraph from "@/components/graphs/graph/DytailGraph.vue";
4 |
5 | export type GraphVariant = {
6 | component: typeof Vue;
7 | name: string;
8 | };
9 |
10 | type GraphVariantPredicate = GraphVariant & {
11 | predicate: (visiblePoints: number) => boolean;
12 | };
13 |
14 | export const availableGraphComponents: GraphVariantPredicate[] = [
15 | {
16 | predicate: (visiblePoints: number): boolean => {
17 | // Do not care about zooming, only use echarts when he have only a handful of data points
18 | return visiblePoints < 30_000;
19 | },
20 | component: EchartsDetailGraph,
21 | name: "Fancy",
22 | },
23 | {
24 | predicate: (): boolean => {
25 | // matches from first to last. this one is the fallback
26 | return true;
27 | },
28 | component: DytailGraph,
29 | name: "Fast",
30 | },
31 | ];
32 |
33 | /**
34 | * Selets a fitting graph variant.
35 | *
36 | * @param visiblePoints the amount of visible points
37 | */
38 | export function selectGraphVariant(visiblePoints: number): GraphVariant | undefined {
39 | return availableGraphComponents.find((it) => it.predicate(visiblePoints));
40 | }
41 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/access/repoaccess/exceptions/FailedToAddRepoException.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.repoaccess.exceptions;
2 |
3 | import de.aaaaaaah.velcom.backend.access.repoaccess.entities.RemoteUrl;
4 | import de.aaaaaaah.velcom.shared.util.StringHelper;
5 |
6 | // TODO: 04.10.20 Update the db schema to make repo names unique and update javadoc
7 | // Add this text to the javadoc below once the db schema has been updated:
8 | // This is most likely due to another repo with the same name already existing.
9 |
10 | /** This exception is thrown when a repo could not be added into the db. */
11 | public class FailedToAddRepoException extends RuntimeException {
12 |
13 | private final String name;
14 | private final RemoteUrl remoteUrl;
15 |
16 | public FailedToAddRepoException(Throwable t, String name, RemoteUrl remoteUrl) {
17 | super(
18 | "failed to add repo named "
19 | + StringHelper.quote(name)
20 | + " for remote url "
21 | + StringHelper.quote(remoteUrl.getUrl()),
22 | t);
23 |
24 | this.name = name;
25 | this.remoteUrl = remoteUrl;
26 | }
27 |
28 | public String getName() {
29 | return name;
30 | }
31 |
32 | public RemoteUrl getRemoteUrl() {
33 | return remoteUrl;
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/storage/repo/exception/AddRepositoryException.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.storage.repo.exception;
2 |
3 | import java.util.Objects;
4 |
5 | /** An exception that occurs when trying to add a repository to a repo storage fails. */
6 | public class AddRepositoryException extends Exception {
7 |
8 | private final String dirName;
9 | private final String remoteUrl;
10 |
11 | /**
12 | * Constructs a new {@link AddRepositoryException}.
13 | *
14 | * @param dirName the directory name for the repository
15 | * @param remoteUrl the remote url of the repository
16 | * @param cause the cause
17 | */
18 | public AddRepositoryException(String dirName, String remoteUrl, Throwable cause) {
19 | super("failed to add repository to directory \"" + dirName + "\": " + remoteUrl, cause);
20 | this.dirName = Objects.requireNonNull(dirName);
21 | this.remoteUrl = Objects.requireNonNull(remoteUrl);
22 | }
23 |
24 | /**
25 | * @return Returns the directory that should have been the directory for the repository
26 | */
27 | public String getDirName() {
28 | return dirName;
29 | }
30 |
31 | /**
32 | * @return Returns the remote url of the repository
33 | */
34 | public String getRemoteUrl() {
35 | return remoteUrl;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/endpoints/DimensionsEndpoint.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.endpoints;
2 |
3 | import de.aaaaaaah.velcom.backend.access.dimensionaccess.DimensionWriteAccess;
4 | import de.aaaaaaah.velcom.backend.restapi.authentication.Admin;
5 | import de.aaaaaaah.velcom.backend.restapi.jsonobjects.JsonDimensionId;
6 | import io.dropwizard.auth.Auth;
7 | import io.micrometer.core.annotation.Timed;
8 | import java.util.List;
9 | import java.util.stream.Collectors;
10 | import javax.validation.constraints.NotNull;
11 | import javax.ws.rs.DELETE;
12 | import javax.ws.rs.Path;
13 | import javax.ws.rs.Produces;
14 | import javax.ws.rs.core.MediaType;
15 |
16 | /** Endpoint for deleting dimensions. */
17 | @Path("/dimensions/")
18 | @Produces(MediaType.APPLICATION_JSON)
19 | public class DimensionsEndpoint {
20 |
21 | private final DimensionWriteAccess dimensionAccess;
22 |
23 | public DimensionsEndpoint(DimensionWriteAccess dimensionAccess) {
24 | this.dimensionAccess = dimensionAccess;
25 | }
26 |
27 | @DELETE
28 | @Timed(histogram = true)
29 | public void delete(@Auth Admin admin, @NotNull List request) {
30 | dimensionAccess.deleteDimensions(
31 | request.stream().map(JsonDimensionId::toDimension).collect(Collectors.toList()));
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/storage/repo/exception/NoSuchRepositoryException.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.storage.repo.exception;
2 |
3 | import de.aaaaaaah.velcom.backend.storage.repo.RepoStorage;
4 | import java.util.NoSuchElementException;
5 |
6 | /**
7 | * An exception that occurs when trying to access a repository stored in a {@link RepoStorage} which
8 | * does not exist.
9 | */
10 | public class NoSuchRepositoryException extends NoSuchElementException {
11 |
12 | private final String dirName;
13 | private final RepoStorage storage;
14 |
15 | /**
16 | * Consturcts a new {@link NoSuchRepositoryException}.
17 | *
18 | * @param dirName the directory that is missing a repository
19 | * @param storage the storage
20 | */
21 | public NoSuchRepositoryException(String dirName, RepoStorage storage) {
22 | super("no repository exists with given name " + dirName + " in storage " + storage);
23 | this.dirName = dirName;
24 | this.storage = storage;
25 | }
26 |
27 | /**
28 | * @return the directory that is missing the repository
29 | */
30 | public String getDirName() {
31 | return dirName;
32 | }
33 |
34 | /**
35 | * @return the storage where the repository is missing in
36 | */
37 | public RepoStorage getStorage() {
38 | return storage;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/runner/single/TeleBinaryOutputStream.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.runner.single;
2 |
3 | import java.io.IOException;
4 | import java.io.OutputStream;
5 | import java.nio.ByteBuffer;
6 | import org.eclipse.jetty.websocket.api.Session;
7 |
8 | /** A binary output stream streaming data to the runner. */
9 | class TeleBinaryOutputStream extends OutputStream {
10 |
11 | private static final int DEFAULT_BUFFER_SIZE = 1024; // 1 MB
12 |
13 | private boolean closed;
14 | private ByteBuffer buffer;
15 | private final Session session;
16 |
17 | public TeleBinaryOutputStream(Session session) {
18 | this.session = session;
19 | this.buffer = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
20 | }
21 |
22 | @Override
23 | public void write(int b) throws IOException {
24 | if (!buffer.hasRemaining()) {
25 | buffer.rewind();
26 | session.getRemote().sendPartialBytes(buffer, false);
27 | buffer = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
28 | }
29 | buffer.put((byte) b);
30 | }
31 |
32 | @Override
33 | public void close() throws IOException {
34 | if (closed) {
35 | return;
36 | }
37 | buffer.limit(buffer.position());
38 | buffer.rewind();
39 | session.getRemote().sendPartialBytes(buffer, true);
40 | closed = true;
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/frontend/src/util/DayEquidistantUtils.ts:
--------------------------------------------------------------------------------
1 | import { GraphDataPoint } from "@/store/types";
2 |
3 | const millisPerDay: number = 1000 * 60 * 60 * 24;
4 |
5 | // https://stackoverflow.com/questions/14446511/most-efficient-method-to-groupby-on-an-array-of-objects
6 | export function groupBy(list: V[], keyGetter: (value: V) => K): Map {
7 | const map = new Map();
8 | list.forEach((item) => {
9 | const key = keyGetter(item);
10 | const collection = map.get(key);
11 | if (!collection) {
12 | map.set(key, [item]);
13 | } else {
14 | collection.push(item);
15 | }
16 | });
17 | return map;
18 | }
19 |
20 | export function spaceDayEquidistant(detailGraph: T[]): T[] {
21 | const dayGroups: Map = groupBy(
22 | detailGraph,
23 | (key) =>
24 | // round to day
25 | Math.floor(key.committerTime.getTime() / millisPerDay) * millisPerDay,
26 | );
27 |
28 | const groupEntries = Array.from(dayGroups.entries());
29 | groupEntries.sort((a, b) => a[0] - b[0]);
30 |
31 | return groupEntries.flatMap(([day, points]) => {
32 | const spacingBetweenElementsMillis = millisPerDay / points.length;
33 |
34 | return points.map((point, index) => {
35 | return point.positionedAt(new Date(day + spacingBetweenElementsMillis * index)) as T;
36 | });
37 | });
38 | }
39 |
--------------------------------------------------------------------------------
/backend/backend/src/main/resources/db/migration/V12__commit_tracking_flags.sql:
--------------------------------------------------------------------------------
1 | ALTER TABLE known_commit RENAME TO known_commit_old;
2 |
3 | CREATE TABLE known_commit (
4 | repo_id CHAR(36) NOT NULL,
5 | hash CHAR(40) NOT NULL,
6 | reachable BOOLEAN NOT NULL, -- Whether this commit is reachable from any branch
7 | tracked BOOLEAN NOT NULL, -- Whether this commit is reachable from a tracked branch
8 | ever_tracked BOOLEAN NOT NULL, -- Whether this commit has ever been tracked
9 | author TEXT NOT NULL,
10 | author_date TIMESTAMP NOT NULL,
11 | committer TEXT NOT NULL,
12 | committer_date TIMESTAMP NOT NULL,
13 | message TEXT NOT NULL,
14 |
15 | -- "tracked" implies "ever_tracked"
16 | CHECK (NOT tracked OR ever_tracked),
17 |
18 | PRIMARY KEY (repo_id, hash),
19 | FOREIGN KEY (repo_id) REFERENCES repo (id) ON UPDATE CASCADE ON DELETE CASCADE
20 | );
21 |
22 | INSERT INTO known_commit
23 | SELECT
24 | repo_id,
25 | hash,
26 | reachable,
27 | tracked,
28 | tracked,
29 | author,
30 | author_date,
31 | committer,
32 | committer_date,
33 | message
34 | FROM known_commit_old;
35 |
36 | DROP TABLE known_commit_old;
37 |
38 | -- Recapture foreign key references
39 | ALTER TABLE known_commit RENAME TO known_commit_old;
40 | ALTER TABLE known_commit_old RENAME TO known_commit;
41 |
--------------------------------------------------------------------------------
/backend/runner/src/main/java/de/aaaaaaah/velcom/runner/Delays.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.runner;
2 |
3 | import java.time.Duration;
4 |
5 | /** A class for keeping all kinds of runner-related delays and timeouts. */
6 | public final class Delays {
7 |
8 | /**
9 | * How long to wait for a reconnect when creating a connection fails. This delay prevents flooding
10 | * the server on the other end with too many connection attempts.
11 | */
12 | public static final Duration RECONNECT_AFTER_FAILED_CONNECTION = Duration.ofSeconds(10);
13 |
14 | /**
15 | * How long to wait for a server response when trying to close a connection before force-closing
16 | * it.
17 | */
18 | public static final Duration CLOSE_CONNECTION_TIMEOUT = Duration.ofSeconds(10);
19 |
20 | /** How long to pause in-between rounds of asking the backends for new benchmarks. */
21 | public static final Duration BACKEND_ROUNDTRIP = Duration.ofSeconds(10);
22 |
23 | /** How long to wait - after sending a command to the server - for a reply to that command. */
24 | public static final Duration AWAIT_COMMAND_REPLY = Duration.ofSeconds(10);
25 |
26 | /** How long to wait until the sigkilling begins (in the Benchmarker). */
27 | public static final Duration TIME_TO_KILL = Duration.ofSeconds(10);
28 |
29 | private Delays() {
30 | throw new UnsupportedOperationException();
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/storage/repo/exception/RepositoryAcquisitionException.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.storage.repo.exception;
2 |
3 | import de.aaaaaaah.velcom.backend.storage.repo.RepoStorage;
4 |
5 | /** An exception that occurs when the acquisition of a local repository has failed. */
6 | public class RepositoryAcquisitionException extends Exception {
7 |
8 | private final RepoStorage repoStorage;
9 | private final String dirName;
10 |
11 | /**
12 | * Constructs a new {@link RepositoryAcquisitionException}.
13 | *
14 | * @param repoStorage the storage wherein the acquisition was attempted
15 | * @param dirName the directory name of the repository to acquire
16 | * @param e the cause for this exception
17 | */
18 | public RepositoryAcquisitionException(RepoStorage repoStorage, String dirName, Exception e) {
19 | super("Failed to acquire repository " + dirName + " in storage " + repoStorage, e);
20 | this.repoStorage = repoStorage;
21 | this.dirName = dirName;
22 | }
23 |
24 | /**
25 | * @return the storage wherein the acquisition was attempted
26 | */
27 | public RepoStorage getRepoStorage() {
28 | return repoStorage;
29 | }
30 |
31 | /**
32 | * @return the directory name of the repository to acquire
33 | */
34 | public String getDirName() {
35 | return dirName;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/backend/shared/src/main/java/de/aaaaaaah/velcom/shared/util/Pair.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.util;
2 |
3 | import java.util.Objects;
4 |
5 | /**
6 | * A simple key-value pair.
7 | *
8 | * This pair has a consistent {@link #equals(Object)} and {@link #hashCode()} method, if the two
9 | * element types have one.
10 | *
11 | * @param the type of the first element in the pair
12 | * @param the type of the second element in the pair
13 | */
14 | public class Pair {
15 |
16 | private final A first;
17 | private final B second;
18 |
19 | public Pair(A first, B second) {
20 | this.first = first;
21 | this.second = second;
22 | }
23 |
24 | public A getFirst() {
25 | return first;
26 | }
27 |
28 | public B getSecond() {
29 | return second;
30 | }
31 |
32 | @Override
33 | public boolean equals(Object o) {
34 | if (this == o) {
35 | return true;
36 | }
37 | if (o == null || getClass() != o.getClass()) {
38 | return false;
39 | }
40 | Pair pair = (Pair) o;
41 | return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
42 | }
43 |
44 | @Override
45 | public int hashCode() {
46 | return Objects.hash(first, second);
47 | }
48 |
49 | @Override
50 | public String toString() {
51 | return "Pair{" + "first=" + first + ", second=" + second + '}';
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/backend/shared/src/test/java/de/aaaaaaah/velcom/shared/util/ExceptionHelperTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.util;
2 |
3 | import static org.assertj.core.api.Assertions.assertThat;
4 |
5 | import org.junit.jupiter.api.Test;
6 |
7 | class ExceptionHelperTest {
8 |
9 | @Test
10 | void containsThisClass() {
11 | String stackTrace = ExceptionHelper.getStackTrace(new Throwable());
12 | assertThat(stackTrace).contains("ExceptionHelperTest").contains("containsThisClass");
13 | }
14 |
15 | @Test
16 | void containsNestedStacktrace() {
17 | RuntimeException inner = new RuntimeException("hello there");
18 | RuntimeException outer = new RuntimeException(inner);
19 |
20 | String stackTrace = ExceptionHelper.getStackTrace(outer);
21 | assertThat(stackTrace)
22 | .contains("ExceptionHelperTest")
23 | .contains("containsNestedStacktrace")
24 | .contains("hello there");
25 | }
26 |
27 | @Test
28 | void containsSuppressedStacktrace() {
29 | RuntimeException inner = new RuntimeException("hello there");
30 | RuntimeException outer = new RuntimeException();
31 | outer.addSuppressed(inner);
32 |
33 | String stackTrace = ExceptionHelper.getStackTrace(outer);
34 | assertThat(stackTrace)
35 | .contains("ExceptionHelperTest")
36 | .contains("containsSuppressedStacktrace")
37 | .contains("hello there");
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/data/significance/SignificanceFactors.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.data.significance;
2 |
3 | /**
4 | * A few factors describing how the standard deviation and significance of a run should be
5 | * determined.
6 | */
7 | public class SignificanceFactors {
8 |
9 | private final double relativeThreshold;
10 | private final double stddevThreshold;
11 | private final int minStddevAmount;
12 |
13 | public SignificanceFactors(
14 | double relativeThreshold, double stddevThreshold, int minStddevAmount) {
15 |
16 | if (relativeThreshold < 0) {
17 | throw new IllegalArgumentException("relative threshold must be >= 0");
18 | }
19 | if (stddevThreshold < 0) {
20 | throw new IllegalArgumentException("stddev threshold must be >= 0");
21 | }
22 | if (minStddevAmount < 2) {
23 | throw new IllegalArgumentException("minimum stddev amount must be at least 2");
24 | }
25 |
26 | this.relativeThreshold = relativeThreshold;
27 | this.stddevThreshold = stddevThreshold;
28 | this.minStddevAmount = minStddevAmount;
29 | }
30 |
31 | public double getRelativeThreshold() {
32 | return relativeThreshold;
33 | }
34 |
35 | public double getStddevThreshold() {
36 | return stddevThreshold;
37 | }
38 |
39 | public int getMinStddevAmount() {
40 | return minStddevAmount;
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/backend/shared/src/main/java/de/aaaaaaah/velcom/shared/protocol/serialization/clientbound/ClientBoundPacket.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.clientbound;
2 |
3 | import com.fasterxml.jackson.annotation.JsonCreator;
4 | import com.fasterxml.jackson.annotation.JsonProperty;
5 | import com.fasterxml.jackson.databind.JsonNode;
6 | import java.util.Objects;
7 |
8 | /** A packet that can be sent to the runner by the backend. */
9 | public class ClientBoundPacket {
10 |
11 | private final ClientBoundPacketType type;
12 | private final JsonNode data;
13 |
14 | @JsonCreator
15 | public ClientBoundPacket(
16 | @JsonProperty(required = true) ClientBoundPacketType type,
17 | @JsonProperty(required = true) JsonNode data) {
18 | this.type = type;
19 | this.data = data;
20 | }
21 |
22 | public ClientBoundPacketType getType() {
23 | return type;
24 | }
25 |
26 | public JsonNode getData() {
27 | return data;
28 | }
29 |
30 | @Override
31 | public boolean equals(Object o) {
32 | if (this == o) {
33 | return true;
34 | }
35 | if (o == null || getClass() != o.getClass()) {
36 | return false;
37 | }
38 | ClientBoundPacket that = (ClientBoundPacket) o;
39 | return type == that.type && data.equals(that.data);
40 | }
41 |
42 | @Override
43 | public int hashCode() {
44 | return Objects.hash(type, data);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/backend/backend/src/test/java/de/aaaaaaah/velcom/backend/access/dimensionaccess/entities/DimensionTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.dimensionaccess.entities;
2 |
3 | import static org.assertj.core.api.Assertions.assertThat;
4 |
5 | import org.junit.jupiter.api.Test;
6 |
7 | class DimensionTest {
8 |
9 | @SuppressWarnings("EqualsWithItself")
10 | @Test
11 | void compareDimensions() {
12 | Dimension dimAA = new Dimension("a", "a");
13 | Dimension dimAB = new Dimension("a", "b");
14 | Dimension dimBA = new Dimension("b", "a");
15 | Dimension dimBB = new Dimension("b", "b");
16 |
17 | assertThat(dimAA.compareTo(dimAA)).isEqualTo(0);
18 | assertThat(dimAA).isLessThan(dimAB);
19 | assertThat(dimAA).isLessThan(dimBA);
20 | assertThat(dimAA).isLessThan(dimBB);
21 |
22 | assertThat(dimAB).isGreaterThan(dimAA);
23 | assertThat(dimAB.compareTo(dimAB)).isEqualTo(0);
24 | assertThat(dimAB).isLessThan(dimBA);
25 | assertThat(dimAB).isLessThan(dimBB);
26 |
27 | assertThat(dimBA).isGreaterThan(dimAA);
28 | assertThat(dimBA).isGreaterThan(dimAB);
29 | assertThat(dimBA.compareTo(dimBA)).isEqualTo(0);
30 | assertThat(dimBA).isLessThan(dimBB);
31 |
32 | assertThat(dimBB).isGreaterThan(dimAA);
33 | assertThat(dimBB).isGreaterThan(dimAB);
34 | assertThat(dimBB).isGreaterThan(dimBA);
35 | assertThat(dimBB.compareTo(dimBB)).isEqualTo(0);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/frontend/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | VelCom
9 |
10 |
20 |
21 |
22 |
39 |
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/access/benchmarkaccess/entities/RunError.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities;
2 |
3 | import java.util.Objects;
4 |
5 | /**
6 | * Occurs when either the benchmark script cause a global error or the runner itself fails to
7 | * execute the benchmark script.
8 | */
9 | public class RunError {
10 |
11 | private final String errorMessage;
12 | private final RunErrorType type;
13 |
14 | public RunError(String errorMessage, RunErrorType type) {
15 | this.errorMessage = Objects.requireNonNull(errorMessage);
16 | this.type = Objects.requireNonNull(type);
17 | }
18 |
19 | public String getMessage() {
20 | return errorMessage;
21 | }
22 |
23 | public RunErrorType getType() {
24 | return type;
25 | }
26 |
27 | @Override
28 | public boolean equals(Object o) {
29 | if (this == o) {
30 | return true;
31 | }
32 | if (o == null || getClass() != o.getClass()) {
33 | return false;
34 | }
35 | RunError runError = (RunError) o;
36 | return Objects.equals(errorMessage, runError.errorMessage) && type == runError.type;
37 | }
38 |
39 | @Override
40 | public int hashCode() {
41 | return Objects.hash(errorMessage, type);
42 | }
43 |
44 | @Override
45 | public String toString() {
46 | return "RunError{" + "errorMessage='" + errorMessage + '\'' + ", type=" + type + '}';
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/backend/shared/src/test/java/de/aaaaaaah/velcom/shared/util/systeminfo/LinuxSystemInfoTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.util.systeminfo;
2 |
3 | import static org.assertj.core.api.Assertions.assertThat;
4 | import static org.junit.jupiter.api.Assumptions.assumeFalse;
5 |
6 | import de.aaaaaaah.velcom.shared.util.OSCheck;
7 | import org.junit.jupiter.api.BeforeEach;
8 | import org.junit.jupiter.api.Test;
9 |
10 | class LinuxSystemInfoTest {
11 |
12 | private LinuxSystemInfo systemInfo;
13 |
14 | @BeforeEach
15 | void setUp() {
16 | systemInfo = LinuxSystemInfo.getCurrent();
17 | }
18 |
19 | @Test
20 | void hasPlausibleCpuInfo() {
21 | assumeFalse(OSCheck.isStupidWindows());
22 |
23 | assertThat(systemInfo.getCpuInfo().cpuCount()).isGreaterThan(0);
24 | assertThat(systemInfo.getCpuInfo().physicalCoreCount()).isGreaterThan(0);
25 | assertThat(systemInfo.getCpuInfo().coreModels()).hasSizeGreaterThanOrEqualTo(1);
26 |
27 | assertThat(systemInfo.getCpuInfo().virtualCoreCount())
28 | .isGreaterThanOrEqualTo(Runtime.getRuntime().availableProcessors());
29 | }
30 |
31 | @Test
32 | void hasPlausibleMemoryInfo() {
33 | assumeFalse(OSCheck.isStupidWindows());
34 |
35 | assertThat(systemInfo.getMemoryInfo().freeMemoryKiB()).isGreaterThanOrEqualTo(0);
36 | assertThat(systemInfo.getMemoryInfo().totalMemoryKib())
37 | .isGreaterThanOrEqualTo(Runtime.getRuntime().maxMemory() / 1024);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonRepo.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import java.util.List;
4 | import java.util.UUID;
5 | import javax.annotation.Nullable;
6 |
7 | public class JsonRepo {
8 |
9 | private final UUID id;
10 | private final String name;
11 | private final String remoteUrl;
12 | private final List branches;
13 | private final List dimensions;
14 | @Nullable private final Long lastGithubUpdate;
15 |
16 | public JsonRepo(
17 | UUID id,
18 | String name,
19 | String remoteUrl,
20 | List branches,
21 | List dimensions,
22 | @Nullable Long lastGithubUpdate) {
23 |
24 | this.id = id;
25 | this.name = name;
26 | this.remoteUrl = remoteUrl;
27 | this.branches = branches;
28 | this.dimensions = dimensions;
29 | this.lastGithubUpdate = lastGithubUpdate;
30 | }
31 |
32 | public UUID getId() {
33 | return id;
34 | }
35 |
36 | public String getName() {
37 | return name;
38 | }
39 |
40 | public String getRemoteUrl() {
41 | return remoteUrl;
42 | }
43 |
44 | public List getBranches() {
45 | return branches;
46 | }
47 |
48 | public List getDimensions() {
49 | return dimensions;
50 | }
51 |
52 | @Nullable
53 | public Long getLastGithubUpdate() {
54 | return lastGithubUpdate;
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/backend/backend/src/test/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonRunTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import com.fasterxml.jackson.core.JsonProcessingException;
4 | import java.util.UUID;
5 | import org.junit.jupiter.api.Test;
6 |
7 | class JsonRunTest extends SerializingTest {
8 |
9 | @Test
10 | void serialize() throws JsonProcessingException {
11 | Object object =
12 | new JsonRun(
13 | UUID.fromString("24dd4fd3-5c6d-4542-a7a4-b181f37295a6"),
14 | "authorName",
15 | "runnerName",
16 | "runnerInfoText",
17 | 1596881630,
18 | 1596881676,
19 | JsonSource.tarSource("descriptionText", null),
20 | JsonResult.velcomError("velcomErrorText"));
21 | String json =
22 | "{"
23 | + "\"id\": \"24dd4fd3-5c6d-4542-a7a4-b181f37295a6\","
24 | + "\"author\": \"authorName\","
25 | + "\"runner_name\": \"runnerName\","
26 | + "\"runner_info\": \"runnerInfoText\","
27 | + "\"start_time\": 1596881630,"
28 | + "\"stop_time\": 1596881676,"
29 | + "\"source\": {"
30 | + " \"type\": \"UPLOADED_TAR\","
31 | + " \"source\": {\"description\": \"descriptionText\"}"
32 | + "},"
33 | + "\"result\": {\"velcom_error\": \"velcomErrorText\"}"
34 | + "}";
35 | serializedEquals(object, json);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/runner/single/state/AwaitAbortRunReply.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.runner.single.state;
2 |
3 | import de.aaaaaaah.velcom.backend.runner.single.RunnerConnection;
4 | import de.aaaaaaah.velcom.backend.runner.single.TeleRunner;
5 | import de.aaaaaaah.velcom.shared.protocol.serialization.serverbound.AbortRunReply;
6 | import de.aaaaaaah.velcom.shared.protocol.serialization.serverbound.ServerBoundPacket;
7 | import de.aaaaaaah.velcom.shared.protocol.serialization.serverbound.ServerBoundPacketType;
8 | import java.util.Optional;
9 |
10 | /** A state waiting for a reply to the GetResult message. */
11 | public class AwaitAbortRunReply extends TimeoutState {
12 |
13 | public AwaitAbortRunReply(TeleRunner runner, RunnerConnection connection) {
14 | super(runner, connection);
15 | }
16 |
17 | @Override
18 | protected Optional onPacket(ServerBoundPacket packet) {
19 | return super.onPacket(packet)
20 | .or(
21 | () ->
22 | Optional.of(packet)
23 | .filter(it -> it.getType() == ServerBoundPacketType.ABORT_RUN_REPLY)
24 | .flatMap(
25 | it ->
26 | connection
27 | .getSerializer()
28 | .deserialize(it.getData(), AbortRunReply.class))
29 | .map(reply -> new IdleState(runner, connection)));
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/backend/runner/src/main/java/de/aaaaaaah/velcom/runner/RunnerCliSpec.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.runner;
2 |
3 | import java.nio.file.Files;
4 | import java.nio.file.Path;
5 | import java.nio.file.Paths;
6 | import java.util.function.Function;
7 | import net.jbock.Command;
8 | import net.jbock.Param;
9 |
10 | /** The runner for VelCom that executes benchmarks. Made by Aaaaaaah! */
11 | @Command(value = "VelCom-Runner")
12 | public abstract class RunnerCliSpec {
13 |
14 | /** The path to the config file. */
15 | @Param(value = 1, mappedBy = ConfigFilePathMapper.class)
16 | public abstract Path configFileLocation();
17 |
18 | /** A mapper for the config file location. */
19 | public static class ConfigFilePathMapper implements Function {
20 |
21 | @Override
22 | public Path apply(String name) {
23 | Path path = Paths.get(name);
24 | if (Files.notExists(path)) {
25 | throw new IllegalArgumentException(
26 | "The given path (" + path.toAbsolutePath() + ") does not exist!");
27 | }
28 | if (!Files.isRegularFile(path)) {
29 | throw new IllegalArgumentException(
30 | "The given path (" + path.toAbsolutePath() + ") is no regular file!");
31 | }
32 | if (!Files.isReadable(path)) {
33 | throw new IllegalArgumentException(
34 | "The given path (" + path.toAbsolutePath() + ") is not readable by me!");
35 | }
36 | return path.toAbsolutePath();
37 | }
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/exception/TaskAlreadyExistsExceptionMapper.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.exception;
2 |
3 | import java.util.UUID;
4 | import javax.ws.rs.core.Response;
5 | import javax.ws.rs.core.Response.Status;
6 | import javax.ws.rs.ext.ExceptionMapper;
7 |
8 | /** An {@link ExceptionMapper} that transforms {@link TaskAlreadyExistsException}s to CONFLICT. */
9 | public class TaskAlreadyExistsExceptionMapper
10 | implements ExceptionMapper {
11 |
12 | @Override
13 | public Response toResponse(TaskAlreadyExistsException exception) {
14 | return Response.status(Status.CONFLICT)
15 | .entity(
16 | new Info(
17 | "that task already exists in the queue",
18 | exception.getRepoId().getId(),
19 | exception.getHash().getHash()))
20 | .build();
21 | }
22 |
23 | private static class Info {
24 |
25 | private final String message;
26 | private final UUID repoId;
27 | private final String hash;
28 |
29 | public Info(String message, UUID repoId, String hash) {
30 | this.message = message;
31 | this.repoId = repoId;
32 | this.hash = hash;
33 | }
34 |
35 | public String getMessage() {
36 | return message;
37 | }
38 |
39 | public UUID getRepoId() {
40 | return repoId;
41 | }
42 |
43 | public String getHash() {
44 | return hash;
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/cli/velcom_cli/__init__.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import configparser
3 | from pathlib import Path
4 |
5 | from . import commands
6 | from .config import Config
7 |
8 |
9 | def make_parser():
10 | parser = argparse.ArgumentParser()
11 | parser.add_argument(
12 | "--config", "-c",
13 | type=Path,
14 | metavar="CONFIGFILE",
15 | help="load config from CONFIGFILE instead of the default"
16 | " paths (~/.config/velcom/velcom.conf, ~/.velcom.conf)",
17 | )
18 | parser.add_argument(
19 | "--profile", "-p",
20 | metavar="PROFILE",
21 | help="name of the config file section to use",
22 | )
23 |
24 | subparsers = parser.add_subparsers(
25 | required=True,
26 | # A metavar or dest is necessary for "required=True" to not crash when
27 | # arguments contain no command. See https://bugs.python.org/issue29298
28 | metavar="COMMAND",
29 | help="one of the following commands:",
30 | )
31 |
32 | commands.bench_dir.register(subparsers)
33 | commands.default_config.register(subparsers)
34 | commands.list_repos.register(subparsers)
35 | commands.print_config.register(subparsers)
36 |
37 | return parser
38 |
39 |
40 | def main():
41 | args = make_parser().parse_args()
42 | config = Config.load(args)
43 | try:
44 | args.f(config)
45 | except configparser.Error as e:
46 | print("Configuration error:")
47 | print(e)
48 | exit(1)
49 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonTask.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import de.aaaaaaah.velcom.backend.access.committaccess.CommitReadAccess;
4 | import de.aaaaaaah.velcom.backend.access.taskaccess.entities.Task;
5 | import java.util.UUID;
6 |
7 | public class JsonTask {
8 |
9 | private final UUID id;
10 | private final String author;
11 | private final long since;
12 | private final JsonSource source;
13 |
14 | public JsonTask(UUID id, String author, long since, JsonSource source) {
15 | this.id = id;
16 | this.author = author;
17 | this.since = since;
18 | this.source = source;
19 | }
20 |
21 | public static JsonTask fromTask(Task task, JsonSource source) {
22 | return new JsonTask(
23 | task.getId().getId(), task.getAuthor(), task.getInsertTime().getEpochSecond(), source);
24 | }
25 |
26 | public static JsonTask fromTask(Task task, CommitReadAccess commitAccess) {
27 | return fromTask(
28 | task,
29 | task.getSource()
30 | .mapLeft(it -> commitAccess.getCommit(it.getRepoId(), it.getHash()))
31 | .consume(JsonSource::fromCommit, JsonSource::fromTarSource));
32 | }
33 |
34 | public UUID getId() {
35 | return id;
36 | }
37 |
38 | public String getAuthor() {
39 | return author;
40 | }
41 |
42 | public long getSince() {
43 | return since;
44 | }
45 |
46 | public JsonSource getSource() {
47 | return source;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/frontend/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "frontend",
3 | "version": "0.1.0",
4 | "private": true,
5 | "scripts": {
6 | "serve": "vue-cli-service serve",
7 | "build": "vue-cli-service build",
8 | "lint": "vue-cli-service lint --no-fix",
9 | "fmt": "prettier . --write",
10 | "fmtchk": "prettier . --check"
11 | },
12 | "dependencies": {
13 | "@types/dygraphs": "^1.1.11",
14 | "ansi_up": "^5.1.0",
15 | "axios": "^1.6.0",
16 | "core-js": "^3.29.1",
17 | "dygraphs": "I-Al-Istannen/dygraphs#1e0170e98b5e8501d0ab12d897e14b1b322bd169",
18 | "vue": "^2.6.14",
19 | "echarts": "^5.4.1",
20 | "vue-class-component": "^7.2.6",
21 | "vue-echarts": "^6.5.4",
22 | "vue-property-decorator": "^9.1.2",
23 | "vue-router": "^3.5.2",
24 | "vuetify": "^2.6.10",
25 | "vuex": "^3.6.2",
26 | "vuex-class-component": "^2.3.6",
27 | "vuex-persist": "^2.2.0"
28 | },
29 | "devDependencies": {
30 | "@mdi/js": "^7.1.96",
31 | "@types/echarts": "^4.9.16",
32 | "@vue/cli-plugin-babel": "^5.0.8",
33 | "@vue/cli-plugin-router": "^5.0.8",
34 | "@vue/cli-plugin-typescript": "^5.0.8",
35 | "@vue/cli-plugin-vuex": "^5.0.8",
36 | "@vue/cli-service": "5.0.8",
37 | "@vue/composition-api": "^1.7.1",
38 | "prettier": "^3.6.2",
39 | "sass": "~1.59.3",
40 | "sass-loader": "^13.2.0",
41 | "typescript": "~5.0.2",
42 | "vue-cli-plugin-vuetify": "~2.5.8",
43 | "vue-template-compiler": "^2.7.14",
44 | "vuetify-loader": "^1.9.2"
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/frontend/src/util/json/QueueJsonHelper.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
2 | import {
3 | Task,
4 | TaskSource,
5 | TarTaskSource,
6 | CommitTaskSource,
7 | CommitDescription,
8 | Worker,
9 | StreamedRunnerOutput,
10 | } from "@/store/types";
11 |
12 | export function workerFromJson(json: any): Worker {
13 | return new Worker(
14 | json.name,
15 | json.info,
16 | json.working_on,
17 | json.working_since ? new Date(json.working_since * 1000) : null,
18 | json.lost_connection,
19 | );
20 | }
21 |
22 | export function taskFromJson(json: any): Task {
23 | return new Task(json.id, json.author, new Date(json.since * 1000), sourceFromJson(json.source));
24 | }
25 |
26 | export function sourceFromJson(json: any): TaskSource {
27 | if (json.type === "COMMIT") {
28 | return new CommitTaskSource(commitDescriptionFromJson(json.source));
29 | } else if (json.type === "UPLOADED_TAR") {
30 | return new TarTaskSource(json.source.description, json.source.repo_id);
31 | }
32 | throw new Error("Unknown task type");
33 | }
34 |
35 | export function commitDescriptionFromJson(json: any): CommitDescription {
36 | return new CommitDescription(
37 | json.repo_id,
38 | json.hash,
39 | json.author,
40 | new Date(json.author_date * 1000),
41 | json.summary,
42 | );
43 | }
44 |
45 | export function streamedRunnerOutputFromJson(json: any): StreamedRunnerOutput {
46 | return new StreamedRunnerOutput(json.output, json.index_of_first_line);
47 | }
48 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/exception/NoSuchCommitExceptionMapper.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.exception;
2 |
3 | import de.aaaaaaah.velcom.backend.access.committaccess.exceptions.NoSuchCommitException;
4 | import java.util.UUID;
5 | import javax.ws.rs.core.Response;
6 | import javax.ws.rs.core.Response.Status;
7 | import javax.ws.rs.ext.ExceptionMapper;
8 |
9 | /** An {@link ExceptionMapper} that transforms {@link NoSuchCommitException}s to NOT_FOUND. */
10 | public class NoSuchCommitExceptionMapper implements ExceptionMapper {
11 |
12 | @Override
13 | public Response toResponse(NoSuchCommitException exception) {
14 | return Response.status(Status.NOT_FOUND)
15 | .entity(
16 | new Info(
17 | "could not find commit",
18 | exception.getRepoId().getId(),
19 | exception.getCommitHash().getHash()))
20 | .build();
21 | }
22 |
23 | private static class Info {
24 |
25 | private final String message;
26 | private final UUID repoId;
27 | private final String hash;
28 |
29 | public Info(String message, UUID repoId, String hash) {
30 | this.message = message;
31 | this.repoId = repoId;
32 | this.hash = hash;
33 | }
34 |
35 | public String getMessage() {
36 | return message;
37 | }
38 |
39 | public UUID getRepoId() {
40 | return repoId;
41 | }
42 |
43 | public String getHash() {
44 | return hash;
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/KnownHostsIgnoringSshdFactory.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend;
2 |
3 | import java.io.File;
4 | import java.net.InetSocketAddress;
5 | import java.security.PublicKey;
6 | import java.util.Collections;
7 | import java.util.List;
8 | import org.eclipse.jgit.transport.CredentialsProvider;
9 | import org.eclipse.jgit.transport.sshd.KeyCache;
10 | import org.eclipse.jgit.transport.sshd.ProxyDataFactory;
11 | import org.eclipse.jgit.transport.sshd.ServerKeyDatabase;
12 | import org.eclipse.jgit.transport.sshd.SshdSessionFactory;
13 |
14 | /** A {@link SshdSessionFactory} that ignores server keys. */
15 | public class KnownHostsIgnoringSshdFactory extends SshdSessionFactory {
16 |
17 | public KnownHostsIgnoringSshdFactory(KeyCache keyCache, ProxyDataFactory proxies) {
18 | super(keyCache, proxies);
19 | }
20 |
21 | @Override
22 | protected ServerKeyDatabase getServerKeyDatabase(File homeDir, File sshDir) {
23 | return new ServerKeyDatabase() {
24 | @Override
25 | public List lookup(
26 | String connectAddress, InetSocketAddress remoteAddress, Configuration config) {
27 | return Collections.emptyList();
28 | }
29 |
30 | @Override
31 | public boolean accept(
32 | String connectAddress,
33 | InetSocketAddress remoteAddress,
34 | PublicKey serverKey,
35 | Configuration config,
36 | CredentialsProvider provider) {
37 | return true;
38 | }
39 | };
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/backend/shared/src/main/java/de/aaaaaaah/velcom/shared/protocol/serialization/serverbound/ServerBoundPacket.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.serverbound;
2 |
3 | import com.fasterxml.jackson.annotation.JsonCreator;
4 | import com.fasterxml.jackson.annotation.JsonProperty;
5 | import com.fasterxml.jackson.databind.JsonNode;
6 | import java.util.Objects;
7 |
8 | /** A packet that can be sent to the backend by the runner. */
9 | public class ServerBoundPacket {
10 |
11 | private final ServerBoundPacketType type;
12 | private final JsonNode data;
13 |
14 | @JsonCreator
15 | public ServerBoundPacket(
16 | @JsonProperty(required = true) ServerBoundPacketType type,
17 | @JsonProperty(required = true) JsonNode data) {
18 | this.type = type;
19 | this.data = data;
20 | }
21 |
22 | public ServerBoundPacketType getType() {
23 | return type;
24 | }
25 |
26 | public JsonNode getData() {
27 | return data;
28 | }
29 |
30 | @Override
31 | public boolean equals(Object o) {
32 | if (this == o) {
33 | return true;
34 | }
35 | if (o == null || getClass() != o.getClass()) {
36 | return false;
37 | }
38 | ServerBoundPacket that = (ServerBoundPacket) o;
39 | return type == that.type && data.equals(that.data);
40 | }
41 |
42 | @Override
43 | public int hashCode() {
44 | return Objects.hash(type, data);
45 | }
46 |
47 | @Override
48 | public String toString() {
49 | return "ServerBoundPacket{" + "type=" + type + ", data=" + data + '}';
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/frontend/src/util/json/RunSearchJsonHelper.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
2 | import { SearchItem, SearchItemBranch, SearchItemCommit, SearchItemRun } from "@/store/types";
3 |
4 | function searchItemCommitFromJson(json: any): SearchItemCommit {
5 | return new SearchItemCommit(
6 | json.repo_id,
7 | json.hash,
8 | json.author,
9 | new Date(json.author_date * 1000),
10 | json.committer,
11 | new Date(json.committer_date * 1000),
12 | json.summary,
13 | json.has_run,
14 | );
15 | }
16 |
17 | function searchItemRunFromJson(json: any): SearchItemRun {
18 | return new SearchItemRun(
19 | json.id,
20 | json.repo_id,
21 | json.commit_hash,
22 | json.commit_summary,
23 | json.tar_description,
24 | new Date(json.start_time * 1000),
25 | new Date(json.stop_time * 1000),
26 | );
27 | }
28 |
29 | function searchItemBranchFromJson(json: any): SearchItemBranch {
30 | return new SearchItemBranch(
31 | json.repo_id,
32 | json.name,
33 | json.commit_hash,
34 | json.commit_summary,
35 | json.has_run,
36 | );
37 | }
38 |
39 | /**
40 | * Converts the result of the search endpoint to a list of search search items.
41 | * @param json the json response
42 | * @return the extracted search items
43 | */
44 | export function searchItemsFromJson(json: any): SearchItem[] {
45 | return json.branches
46 | .map(searchItemBranchFromJson)
47 | .concat(json.commits.map(searchItemCommitFromJson))
48 | .concat(json.runs.map(searchItemRunFromJson));
49 | }
50 |
--------------------------------------------------------------------------------
/backend/shared/src/test/java/de/aaaaaaah/velcom/shared/protocol/serialization/clientbound/RequestRunReplyTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.clientbound;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertTrue;
5 |
6 | import com.fasterxml.jackson.core.JsonProcessingException;
7 | import de.aaaaaaah.velcom.shared.protocol.serialization.SerializerBasedTest;
8 | import java.util.Optional;
9 | import java.util.UUID;
10 | import org.junit.jupiter.api.Test;
11 |
12 | class RequestRunReplyTest extends SerializerBasedTest {
13 |
14 | @Test
15 | void deserializeWithNoOptionals() throws JsonProcessingException {
16 | String json = "{\"bench\": false, \"run\": false}";
17 | Optional result = serializer.deserialize(json, RequestRunReply.class);
18 |
19 | assertTrue(result.isPresent());
20 | assertEquals(new RequestRunReply(false, null, false, null), result.get());
21 | }
22 |
23 | @Test
24 | void deserializeWithAllOptionals() throws JsonProcessingException {
25 | String json =
26 | "{\"bench\": true, \"bench_hash\": \"yay, I'm a hash\", \"run\": true, \"run_id\": \"576afdcb-eaf9-46b2-9287-fc3bf8df83df\"}";
27 | Optional result = serializer.deserialize(json, RequestRunReply.class);
28 |
29 | UUID uuid = UUID.fromString("576afdcb-eaf9-46b2-9287-fc3bf8df83df");
30 | assertTrue(result.isPresent());
31 | assertEquals(new RequestRunReply(true, "yay, I'm a hash", true, uuid), result.get());
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonRunDescription.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities.Measurement;
4 | import de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities.RunError;
5 | import de.aaaaaaah.velcom.shared.util.Either;
6 | import java.util.Collection;
7 | import java.util.UUID;
8 |
9 | public class JsonRunDescription {
10 |
11 | private final UUID id;
12 | private final long startTime;
13 | private final JsonSuccess success;
14 | private final JsonSource source;
15 |
16 | public JsonRunDescription(UUID id, long startTime, JsonSuccess success, JsonSource source) {
17 | this.id = id;
18 | this.startTime = startTime;
19 | this.success = success;
20 | this.source = source;
21 | }
22 |
23 | public UUID getId() {
24 | return id;
25 | }
26 |
27 | public long getStartTime() {
28 | return startTime;
29 | }
30 |
31 | public JsonSuccess getSuccess() {
32 | return success;
33 | }
34 |
35 | public JsonSource getSource() {
36 | return source;
37 | }
38 |
39 | public enum JsonSuccess {
40 | SUCCESS,
41 | PARTIAL_SUCCESS,
42 | FAILURE;
43 |
44 | public static JsonSuccess fromRunResult(Either> result) {
45 | return result
46 | .getRight()
47 | .map(
48 | ms -> ms.stream().allMatch(m -> m.getContent().isRight()) ? SUCCESS : PARTIAL_SUCCESS)
49 | .orElse(FAILURE);
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # VelCom
2 |
3 | VelCom lets you progressively benchmark one or more projects and monitor or
4 | compare the benchmark results. This makes it easier to notice performance
5 | regressions or see how different branches compare. It also lets you visualize
6 | how different metrics have developed over time.
7 |
8 | Here are a few links to get started:
9 | - [Installation](docs/install.md)
10 | - [CLI readme](cli/README.md)
11 | - [Benchmark repo specification](docs/bench_repo_specification.md)
12 | - [Guide to contributing](docs/contributing.md)
13 |
14 | ## Uploading a tar via curl
15 |
16 | If you quickly want to benchmark your current directory from the command line,
17 | run this command, replacing `VELCOM_ADDRESS` and `ADMIN_PASSWORD` with the
18 | proper values:
19 |
20 | ```
21 | tar -czO . | curl VELCOM_ADDRESS/api/queue/upload/tar \
22 | -F 'file=@-;filename=file.tar.gz' \
23 | -F description='console upload' \
24 | -u admin:ADMIN_PASSWORD
25 | ```
26 |
27 | If you want to assign the tar to a specific repository, append this flag to the
28 | command above, replacing `REPO_ID` with the repo's UUID (can be found on the
29 | repo detail page):
30 |
31 | ```
32 | -F repo_id=REPO_ID
33 | ```
34 |
35 | Here is an example with all of the above:
36 |
37 | ```
38 | tar -czO . | curl https://velcom.aaaaaaah.de/api/queue/upload/tar \
39 | -F 'file=@-;filename=file.tar.gz' \
40 | -F description='console upload' \
41 | -u admin:12345 \
42 | -F repo_id=44bb5c8d-b20d-4bef-bdad-c92767dfa489
43 | ```
44 |
45 | For a nicer looking result, pipe the output from `curl` into `jq`.
46 |
--------------------------------------------------------------------------------
/backend/shared/src/test/java/de/aaaaaaah/velcom/shared/protocol/serialization/clientbound/ClientBoundPacketTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.clientbound;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertTrue;
5 |
6 | import com.fasterxml.jackson.core.JsonProcessingException;
7 | import com.fasterxml.jackson.databind.JsonNode;
8 | import de.aaaaaaah.velcom.shared.protocol.serialization.SerializerBasedTest;
9 | import java.util.Optional;
10 | import org.junit.jupiter.api.Test;
11 |
12 | class ClientBoundPacketTest extends SerializerBasedTest {
13 |
14 | @Test
15 | void serializeCorrectly() throws JsonProcessingException {
16 | ClientBoundPacket packet =
17 | new ClientBoundPacket(ClientBoundPacketType.CLEAR_RESULT, objectMapper.createArrayNode());
18 | JsonNode packetTree = serializer.serializeTree(packet);
19 |
20 | String expected = "{\"type\": \"clear_result\", \"data\": []}";
21 | JsonNode expectedTree = objectMapper.readTree(expected);
22 |
23 | assertEquals(expectedTree, packetTree);
24 | }
25 |
26 | @Test
27 | void deserializeCorrectly() {
28 | String json = "{\"type\": \"request_run_reply\", \"data\": {}}";
29 | Optional result = serializer.deserialize(json, ClientBoundPacket.class);
30 |
31 | assertTrue(result.isPresent());
32 | assertEquals(
33 | new ClientBoundPacket(
34 | ClientBoundPacketType.REQUEST_RUN_REPLY, objectMapper.createObjectNode()),
35 | result.get());
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/access/benchmarkaccess/entities/RunErrorType.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities;
2 |
3 | /** Describes which type of error has occurred when trying to perform a benchmark run. */
4 | public enum RunErrorType {
5 |
6 | /** The benchmark script returned a global error. */
7 | BENCH_SCRIPT_ERROR("BENCH"),
8 |
9 | /** Some error occurred in velcom which prevented the execution of the benchmark script. */
10 | VELCOM_ERROR("VELCOM");
11 |
12 | private final String textualRepresentation;
13 |
14 | RunErrorType(String textualRepresentation) {
15 | this.textualRepresentation = textualRepresentation;
16 | }
17 |
18 | public String getTextualRepresentation() {
19 | return textualRepresentation;
20 | }
21 |
22 | /**
23 | * Tries to find the error type that matches the given string representation.
24 | *
25 | * @param representation the representation
26 | * @return the error type that matches the given string representation
27 | * @throws IllegalArgumentException if no error type matches the given string representation
28 | */
29 | public static RunErrorType fromTextualRepresentation(String representation)
30 | throws IllegalArgumentException {
31 |
32 | for (RunErrorType runErrorType : RunErrorType.values()) {
33 | if (runErrorType.getTextualRepresentation().equals(representation)) {
34 | return runErrorType;
35 | }
36 | }
37 |
38 | throw new IllegalArgumentException("\"" + representation + "\" is not a valid error type");
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/access/taskaccess/entities/TaskPriority.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.taskaccess.entities;
2 |
3 | /** The priority a task can have in the queue. Lower means more important. */
4 | public enum TaskPriority {
5 | /**
6 | * The task has been manually prioritized. In the case of commits, manually adding them to the
7 | * queue automatically prioritizes them.
8 | */
9 | MANUAL(0),
10 | /**
11 | * The task has been created by a user (e. g. from an uploaded tar file or a GitHub command), but
12 | * should not have priority over manually prioritized tasks.
13 | */
14 | USER_CREATED(1),
15 | /**
16 | * The task represents a commit that has been automatically added to the queue by the listener.
17 | */
18 | LISTENER(2);
19 |
20 | private final int priority;
21 |
22 | TaskPriority(int priority) {
23 | this.priority = priority;
24 | }
25 |
26 | /**
27 | * Convert an int to a {@link TaskPriority}. Integers that don't correspond to a particular
28 | * priority are interpreted as the closest available priority.
29 | *
30 | * @param priority the int to convert
31 | * @return the matching priority
32 | */
33 | public static TaskPriority fromInt(int priority) {
34 | if (priority <= 0) {
35 | return MANUAL;
36 | } else if (priority == 1) {
37 | return USER_CREATED;
38 | } else {
39 | return LISTENER;
40 | }
41 | }
42 |
43 | /**
44 | * @return the priority as an integer
45 | */
46 | public int asInt() {
47 | return priority;
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/exception/NoSuchDimensionExceptionMapper.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.exception;
2 |
3 | import de.aaaaaaah.velcom.backend.access.dimensionaccess.exceptions.NoSuchDimensionException;
4 | import javax.ws.rs.core.Response;
5 | import javax.ws.rs.core.Response.Status;
6 | import javax.ws.rs.ext.ExceptionMapper;
7 |
8 | /** An {@link ExceptionMapper} that transforms {@link NoSuchDimensionException}s to NOT_FOUND. */
9 | public class NoSuchDimensionExceptionMapper implements ExceptionMapper {
10 |
11 | @Override
12 | public Response toResponse(NoSuchDimensionException exception) {
13 | return Response.status(Status.NOT_FOUND)
14 | .entity(
15 | new Info(
16 | "could not find dimension",
17 | exception.getInvalidDimension().getBenchmark(),
18 | exception.getInvalidDimension().getMetric()))
19 | .build();
20 | }
21 |
22 | private static class Info {
23 |
24 | private final String message;
25 | private final String benchmark;
26 | private final String metric;
27 |
28 | public Info(String message, String benchmark, String metric) {
29 | this.message = message;
30 | this.benchmark = benchmark;
31 | this.metric = metric;
32 | }
33 |
34 | public String getMessage() {
35 | return message;
36 | }
37 |
38 | public String getBenchmark() {
39 | return benchmark;
40 | }
41 |
42 | public String getMetric() {
43 | return metric;
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/access/benchmarkaccess/entities/sources/TarSource.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities.sources;
2 |
3 | import de.aaaaaaah.velcom.backend.access.repoaccess.entities.RepoId;
4 | import java.util.Objects;
5 | import java.util.Optional;
6 | import javax.annotation.Nullable;
7 |
8 | /** A source describing that the task originated from a tar. The task may be attached to a repo. */
9 | public class TarSource {
10 |
11 | private final String description;
12 | @Nullable private final RepoId repoId;
13 |
14 | public TarSource(String description, @Nullable RepoId repoId) {
15 | this.description = Objects.requireNonNull(description);
16 | this.repoId = repoId;
17 | }
18 |
19 | public String getDescription() {
20 | return description;
21 | }
22 |
23 | public Optional getRepoId() {
24 | return Optional.ofNullable(repoId);
25 | }
26 |
27 | @Override
28 | public boolean equals(Object o) {
29 | if (this == o) {
30 | return true;
31 | }
32 | if (o == null || getClass() != o.getClass()) {
33 | return false;
34 | }
35 | TarSource tarSource = (TarSource) o;
36 | return Objects.equals(description, tarSource.description)
37 | && Objects.equals(repoId, tarSource.repoId);
38 | }
39 |
40 | @Override
41 | public int hashCode() {
42 | return Objects.hash(description, repoId);
43 | }
44 |
45 | @Override
46 | public String toString() {
47 | return "TarSource{" + "description='" + description + '\'' + ", repoId=" + repoId + '}';
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/backend/backend/src/main/resources/db/migration/V8__global_dimensions_part_2.sql:
--------------------------------------------------------------------------------
1 | -----------------------------------
2 | -- Renaming to-be-deleted tables --
3 | -----------------------------------
4 |
5 | ALTER TABLE measurement RENAME TO measurement_old;
6 |
7 | -------------------------
8 | -- Creating new tables --
9 | -------------------------
10 |
11 | CREATE TABLE IF NOT EXISTS measurement (
12 | id CHAR(36) NOT NULL PRIMARY KEY,
13 | run_id CHAR(36) NOT NULL,
14 | benchmark TEXT NOT NULL,
15 | metric TEXT NOT NULL,
16 | unit TEXT,
17 | interpretation TEXT,
18 | error TEXT,
19 |
20 | FOREIGN KEY (run_id) REFERENCES run(id) ON UPDATE CASCADE ON DELETE CASCADE,
21 | FOREIGN KEY (benchmark, metric) REFERENCES dimension(benchmark, metric) ON UPDATE CASCADE ON DELETE CASCADE,
22 |
23 | CHECK (interpretation IN ('LESS_IS_BETTER', 'MORE_IS_BETTER', 'NEUTRAL'))
24 | );
25 |
26 | ------------------------
27 | -- Filling new tables --
28 | ------------------------
29 |
30 | INSERT INTO measurement
31 | SELECT *
32 | FROM measurement_old;
33 |
34 | -------------------------
35 | -- Deleting old tables --
36 | -------------------------
37 |
38 | DROP TABLE measurement_old;
39 |
40 | -- A little dance to capture all foreign key constraints previously pointing to measurement
41 | ALTER TABLE measurement RENAME TO measurement_old;
42 | ALTER TABLE measurement_old RENAME TO measurement;
43 |
44 | -----------------------------------
45 | -- Ensure foreign keys are valid --
46 | -----------------------------------
47 |
48 | PRAGMA foreign_key_check;
49 |
--------------------------------------------------------------------------------
/backend/shared/src/test/java/de/aaaaaaah/velcom/shared/protocol/serialization/serverbound/ServerBoundPacketTest.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.serverbound;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertTrue;
5 |
6 | import com.fasterxml.jackson.core.JsonProcessingException;
7 | import com.fasterxml.jackson.databind.JsonNode;
8 | import de.aaaaaaah.velcom.shared.protocol.serialization.SerializerBasedTest;
9 | import java.util.Optional;
10 | import org.junit.jupiter.api.Test;
11 |
12 | class ServerBoundPacketTest extends SerializerBasedTest {
13 |
14 | @Test
15 | void serializeCorrectly() throws JsonProcessingException {
16 | ServerBoundPacket packet =
17 | new ServerBoundPacket(ServerBoundPacketType.REQUEST_RUN, objectMapper.createArrayNode());
18 | JsonNode packetTree = serializer.serializeTree(packet);
19 |
20 | String expected = "{\"type\": \"request_run\", \"data\": []}";
21 | JsonNode expectedTree = objectMapper.readTree(expected);
22 |
23 | assertEquals(expectedTree, packetTree);
24 | }
25 |
26 | @Test
27 | void deserializeCorrectly() throws JsonProcessingException {
28 | String json = "{\"type\": \"get_status_reply\", \"data\": {}}";
29 | Optional result = serializer.deserialize(json, ServerBoundPacket.class);
30 |
31 | assertTrue(result.isPresent());
32 | assertEquals(
33 | new ServerBoundPacket(
34 | ServerBoundPacketType.GET_STATUS_REPLY, objectMapper.createObjectNode()),
35 | result.get());
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/frontend/src/plugins/vuetify.ts:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuetify from "vuetify/lib/framework";
3 |
4 | Vue.use(Vuetify);
5 |
6 | export default new Vuetify({
7 | theme: {
8 | options: {
9 | customProperties: true,
10 | },
11 | themes: {
12 | light: {
13 | primary: "#3f51b5",
14 | secondary: "#c51162",
15 | accent: "#1faa00",
16 | error: "#e53935",
17 | toolbarColor: "#193a9a",
18 | info: "#3f51b5",
19 | success: "#1faa00",
20 | snackbarSuccess: "#1faa00",
21 | warning: "#c51162",
22 | graphBackground: "#FFFFFF", // white
23 | graphFailedOrUnbenchmarked: "#696969", // dimgrey
24 | graphReferenceElements: "808080", // grey
25 | rowHighlight: "#d3d3d3",
26 | // only used in graphs. Should match normal text color
27 | graphTextColor: "#212121",
28 | },
29 | dark: {
30 | primary: "#7f9bff",
31 | secondary: "#c51162",
32 | accent: "#eb7b18",
33 | toolbarColor: "#4268c6",
34 | info: "#3f51b5",
35 | success: "#73bf69",
36 | snackbarSuccess: "#3db223",
37 | warning: "#ff9830",
38 | error: "#f2495c",
39 | graphBackground: "#2f3136",
40 | graphFailedOrUnbenchmarked: "#d3d3d3", // lightgray
41 | graphReferenceElements: "#d3d3d3", // lightgray
42 | rowHighlight: "#616161",
43 | // only used in graphs. Should match normal text color
44 | graphTextColor: "#e6ebf8",
45 | },
46 | },
47 | },
48 | icons: {
49 | iconfont: "mdiSvg",
50 | },
51 | });
52 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonRun.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import java.util.UUID;
4 |
5 | public class JsonRun {
6 |
7 | private final UUID id;
8 | private final String author;
9 | private final String runnerName;
10 | private final String runnerInfo;
11 | private final long startTime;
12 | private final long stopTime;
13 | private final JsonSource source;
14 | private final JsonResult result;
15 |
16 | public JsonRun(
17 | UUID id,
18 | String author,
19 | String runnerName,
20 | String runnerInfo,
21 | long startTime,
22 | long stopTime,
23 | JsonSource source,
24 | JsonResult result) {
25 |
26 | this.id = id;
27 | this.author = author;
28 | this.runnerName = runnerName;
29 | this.runnerInfo = runnerInfo;
30 | this.startTime = startTime;
31 | this.stopTime = stopTime;
32 | this.source = source;
33 | this.result = result;
34 | }
35 |
36 | public UUID getId() {
37 | return id;
38 | }
39 |
40 | public String getAuthor() {
41 | return author;
42 | }
43 |
44 | public String getRunnerName() {
45 | return runnerName;
46 | }
47 |
48 | public String getRunnerInfo() {
49 | return runnerInfo;
50 | }
51 |
52 | public long getStartTime() {
53 | return startTime;
54 | }
55 |
56 | public long getStopTime() {
57 | return stopTime;
58 | }
59 |
60 | public JsonSource getSource() {
61 | return source;
62 | }
63 |
64 | public JsonResult getResult() {
65 | return result;
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/frontend/src/components/queue/WorkerOverview.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | {{ worker.name }}
8 | (Lost connection)
9 |
10 |
11 | {{ formatWorkerInformation(worker) }}
12 |
13 |
14 |
15 |
16 | No worker registered :(
17 | I will not be able to benchmark anything!
18 |
Please setup a runner and point it to this instance.
19 |
20 |
21 |
22 |
23 |
24 |
43 |
44 |
50 |
--------------------------------------------------------------------------------
/backend/backend/src/main/java/de/aaaaaaah/velcom/backend/restapi/jsonobjects/JsonShortRunDescription.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.backend.restapi.jsonobjects;
2 |
3 | import de.aaaaaaah.velcom.backend.access.benchmarkaccess.entities.ShortRunDescription;
4 | import java.util.UUID;
5 | import javax.annotation.Nullable;
6 |
7 | public class JsonShortRunDescription {
8 |
9 | private final UUID id;
10 | @Nullable private final String commitHash;
11 | @Nullable private final String commitSummary;
12 | @Nullable private final String tarDescription;
13 |
14 | public JsonShortRunDescription(
15 | UUID id,
16 | @Nullable String commitHash,
17 | @Nullable String commitSummary,
18 | @Nullable String tarDescription) {
19 |
20 | this.id = id;
21 | this.commitHash = commitHash;
22 | this.commitSummary = commitSummary;
23 | this.tarDescription = tarDescription;
24 | }
25 |
26 | public static JsonShortRunDescription fromShortRunDescription(ShortRunDescription description) {
27 | return new JsonShortRunDescription(
28 | description.getId().getId(),
29 | description.getCommitHash().orElse(null),
30 | description.getCommitSummary().orElse(null),
31 | description.getTarDescription().orElse(null));
32 | }
33 |
34 | public UUID getId() {
35 | return id;
36 | }
37 |
38 | @Nullable
39 | public String getCommitHash() {
40 | return commitHash;
41 | }
42 |
43 | @Nullable
44 | public String getCommitSummary() {
45 | return commitSummary;
46 | }
47 |
48 | @Nullable
49 | public String getTarDescription() {
50 | return tarDescription;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/frontend/src/components/misc/ThemeSelector.vue:
--------------------------------------------------------------------------------
1 |
2 |
21 |
22 |
23 |
43 |
44 |
60 |
--------------------------------------------------------------------------------
/backend/shared/src/main/java/de/aaaaaaah/velcom/shared/protocol/serialization/clientbound/ClientBoundPacketType.java:
--------------------------------------------------------------------------------
1 | package de.aaaaaaah.velcom.shared.protocol.serialization.clientbound;
2 |
3 | import com.fasterxml.jackson.annotation.JsonValue;
4 | import java.util.Optional;
5 |
6 | /** The types of packets that can be sent to the runner by the backend. */
7 | public enum ClientBoundPacketType {
8 | ABORT_RUN("abort_run", AbortRun.class),
9 | CLEAR_RESULT("clear_result", ClearResult.class),
10 | GET_RESULT("get_result", GetResult.class),
11 | GET_STATUS("get_status", GetStatus.class),
12 | REQUEST_RUN_REPLY("request_run_reply", RequestRunReply.class);
13 |
14 | private final String type;
15 | private final Class dataClass;
16 |
17 | ClientBoundPacketType(String type, Class dataClass) {
18 | this.type = type;
19 | this.dataClass = dataClass;
20 | }
21 |
22 | static Optional ofType(String type) {
23 | for (ClientBoundPacketType value : ClientBoundPacketType.values()) {
24 | if (value.type.equals(type)) {
25 | return Optional.of(value);
26 | }
27 | }
28 | return Optional.empty();
29 | }
30 |
31 | static Optional ofClass(Class theClass) {
32 | for (ClientBoundPacketType value : ClientBoundPacketType.values()) {
33 | if (value.dataClass.equals(theClass)) {
34 | return Optional.of(value);
35 | }
36 | }
37 | return Optional.empty();
38 | }
39 |
40 | @JsonValue
41 | public String getType() {
42 | return type;
43 | }
44 |
45 | public Class getDataClass() {
46 | return dataClass;
47 | }
48 | }
49 |
--------------------------------------------------------------------------------