Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testDFASimulatorOracle() { DFA<?, Symbol> dfa = ExamplePaulAndMary.constructMachine(); SimulatorOracle<Symbol, Boolean> oracle = new SimulatorOracle<>(dfa); List<DefaultQuery<Symbol, Boolean>> queries = new ArrayList<>(); DefaultQuery<Symbol, Boolean> q1 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_PAUL, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_MARY)); DefaultQuery<Symbol, Boolean> q2 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_MARY, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_PAUL)); queries.add(q1); queries.add(q2); Assert.assertEquals(queries.get(0).getInput().size(), 3); Assert.assertEquals(queries.get(1).getInput().size(), 3); oracle.processQueries(queries); Assert.assertEquals(queries.get(0).getOutput(), Boolean.TRUE); Assert.assertEquals(queries.get(1).getOutput(), Boolean.FALSE); }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); }
SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } }
SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); }
SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); @Override D answerQuery(Word<I> prefix, Word<I> suffix); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); @Override D answerQuery(Word<I> prefix, Word<I> suffix); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
@Test public void testResetIdempotency() { final StateLocalInputSUL<Character, Integer> mock = Mockito.spy(sul); Mockito.doAnswer(invocation -> Collections.singleton('a')).when(mock).currentlyEnabledInputs(); final SULSymbolQueryOracle<Character, Integer> oracle = new StateLocalInputSULSymbolQueryOracle<>(mock, example.getUndefinedOutput()); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); Mockito.verify(mock, Mockito.times(0)).currentlyEnabledInputs(); oracle.reset(); oracle.reset(); oracle.reset(); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); Mockito.verify(mock, Mockito.times(0)).currentlyEnabledInputs(); }
@Override public void reset() { super.reset(); this.fetchRequired = true; }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); @Override void reset(); }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); @Override void reset(); }
@Test public void testQueriesAndCleanUp() { final StateLocalInputSUL<Character, Integer> mock = Mockito.spy(sul); Mockito.doAnswer(invocation -> Collections.singleton('a')).when(mock).currentlyEnabledInputs(); final SULSymbolQueryOracle<Character, Integer> oracle = new StateLocalInputSULSymbolQueryOracle<>(mock, example.getUndefinedOutput()); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); final Word<Character> i1 = Word.fromCharSequence("abcabcabc"); final Word<Integer> o1 = oracle.answerQuery(i1); oracle.reset(); Assert.assertEquals(o1.firstSymbol(), example.getReferenceAutomaton().computeOutput(i1).firstSymbol()); Assert.assertEquals(o1.subWord(1), Word.fromList(Collections.nCopies(i1.size() - 1, example.getUndefinedOutput()))); Mockito.verify(mock, Mockito.times(1)).pre(); Mockito.verify(mock, Mockito.times(1)).post(); Mockito.verify(mock, Mockito.times(2)).currentlyEnabledInputs(); Mockito.verify(mock, Mockito.times(1)).step(Mockito.anyChar()); final Word<Character> i2 = Word.fromCharSequence("aaaaa"); final Word<Integer> o2 = oracle.answerQuery(i2); oracle.reset(); oracle.reset(); Assert.assertEquals(o2, example.getReferenceAutomaton().computeOutput(i2)); Mockito.verify(mock, Mockito.times(2)).pre(); Mockito.verify(mock, Mockito.times(2)).post(); Mockito.verify(mock, Mockito.times(2 + i2.size())).currentlyEnabledInputs(); Mockito.verify(mock, Mockito.times(1 + i2.size())).step(Mockito.anyChar()); }
@Override public void reset() { super.reset(); this.fetchRequired = true; }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); @Override void reset(); }
StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); @Override void reset(); }
@Test public void testComposition() { mappedSUL.pre(); Character result = mappedSUL.step('A'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'A'); result = mappedSUL.step(INNER_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); result = mappedSUL.step('C'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); result = mappedSUL.step(null); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); mappedSUL.post(); mappedSUL.pre(); result = mappedSUL.step('A'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'A'); result = mappedSUL.step(OUTER_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), OUTER_EXCEPTION_RESULT); result = mappedSUL.step('C'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'C'); result = mappedSUL.step(NESTED_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), NESTED_EXCEPTION_TRIGGER_CHAR); Assert.assertThrows(NullPointerException.class, () -> mappedSUL.step(null)); mappedSUL.post(); mappedSUL.pre(); mappedSUL.pre(); Assert.assertEquals(4, this.innerUnwrappedMapper.getPreCounter()); Assert.assertEquals(4, this.outerWrappedMapper.getPreCounter()); Assert.assertEquals(2, this.innerUnwrappedMapper.getPostCounter()); Assert.assertEquals(2, this.outerWrappedMapper.getPostCounter()); Assert.assertFalse(mappedSUL.canFork()); Assert.assertThrows(mappedSUL::fork); }
@Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); }
SULMapperComposition extends MapperComposition<AI, AO, ACI, CAO, CI, CO, SULMapper<? super AI, ? extends AO, ACI, CAO>, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO>> implements SULMapper<AI, AO, CI, CO> { @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } }
SULMapperComposition extends MapperComposition<AI, AO, ACI, CAO, CI, CO, SULMapper<? super AI, ? extends AO, ACI, CAO>, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO>> implements SULMapper<AI, AO, CI, CO> { @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } SULMapperComposition(SULMapper<? super AI, ? extends AO, ACI, CAO> outerMapper, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO> innerMapper); }
SULMapperComposition extends MapperComposition<AI, AO, ACI, CAO, CI, CO, SULMapper<? super AI, ? extends AO, ACI, CAO>, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO>> implements SULMapper<AI, AO, CI, CO> { @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } SULMapperComposition(SULMapper<? super AI, ? extends AO, ACI, CAO> outerMapper, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO> innerMapper); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapWrappedException(SULException exception); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapUnwrappedException(RuntimeException exception); @Override boolean canFork(); @Override SULMapper<AI, AO, CI, CO> fork(); }
SULMapperComposition extends MapperComposition<AI, AO, ACI, CAO, CI, CO, SULMapper<? super AI, ? extends AO, ACI, CAO>, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO>> implements SULMapper<AI, AO, CI, CO> { @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } SULMapperComposition(SULMapper<? super AI, ? extends AO, ACI, CAO> outerMapper, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO> innerMapper); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapWrappedException(SULException exception); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapUnwrappedException(RuntimeException exception); @Override boolean canFork(); @Override SULMapper<AI, AO, CI, CO> fork(); }
@Test public void testSingleMethods() { final ParallelOmegaOracle<?, Integer, TestOutput> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
@Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); }
StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } }
StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } StaticParallelOmegaOracle(Collection<? extends OmegaMembershipOracle<S, I, D>> oracles, @NonNegative int minBatchSize, PoolPolicy policy); }
StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } StaticParallelOmegaOracle(Collection<? extends OmegaMembershipOracle<S, I, D>> oracles, @NonNegative int minBatchSize, PoolPolicy policy); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } StaticParallelOmegaOracle(Collection<? extends OmegaMembershipOracle<S, I, D>> oracles, @NonNegative int minBatchSize, PoolPolicy policy); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
@Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadCreation(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final int expectedThreads = queries.size(); final CountDownLatch latch = new CountDownLatch(expectedThreads); final NullOracle[] oracles = new NullOracle[expectedThreads]; for (int i = 0; i < expectedThreads; i++) { oracles[i] = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { try { latch.countDown(); latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; } final ParallelOmegaOracle<?, Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOmegaOracle(oracles[0], Arrays.copyOfRange(oracles, 1, oracles.length)) .withBatchSize(1) .withPoolSize(oracles.length) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
@Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
@Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadScheduling(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final CountDownLatch latch = new CountDownLatch(queries.size() - 1); final NullOracle awaitingOracle = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { try { latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; final NullOracle countDownOracle = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { latch.countDown(); super.processQueries(queries); } }; final ParallelOmegaOracle<?, Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOmegaOracle(awaitingOracle, countDownOracle) .withPoolSize(2) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
@Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
@Test public void testSingleMethods() { final ParallelOmegaOracle<?, Void, Void> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
@Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }
@Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadCreation(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final int expectedThreads = queries.size(); final CountDownLatch latch = new CountDownLatch(expectedThreads); final NullOracle[] oracles = new NullOracle[expectedThreads]; for (int i = 0; i < expectedThreads; i++) { oracles[i] = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { try { latch.countDown(); latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; } final ParallelOracle<Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOracle(oracles[0], Arrays.copyOfRange( oracles, 1, oracles.length)) .withBatchSize(1) .withPoolSize(oracles.length) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
@Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadScheduling(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final CountDownLatch latch = new CountDownLatch(queries.size() - 1); final NullOracle awaitingOracle = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { try { latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; final NullOracle countDownOracle = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { latch.countDown(); super.processQueries(queries); } }; final ParallelOracle<Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOracle(awaitingOracle, countDownOracle) .withPoolSize(2) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends Query<I, D>> queries); }
@Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0, 0, 0); }
@Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
@Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0, 0, 0); }
@Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
@Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10, 2.5, 0); }
@Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
@Test(dependsOnMethods = "testSecondQueryBatch") public void testSummary() throws IOException { final String details = oracle.getStatisticalData().getDetails(); final String summary = oracle.getStatisticalData().getSummary(); try (InputStream detailStream = HistogramOracleTest.class.getResourceAsStream("/histogram_details.txt"); InputStream summaryStream = HistogramOracleTest.class.getResourceAsStream("/histogram_summary.txt")) { final String expectedDetail = CharStreams.toString(IOUtil.asBufferedUTF8Reader(detailStream)); final String expectedSummary = CharStreams.toString(IOUtil.asBufferedUTF8Reader(summaryStream)); Assert.assertEquals(details, expectedDetail); Assert.assertEquals(summary, expectedSummary); } }
@Override public final HistogramDataSet getStatisticalData() { return this.dataSet; }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
@Test public void testWrite() { SuffixASCIIWriter<String, String> writer = new SuffixASCIIWriter<>(); ObservationTable<String, String> ot = ObservationTableSource.otWithFourSuffixes(); Assert.assertEquals(OTUtils.toString(ot, writer), ";A;B;A,B"); }
@Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); }
SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } }
SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } SuffixASCIIWriter(); }
SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } SuffixASCIIWriter(); @Override void write(ObservationTable<? extends I, ? extends D> table, Appendable out); }
SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } SuffixASCIIWriter(); @Override void write(ObservationTable<? extends I, ? extends D> table, Appendable out); }
@Test public void testGetName() { Assert.assertEquals(oracle.getStatisticalData().getName(), COUNTER_NAME); }
@Override public final HistogramDataSet getStatisticalData() { return this.dataSet; }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }
@Test public void testInitialState() { Assert.assertEquals(oracle.getCount(), 0L); }
public long getCount() { return counter.getCount(); }
CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } }
CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); }
CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }
CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }
@Test public void testGetName() { Assert.assertEquals(oracle.getCounter().getName(), COUNTER_NAME); }
public Counter getCounter() { return this.counter; }
CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } }
CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); }
CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }
CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }
@Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0); }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
@Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0); }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
@Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10); }
@Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }
@Test(expectedExceptions = Exception.class) public void testMealyDHCInternalSate() { ExampleStack stackExample = ExampleStack.createExample(); MealyMachine<?, ExampleStack.Input, ?, ExampleStack.Output> fm = stackExample.getReferenceAutomaton(); Alphabet<ExampleStack.Input> alphabet = stackExample.getAlphabet(); MealySimulatorOracle<ExampleStack.Input, ExampleStack.Output> simoracle = new MealySimulatorOracle<>(fm); MealyDHC<ExampleStack.Input, ExampleStack.Output> dhc = new MealyDHC<>(alphabet, simoracle); dhc.getHypothesisModel(); }
@Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; }
MealyDHC implements MealyLearner<I, O>, AccessSequenceTransformer<I>, GlobalSuffixLearnerMealy<I, O>, SupportsGrowingAlphabet<I>, Resumable<MealyDHCState<I, O>> { @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } }
MealyDHC implements MealyLearner<I, O>, AccessSequenceTransformer<I>, GlobalSuffixLearnerMealy<I, O>, SupportsGrowingAlphabet<I>, Resumable<MealyDHCState<I, O>> { @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle); @GenerateBuilder(defaults = BuilderDefaults.class, builderFinal = false) MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle, GlobalSuffixFinder<? super I, ? super Word<O>> suffixFinder, Collection<? extends Word<I>> initialSplitters); }
MealyDHC implements MealyLearner<I, O>, AccessSequenceTransformer<I>, GlobalSuffixLearnerMealy<I, O>, SupportsGrowingAlphabet<I>, Resumable<MealyDHCState<I, O>> { @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle); @GenerateBuilder(defaults = BuilderDefaults.class, builderFinal = false) MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle, GlobalSuffixFinder<? super I, ? super Word<O>> suffixFinder, Collection<? extends Word<I>> initialSplitters); @Override Collection<Word<I>> getGlobalSuffixes(); @Override boolean addGlobalSuffixes(Collection<? extends Word<I>> newGlobalSuffixes); @Override void startLearning(); @Override boolean refineHypothesis(DefaultQuery<I, Word<O>> ceQuery); @Override CompactMealy<I, O> getHypothesisModel(); @Override void addAlphabetSymbol(I symbol); @Override MealyDHCState<I, O> suspend(); @Override void resume(final MealyDHCState<I, O> state); @Override Word<I> transformAccessSequence(Word<I> word); @Override boolean isAccessSequence(Word<I> word); }
MealyDHC implements MealyLearner<I, O>, AccessSequenceTransformer<I>, GlobalSuffixLearnerMealy<I, O>, SupportsGrowingAlphabet<I>, Resumable<MealyDHCState<I, O>> { @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle); @GenerateBuilder(defaults = BuilderDefaults.class, builderFinal = false) MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle, GlobalSuffixFinder<? super I, ? super Word<O>> suffixFinder, Collection<? extends Word<I>> initialSplitters); @Override Collection<Word<I>> getGlobalSuffixes(); @Override boolean addGlobalSuffixes(Collection<? extends Word<I>> newGlobalSuffixes); @Override void startLearning(); @Override boolean refineHypothesis(DefaultQuery<I, Word<O>> ceQuery); @Override CompactMealy<I, O> getHypothesisModel(); @Override void addAlphabetSymbol(I symbol); @Override MealyDHCState<I, O> suspend(); @Override void resume(final MealyDHCState<I, O> state); @Override Word<I> transformAccessSequence(Word<I> word); @Override boolean isAccessSequence(Word<I> word); }
@Test public void testAutomaton() { final int states = 10; final Alphabet<Character> alphabet = Alphabets.characters('a', 'd'); final ADTHypothesis<Character, Integer> automaton = new ADTHypothesis<>(alphabet); automaton.addInitialState(); for (int i = 1; i < states; i++) { automaton.addState(); } Assert.assertEquals(states, automaton.size()); automaton.getStates().forEach(x -> Assert.assertTrue(x.getIncomingTransitions().isEmpty())); final StateIDs<ADTState<Character, Integer>> stateIds = automaton.stateIDs(); for (int s = 0; s < automaton.size(); s++) { for (final Character i : alphabet) { automaton.addTransition(stateIds.getState(s), i, automaton.getInitialState(), 0); } } Assert.assertEquals(states * alphabet.size(), automaton.getInitialState().getIncomingTransitions().size()); final ADTState<Character, Integer> s1 = stateIds.getState(1), s2 = stateIds.getState(2), s3 = stateIds.getState(3); automaton.removeAllTransitions(s1); Assert.assertEquals((states - 1) * alphabet.size(), automaton.getInitialState().getIncomingTransitions().size()); automaton.removeAllTransitions(s2, alphabet.getSymbol(0)); Assert.assertEquals((states - 1) * alphabet.size() - 1, automaton.getInitialState().getIncomingTransitions().size()); automaton.addTransition(s2, alphabet.getSymbol(0), s1, 0); for (int i = 1; i < alphabet.size(); i++) { ADTTransition<Character, Integer> transition = automaton.getTransition(s2, alphabet.getSymbol(i)); transition.setTarget(s1); } Assert.assertEquals(alphabet.size(), s1.getIncomingTransitions().size()); for (int i = 0; i < alphabet.size(); i++) { automaton.setTransition(s3, alphabet.getSymbol(i), s1, 0); } Assert.assertEquals(alphabet.size() * 2, s1.getIncomingTransitions().size()); }
@Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } }
ADTHypothesis extends AbstractFastMutableDet<ADTState<I, O>, I, ADTTransition<I, O>, Void, O> implements MutableMealyMachine<ADTState<I, O>, I, ADTTransition<I, O>, O>, AccessSequenceTransformer<I> { @Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } } }
ADTHypothesis extends AbstractFastMutableDet<ADTState<I, O>, I, ADTTransition<I, O>, Void, O> implements MutableMealyMachine<ADTState<I, O>, I, ADTTransition<I, O>, O>, AccessSequenceTransformer<I> { @Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } } ADTHypothesis(final Alphabet<I> alphabet); }
ADTHypothesis extends AbstractFastMutableDet<ADTState<I, O>, I, ADTTransition<I, O>, Void, O> implements MutableMealyMachine<ADTState<I, O>, I, ADTTransition<I, O>, O>, AccessSequenceTransformer<I> { @Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } } ADTHypothesis(final Alphabet<I> alphabet); @Override ADTState<I, O> getSuccessor(final ADTTransition<I, O> transition); ADTTransition<I, O> createOpenTransition(final ADTState<I, O> source, final I input, final ADTNode<ADTState<I, O>, I, O> siftTarget); @Override void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition); @Override ADTTransition<I, O> createTransition(final ADTState<I, O> successor, final O properties); @Override void setTransitionOutput(final ADTTransition<I, O> transition, final O output); @Override O getTransitionOutput(final ADTTransition<I, O> transition); @SuppressWarnings("nullness") // hypothesis is always complete @Override Word<I> transformAccessSequence(final Word<I> word); @SuppressWarnings("nullness") // hypothesis is always complete @Override boolean isAccessSequence(final Word<I> word); }
ADTHypothesis extends AbstractFastMutableDet<ADTState<I, O>, I, ADTTransition<I, O>, Void, O> implements MutableMealyMachine<ADTState<I, O>, I, ADTTransition<I, O>, O>, AccessSequenceTransformer<I> { @Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } } ADTHypothesis(final Alphabet<I> alphabet); @Override ADTState<I, O> getSuccessor(final ADTTransition<I, O> transition); ADTTransition<I, O> createOpenTransition(final ADTState<I, O> source, final I input, final ADTNode<ADTState<I, O>, I, O> siftTarget); @Override void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition); @Override ADTTransition<I, O> createTransition(final ADTState<I, O> successor, final O properties); @Override void setTransitionOutput(final ADTTransition<I, O> transition, final O output); @Override O getTransitionOutput(final ADTTransition<I, O> transition); @SuppressWarnings("nullness") // hypothesis is always complete @Override Word<I> transformAccessSequence(final Word<I> word); @SuppressWarnings("nullness") // hypothesis is always complete @Override boolean isAccessSequence(final Word<I> word); }
@Test public void testFindCounterExample() { final DefaultQuery<Character, D> cex = bfeo.findCounterExample(automaton, ALPHABET); Assert.assertEquals(cex, query); }
@Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
@Test public void testIsCounterExample() { bfeo.isCounterExample(automaton, query.getInput(), query.getOutput()); }
@Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
@Test public void testGetPropertyOracles() { Assert.assertEquals(oracle.getPropertyOracles().size(), 2); }
@Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
@Test public void testFindCounterExample() { final DefaultQuery<Boolean, Boolean> ce = oracle.findCounterExample(automaton, inputs); Assert.assertEquals(ce, query); Mockito.verify(po1, Mockito.times(1)).disprove(automaton, inputs); Mockito.verify(po2).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).doFindCounterExample(automaton, inputs); }
@Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; } }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
@Test public void testIsCounterExample() { Assert.assertTrue(bfio.isCounterExample(automaton, query.getInput(), query.getOutput())); }
@Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); }
AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } }
AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); }
AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }
@Test void ofDirectory() throws Exception { final Entry<Void> e = Entry.ofDirectory(new Revision(1), "/"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isFalse(); assertThatThrownBy(e::content).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsJson).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsText).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsPrettyText).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(() -> e.contentAsJson(JsonNode.class)).isInstanceOf(EntryNoContentException.class); final Entry<Void> e2 = Entry.ofDirectory(new Revision(1), "/"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofDirectory(new Revision(2), "/")); assertThat(e).isNotEqualTo(Entry.ofDirectory(new Revision(1), "/foo")); final Entry<String> e3 = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<JsonNode> e4 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); }
Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } }
Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); }
Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
@Test void testEmptyMirrors() { assertThat(metaRepo.mirrors()).isEmpty(); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert("/credentials.json", "[]")); assertThat(metaRepo.mirrors()).isEmpty(); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert("/mirrors.json", "[]")); assertThat(metaRepo.mirrors()).isEmpty(); }
@Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
@Test void testInvalidMirrors() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert(PATH_MIRRORS, "{}")).join(); assertThatThrownBy(() -> metaRepo.mirrors()).isInstanceOf(RepositoryMetadataException.class); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert(PATH_MIRRORS, "\"oops\"")).join(); assertThatThrownBy(() -> metaRepo.mirrors()).isInstanceOf(RepositoryMetadataException.class); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert(PATH_MIRRORS, "[ null ]")).join(); assertThatThrownBy(() -> metaRepo.mirrors()).isInstanceOf(RepositoryMetadataException.class); }
@Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
@Test void testSingleTypeMirror() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"enabled\": true," + " \"type\": \"single\"," + " \"direction\": \"LOCAL_TO_REMOTE\"," + " \"localRepo\": \"foo\"," + " \"localPath\": \"/mirrors/foo\"," + " \"remoteUri\": \"git+ssh: "},{" + " \"enabled\": true," + " \"type\": \"single\"," + " \"schedule\": \"*/10 * * * * ?\"," + " \"direction\": \"REMOTE_TO_LOCAL\"," + " \"localRepo\": \"bar\"," + " \"remoteUri\": \"git+ssh: "}, {" + " \"type\": \"single\"," + " \"direction\": \"LOCAL_TO_REMOTE\"," + " \"localRepo\": \"qux\"," + " \"remoteUri\": \"git+ssh: "}, {" + " \"enabled\": false," + " \"type\": \"single\"," + " \"direction\": \"LOCAL_TO_REMOTE\"," + " \"localRepo\": \"foo\"," + " \"localPath\": \"/mirrors/bar\"," + " \"remoteUri\": \"git+ssh: "}]"), UPSERT_CREDENTIALS).join(); assertThat(metaRepo.mirrors()).isEmpty(); project.repos().create("foo", Author.SYSTEM); project.repos().create("bar", Author.SYSTEM); project.repos().create("qux", Author.SYSTEM); final List<Mirror> mirrors = findMirrors(); assertThat(mirrors.stream() .map(m -> m.localRepo().name()) .collect(Collectors.toList())).containsExactly("bar", "foo", "qux"); final Mirror foo = mirrors.get(1); final Mirror bar = mirrors.get(0); final Mirror qux = mirrors.get(2); assertThat(foo.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(bar.direction()).isEqualTo(MirrorDirection.REMOTE_TO_LOCAL); assertThat(qux.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(foo.schedule().equivalent(cronParser.parse("0 * * * * ?"))).isTrue(); assertThat(bar.schedule().equivalent(cronParser.parse("*/10 * * * * ?"))).isTrue(); assertThat(qux.schedule().equivalent(cronParser.parse("0 * * * * ?"))).isTrue(); assertThat(foo.localPath()).isEqualTo("/mirrors/foo/"); assertThat(bar.localPath()).isEqualTo("/"); assertThat(qux.localPath()).isEqualTo("/"); assertThat(foo.remoteRepoUri().toString()).isEqualTo("git+ssh: assertThat(bar.remoteRepoUri().toString()).isEqualTo("git+ssh: assertThat(qux.remoteRepoUri().toString()).isEqualTo("git+ssh: assertThat(foo.remotePath()).isEqualTo("/"); assertThat(bar.remotePath()).isEqualTo("/some-path/"); assertThat(qux.remotePath()).isEqualTo("/"); assertThat(foo.remoteBranch()).isEqualTo("master"); assertThat(bar.remoteBranch()).isEqualTo("master"); assertThat(qux.remoteBranch()).isEqualTo("develop"); assertThat(foo.credential()).isInstanceOf(PasswordMirrorCredential.class); assertThat(bar.credential()).isInstanceOf(PasswordMirrorCredential.class); assertThat(qux.credential()).isInstanceOf(NoneMirrorCredential.class); final PasswordMirrorCredential fooCredential = (PasswordMirrorCredential) foo.credential(); final PasswordMirrorCredential barCredential = (PasswordMirrorCredential) bar.credential(); assertThat(fooCredential.username()).isEqualTo("alice"); assertThat(fooCredential.password()).isEqualTo("secret_a"); assertThat(barCredential.username()).isEqualTo("bob"); assertThat(barCredential.password()).isEqualTo("secret_b"); }
@Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
@Test void testMultipleTypeMirror() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"enabled\": true," + " \"type\": \"multiple\"," + " \"defaultDirection\": \"LOCAL_TO_REMOTE\"," + " \"defaultLocalPath\": \"/source\"," + " \"includes\": [{" + " \"pattern\": \"^([^.]+)(\\\\.[^.]+)$\"," + " \"replacement\": \"git+ssh: " }]," + " \"excludes\": [ \"^qux\\\\.net$\" ]" + "}, {" + " \"type\": \"multiple\"," + " \"defaultDirection\": \"LOCAL_TO_REMOTE\"," + " \"defaultLocalPath\": \"/source\"," + " \"defaultSchedule\": \"* * * * * ?\"," + " \"includes\": [{" + " \"pattern\": \"^qux\\\\.net$\"," + " \"replacement\": \"dogma: " \"schedule\": \"0 0 * * * ?\"," + " \"direction\": \"REMOTE_TO_LOCAL\"," + " \"localPath\": \"/mirrored/qux\"" + " }]" + "}, {" + " \"enabled\": false," + " \"type\": \"multiple\"," + " \"defaultDirection\": \"REMOTE_TO_LOCAL\"," + " \"defaultLocalPath\": \"/otherSource\"," + " \"includes\": [{" + " \"pattern\": \"^([^.]+)(\\\\.[^.]+)$\"," + " \"replacement\": \"git+ssh: " }]" + "}]"), UPSERT_CREDENTIALS).join(); assertThat(metaRepo.mirrors()).isEmpty(); project.repos().create("foo.com", Author.SYSTEM); project.repos().create("bar.org", Author.SYSTEM); project.repos().create("qux.net", Author.SYSTEM); final List<Mirror> mirrors = findMirrors(); assertThat(mirrors.stream() .map(m -> m.localRepo().name()) .collect(Collectors.toList())).containsExactly("bar.org", "foo.com", "qux.net"); final Mirror foo = mirrors.get(1); final Mirror bar = mirrors.get(0); final Mirror qux = mirrors.get(2); assertThat(foo.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(bar.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(qux.direction()).isEqualTo(MirrorDirection.REMOTE_TO_LOCAL); assertThat(foo.schedule().equivalent(cronParser.parse("0 * * * * ?"))).isTrue(); assertThat(bar.schedule().equivalent(cronParser.parse("0 * * * * ?"))).isTrue(); assertThat(qux.schedule().equivalent(cronParser.parse("0 0 * * * ?"))).isTrue(); assertThat(foo.localPath()).isEqualTo("/source/"); assertThat(bar.localPath()).isEqualTo("/source/"); assertThat(qux.localPath()).isEqualTo("/mirrored/qux/"); assertThat(foo.remoteRepoUri().toASCIIString()).isEqualTo("git+ssh: assertThat(bar.remoteRepoUri().toASCIIString()).isEqualTo("git+ssh: assertThat(qux.remoteRepoUri().toASCIIString()).isEqualTo("dogma: assertThat(foo.remotePath()).isEqualTo("/"); assertThat(bar.remotePath()).isEqualTo("/"); assertThat(qux.remotePath()).isEqualTo("/some-path/"); assertThat(foo.remoteBranch()).isEqualTo("develop-foo"); assertThat(bar.remoteBranch()).isEqualTo("develop-bar"); assertThat(qux.remoteBranch()).isNull(); assertThat(foo.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(bar.direction()).isEqualTo(MirrorDirection.LOCAL_TO_REMOTE); assertThat(qux.direction()).isEqualTo(MirrorDirection.REMOTE_TO_LOCAL); }
@Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
@Test void testMultipleTypeMirrorWithCredentialId() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"type\": \"multiple\"," + " \"defaultDirection\": \"REMOTE_TO_LOCAL\"," + " \"includes\": [{" + " \"pattern\": \"^(foo|bar)$\"," + " \"replacement\": \"git+ssh: " \"credentialId\": \"alice\"" + " }]" + "}, {" + " \"type\": \"multiple\"," + " \"defaultDirection\": \"REMOTE_TO_LOCAL\"," + " \"defaultCredentialId\": \"alice\"," + " \"includes\": [{" + " \"pattern\": \"^(qux)$\"," + " \"replacement\": \"git+ssh: " }]" + "}]"), UPSERT_CREDENTIALS).join(); assertThat(metaRepo.mirrors()).isEmpty(); project.repos().create("foo", Author.SYSTEM); project.repos().create("bar", Author.SYSTEM); project.repos().create("qux", Author.SYSTEM); final List<Mirror> mirrors = findMirrors(); assertThat(mirrors.stream() .map(m -> m.localRepo().name()) .collect(Collectors.toList())).containsExactly("bar", "foo", "qux"); final MirrorCredential fooCredential = mirrors.get(1).credential(); assertThat(fooCredential).isInstanceOf(PasswordMirrorCredential.class); assertThat(((PasswordMirrorCredential) fooCredential).username()).isEqualTo("alice"); assertThat(mirrors.get(0).credential()).isSameAs(fooCredential); assertThat(mirrors.get(2).credential()).isSameAs(fooCredential); }
@Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } return mirrors; } finally { mirrorLock.unlock(); } } DefaultMetaRepository(Repository repo); @Override Set<Mirror> mirrors(); }
@Test void find() { final Repository repo = setMockNames(newCachingRepo()); final Map<String, Entry<?>> entries = ImmutableMap.of("/baz.txt", Entry.ofText(new Revision(10), "/baz.txt", "qux")); doReturn(new Revision(10)).when(delegateRepo).normalizeNow(new Revision(10)); doReturn(new Revision(10)).when(delegateRepo).normalizeNow(HEAD); when(delegateRepo.find(any(), any(), any())).thenReturn(completedFuture(entries)); assertThat(repo.find(HEAD, "/**", ImmutableMap.of()).join()).isEqualTo(entries); verify(delegateRepo).find(new Revision(10), "/**", ImmutableMap.of()); verifyNoMoreInteractions(delegateRepo); clearInvocations(delegateRepo); assertThat(repo.find(HEAD, "/**", ImmutableMap.of()).join()).isEqualTo(entries); assertThat(repo.find(new Revision(10), "/**", ImmutableMap.of()).join()).isEqualTo(entries); verify(delegateRepo, never()).find(any(), any(), any()); verifyNoMoreInteractions(delegateRepo); }
@Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); }
CachingRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); } }
CachingRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); } CachingRepository(Repository repo, RepositoryCache cache); }
CachingRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
CachingRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
@Test void history() { final Repository repo = setMockNames(newCachingRepo()); final List<Commit> commits = ImmutableList.of( new Commit(new Revision(3), SYSTEM, "third", "", Markup.MARKDOWN), new Commit(new Revision(3), SYSTEM, "second", "", Markup.MARKDOWN), new Commit(new Revision(3), SYSTEM, "first", "", Markup.MARKDOWN)); doReturn(new RevisionRange(3, 1)).when(delegateRepo).normalizeNow(HEAD, INIT); doReturn(new RevisionRange(3, 1)).when(delegateRepo).normalizeNow(HEAD, new Revision(-3)); doReturn(new RevisionRange(3, 1)).when(delegateRepo).normalizeNow(new Revision(3), new Revision(-3)); doReturn(new RevisionRange(3, 1)).when(delegateRepo).normalizeNow(new Revision(3), INIT); when(delegateRepo.history(any(), any(), any(), anyInt())).thenReturn(completedFuture(commits)); assertThat(repo.history(HEAD, INIT, "/**", Integer.MAX_VALUE).join()).isEqualTo(commits); verify(delegateRepo).history(new Revision(3), INIT, "/**", 3); verifyNoMoreInteractions(delegateRepo); clearInvocations(delegateRepo); assertThat(repo.history(HEAD, new Revision(-3), "/**", 3).join()).isEqualTo(commits); assertThat(repo.history(HEAD, INIT, "/**", 4).join()).isEqualTo(commits); assertThat(repo.history(new Revision(3), new Revision(-3), "/**", 5).join()).isEqualTo(commits); assertThat(repo.history(new Revision(3), INIT, "/**", 6).join()).isEqualTo(commits); verify(delegateRepo, never()).history(any(), any(), any(), anyInt()); verifyNoMoreInteractions(delegateRepo); }
@Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expected: > 0)"); } final RevisionRange range = normalizeNow(from, to); final int actualMaxCommits = Math.min( maxCommits, Math.abs(range.from().major() - range.to().major()) + 1); return cache.get(new CacheableHistoryCall(repo, range.from(), range.to(), pathPattern, actualMaxCommits)); }
CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expected: > 0)"); } final RevisionRange range = normalizeNow(from, to); final int actualMaxCommits = Math.min( maxCommits, Math.abs(range.from().major() - range.to().major()) + 1); return cache.get(new CacheableHistoryCall(repo, range.from(), range.to(), pathPattern, actualMaxCommits)); } }
CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expected: > 0)"); } final RevisionRange range = normalizeNow(from, to); final int actualMaxCommits = Math.min( maxCommits, Math.abs(range.from().major() - range.to().major()) + 1); return cache.get(new CacheableHistoryCall(repo, range.from(), range.to(), pathPattern, actualMaxCommits)); } CachingRepository(Repository repo, RepositoryCache cache); }
CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expected: > 0)"); } final RevisionRange range = normalizeNow(from, to); final int actualMaxCommits = Math.min( maxCommits, Math.abs(range.from().major() - range.to().major()) + 1); return cache.get(new CacheableHistoryCall(repo, range.from(), range.to(), pathPattern, actualMaxCommits)); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expected: > 0)"); } final RevisionRange range = normalizeNow(from, to); final int actualMaxCommits = Math.min( maxCommits, Math.abs(range.from().major() - range.to().major()) + 1); return cache.get(new CacheableHistoryCall(repo, range.from(), range.to(), pathPattern, actualMaxCommits)); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
@Test void metrics() { final MeterRegistry meterRegistry = PrometheusMeterRegistries.newRegistry(); final Repository repo = newCachingRepo(meterRegistry); final Map<String, Double> meters = MoreMeters.measureAll(meterRegistry); assertThat(meters).containsKeys("cache.load#count{cache=repository,result=success}"); assertThat(repo.normalizeNow(HEAD)).isNotEqualTo(""); }
@Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); }
CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } }
CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } CachingRepository(Repository repo, RepositoryCache cache); }
CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }
@Test void testByteHexDirName() { assertThat(TagUtil.byteHexDirName(0x00000001)).isEqualTo("01/"); assertThat(TagUtil.byteHexDirName(0x00000b0a)).isEqualTo("0a/0b/"); assertThat(TagUtil.byteHexDirName(0x000c0b0a)).isEqualTo("0a/0b/0c/"); assertThat(TagUtil.byteHexDirName(0x0d0c0b0a)).isEqualTo("0a/0b/0c/0d/"); }
static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
@Test void testByteHexDirNameException() { assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(0)); assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(-1)); }
static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }
@Test void cannotPatchNull() { final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); assertThatNullPointerException() .isThrownBy(() -> patch.apply(null)); }
public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
@Test void testRemoval() { assertThatThrownBy(() -> repo .commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRemoval(jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); Revision revision = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThat(repo.exists(revision, jsonPaths[0]).join()).isTrue(); revision = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRemoval(jsonPaths[0])).join(); assertThat(repo.exists(revision, jsonPaths[0]).join()).isFalse(); assertThatThrownBy(() -> repo .commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRemoval(jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testRename() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[1])).join(); assertThat(repo.exists(HEAD, jsonPaths[0]).join()).isFalse(); assertThat(repo.exists(HEAD, jsonPaths[1]).join()).isTrue(); assertThat(repo.exists(HEAD, jsonPaths[2]).join()).isFalse(); assertThatJson(repo.get(HEAD, jsonPaths[1]).join().content()) .isEqualTo(jsonUpserts[0].content()); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[1], jsonPaths[2]), Change.ofJsonPatch(jsonPaths[2], jsonPatches[1].content()), Change.ofJsonPatch(jsonPaths[2], jsonPatches[2].content())).join(); assertThat(repo.exists(HEAD, jsonPaths[0]).join()).isFalse(); assertThat(repo.exists(HEAD, jsonPaths[1]).join()).isFalse(); assertThat(repo.exists(HEAD, jsonPaths[2]).join()).isTrue(); assertThatJson(repo.get(HEAD, jsonPaths[2]).join().content()) .isEqualTo(jsonUpserts[2].content()); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testRenameFailure() { assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0], jsonUpserts[1], Change.ofRename(jsonPaths[0], jsonPaths[1])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[1], Change.ofRename(jsonPaths[1], jsonPaths[1])) .join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testLateCommit() { final Revision rev = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo .commit(new Revision(rev.major() - 1), 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[1]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testEmptyCommit() { assertThatThrownBy( () -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Collections.emptyList()).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testEmptyCommitWithRedundantRenames() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[1]), Change.ofRename(jsonPaths[1], jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testEmptyCommitWithRedundantUpsert() { assertThatThrownBy( () -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Collections.emptyList()).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy( () -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testEmptyCommitWithRedundantUpsert2() { final Change<JsonNode> change1 = Change.ofJsonUpsert("/redundant_upsert_2.json", "{ \"foo\": 0, \"bar\": 1 }"); final Change<String> change2 = Change.ofTextUpsert("/redundant_upsert_2.txt", "foo"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change1).join(); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change2).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change1).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change2).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); final Change<JsonNode> change1a = Change.ofJsonUpsert("/redundant_upsert_2.json", "{ \"bar\": 1, \"foo\": 0 }"); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change1a).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testTextSanitization() { final Change<String> dosText = Change.ofTextUpsert("/text_sanitization_dos.txt", "foo\r\nbar\r\n"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, dosText).join(); assertThat(repo.get(HEAD, dosText.path()).join().contentAsText()).isEqualTo("foo\nbar\n"); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofTextUpsert(dosText.path(), "foo\nbar\n")).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofTextUpsert(dosText.path(), "foo\nbar")).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofTextUpsert(dosText.path(), "foo\nbar\r\n\n")).join(); assertThat(repo.get(HEAD, dosText.path()).join().contentAsText()).isEqualTo("foo\nbar\n\n"); final Change<String> withoutNewline = Change.ofTextUpsert("/text_sanitization_without_lf.txt", "foo"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, withoutNewline).join(); assertThat(repo.get(HEAD, withoutNewline.path()).join().contentAsText()).isEqualTo("foo\n"); final Change<String> withNewline = Change.ofTextUpsert("/text_sanitization_with_lf.txt", "foo\n"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, withNewline).join(); assertThat(repo.get(HEAD, withNewline.path()).join().contentAsText()).isEqualTo("foo\n"); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testRenameWithConflict() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void operationsAreCalledInOrder() { final JsonNode node1 = FACTORY.textNode("hello"); final JsonNode node2 = FACTORY.textNode("world"); when(op1.apply(node1)).thenReturn(node2); final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); final ArgumentCaptor<JsonNode> captor = ArgumentCaptor.forClass(JsonNode.class); patch.apply(node1); verify(op1, only()).apply(same(node1)); verify(op2, only()).apply(captor.capture()); assertThat(captor.getValue()).isSameAs(node2); }
public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
@Test void testMultipleChangesWithConflict() { assertThatThrownBy(() -> repo .commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0], jsonPatches[2]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testPreviewDiff() { final Map<String, Change<?>> changeMap = repo.previewDiff(HEAD, jsonUpserts[0]).join(); assertThat(changeMap).containsEntry(jsonPaths[0], jsonUpserts[0]); assertThatThrownBy(() -> repo.previewDiff(HEAD, jsonPatches[1]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); assertThatThrownBy(() -> repo.previewDiff(HEAD, Change.ofRemoval(jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); final List<Change<?>> changes = Arrays.asList(jsonUpserts[0], jsonPatches[1], jsonPatches[2], Change.ofRename(jsonPaths[0], jsonPaths[1]), Change.ofRemoval(jsonPaths[1])); Map<String, Change<?>> returnedChangeMap = repo.previewDiff(HEAD, changes).join(); assertThat(returnedChangeMap).isEmpty(); assertThatThrownBy(() -> repo.previewDiff(new Revision(Integer.MAX_VALUE), changes).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RevisionNotFoundException.class); assertThat(repo.previewDiff(new Revision(-1), Collections.emptyList()).join()).isEmpty(); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonPatches[0], jsonPatches[1]).join(); returnedChangeMap = repo.previewDiff(HEAD, jsonUpserts[0]).join(); assertThat(returnedChangeMap.get(jsonPaths[0]).type()).isEqualTo(ChangeType.APPLY_JSON_PATCH); }
@Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testFindNone() { assertThat(repo.find(HEAD, "/non-existent").join()).isEmpty(); assertThat(repo.find(HEAD, "non-existent").join()).isEmpty(); }
@Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testFind_invalidPathPattern() { final String pattern = "a'\"><img src=1 onerror=alert(document.domain)>"; assertThatThrownBy(() -> repo.find(HEAD, pattern).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(IllegalArgumentException.class); }
@Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testJsonPathQuery() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofJsonUpsert("/instances.json", '[' + " {" + " \"name\": \"a\"," + " \"groups\": [{" + " \"type\": \"phase\"," + " \"name\": \"alpha\"" + " }, {" + " \"type\": \"not_phase\"," + " \"name\": \"beta\"" + " }]" + " }, {" + " \"name\": \"b\"," + " \"groups\": [{" + " \"type\": \"phase\"," + " \"name\": \"beta\"" + " }, {" + " \"type\": \"not_phase\"," + " \"name\": \"alpha\"" + " }]" + " }" + ']')).join(); final Entry<JsonNode> res1 = repo.get(HEAD, Query.ofJsonPath( "/instances.json", "$[?(@.name == 'b')]")).join(); assertThatJson(res1.content()).isEqualTo("[{" + " \"name\": \"b\"," + " \"groups\": [{" + " \"type\": \"phase\"," + " \"name\": \"beta\"" + " }, {" + " \"type\": \"not_phase\"," + " \"name\": \"alpha\"" + " }]" + "}]"); final Entry<JsonNode> res2 = repo.get(HEAD, Query.ofJsonPath( "/instances.json", "$..groups[?(@.type == 'not_phase' && @.name == 'alpha')]")).join(); assertThatJson(res2.content()).isEqualTo("[{" + " \"type\": \"not_phase\"," + " \"name\": \"alpha\"" + "}]"); final Entry<JsonNode> res3 = repo.get(HEAD, Query.ofJsonPath( "/instances.json", "$[?(@.groups[?(@.type == 'phase' && @.name == 'alpha')] empty false)]")) .join(); assertThatJson(res3.content()).isEqualTo("[{" + " \"name\": \"a\"," + " \"groups\": [{" + " \"type\": \"phase\"," + " \"name\": \"alpha\"" + " }, {" + " \"type\": \"not_phase\"," + " \"name\": \"beta\"" + " }]" + "}]"); }
@Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "commit", baseRevision, author, summary); return blockingCommit(baseRevision, commitTimeMillis, author, summary, detail, markup, changes, false); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testWatch() throws Exception { final Revision rev1 = repo.normalizeNow(HEAD); final Revision rev2 = rev1.forward(1); final CompletableFuture<Revision> f = repo.watch(rev1, Repository.ALL_PATH); assertThat(f).isNotDone(); repo.commit(rev1, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]); assertThat(f.get(3, TimeUnit.SECONDS)).isEqualTo(rev2); assertThat(repo.normalizeNow(HEAD)).isEqualTo(rev2); ensureWatcherCleanUp(); }
@Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testWatchWithQueryCancellation() throws Exception { final AtomicInteger numSubtasks = new AtomicInteger(); final CountDownLatch subtaskCancelled = new CountDownLatch(1); watchConsumer = f -> { numSubtasks.getAndIncrement(); f.exceptionally(cause -> { if (cause instanceof CancellationException) { subtaskCancelled.countDown(); } return null; }); }; final CompletableFuture<Entry<JsonNode>> f = repo.watch(HEAD, Query.ofJsonPath(jsonPaths[0], "$")); assertThatThrownBy(() -> f.get(500, TimeUnit.MILLISECONDS)) .isInstanceOf(TimeoutException.class); assertThat(numSubtasks.get()).isEqualTo(1); assertThat(subtaskCancelled.getCount()).isEqualTo(1L); assertThat(f.cancel(true)).isTrue(); assertThatThrownBy(() -> f.get(3, TimeUnit.SECONDS)) .isInstanceOf(CancellationException.class); assertThat(subtaskCancelled.await(3, TimeUnit.SECONDS)).isTrue(); assertThat(numSubtasks.get()).isEqualTo(1); ensureWatcherCleanUp(); }
@Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); final CompletableFuture<Revision> future = new CompletableFuture<>(); CompletableFuture.runAsync(() -> { failFastIfTimedOut(this, logger, ctx, "watch", lastKnownRevision, pathPattern); readLock(); try { final Revision latestRevision = blockingFindLatestRevision(normLastKnownRevision, pathPattern); if (latestRevision != null) { future.complete(latestRevision); } else { commitWatchers.add(normLastKnownRevision, pathPattern, future); } } finally { readUnlock(); } }, repositoryWorker).exceptionally(cause -> { future.completeExceptionally(cause); return null; }); return future; } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }
@Test void testWithToken() throws Exception { final MockTokenlessClientLogger logger = new MockTokenlessClientLogger(); final ServiceRequestContext ctx = mock(ServiceRequestContext.class); final HttpRequest req = newRequestWithToken(); logger.serve(ctx, req); assertThat(logger.hostname).isNull(); assertThat(logger.ip).isNull(); verify(delegate, times(1)).serve(ctx, req); verify(clock, never()).instant(); }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); @Override HttpResponse serve(ServiceRequestContext ctx, HttpRequest req); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); @Override HttpResponse serve(ServiceRequestContext ctx, HttpRequest req); }
@Test void testWithoutToken() throws Exception { final MockTokenlessClientLogger logger = new MockTokenlessClientLogger(); final Instant startTime = Instant.now(); when(clock.instant()).thenReturn(startTime); final ServiceRequestContext ctx = newContext("foo", "192.168.0.1"); final HttpRequest req = newRequestWithoutToken(); logger.serve(ctx, req); assertThat(logger.hostname).isEqualTo("foo"); assertThat(logger.ip).isEqualTo("192.168.0.1"); verify(delegate, times(1)).serve(ctx, req); final ServiceRequestContext ctx2 = newContext("bar", "192.168.0.1"); final HttpRequest req2 = newRequestWithoutToken(); when(clock.instant()).thenReturn(startTime.plus(30, ChronoUnit.MINUTES)); logger.serve(ctx2, req2); assertThat(logger.hostname).isNull(); assertThat(logger.ip).isNull(); verify(delegate, times(1)).serve(ctx2, req2); final ServiceRequestContext ctx3 = newContext("baz", "192.168.0.1"); final HttpRequest req3 = newRequestWithoutToken(); when(clock.instant()).thenReturn(startTime.plus(1, ChronoUnit.DAYS)); logger.serve(ctx3, req3); assertThat(logger.hostname).isEqualTo("baz"); assertThat(logger.ip).isEqualTo("192.168.0.1"); verify(delegate, times(1)).serve(ctx3, req3); final ServiceRequestContext ctx4 = newContext("qux", "192.168.0.2"); final HttpRequest req4 = newRequestWithoutToken(); logger.serve(ctx4, req4); assertThat(logger.hostname).isEqualTo("qux"); assertThat(logger.ip).isEqualTo("192.168.0.2"); verify(delegate, times(1)).serve(ctx4, req4); }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); @Override HttpResponse serve(ServiceRequestContext ctx, HttpRequest req); }
TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null || !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); @Override HttpResponse serve(ServiceRequestContext ctx, HttpRequest req); }
@Test void testBase64Passphrase() { final PublicKeyMirrorCredential c = new PublicKeyMirrorCredential( null, null, USERNAME, PUBLIC_KEY, PRIVATE_KEY, PASSPHRASE_BASE64); assertThat(c.passphrase()).isEqualTo(PASSPHRASE.getBytes(StandardCharsets.UTF_8)); }
@Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } }
PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } }
PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id, @JsonProperty("hostnamePatterns") @Nullable @JsonDeserialize(contentAs = Pattern.class) Iterable<Pattern> hostnamePatterns, @JsonProperty("username") String username, @JsonProperty("publicKey") String publicKey, @JsonProperty("privateKey") String privateKey, @JsonProperty("passphrase") @Nullable String passphrase); PublicKeyMirrorCredential(@Nullable String id, @Nullable Iterable<Pattern> hostnamePatterns, String username, byte[] publicKey, byte[] privateKey, @Nullable byte[] passphrase); }
PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id, @JsonProperty("hostnamePatterns") @Nullable @JsonDeserialize(contentAs = Pattern.class) Iterable<Pattern> hostnamePatterns, @JsonProperty("username") String username, @JsonProperty("publicKey") String publicKey, @JsonProperty("privateKey") String privateKey, @JsonProperty("passphrase") @Nullable String passphrase); PublicKeyMirrorCredential(@Nullable String id, @Nullable Iterable<Pattern> hostnamePatterns, String username, byte[] publicKey, byte[] privateKey, @Nullable byte[] passphrase); String username(); byte[] publicKey(); byte[] privateKey(); @Nullable byte[] passphrase(); @Override boolean equals(Object o); @Override int hashCode(); }
PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id, @JsonProperty("hostnamePatterns") @Nullable @JsonDeserialize(contentAs = Pattern.class) Iterable<Pattern> hostnamePatterns, @JsonProperty("username") String username, @JsonProperty("publicKey") String publicKey, @JsonProperty("privateKey") String privateKey, @JsonProperty("passphrase") @Nullable String passphrase); PublicKeyMirrorCredential(@Nullable String id, @Nullable Iterable<Pattern> hostnamePatterns, String username, byte[] publicKey, byte[] privateKey, @Nullable byte[] passphrase); String username(); byte[] publicKey(); byte[] privateKey(); @Nullable byte[] passphrase(); @Override boolean equals(Object o); @Override int hashCode(); }
@Test void whenOneOperationFailsNextOperationIsNotCalled() { final String message = "foo"; when(op1.apply(any(JsonNode.class))) .thenThrow(new JsonPatchException(message)); final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); assertThatThrownBy(() -> patch.apply(FACTORY.nullNode())) .isInstanceOf(JsonPatchException.class) .hasMessage(message); verifyNoMoreInteractions(op2); }
public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }
@Test void shouldReturnNonNull() { final Session expiredAfterOneHour = createSession(Instant.now().plus(1, ChronoUnit.HOURS)); final SessionManager delegate = mock(SessionManager.class); when(delegate.get(any())).thenReturn(CompletableFuture.completedFuture(expiredAfterOneHour)); final ExpiredSessionDeletingSessionManager manager = new ExpiredSessionDeletingSessionManager(delegate); assertThat(manager.get("id").join()).isEqualTo(expiredAfterOneHour); }
@Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); @Override CompletableFuture<Session> get(String sessionId); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); @Override CompletableFuture<Session> get(String sessionId); }
@Test void shouldReturnNull() { final Session expiredSession = createSession(Instant.EPOCH); final SessionManager delegate = mock(SessionManager.class); when(delegate.get(any())).thenReturn(CompletableFuture.completedFuture(expiredSession)); final ExpiredSessionDeletingSessionManager manager = new ExpiredSessionDeletingSessionManager(delegate); assertThat(manager.get("id").join()).isNull(); }
@Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); @Override CompletableFuture<Session> get(String sessionId); }
ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); @Override CompletableFuture<Session> get(String sessionId); }
@Test void shuttingDown() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, new ShuttingDownException()) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"com.linecorp.centraldogma.common.ShuttingDownException\"," + " \"message\":\"\"" + '}'); }
@Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
@Test void failure() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, new Exception("oops")) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"java.lang.Exception\"," + " \"message\":\"oops\"" + '}'); }
@Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
@Test void incorrectToken() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, null) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.UNAUTHORIZED); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"com.linecorp.centraldogma.common.AuthorizationException\"," + " \"message\":\"\"" + '}'); }
@Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }
@Test void maxRemovedRepositoryAgeMillis() throws Exception { final CentralDogmaConfig cfg = Jackson.readValue("{\n" + " \"dataDir\": \"./data\",\n" + " \"ports\": [\n" + " {\n" + " \"localAddress\": {\n" + " \"host\": \"*\",\n" + " \"port\": 36462\n" + " },\n" + " \"protocols\": [\n" + " \"https\",\n" + " \"http\",\n" + " \"proxy\"\n" + " ]\n" + " }\n" + " ],\n" + " \"maxRemovedRepositoryAgeMillis\": 50000 \n" + '}', CentralDogmaConfig.class); assertThat(cfg.maxRemovedRepositoryAgeMillis()).isEqualTo(50000); }
@JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); @JsonProperty File dataDir(); @JsonProperty @JsonSerialize(contentUsing = ServerPortSerializer.class) List<ServerPort> ports(); @Nullable @JsonProperty TlsConfig tls(); @Nullable @JsonProperty List<String> trustedProxyAddresses(); @Nullable @JsonProperty List<String> clientAddressSources(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> numWorkers(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxNumConnections(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> requestTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> idleTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxFrameLength(); @JsonProperty long maxRemovedRepositoryAgeMillis(); @JsonProperty @Deprecated String cacheSpec(); @JsonProperty String repositoryCacheSpec(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<GracefulShutdownTimeout> gracefulShutdownTimeout(); @JsonProperty boolean isWebAppEnabled(); @Nullable @JsonProperty("webAppTitle") String webAppTitle(); @JsonProperty boolean isMirroringEnabled(); @JsonProperty int numMirroringThreads(); @JsonProperty int maxNumFilesPerMirror(); @JsonProperty long maxNumBytesPerMirror(); @JsonProperty("replication") ReplicationConfig replicationConfig(); @JsonProperty boolean isCsrfTokenRequiredForThrift(); @JsonProperty @Nullable String accessLogFormat(); @Nullable @JsonProperty("authentication") AuthConfig authConfig(); @Override String toString(); }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); @JsonProperty File dataDir(); @JsonProperty @JsonSerialize(contentUsing = ServerPortSerializer.class) List<ServerPort> ports(); @Nullable @JsonProperty TlsConfig tls(); @Nullable @JsonProperty List<String> trustedProxyAddresses(); @Nullable @JsonProperty List<String> clientAddressSources(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> numWorkers(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxNumConnections(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> requestTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> idleTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxFrameLength(); @JsonProperty long maxRemovedRepositoryAgeMillis(); @JsonProperty @Deprecated String cacheSpec(); @JsonProperty String repositoryCacheSpec(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<GracefulShutdownTimeout> gracefulShutdownTimeout(); @JsonProperty boolean isWebAppEnabled(); @Nullable @JsonProperty("webAppTitle") String webAppTitle(); @JsonProperty boolean isMirroringEnabled(); @JsonProperty int numMirroringThreads(); @JsonProperty int maxNumFilesPerMirror(); @JsonProperty long maxNumBytesPerMirror(); @JsonProperty("replication") ReplicationConfig replicationConfig(); @JsonProperty boolean isCsrfTokenRequiredForThrift(); @JsonProperty @Nullable String accessLogFormat(); @Nullable @JsonProperty("authentication") AuthConfig authConfig(); @Override String toString(); }
@Test void maxRemovedRepositoryAgeMillis_withDefault() throws Exception { final CentralDogmaConfig cfg = Jackson.readValue("{\n" + " \"dataDir\": \"./data\",\n" + " \"ports\": [\n" + " {\n" + " \"localAddress\": {\n" + " \"host\": \"*\",\n" + " \"port\": 36462\n" + " },\n" + " \"protocols\": [\n" + " \"https\",\n" + " \"http\",\n" + " \"proxy\"\n" + " ]\n" + " }\n" + " ]\n" + '}', CentralDogmaConfig.class); assertThat(cfg.maxRemovedRepositoryAgeMillis()).isEqualTo(DEFAULT_MAX_REMOVED_REPOSITORY_AGE_MILLIS); }
@JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); @JsonProperty File dataDir(); @JsonProperty @JsonSerialize(contentUsing = ServerPortSerializer.class) List<ServerPort> ports(); @Nullable @JsonProperty TlsConfig tls(); @Nullable @JsonProperty List<String> trustedProxyAddresses(); @Nullable @JsonProperty List<String> clientAddressSources(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> numWorkers(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxNumConnections(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> requestTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> idleTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxFrameLength(); @JsonProperty long maxRemovedRepositoryAgeMillis(); @JsonProperty @Deprecated String cacheSpec(); @JsonProperty String repositoryCacheSpec(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<GracefulShutdownTimeout> gracefulShutdownTimeout(); @JsonProperty boolean isWebAppEnabled(); @Nullable @JsonProperty("webAppTitle") String webAppTitle(); @JsonProperty boolean isMirroringEnabled(); @JsonProperty int numMirroringThreads(); @JsonProperty int maxNumFilesPerMirror(); @JsonProperty long maxNumBytesPerMirror(); @JsonProperty("replication") ReplicationConfig replicationConfig(); @JsonProperty boolean isCsrfTokenRequiredForThrift(); @JsonProperty @Nullable String accessLogFormat(); @Nullable @JsonProperty("authentication") AuthConfig authConfig(); @Override String toString(); }
CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig( @JsonProperty(value = "dataDir", required = true) File dataDir, @JsonProperty(value = "ports", required = true) @JsonDeserialize(contentUsing = ServerPortDeserializer.class) List<ServerPort> ports, @JsonProperty("tls") @Nullable TlsConfig tls, @JsonProperty("trustedProxyAddresses") @Nullable List<String> trustedProxyAddresses, @JsonProperty("clientAddressSources") @Nullable List<String> clientAddressSources, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxNumConnections") @Nullable Integer maxNumConnections, @JsonProperty("requestTimeoutMillis") @Nullable Long requestTimeoutMillis, @JsonProperty("idleTimeoutMillis") @Nullable Long idleTimeoutMillis, @JsonProperty("maxFrameLength") @Nullable Integer maxFrameLength, @JsonProperty("numRepositoryWorkers") @Nullable Integer numRepositoryWorkers, @JsonProperty("repositoryCacheSpec") @Nullable String repositoryCacheSpec, @JsonProperty("maxRemovedRepositoryAgeMillis") @Nullable Long maxRemovedRepositoryAgeMillis, @JsonProperty("gracefulShutdownTimeout") @Nullable GracefulShutdownTimeout gracefulShutdownTimeout, @JsonProperty("webAppEnabled") @Nullable Boolean webAppEnabled, @JsonProperty("webAppTitle") @Nullable String webAppTitle, @JsonProperty("mirroringEnabled") @Nullable Boolean mirroringEnabled, @JsonProperty("numMirroringThreads") @Nullable Integer numMirroringThreads, @JsonProperty("maxNumFilesPerMirror") @Nullable Integer maxNumFilesPerMirror, @JsonProperty("maxNumBytesPerMirror") @Nullable Long maxNumBytesPerMirror, @JsonProperty("replication") @Nullable ReplicationConfig replicationConfig, @JsonProperty("csrfTokenRequiredForThrift") @Nullable Boolean csrfTokenRequiredForThrift, @JsonProperty("accessLogFormat") @Nullable String accessLogFormat, @JsonProperty("authentication") @Nullable AuthConfig authConfig); @JsonProperty File dataDir(); @JsonProperty @JsonSerialize(contentUsing = ServerPortSerializer.class) List<ServerPort> ports(); @Nullable @JsonProperty TlsConfig tls(); @Nullable @JsonProperty List<String> trustedProxyAddresses(); @Nullable @JsonProperty List<String> clientAddressSources(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> numWorkers(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxNumConnections(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> requestTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Long> idleTimeoutMillis(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<Integer> maxFrameLength(); @JsonProperty long maxRemovedRepositoryAgeMillis(); @JsonProperty @Deprecated String cacheSpec(); @JsonProperty String repositoryCacheSpec(); @JsonProperty @JsonSerialize(converter = OptionalConverter.class) Optional<GracefulShutdownTimeout> gracefulShutdownTimeout(); @JsonProperty boolean isWebAppEnabled(); @Nullable @JsonProperty("webAppTitle") String webAppTitle(); @JsonProperty boolean isMirroringEnabled(); @JsonProperty int numMirroringThreads(); @JsonProperty int maxNumFilesPerMirror(); @JsonProperty long maxNumBytesPerMirror(); @JsonProperty("replication") ReplicationConfig replicationConfig(); @JsonProperty boolean isCsrfTokenRequiredForThrift(); @JsonProperty @Nullable String accessLogFormat(); @Nullable @JsonProperty("authentication") AuthConfig authConfig(); @Override String toString(); }
@Test void testValidateFilePath() { assertFilePathValidationSuccess("/foo.txt"); assertFilePathValidationSuccess("/foo/bar.txt"); assertFilePathValidationSuccess("/foo.bar/baz.json"); assertFilePathValidationSuccess("/foo-bar/baz-json"); assertFilePathValidationFailure("foo"); assertFilePathValidationFailure("/"); assertFilePathValidationFailure("/foo/"); assertFilePathValidationFailure(" assertFilePathValidationFailure("/foo assertFilePathValidationFailure("/."); assertFilePathValidationFailure("/.."); assertFilePathValidationFailure("/.foo"); assertFilePathValidationFailure("/foo."); assertFilePathValidationFailure("/.foo."); assertFilePathValidationFailure("/\t"); assertFilePathValidationFailure("/80:20"); assertFilePathValidationFailure("/foo*.txt"); assertFilePathValidationFailure("/bar?.txt"); assertFilePathValidationFailure("/baz|.txt"); assertFilePathValidationFailure("/\uAC00\uB098\uB2E4.json"); }
public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; }
Util { public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; } }
Util { public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; } private Util(); }
Util { public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
Util { public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
@Test void testValidateJsonFilePath() { assertJsonFilePathValidationSuccess("/foo.json"); assertJsonFilePathValidationSuccess("/foo/bar.json"); assertJsonFilePathValidationSuccess("/foo.bar/baz.json"); assertJsonFilePathValidationSuccess("/foo.JSON"); assertJsonFilePathValidationSuccess("/foo.Json"); assertJsonFilePathValidationSuccess("/foo.jsoN"); assertJsonFilePathValidationFailure("/foo.txt"); assertJsonFilePathValidationFailure("/foo/bar.txt"); assertJsonFilePathValidationFailure("/foo.bar/baz.json.txt"); assertJsonFilePathValidationFailure("/foo-bar/baz-json"); assertJsonFilePathValidationFailure("/"); assertJsonFilePathValidationFailure("/foo/"); assertJsonFilePathValidationFailure("/."); assertJsonFilePathValidationFailure("/.."); assertJsonFilePathValidationFailure("/.json"); assertJsonFilePathValidationFailure("/json."); assertJsonFilePathValidationFailure("/.json."); assertJsonFilePathValidationFailure("/\t"); assertJsonFilePathValidationFailure("/80:20"); assertJsonFilePathValidationFailure("/foo*.json"); assertJsonFilePathValidationFailure("/bar?.json"); assertJsonFilePathValidationFailure("/baz|.json"); assertJsonFilePathValidationFailure("/\uAC00\uB098\uB2E4.json"); }
public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; }
Util { public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; } }
Util { public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; } private Util(); }
Util { public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
Util { public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
@Test void testValidateDirPath() { assertDirPathValidationSuccess("/"); assertDirPathValidationSuccess("/foo"); assertDirPathValidationSuccess("/foo/"); assertDirPathValidationSuccess("/foo/bar"); assertDirPathValidationSuccess("/foo/bar/"); assertDirPathValidationSuccess("/foo.bar/"); assertDirPathValidationSuccess("/foo-bar/"); assertDirPathValidationFailure("foo"); assertDirPathValidationFailure(" assertDirPathValidationFailure("/foo assertDirPathValidationFailure("/./"); assertDirPathValidationFailure("/../"); assertDirPathValidationFailure("/.foo/"); assertDirPathValidationFailure("/foo./"); assertDirPathValidationFailure("/.foo./"); assertDirPathValidationFailure("/\t/"); assertDirPathValidationFailure("/80:20/"); assertDirPathValidationFailure("/foo*/"); assertDirPathValidationFailure("/bar?/"); assertDirPathValidationFailure("/baz|/"); assertDirPathValidationFailure("/\uAC00\uB098\uB2E4/"); }
public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; }
Util { public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; } }
Util { public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; } private Util(); }
Util { public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
Util { public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }
@Test void testMakeReasonable() { assertThat(availableTimeout(1_000, 0)).isEqualTo(1_000); assertThat(availableTimeout(1_000, 1_000)).isEqualTo(1_000); assertThat(availableTimeout(MAX_MILLIS, 1_000)).isEqualTo(MAX_MILLIS - 1_000); assertThat(availableTimeout(MAX_MILLIS + 1_000, 0)).isEqualTo(MAX_MILLIS); assertThat(availableTimeout(MAX_MILLIS - 1_000, 500)).isEqualTo(MAX_MILLIS - 1000); assertThatThrownBy(() -> availableTimeout(0, 1_000)) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> availableTimeout(-1, 1_000)) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> availableTimeout(1_000, -1)) .isInstanceOf(IllegalArgumentException.class); }
public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); }
WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } }
WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } private WatchTimeout(); }
WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } private WatchTimeout(); static long availableTimeout(long expectedTimeoutMillis); static long availableTimeout(long expectedTimeoutMillis, long currentTimeoutMillis); }
WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } private WatchTimeout(); static long availableTimeout(long expectedTimeoutMillis); static long availableTimeout(long expectedTimeoutMillis, long currentTimeoutMillis); static final long MAX_MILLIS; }
@Test void normalizeRevision() { final Revision latestRevision = new Revision(2); for (int i = 1; i <= latestRevision.major(); i++) { final Revision revision = new Revision(i); when(delegate.normalizeRevision(any(), any(), any())).thenReturn(completedFuture(revision)); assertThat(dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()).isEqualTo(revision); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.HEAD); verifyNoMoreInteractions(delegate); reset(delegate); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(revision); } when(delegate.normalizeRevision(any(), any(), any())).thenReturn( exceptionallyCompletedFuture(new RevisionNotFoundException()), completedFuture(latestRevision.backward(1)), completedFuture(latestRevision)); assertThat(dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()).isEqualTo(latestRevision); verify(delegate, times(3)).normalizeRevision("foo", "bar", Revision.HEAD); verifyNoMoreInteractions(delegate); reset(delegate); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(latestRevision); final Revision newLatestRevision = latestRevision.forward(1); when(delegate.normalizeRevision(any(), any(), any())).thenReturn(completedFuture(newLatestRevision)); assertThat(dogma.normalizeRevision("foo", "bar", newLatestRevision).join()) .isEqualTo(newLatestRevision); verify(delegate, times(1)).normalizeRevision("foo", "bar", newLatestRevision); verifyNoMoreInteractions(delegate); reset(delegate); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(newLatestRevision); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(Revision.INIT)); assertThat(dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()).isEqualTo(Revision.INIT); verify(delegate, times(4)).normalizeRevision("foo", "bar", Revision.HEAD); verifyNoMoreInteractions(delegate); reset(delegate); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(exceptionallyCompletedFuture(new RevisionNotFoundException())); assertThatThrownBy(() -> dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RevisionNotFoundException.class); verify(delegate, times(4)).normalizeRevision("foo", "bar", Revision.HEAD); verifyNoMoreInteractions(delegate); }
@Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void normalizeRevisionAndExecuteWithRetries() throws Exception { final Revision latestRevision = new Revision(3); when(delegate.normalizeRevision(any(), any(), any())).thenReturn(completedFuture(latestRevision)); when(delegate.getFile(any(), any(), any(), any(Query.class))).thenReturn( exceptionallyCompletedFuture(new RevisionNotFoundException()), exceptionallyCompletedFuture(new RevisionNotFoundException()), completedFuture(Entry.ofJson(latestRevision, "/foo.json", "{ \"a\": \"b\" }"))); assertThat(dogma.getFile("foo", "bar", Revision.HEAD, Query.ofJson("/foo.json")).join()) .isEqualTo(Entry.ofJson(latestRevision, "/foo.json", "{ \"a\": \"b\" }")); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.HEAD); verify(delegate, times(3)).getFile("foo", "bar", latestRevision, Query.ofJson("/foo.json")); verifyNoMoreInteractions(delegate); }
private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<CompletableFuture<T>>() { @Override public CompletableFuture<T> get() { return taskRunner.apply(normRev); } @Override public String toString() { return taskRunner + " with " + normRev; } }, (res, cause) -> cause != null && handleRevisionNotFound(projectName, repositoryName, normRev, cause))); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<CompletableFuture<T>>() { @Override public CompletableFuture<T> get() { return taskRunner.apply(normRev); } @Override public String toString() { return taskRunner + " with " + normRev; } }, (res, cause) -> cause != null && handleRevisionNotFound(projectName, repositoryName, normRev, cause))); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<CompletableFuture<T>>() { @Override public CompletableFuture<T> get() { return taskRunner.apply(normRev); } @Override public String toString() { return taskRunner + " with " + normRev; } }, (res, cause) -> cause != null && handleRevisionNotFound(projectName, repositoryName, normRev, cause))); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<CompletableFuture<T>>() { @Override public CompletableFuture<T> get() { return taskRunner.apply(normRev); } @Override public String toString() { return taskRunner + " with " + normRev; } }, (res, cause) -> cause != null && handleRevisionNotFound(projectName, repositoryName, normRev, cause))); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<CompletableFuture<T>>() { @Override public CompletableFuture<T> get() { return taskRunner.apply(normRev); } @Override public String toString() { return taskRunner + " with " + normRev; } }, (res, cause) -> cause != null && handleRevisionNotFound(projectName, repositoryName, normRev, cause))); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void listRepositories() { final Revision latestRevision = new Revision(2); for (int i = 1; i <= latestRevision.major(); i++) { final Revision revision = new Revision(i); when(delegate.listRepositories(any())).thenReturn(completedFuture( ImmutableMap.of("bar", new RepositoryInfo("bar", revision)))); assertThat(dogma.listRepositories("foo").join()).isEqualTo( ImmutableMap.of("bar", new RepositoryInfo("bar", revision))); verify(delegate, times(1)).listRepositories("foo"); verifyNoMoreInteractions(delegate); reset(delegate); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(revision); } when(delegate.listRepositories(any())).thenReturn( completedFuture(ImmutableMap.of( "bar", new RepositoryInfo("bar", latestRevision.backward(1)))), completedFuture(ImmutableMap.of( "bar", new RepositoryInfo("bar", latestRevision)))); assertThat(dogma.listRepositories("foo").join()) .isEqualTo(ImmutableMap.of("bar", new RepositoryInfo("bar", latestRevision))); verify(delegate, times(2)).listRepositories("foo"); verifyNoMoreInteractions(delegate); reset(delegate); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(latestRevision); when(delegate.listRepositories(any())).thenReturn(completedFuture( ImmutableMap.of("bar", new RepositoryInfo("bar", Revision.INIT)))); assertThat(dogma.listRepositories("foo").join()).isEqualTo( ImmutableMap.of("bar", new RepositoryInfo("bar", Revision.INIT))); verify(delegate, times(4)).listRepositories("foo"); verifyNoMoreInteractions(delegate); }
@Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Override public String toString() { return "listRepositories(" + projectName + ')'; } }, (res, cause) -> { if (res != null) { for (RepositoryInfo info : res.values()) { if (!updateLatestKnownRevision(projectName, info.name(), info.headRevision())) { return true; } } } return false; }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Override public String toString() { return "listRepositories(" + projectName + ')'; } }, (res, cause) -> { if (res != null) { for (RepositoryInfo info : res.values()) { if (!updateLatestKnownRevision(projectName, info.name(), info.headRevision())) { return true; } } } return false; }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Override public String toString() { return "listRepositories(" + projectName + ')'; } }, (res, cause) -> { if (res != null) { for (RepositoryInfo info : res.values()) { if (!updateLatestKnownRevision(projectName, info.name(), info.headRevision())) { return true; } } } return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Override public String toString() { return "listRepositories(" + projectName + ')'; } }, (res, cause) -> { if (res != null) { for (RepositoryInfo info : res.values()) { if (!updateLatestKnownRevision(projectName, info.name(), info.headRevision())) { return true; } } } return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Override public String toString() { return "listRepositories(" + projectName + ')'; } }, (res, cause) -> { if (res != null) { for (RepositoryInfo info : res.values()) { if (!updateLatestKnownRevision(projectName, info.name(), info.headRevision())) { return true; } } } return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void ofText() throws Exception { final Entry<String> e = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isTrue(); e.ifHasContent(content -> assertThat(content).isEqualTo("foo")); assertThat(e.content()).isEqualTo("foo"); assertThat(e.contentAsText()).isEqualTo("foo"); assertThat(e.contentAsPrettyText()).isEqualTo("foo"); assertThatThrownBy(e::contentAsJson).isInstanceOf(JsonParseException.class); assertThatThrownBy(() -> e.contentAsJson(JsonNode.class)).isInstanceOf(JsonParseException.class); assertThat(Entry.ofText(new Revision(1), "/a.txt", "null").contentAsJson()) .isEqualTo(Jackson.nullNode); assertThat(Entry.ofText(new Revision(1), "/a.txt", "null").contentAsJson(JsonNode.class)) .isEqualTo(Jackson.nullNode); final Entry<String> e2 = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(2), "/a.txt", "foo")); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(1), "/b.txt", "foo")); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(1), "/a.txt", "bar")); final Entry<JsonNode> e3 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<Void> e4 = Entry.ofDirectory(new Revision(1), "/foo"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); }
Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } }
Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); }
Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
@Test void retryOnlyOnRevisionNotFoundException() { when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(exceptionallyCompletedFuture(new ProjectNotFoundException())); assertThatThrownBy(() -> dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ProjectNotFoundException.class); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.HEAD); verifyNoMoreInteractions(delegate); }
@Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, revision); } @Override public String toString() { return "normalizeRevision(" + projectName + ", " + repositoryName + ", " + revision + ')'; } }, (res, cause) -> { if (cause != null) { return handleRevisionNotFound(projectName, repositoryName, revision, cause); } if (revision.isRelative()) { final Revision headRevision = res.forward(-(revision.major() + 1)); return !updateLatestKnownRevision(projectName, repositoryName, headRevision); } updateLatestKnownRevision(projectName, repositoryName, revision); return false; }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void push() { final PushResult pushResult = new PushResult(new Revision(3), 42L); when(delegate.push(any(), any(), any(), any(), any(), any(), any(Iterable.class))) .thenReturn(completedFuture(pushResult)); assertThat(dogma.push("foo", "bar", Revision.HEAD, "summary", "detail", Markup.MARKDOWN, ImmutableList.of(Change.ofTextUpsert("/a.txt", "a"))).join()) .isEqualTo(pushResult); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(pushResult.revision()); }
@Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<PushResult> get() { return delegate.push(projectName, repositoryName, baseRevision, summary, detail, markup, changes); } @Override public String toString() { return "push(" + projectName + ", " + repositoryName + ", " + baseRevision + ", " + summary + ", ...)"; } }, pushRetryPredicate(projectName, repositoryName, baseRevision)); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<PushResult> get() { return delegate.push(projectName, repositoryName, baseRevision, summary, detail, markup, changes); } @Override public String toString() { return "push(" + projectName + ", " + repositoryName + ", " + baseRevision + ", " + summary + ", ...)"; } }, pushRetryPredicate(projectName, repositoryName, baseRevision)); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<PushResult> get() { return delegate.push(projectName, repositoryName, baseRevision, summary, detail, markup, changes); } @Override public String toString() { return "push(" + projectName + ", " + repositoryName + ", " + baseRevision + ", " + summary + ", ...)"; } }, pushRetryPredicate(projectName, repositoryName, baseRevision)); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<PushResult> get() { return delegate.push(projectName, repositoryName, baseRevision, summary, detail, markup, changes); } @Override public String toString() { return "push(" + projectName + ", " + repositoryName + ", " + baseRevision + ", " + summary + ", ...)"; } }, pushRetryPredicate(projectName, repositoryName, baseRevision)); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<PushResult> get() { return delegate.push(projectName, repositoryName, baseRevision, summary, detail, markup, changes); } @Override public String toString() { return "push(" + projectName + ", " + repositoryName + ", " + baseRevision + ", " + summary + ", ...)"; } }, pushRetryPredicate(projectName, repositoryName, baseRevision)); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void watchRepository() { final Revision latestRevision = new Revision(3); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(Revision.INIT)); when(delegate.watchRepository(any(), any(), any(), any(), anyLong())) .thenReturn(completedFuture(latestRevision)); assertThat(dogma.watchRepository("foo", "bar", Revision.INIT, "/**", 10000L).join()) .isEqualTo(latestRevision); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(latestRevision); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.INIT); verify(delegate, times(1)).watchRepository("foo", "bar", Revision.INIT, "/**", 10000L); verifyNoMoreInteractions(delegate); reset(delegate); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(latestRevision)); when(delegate.getFile(any(), any(), any(), any(Query.class))) .thenReturn(exceptionallyCompletedFuture(new RevisionNotFoundException()), completedFuture(Entry.ofText(latestRevision, "/a.txt", "a"))); assertThat(dogma.getFile("foo", "bar", Revision.HEAD, Query.ofText("/a.txt")).join()) .isEqualTo(Entry.ofText(latestRevision, "/a.txt", "a")); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.HEAD); verify(delegate, times(2)).getFile("foo", "bar", latestRevision, Query.ofText("/a.txt")); verifyNoMoreInteractions(delegate); }
@Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> apply(Revision normLastKnownRevision) { return delegate.watchRepository(projectName, repositoryName, normLastKnownRevision, pathPattern, timeoutMillis) .thenApply(newLastKnownRevision -> { if (newLastKnownRevision != null) { updateLatestKnownRevision(projectName, repositoryName, newLastKnownRevision); } return newLastKnownRevision; }); } @Override public String toString() { return "watchRepository(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + pathPattern + ", " + timeoutMillis + ')'; } }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> apply(Revision normLastKnownRevision) { return delegate.watchRepository(projectName, repositoryName, normLastKnownRevision, pathPattern, timeoutMillis) .thenApply(newLastKnownRevision -> { if (newLastKnownRevision != null) { updateLatestKnownRevision(projectName, repositoryName, newLastKnownRevision); } return newLastKnownRevision; }); } @Override public String toString() { return "watchRepository(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + pathPattern + ", " + timeoutMillis + ')'; } }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> apply(Revision normLastKnownRevision) { return delegate.watchRepository(projectName, repositoryName, normLastKnownRevision, pathPattern, timeoutMillis) .thenApply(newLastKnownRevision -> { if (newLastKnownRevision != null) { updateLatestKnownRevision(projectName, repositoryName, newLastKnownRevision); } return newLastKnownRevision; }); } @Override public String toString() { return "watchRepository(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + pathPattern + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> apply(Revision normLastKnownRevision) { return delegate.watchRepository(projectName, repositoryName, normLastKnownRevision, pathPattern, timeoutMillis) .thenApply(newLastKnownRevision -> { if (newLastKnownRevision != null) { updateLatestKnownRevision(projectName, repositoryName, newLastKnownRevision); } return newLastKnownRevision; }); } @Override public String toString() { return "watchRepository(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + pathPattern + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> apply(Revision normLastKnownRevision) { return delegate.watchRepository(projectName, repositoryName, normLastKnownRevision, pathPattern, timeoutMillis) .thenApply(newLastKnownRevision -> { if (newLastKnownRevision != null) { updateLatestKnownRevision(projectName, repositoryName, newLastKnownRevision); } return newLastKnownRevision; }); } @Override public String toString() { return "watchRepository(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + pathPattern + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void watchFile() { final Revision latestRevision = new Revision(3); final Entry<String> latestEntry = Entry.ofText(latestRevision, "/a.txt", "a"); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(Revision.INIT)); when(delegate.watchFile(any(), any(), any(), (Query<String>) any(), anyLong())) .thenReturn(completedFuture(latestEntry)); assertThat(dogma.watchFile("foo", "bar", Revision.INIT, Query.ofText("/a.txt"), 10000L).join()) .isEqualTo(latestEntry); assertThat(dogma.latestKnownRevision("foo", "bar")).isEqualTo(latestRevision); verify(delegate, times(1)).normalizeRevision("foo", "bar", Revision.INIT); verify(delegate, times(1)).watchFile("foo", "bar", Revision.INIT, Query.ofText("/a.txt"), 10000L); verifyNoMoreInteractions(delegate); }
@Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normLastKnownRevision) { return delegate.watchFile(projectName, repositoryName, normLastKnownRevision, query, timeoutMillis) .thenApply(entry -> { if (entry != null) { updateLatestKnownRevision(projectName, repositoryName, entry.revision()); } return entry; }); } @Override public String toString() { return "watchFile(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + query + ", " + timeoutMillis + ')'; } }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normLastKnownRevision) { return delegate.watchFile(projectName, repositoryName, normLastKnownRevision, query, timeoutMillis) .thenApply(entry -> { if (entry != null) { updateLatestKnownRevision(projectName, repositoryName, entry.revision()); } return entry; }); } @Override public String toString() { return "watchFile(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + query + ", " + timeoutMillis + ')'; } }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normLastKnownRevision) { return delegate.watchFile(projectName, repositoryName, normLastKnownRevision, query, timeoutMillis) .thenApply(entry -> { if (entry != null) { updateLatestKnownRevision(projectName, repositoryName, entry.revision()); } return entry; }); } @Override public String toString() { return "watchFile(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + query + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normLastKnownRevision) { return delegate.watchFile(projectName, repositoryName, normLastKnownRevision, query, timeoutMillis) .thenApply(entry -> { if (entry != null) { updateLatestKnownRevision(projectName, repositoryName, entry.revision()); } return entry; }); } @Override public String toString() { return "watchFile(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + query + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normLastKnownRevision) { return delegate.watchFile(projectName, repositoryName, normLastKnownRevision, query, timeoutMillis) .thenApply(entry -> { if (entry != null) { updateLatestKnownRevision(projectName, repositoryName, entry.revision()); } return entry; }); } @Override public String toString() { return "watchFile(" + projectName + ", " + repositoryName + ", " + lastKnownRevision + ", " + query + ", " + timeoutMillis + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void getFile() { final Revision latestRevision = new Revision(3); final Entry<String> latestEntry = Entry.ofText(latestRevision, "/a.txt", "a"); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(latestRevision)); when(delegate.getFile(any(), any(), any(), any(Query.class))) .thenAnswer(invocation -> CompletableFuture.supplyAsync(() -> { throw new RevisionNotFoundException(); })) .thenReturn(completedFuture(latestEntry)); assertThat(dogma.getFile("foo", "bar", Revision.HEAD, "/a.txt").join()) .isEqualTo(latestEntry); verify(delegate).normalizeRevision("foo", "bar", Revision.HEAD); verify(delegate, times(2)).getFile("foo", "bar", latestRevision, Query.ofText("/a.txt")); verifyNoMoreInteractions(delegate); }
@Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normRev) { return delegate.getFile(projectName, repositoryName, normRev, query); } @Override public String toString() { return "getFile(" + projectName + ", " + repositoryName + ", " + revision + ", " + query + ')'; } }); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normRev) { return delegate.getFile(projectName, repositoryName, normRev, query); } @Override public String toString() { return "getFile(" + projectName + ", " + repositoryName + ", " + revision + ", " + query + ')'; } }); } }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normRev) { return delegate.getFile(projectName, repositoryName, normRev, query); } @Override public String toString() { return "getFile(" + projectName + ", " + repositoryName + ", " + revision + ", " + query + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normRev) { return delegate.getFile(projectName, repositoryName, normRev, query); } @Override public String toString() { return "getFile(" + projectName + ", " + repositoryName + ", " + revision + ", " + query + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry<T>> apply(Revision normRev) { return delegate.getFile(projectName, repositoryName, normRev, query); } @Override public String toString() { return "getFile(" + projectName + ", " + repositoryName + ", " + revision + ", " + query + ')'; } }); } ReplicationLagTolerantCentralDogma(ScheduledExecutorService executor, CentralDogma delegate, int maxRetries, long retryIntervalMillis, Supplier<?> currentReplicaHintSupplier); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles( String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles( String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff( String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs( String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs( String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void testEncodePathPattern() { assertThat(encodePathPattern("/")).isEqualTo("/"); assertThat(encodePathPattern(" ")).isEqualTo("%20"); assertThat(encodePathPattern(" ")).isEqualTo("%20%20"); assertThat(encodePathPattern("a b")).isEqualTo("a%20b"); assertThat(encodePathPattern(" a ")).isEqualTo("%20a%20"); final String pathPatternThatDoesNotNeedEscaping = "*.jar"; assertThat(encodePathPattern(pathPatternThatDoesNotNeedEscaping)) .isSameAs(pathPatternThatDoesNotNeedEscaping); }
@VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.append("%20"); pos = spacePos + 1; spacePos = pathPattern.indexOf(' ', pos); if (spacePos < 0) { buf.append(pathPattern, pos, pathPattern.length()); break; } } return buf.toString(); }
ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.append("%20"); pos = spacePos + 1; spacePos = pathPattern.indexOf(' ', pos); if (spacePos < 0) { buf.append(pathPattern, pos, pathPattern.length()); break; } } return buf.toString(); } }
ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.append("%20"); pos = spacePos + 1; spacePos = pathPattern.indexOf(' ', pos); if (spacePos < 0) { buf.append(pathPattern, pos, pathPattern.length()); break; } } return buf.toString(); } ArmeriaCentralDogma(ScheduledExecutorService executor, WebClient client, String accessToken); }
ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.append("%20"); pos = spacePos + 1; spacePos = pathPattern.indexOf(' ', pos); if (spacePos < 0) { buf.append(pathPattern, pos, pathPattern.length()); break; } } return buf.toString(); } ArmeriaCentralDogma(ScheduledExecutorService executor, WebClient client, String accessToken); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.append("%20"); pos = spacePos + 1; spacePos = pathPattern.indexOf(' ', pos); if (spacePos < 0) { buf.append(pathPattern, pos, pathPattern.length()); break; } } return buf.toString(); } ArmeriaCentralDogma(ScheduledExecutorService executor, WebClient client, String accessToken); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void decode() throws Exception { final EndpointListDecoder<JsonNode> decoder = EndpointListDecoder.JSON; final List<Endpoint> decoded = decoder.decode( objectMapper.readTree(objectMapper.writeValueAsString(HOST_AND_PORT_LIST))); assertThat(decoded).hasSize(4); assertThat(decoded).isEqualTo(ENDPOINT_LIST); }
@Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); }
JsonEndpointListDecoder implements EndpointListDecoder<JsonNode> { @Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); } }
JsonEndpointListDecoder implements EndpointListDecoder<JsonNode> { @Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); } }
JsonEndpointListDecoder implements EndpointListDecoder<JsonNode> { @Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); } @Override List<Endpoint> decode(JsonNode node); }
JsonEndpointListDecoder implements EndpointListDecoder<JsonNode> { @Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); } @Override List<Endpoint> decode(JsonNode node); }
@Test void decode() { final EndpointListDecoder<String> decoder = EndpointListDecoder.TEXT; final List<Endpoint> decoded = decoder.decode(String.join("\n", HOST_AND_PORT_LIST)); assertThat(decoded).hasSize(4); assertThat(decoded).isEqualTo(ENDPOINT_LIST); }
@Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); }
TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } }
TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } }
TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } @Override List<Endpoint> decode(String object); }
TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } @Override List<Endpoint> decode(String object); }
@Test void newClientBuilderCustomizationOrder() { final ClientFactory cf1 = mock(ClientFactory.class); final ClientFactory cf2 = mock(ClientFactory.class); final ClientFactory cf3 = mock(ClientFactory.class); final ArmeriaCentralDogmaBuilder b = new ArmeriaCentralDogmaBuilder(); final StringBuilder buf = new StringBuilder(); b.clientFactory(cf1); b.clientConfigurator(cb -> { buf.append('2'); cb.factory(cf2); }); final ClientBuilder cb = b.newClientBuilder("none+http", Endpoint.of("127.0.0.1"), cb2 -> { cb2.factory(cf3); buf.append('1'); }, "/"); assertThat(buf.toString()).isEqualTo("12"); cb.build(HttpClient.class); verify(cf1, times(1)).newClient(any()); verify(cf2, never()).newClient(any()); verify(cf3, never()).newClient(any()); }
public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } }
ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } } }
ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } } }
ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } } CentralDogma build(); }
ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } } CentralDogma build(); }
@Test void execute() throws Exception { check("listProjects", 1000L, 1L, 1L); }
@Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) || "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); }
LegacyCentralDogmaTimeoutScheduler extends SimpleDecoratingRpcClient { @Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) || "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); } }
LegacyCentralDogmaTimeoutScheduler extends SimpleDecoratingRpcClient { @Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) || "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); } LegacyCentralDogmaTimeoutScheduler(RpcClient delegate); }
LegacyCentralDogmaTimeoutScheduler extends SimpleDecoratingRpcClient { @Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) || "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); } LegacyCentralDogmaTimeoutScheduler(RpcClient delegate); @Override RpcResponse execute(ClientRequestContext ctx, RpcRequest req); }
LegacyCentralDogmaTimeoutScheduler extends SimpleDecoratingRpcClient { @Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) || "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); } LegacyCentralDogmaTimeoutScheduler(RpcClient delegate); @Override RpcResponse execute(ClientRequestContext ctx, RpcRequest req); }
@Test void ofJson() throws Exception { final Entry<JsonNode> e = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isTrue(); e.ifHasContent(content -> assertThatJson(content).isEqualTo("{ \"foo\": \"bar\" }")); assertThatJson(e.content()).isEqualTo("{ \"foo\": \"bar\" }"); assertThat(e.contentAsText()).isEqualTo("{\"foo\":\"bar\"}"); assertThat(e.contentAsPrettyText()).isEqualTo("{\n \"foo\": \"bar\"\n}"); assertThat(e.content()).isSameAs(e.contentAsJson()); assertThat(e.content()).isEqualTo(e.contentAsJson(JsonNode.class)); final Entry<JsonNode> e2 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(2), "/a.json", "{ \"foo\": \"bar\" }")); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(1), "/b.json", "{ \"foo\": \"bar\" }")); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(1), "/a.json", "null")); final Entry<String> e3 = Entry.ofText(new Revision(1), "/a.json", "{\"foo\":\"bar\"}"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<Void> e4 = Entry.ofDirectory(new Revision(1), "/foo"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); }
Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } }
Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); }
Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
@Test void createProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).createProject(any(), any()); assertThat(client.createProject("project").get()).isNull(); verify(iface).createProject(eq("project"), any()); }
@Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void removeProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).removeProject(any(), any()); assertThat(client.removeProject("project").get()).isNull(); verify(iface).removeProject(eq("project"), any()); }
@Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void purgeProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).purgeProject(any(), any()); assertThat(client.purgeProject("project").get()).isNull(); verify(iface).purgeProject(eq("project"), any()); }
@Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void unremoveProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).unremoveProject(any(), any()); assertThat(client.unremoveProject("project").get()).isNull(); verify(iface).unremoveProject(eq("project"), any()); }
@Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void listProjects() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<List<Project>> callback = invocation.getArgument(0); callback.onComplete(ImmutableList.of(new Project("project"))); return null; }).when(iface).listProjects(any()); assertThat(client.listProjects().get()).isEqualTo(ImmutableSet.of("project")); verify(iface).listProjects(any()); }
@Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void listRemovedProjects() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Set<String>> callback = invocation.getArgument(0); callback.onComplete(ImmutableSet.of("project")); return null; }).when(iface).listRemovedProjects(any()); assertThat(client.listRemovedProjects().get()).isEqualTo(ImmutableSet.of("project")); verify(iface).listRemovedProjects(any()); }
@Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void createRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).createRepository(anyString(), anyString(), any()); assertThat(client.createRepository("project", "repo").get()).isNull(); verify(iface).createRepository(eq("project"), eq("repo"), any()); }
@Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void removeRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).removeRepository(anyString(), anyString(), any()); assertThat(client.removeRepository("project", "repo").get()).isNull(); verify(iface).removeRepository(eq("project"), eq("repo"), any()); }
@Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void purgeRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).purgeRepository(anyString(), anyString(), any()); assertThat(client.purgeRepository("project", "repo").get()).isNull(); verify(iface).purgeRepository(eq("project"), eq("repo"), any()); }
@Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void unremoveRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).unremoveRepository(anyString(), anyString(), any()); assertThat(client.unremoveRepository("project", "repo").get()).isNull(); verify(iface).unremoveRepository(eq("project"), eq("repo"), any()); }
@Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
@Test void of() { assertThatThrownBy(() -> Entry.of(null, "/1.txt", EntryType.TEXT, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), null, EntryType.TEXT, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", null, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", EntryType.TEXT, null)) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", EntryType.TEXT, new Object())) .isInstanceOf(ClassCastException.class); Entry.of(new Revision(1), "/a", EntryType.DIRECTORY, null); assertThatThrownBy(() -> Entry.of(new Revision(1), "/a", EntryType.DIRECTORY, "foo")) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("expected: null"); }
public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); }
Entry implements ContentHolder<T> { public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } }
Entry implements ContentHolder<T> { public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); }
Entry implements ContentHolder<T> { public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
Entry implements ContentHolder<T> { public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }
@Test void listRepositories() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<List<Repository>> callback = invocation.getArgument(1); final Repository repository = new Repository("repo").setHead( new TCommit(new TRevision(42), new TAuthor("hitchhiker", "[email protected]"), "1978-03-08T00:00:00Z", "The primary phrase", new Comment(""), null)); callback.onComplete(ImmutableList.of(repository)); return null; }).when(iface).listRepositories(any(), any()); assertThat(client.listRepositories("project").get()).isEqualTo(ImmutableMap.of( "repo", new RepositoryInfo("repo", new Revision(42)))); verify(iface).listRepositories(eq("project"), any()); }
@Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.identity(), Repository::getName, r -> new RepositoryInfo( r.getName(), RevisionConverter.TO_MODEL.convert(r.getHead().getRevision())))); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.identity(), Repository::getName, r -> new RepositoryInfo( r.getName(), RevisionConverter.TO_MODEL.convert(r.getHead().getRevision())))); } }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.identity(), Repository::getName, r -> new RepositoryInfo( r.getName(), RevisionConverter.TO_MODEL.convert(r.getHead().getRevision())))); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.identity(), Repository::getName, r -> new RepositoryInfo( r.getName(), RevisionConverter.TO_MODEL.convert(r.getHead().getRevision())))); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }
LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.identity(), Repository::getName, r -> new RepositoryInfo( r.getName(), RevisionConverter.TO_MODEL.convert(r.getHead().getRevision())))); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }