@Override public Subject register(final String subjectName, final SubjectConfig config) { return repo.register(subjectName, config); }
@Override public void close() throws IOException { repo.close(); }
@Override public Subject lookup(final String subjectName) { return repo.lookup(subjectName); }
@Test public void testWriteCloseRead() throws Exception { try { repo.register("sub1", null).register("sc1"); repo.register("sub2", null).register("sc2"); repo.register("sub2", null).register("sc3"); } finally { repo.close(); } // Calling close() and createRepository() is like bouncing the repo, to ensure its state persists. repo = createRepository(); try { Subject s1 = repo.lookup("sub1"); Assert.assertNotNull(s1); Subject s2 = repo.lookup("sub2"); Assert.assertNotNull(s2); SchemaEntry e1 = s1.lookupBySchema("sc1"); Assert.assertNotNull(e1); Assert.assertEquals("sc1", e1.getSchema()); SchemaEntry e2 = s2.lookupBySchema("sc2"); Assert.assertNotNull(e2); Assert.assertEquals("sc2", e2.getSchema()); SchemaEntry e3 = s2.lookupBySchema("sc3"); Assert.assertNotNull(e3); Assert.assertEquals("sc3", e3.getSchema()); } finally { repo.close(); } }
Subject none = repo.lookup(SUB); Assert.assertNull("non-existent subject lookup should return null", none); Iterable<Subject> subjects = repo.subjects(); Assert.assertNotNull("subjects must not be null"); Assert.assertFalse("subjects must be empty", subjects.iterator().hasNext()); Subject sub = repo.register(SUB, null); Assert.assertNotNull("failed to register subject: " + SUB, sub); Subject sub2 = repo.register(SUB, null); Assert.assertNotNull("failed to re-register subject: " + SUB, sub2); Assert.assertEquals( Subject sub3 = repo.lookup(SUB); Assert.assertNotNull("subject lookup failed", sub3); Assert.assertEquals("subject lookup failed", sub.getName(), sub3.getName()); Subject none2 = repo.lookup("nothing"); Assert.assertNull("non-existent subject lookup should return null", none2); for (Subject s : repo.subjects()) { if (sub.getName().equals(s.getName())) { hasSub = true; Subject subject = repo.lookup(SUB); Assert.assertNotNull("lookup of previously registered subject failed", subject);
@Override public Iterable<Subject> subjects() { return repo.subjects(); }
@Override public Iterable<Subject> subjects() { return repo.subjects(); }
@Test public void testAllEntriesMultiLineSchema() throws Exception { String endOfLine = System.getProperty("line.separator"); String multiLineSchema1 = "first line" + endOfLine + "second line"; String multiLineSchema2 = "first line" + endOfLine + "second line" + endOfLine; repo.register("sub1", null).register(multiLineSchema1); repo.register("sub1", null).register(multiLineSchema2); Subject s1 = repo.lookup("sub1"); Assert.assertNotNull(s1); Iterable<SchemaEntry> allEntries = s1.allEntries(); boolean foundSub1 = false, foundSub2 = false; for (SchemaEntry entry: allEntries) { if (entry.getSchema().equals(multiLineSchema1)) { foundSub1 = true; } else if (entry.getSchema().equals(multiLineSchema2)) { foundSub2 = true; } } Assert.assertTrue("Check that allEntries() returns proper multi-line schemas", foundSub1 && foundSub2); }
@Override public Subject lookup(final String subjectName) { return repo.lookup(subjectName); }
@Override public Subject register(final String subjectName, final SubjectConfig config) { return repo.register(subjectName, config); }
@Override public Iterable<Subject> subjects() { // the full list of subjects cannot be cached. // however we can populate the cache with the result Iterable<Subject> subs = repo.subjects(); for (Subject s : subs) { cache.add(s); } return subs; }
@Override public void close() throws IOException { repo.close(); }
@Test public void testSubjectConfigs() { String testKey = "test.key"; String testVal = "test.val"; String testVal2 = "test.val2"; SubjectConfig conf = new SubjectConfig.Builder().set(testKey, testVal).build(); SubjectConfig conf2 = new SubjectConfig.Builder().set(testKey, testVal2).build(); // lookup a subject that does not exist, when none do Subject none = repo.lookup(CONF); Assert.assertNull("non-existent subject lookup should return null", none); // register a subject Subject sub = repo.register(CONF, conf); Assert.assertNotNull("failed to register subject: " + CONF, sub); // a duplicate register is idempotent; the result is the same Subject sub2 = repo.register(CONF, conf2); Assert.assertNotNull("failed to re-register subject: " + SUB, sub2); validateSubject(sub, sub2); // lookup subject that was just registered Subject sub3 = repo.lookup(CONF); validateSubject(sub, sub3); // lookup something that is not there Subject sub4 = repo.lookup(NOCONF); Assert.assertNull("subject should not exist", sub4); }
private Subject getSubject(String subjectName) { Subject subject = repo.lookup(subjectName); if (null == subject) { throw new NotFoundException(MessageStrings.SUBJECT_DOES_NOT_EXIST_ERROR); } return subject; }
/** * This sets mutable data, hence it will always result in a call to the * underlying schema repo implementation. * * If the subject does not exist, it will be initialized with the given * config, but will not contain any ID/schema pair. * * @param subjectName to change the config for * @param subjectConfig to set for the given subject */ public void setConfig(SUBJECT subjectName, SubjectConfig subjectConfig) { repo.register(convertSubject.toString(subjectName), subjectConfig); }
@Override public Iterable<Subject> subjects() { ArrayList<Subject> subjects = new ArrayList<Subject>(); for(Subject sub : repo.subjects()) { subjects.add(Subject.readOnly(sub)); } return subjects; }
@Override public void lifeCycleStopped(LifeCycle event) { logger.info("Waited {} ms to drain requests before closing the repo and exiting. " + "This wait time can be adjusted with the {} config property.", gracefulShutdown, Config.JETTY_GRACEFUL_SHUTDOWN); try { repo.close(); logger.info("Successfully closed the repo."); } catch (IOException e) { logger.warn("Failed to properly close repo", e); } } }