• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

FIWARE / contract-management / #116

04 Nov 2026 06:22AM UTC coverage: 7.885% (+3.4%) from 4.488%
#116

Pull #31

wistefan
Address the review comments of PR #31

* OID4VP flows triggered by a participant-chosen sink use their own non-redirecting client
* a reached subscription cap is refused with 503 instead of 409, which a subscriber reads as an existing subscription
* document the broadcast semantics of subscriptions in the security notes
Pull Request #31: subscriptions, webhook handshake and delivery

1035 of 1054 new or added lines in 36 files covered. (98.2%)

2927 of 37120 relevant lines covered (7.89%)

0.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.38
/src/main/java/org/fiware/iam/dataspace/DataSpaceEventSubscriber.java
1
package org.fiware.iam.dataspace;
2

3
import io.micronaut.context.annotation.Context;
4
import io.micronaut.context.annotation.Requires;
5
import io.micronaut.context.event.ApplicationEventListener;
6
import io.micronaut.core.annotation.Nullable;
7
import io.micronaut.runtime.context.scope.refresh.RefreshEvent;
8
import io.micronaut.runtime.server.event.ServerStartupEvent;
9
import io.micronaut.scheduling.TaskExecutors;
10
import io.micronaut.scheduling.TaskScheduler;
11
import jakarta.inject.Named;
12
import jakarta.inject.Singleton;
13
import lombok.RequiredArgsConstructor;
14
import lombok.extern.slf4j.Slf4j;
15
import org.fiware.iam.configuration.DataSpaceEventsProperties;
16
import org.fiware.iam.configuration.DataSpaceEventsProperties.Publisher;
17
import org.fiware.iam.configuration.DataSpaceEventsProperties.SubscriberSettings;
18
import org.fiware.iam.configuration.GeneralProperties;
19
import org.fiware.iam.logging.DownstreamError;
20
import reactor.core.publisher.Mono;
21

22
import java.time.Clock;
23
import java.time.Duration;
24
import java.time.Instant;
25
import java.util.LinkedHashMap;
26
import java.util.Map;
27
import java.util.Optional;
28
import java.util.Set;
29
import java.util.concurrent.atomic.AtomicBoolean;
30

31
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_CONFLICT_RENEWAL_INTERVAL;
32
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_INITIAL_DELAY;
33
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_MIN_RENEWAL_DELAY;
34
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_RECONCILE_INTERVAL;
35
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_RENEWAL_FRACTION;
36
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_RETRY_INITIAL_BACKOFF;
37
import static org.fiware.iam.configuration.DataSpaceEventsProperties.DEFAULT_SUBSCRIBER_RETRY_MAX_BACKOFF;
38

39
/**
40
 * Registers the own POST /events as webhook sink at every publisher with a subscriptions-url, renews each lease before it
41
 * expires and retries failures with a saturating backoff. Settings are read from the refreshable bean on every use;
42
 * a refresh or the periodic backstop reconcile registers added, re-registers changed and unsubscribes removed publishers.
43
 */
44
@Context
45
@Requires(condition = DataSpaceEventsProperties.SubscriberCondition.class)
46
@Slf4j
1 ✔
47
public class DataSpaceEventSubscriber implements ApplicationEventListener<ServerStartupEvent> {
48

49
    /**
50
     * Upper bound for every scheduled delay: an unlimited lease or an oversized interval would overflow the scheduler.
51
     */
52
    static final Duration MAX_SCHEDULE_DELAY = Duration.ofDays(1);
1 ✔
53

54
    /**
55
     * Health detail of an entry whose values could not be read, e.g. a null element in its types or scopes.
56
     */
57
    static final String INVALID_ENTRY_REASON = "the publisher entry could not be read";
58

59
    private final DataSpaceEventsProperties properties;
60
    private final GeneralProperties generalProperties;
61
    private final PublisherSubscriptionClient client;
62
    private final SubscriptionStateStore store;
63
    private final TaskScheduler taskScheduler;
64
    private final Clock clock;
65
    private final ConfigurationRefreshLock refreshLock;
66
    private final AtomicBoolean started = new AtomicBoolean();
1 ✔
67
    // only touched inside the synchronized reconcile
68
    private Set<String> reportedWarnings = Set.of();
1 ✔
69

70
    public DataSpaceEventSubscriber(DataSpaceEventsProperties properties, GeneralProperties generalProperties,
71
                                    PublisherSubscriptionClient client, SubscriptionStateStore store,
72
                                    @Named(TaskExecutors.SCHEDULED) TaskScheduler taskScheduler, Clock clock,
73
                                    ConfigurationRefreshLock refreshLock) {
1 ✔
74
        this.properties = properties;
1 ✔
75
        this.generalProperties = generalProperties;
1 ✔
76
        this.client = client;
1 ✔
77
        this.store = store;
1 ✔
78
        this.taskScheduler = taskScheduler;
1 ✔
79
        this.clock = clock;
1 ✔
80
        this.refreshLock = refreshLock;
1 ✔
81
    }
1 ✔
82

83
    @Override
84
    public void onApplicationEvent(ServerStartupEvent event) {
85
        if (started.compareAndSet(false, true)) {
1 ✔
86
            taskScheduler.schedule(positiveOrDefault(settings().getInitialDelay(), DEFAULT_SUBSCRIBER_INITIAL_DELAY),
1 ✔
87
                    this::backstopTick);
88
        }
89
    }
1 ✔
90

91
    /**
92
     * Schedules a one-shot reconcile. Ignored before startup, whose own reconcile reads the then-current values anyway.
93
     */
94
    void onRefresh() {
95
        if (!started.get()) {
1 ✔
96
            log.debug("Ignoring a configuration refresh before startup.");
1 ✔
97
            return;
1 ✔
98
        }
99
        // the listener may run before the properties are rebound, so the reconcile runs async and waits for the rebind
100
        taskScheduler.schedule(Duration.ZERO, this::reconcile);
1 ✔
101
    }
1 ✔
102

103
    // the only scheduler of itself, so there is exactly one chain however many refresh-triggered runs happen
104
    private void backstopTick() {
105
        try {
106
            reconcile();
1 ✔
107
        } finally {
108
            scheduleBackstop();
1 ✔
109
        }
110
    }
1 ✔
111

112
    private void scheduleBackstop() {
113
        try {
114
            taskScheduler.schedule(capped(positiveOrDefault(settings().getReconcileInterval(),
1 ✔
115
                    DEFAULT_SUBSCRIBER_RECONCILE_INTERVAL)), this::backstopTick);
NEW
116
        } catch (RuntimeException e) {
×
NEW
117
            log.warn("Could not schedule the next periodic reconcile; publisher changes now only apply on a refresh.", e);
×
118
        }
1 ✔
119
    }
1 ✔
120

121
    /**
122
     * Brings the states in line with the configured publishers: adds, re-registers on change, drops removed ones.
123
     * The only place states are created or removed; synchronized, so overlapping runs cannot duplicate a state.
124
     */
125
    synchronized void reconcile() {
126
        try {
127
            // both refresh paths rebind under this lock, so the read never sees half-rebound properties
128
            Reading reading = refreshLock.exclusively(this::read);
1 ✔
129
            report(reading.warnings());
1 ✔
130
            if (reading.settingsProblem().isPresent()) {
1 ✔
131
                store.markUnusableSettings(reading.settingsProblem().get());
1 ✔
132
                return;
1 ✔
133
            }
134
            for (String publisherId : store.publisherIds()) {
1 ✔
135
                if (!reading.wanted().containsKey(publisherId)) {
1 ✔
136
                    remove(publisherId);
1 ✔
137
                }
138
            }
1 ✔
139
            reading.wanted().forEach(this::reconcilePublisher);
1 ✔
140
            store.markReconciled();
1 ✔
141
        } catch (RuntimeException e) {
1 ✔
142
            log.warn("Reconciling the publisher subscriptions failed.", e);
1 ✔
143
        }
1 ✔
144
    }
1 ✔
145

146
    private Reading read() {
147
        Map<String, Throwable> warnings = new LinkedHashMap<>();
1 ✔
148
        SubscriberSettings settings = settings();
1 ✔
149
        String ownId = properties.ownId(generalProperties);
1 ✔
150
        Optional<String> settingsProblem = SubscriberSettingsValidator.problem(settings, ownId);
1 ✔
151
        if (settingsProblem.isPresent()) {
1 ✔
152
            warnings.put("Not subscribing to any publisher: " + settingsProblem.get(), null);
1 ✔
153
            return new Reading(settingsProblem, Map.of(), warnings);
1 ✔
154
        }
155
        Map<String, Wanted> wanted = new LinkedHashMap<>();
1 ✔
156
        for (Publisher publisher : properties.getPublishers()) {
1 ✔
157
            try {
158
                read(publisher, settings, ownId, wanted, warnings);
1 ✔
159
            } catch (RuntimeException e) {
1 ✔
160
                // one broken entry (e.g. a null list element) must not keep the others from being subscribed
161
                String publisherId = publisher == null ? null : publisher.getId();
1 ✔
162
                warnings.put("Not subscribing to publisher " + publisherId + ": its entry could not be read.", e);
1 ✔
163
                if (!isBlank(publisherId)) {
1 ✔
164
                    wanted.putIfAbsent(publisherId, Wanted.skip(INVALID_ENTRY_REASON));
1 ✔
165
                }
166
            }
1 ✔
167
        }
1 ✔
168
        return new Reading(Optional.empty(), wanted, warnings);
1 ✔
169
    }
170

171
    private static void read(Publisher publisher, SubscriberSettings settings, String ownId, Map<String, Wanted> wanted,
172
                             Map<String, Throwable> warnings) {
173
        if (isBlank(publisher.getSubscriptionsUrl())) {
1 ✔
174
            return;
1 ✔
175
        }
176
        String publisherId = publisher.getId();
1 ✔
177
        if (isBlank(publisherId)) {
1 ✔
NEW
178
            warnings.put("Not subscribing at " + publisher.getSubscriptionsUrl() + ": the publisher entry has no id.", null);
×
NEW
179
            return;
×
180
        }
181
        if (wanted.containsKey(publisherId)) {
1 ✔
182
            warnings.put("Publisher " + publisherId + " is configured more than once; only its first entry is subscribed to.",
1 ✔
183
                    null);
184
            return;
1 ✔
185
        }
186
        Optional<String> skipReason = skipReason(publisher);
1 ✔
187
        if (skipReason.isPresent()) {
1 ✔
188
            warnings.put("Not subscribing to publisher " + publisherId + ": " + skipReason.get() + ".", null);
1 ✔
189
            wanted.put(publisherId, Wanted.skip(skipReason.get()));
1 ✔
190
            return;
1 ✔
191
        }
192
        wanted.put(publisherId, new Wanted(SubscriptionTarget.of(publisher, settings, ownId), null));
1 ✔
193
    }
1 ✔
194

195
    // the backstop re-reads every minute; a lasting misconfiguration is warned about once, not on every run
196
    private void report(Map<String, Throwable> warnings) {
197
        warnings.forEach((message, cause) -> {
1 ✔
198
            if (!reportedWarnings.contains(message)) {
1 ✔
199
                log.warn(message, cause);
1 ✔
200
            }
201
        });
1 ✔
202
        reportedWarnings = Set.copyOf(warnings.keySet());
1 ✔
203
    }
1 ✔
204

205
    private void reconcilePublisher(String publisherId, Wanted wanted) {
206
        Optional<PublisherState> existing = store.get(publisherId);
1 ✔
207
        SubscriptionTarget current = existing.map(PublisherState::target).orElse(null);
1 ✔
208
        if (wanted.target() == null) {
1 ✔
209
            if (current != null) {
1 ✔
210
                log.info("Publisher {} can no longer be subscribed to ({}); dropping its subscription.", publisherId,
1 ✔
211
                        wanted.skipReason());
1 ✔
212
                retire(existing.get());
1 ✔
213
            }
214
            if (current != null || existing.isEmpty() || !wanted.skipReason().equals(existing.get().status().reason())) {
1 ✔
215
                store.put(publisherId, PublisherState.skipped(wanted.skipReason()));
1 ✔
216
            }
217
            return;
1 ✔
218
        }
219
        if (current == null) {
1 ✔
220
            PublisherState state = PublisherState.pending(wanted.target());
1 ✔
221
            store.put(publisherId, state);
1 ✔
222
            register(state, state.generation());
1 ✔
223
        } else if (!current.equals(wanted.target())) {
1 ✔
224
            retarget(existing.get(), current, wanted.target());
1 ✔
225
        }
226
    }
1 ✔
227

228
    private void retarget(PublisherState state, SubscriptionTarget current, SubscriptionTarget changed) {
229
        boolean rekeyed = !current.sameKeyAs(changed);
1 ✔
230
        String oldId;
231
        long generation;
232
        synchronized (state) {
1 ✔
233
            oldId = state.subscriptionId();
1 ✔
234
            generation = state.retarget(changed, rekeyed);
1 ✔
235
        }
1 ✔
236
        if (!rekeyed) {
1 ✔
237
            log.info("Subscription settings for publisher {} changed; renewing in place.", changed.publisherId());
1 ✔
238
            register(state, generation);
1 ✔
239
            return;
1 ✔
240
        }
241
        log.info("Subscription key for publisher {} changed; re-registering at {}.", changed.publisherId(),
1 ✔
242
                changed.subscriptionsUrl());
1 ✔
243
        if (oldId == null) {
1 ✔
244
            register(state, generation);
1 ✔
245
            return;
1 ✔
246
        }
247
        // deleting first frees the old subscription's slot under the publisher's per-subscriber cap
248
        unsubscribe(current, oldId).then(Mono.fromRunnable(() -> register(state, generation))).subscribe();
1 ✔
249
    }
1 ✔
250

251
    private void remove(String publisherId) {
252
        store.get(publisherId).ifPresent(state -> {
1 ✔
253
            store.remove(publisherId);
1 ✔
254
            retire(state);
1 ✔
255
            if (state.target() != null) {
1 ✔
256
                log.info("Publisher {} is no longer configured for subscription; dropped its subscription.", publisherId);
1 ✔
257
            }
258
        });
1 ✔
259
    }
1 ✔
260

261
    // stops the loop and removes the subscription at the publisher if its id is known; the lease expires anyway otherwise
262
    private void retire(PublisherState state) {
263
        SubscriptionTarget target;
264
        String subscriptionId;
265
        synchronized (state) {
1 ✔
266
            state.cancel();
1 ✔
267
            target = state.target();
1 ✔
268
            subscriptionId = state.subscriptionId();
1 ✔
269
        }
1 ✔
270
        if (target != null && subscriptionId != null) {
1 ✔
271
            unsubscribe(target, subscriptionId).subscribe();
1 ✔
272
        }
273
    }
1 ✔
274

275
    private Mono<Void> unsubscribe(SubscriptionTarget target, String subscriptionId) {
276
        return Mono.defer(() -> client.unsubscribe(target, subscriptionId))
1 ✔
277
                .doOnSuccess(ignored -> log.info("Removed subscription {} at {}.", subscriptionId, target.subscriptionsUrl()))
1 ✔
278
                .onErrorResume(error -> {
1 ✔
279
                    log.info("Could not remove subscription {} at {}: {}. It ends when its lease expires.", subscriptionId,
1 ✔
280
                            target.subscriptionsUrl(), DownstreamError.reason(error));
1 ✔
281
                    return Mono.empty();
1 ✔
282
                });
283
    }
284

285
    /**
286
     * Delay before retry number attempt + 1: doubles from the initial backoff and saturates at the maximum.
287
     */
288
    Duration backoff(int attempt) {
289
        SubscriberSettings.Retry retry = settings().getRetry();
1 ✔
290
        Duration maxBackoff = positiveOrDefault(retry.getMaxBackoff(), DEFAULT_SUBSCRIBER_RETRY_MAX_BACKOFF);
1 ✔
291
        Duration delay = positiveOrDefault(retry.getInitialBackoff(), DEFAULT_SUBSCRIBER_RETRY_INITIAL_BACKOFF);
1 ✔
292
        for (int doublings = 0; doublings < attempt && delay.compareTo(maxBackoff) < 0; doublings++) {
1 ✔
293
            delay = delay.compareTo(maxBackoff.dividedBy(2)) > 0 ? maxBackoff : delay.multipliedBy(2);
1 ✔
294
        }
295
        return delay.compareTo(maxBackoff) > 0 ? maxBackoff : delay;
1 ✔
296
    }
297

298
    private void register(PublisherState state, long generation) {
299
        if (!state.isCurrent(generation)) {
1 ✔
NEW
300
            return;
×
301
        }
302
        SubscriptionTarget target = state.target();
1 ✔
303
        try {
304
            client.subscribe(target)
1 ✔
305
                    .switchIfEmpty(Mono.error(() -> new IllegalStateException("the subscription request completed without an answer")))
1 ✔
306
                    .subscribe(
1 ✔
307
                    registration -> onRegistration(state, generation, target, registration),
1 ✔
308
                    error -> onFailure(state, generation, target, error));
1 ✔
309
        } catch (RuntimeException e) {
1 ✔
310
            onFailure(state, generation, target, e);
1 ✔
311
        }
1 ✔
312
    }
1 ✔
313

314
    private void onRegistration(PublisherState state, long generation, SubscriptionTarget target,
315
                                PublisherSubscriptionClient.Registration registration) {
316
        try {
317
            Instant now = clock.instant();
1 ✔
318
            Duration delay;
319
            synchronized (state) {
1 ✔
320
                if (!state.isCurrent(generation)) {
1 ✔
321
                    return;
1 ✔
322
                }
323
                if (registration.conflict() || registration.expiresAt() == null) {
1 ✔
324
                    delay = capped(positiveOrDefault(settings().getConflictRenewalInterval(),
1 ✔
325
                            DEFAULT_SUBSCRIBER_CONFLICT_RENEWAL_INTERVAL));
326
                    // a max-backoff of grace: a failing re-registration is retried before the publisher counts as expired
327
                    Instant validUntil = now.plus(delay).plus(capped(backoff(Integer.MAX_VALUE)));
1 ✔
328
                    // CONFLICT stays reserved for a real 409, i.e. a publisher reporting an existing subscription;
329
                    // a CM publisher never answers 409 (a reached cap is a 503 and retried), only the timing is shared
330
                    if (registration.conflict()) {
1 ✔
331
                        state.conflict(registration.id(), validUntil);
1 ✔
332
                    } else {
333
                        state.registered(registration.id(), validUntil);
1 ✔
334
                    }
335
                } else {
1 ✔
336
                    delay = renewalDelay(now, registration.expiresAt());
1 ✔
337
                    state.registered(registration.id(), registration.expiresAt());
1 ✔
338
                }
339
                scheduleNext(state, generation, delay);
1 ✔
340
            }
1 ✔
341
            if (registration.conflict()) {
1 ✔
342
                log.info("Publisher {} at {} answered 409, treated as existing subscription; re-registering in {}.",
1 ✔
343
                        target.publisherId(), target.subscriptionsUrl(), delay);
1 ✔
344
            } else if (registration.expiresAt() == null) {
1 ✔
345
                log.info("Subscribed to {} at {} without an expiry; re-registering in {}.",
1 ✔
346
                        target.publisherId(), target.subscriptionsUrl(), delay);
1 ✔
347
            } else {
348
                log.info("Subscribed to {} at {} until {}.", target.publisherId(), target.subscriptionsUrl(),
1 ✔
349
                        registration.expiresAt());
1 ✔
350
            }
NEW
351
        } catch (RuntimeException e) {
×
NEW
352
            onFailure(state, generation, target, e);
×
353
        }
1 ✔
354
    }
1 ✔
355

356
    private void onFailure(PublisherState state, long generation, SubscriptionTarget target, Throwable error) {
357
        try {
358
            Duration delay;
359
            synchronized (state) {
1 ✔
360
                if (!state.isCurrent(generation)) {
1 ✔
NEW
361
                    return;
×
362
                }
363
                Duration backoff = backoff(state.attempt());
1 ✔
364
                state.attemptFailed(backoff.compareTo(backoff(Integer.MAX_VALUE)) >= 0);
1 ✔
365
                delay = capped(backoff);
1 ✔
366
                scheduleNext(state, generation, delay);
1 ✔
367
            }
1 ✔
368
            log.warn("Subscribing to {} at {} failed: {}. Retrying in {}.", target.publisherId(), target.subscriptionsUrl(),
1 ✔
369
                    DownstreamError.reason(error), delay, error);
1 ✔
370
        } catch (RuntimeException e) {
1 ✔
371
            log.warn("Could not schedule the next subscription attempt for publisher {}; it is retried after a reconcile.",
1 ✔
372
                    target.publisherId(), e);
1 ✔
373
        }
1 ✔
374
    }
1 ✔
375

376
    private void scheduleNext(PublisherState state, long generation, Duration delay) {
377
        state.scheduled(taskScheduler.schedule(delay, () -> register(state, generation)));
1 ✔
378
    }
1 ✔
379

380
    private Duration renewalDelay(Instant now, Instant expiresAt) {
381
        double fraction = settings().getRenewalFraction();
1 ✔
382
        if (!(fraction > 0 && fraction < 1)) {
1 ✔
383
            fraction = DEFAULT_SUBSCRIBER_RENEWAL_FRACTION;
1 ✔
384
        }
385
        Duration remaining = Duration.between(now, expiresAt);
1 ✔
386
        Duration delay = remaining.isNegative() ? Duration.ZERO : Duration.ofMillis((long) (remaining.toMillis() * fraction));
1 ✔
387
        Duration minRenewalDelay = positiveOrDefault(settings().getMinRenewalDelay(), DEFAULT_SUBSCRIBER_MIN_RENEWAL_DELAY);
1 ✔
388
        return capped(delay.compareTo(minRenewalDelay) < 0 ? minRenewalDelay : delay);
1 ✔
389
    }
390

391
    private SubscriberSettings settings() {
392
        return properties.getSubscriber();
1 ✔
393
    }
394

395
    // a subscriptions-url alone is not enough: without types nothing is subscribed, without the origin our handshake answer fails
396
    private static Optional<String> skipReason(Publisher publisher) {
397
        if (publisher.getTypes() == null || publisher.getTypes().isEmpty()) {
1 ✔
398
            return Optional.of("no types configured");
1 ✔
399
        }
400
        if (isBlank(publisher.getOrigin())) {
1 ✔
401
            return Optional.of("no origin configured, the webhook handshake would fail");
1 ✔
402
        }
403
        return Optional.empty();
1 ✔
404
    }
405

406
    // invalid values (e.g. blanked by a refresh) fall back to the defaults instead of breaking the subscriptions
407
    private static Duration positiveOrDefault(@Nullable Duration value, Duration defaultValue) {
408
        return value != null && value.isPositive() ? value : defaultValue;
1 ✔
409
    }
410

411
    private static Duration capped(Duration delay) {
412
        return delay.compareTo(MAX_SCHEDULE_DELAY) > 0 ? MAX_SCHEDULE_DELAY : delay;
1 ✔
413
    }
414

415
    private static boolean isBlank(@Nullable String value) {
416
        return value == null || value.isBlank();
1 ✔
417
    }
418

419
    private record Reading(Optional<String> settingsProblem, Map<String, Wanted> wanted, Map<String, Throwable> warnings) {
1 ✔
420
    }
421

422
    // either the target to subscribe with or why the publisher is skipped
423
    private record Wanted(@Nullable SubscriptionTarget target, @Nullable String skipReason) {
1 ✔
424

425
        static Wanted skip(String reason) {
426
            return new Wanted(null, reason);
1 ✔
427
        }
428
    }
429

430
    /**
431
     * Forwards every RefreshEvent to the subscriber; a separate bean, because one class cannot listen to two event types.
432
     */
433
    @Singleton
434
    @Requires(condition = DataSpaceEventsProperties.SubscriberCondition.class)
435
    @RequiredArgsConstructor
436
    static class RefreshListener implements ApplicationEventListener<RefreshEvent> {
437

438
        private final DataSpaceEventSubscriber subscriber;
439

440
        @Override
441
        public void onApplicationEvent(RefreshEvent event) {
442
            subscriber.onRefresh();
1 ✔
443
        }
1 ✔
444
    }
445
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc