@Test public void test_get_schemas() { Set<Schema> schemas = generateSchemas(10, 10); for (Schema schema : schemas) { manager.registerSchema(schema); Schema response = manager.getSchema(schema.getName()); assertThat(schema, equalTo(response)); } Map<String, Schema> schemaNames = manager.getSchemas(); for (Schema s : schemas) { assertTrue(schemaNames.containsKey(s.getName())); } }
@Test public void test_remove_schema() { Set<Schema> schemas = generateSchemas(2, 2); for (Schema schema : schemas) { manager.registerSchema(schema); Schema response = manager.getSchema(schema.getName()); assertThat(schema, equalTo(response)); } Schema s = schemas.iterator().next(); assertThat(manager.getSchema(s.getName()), is(s)); manager.removeSchema(s.getName()); try { s = manager.getSchema(s.getName()); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(Events.CFG101)); } }
@Test public void test_add_get_schema() { Set<Schema> schemas = generateSchemas(10, 10); for (Schema schema : schemas) { manager.registerSchema(schema); Schema response = manager.getSchema(schema.getName()); assertThat(schema, equalTo(response)); } }
@Override public Map<String, Schema> getSchemas() { doLookup(); Map<String, Schema> schemas = schemaManager.getSchemas(); return schemas; }
@Override public BeanQuery newQuery(String schemaName) { doLookup(); Schema schema = schemaManager.getSchema(schemaName); Preconditions.checkNotNull(schema, "Schema " + schemaName + " does not exist."); return beanManager.newQuery(schema); }
@Override public void unregister(Class<?>... configurable) { doLookup(); for (Class<?> clazz : configurable) { Schema schema = conversion.convert(clazz, Schema.class); schemaManager.removeSchema(schema.getName()); core.removeIndex(schema); } }
private Schema getSchema(Class<?> clazz) { Schema schema = schemas.get(clazz); if(schema != null) { return schema; } ClassIntrospector introspector = new ClassIntrospector(clazz); Config config = introspector.getAnnotation(Config.class); if (config == null) { throw CFG102_NOT_CONFIGURABLE(clazz); } String schemaName = config.name(); if (schemaName == null || "".equals(schemaName)) { schemaName = clazz.getName(); } schema = conversion.convert(clazz, Schema.class); for (Class<?> cls : schema.getReferenceSchemaTypes()) { if (schemas.get(clazz) != null) { getSchema(cls); } } properties.registerSchema(schema); schemas.put(schema.getName(), schema); schemaManager.registerSchema(schema); core.putIndex(schema); return schema; } }
@Override public void register(Class<?>... configurable) { doLookup(); for (Class<?> clazz : configurable) { Schema schema = conversion.convert(clazz, Schema.class); schemaManager.regsiterSchema(schema); if (schema.getId().isSingleton()) { beanManager.createSingleton(getSingletonId(schema, clazz)); } // ok to not have validation manager available if (validationManager != null) { validationManager.register(schema.getName(), clazz); } } }
@Override public Map<String, Schema> getSchemas() { doLookup(); return schemaManager.getSchemas(); }
private Schema getSchema(Class<?> clazz) { ClassIntrospector introspector = new ClassIntrospector(clazz); Config config = introspector.getAnnotation(Config.class); if (config == null) { throw CFG102_NOT_CONFIGURABLE(clazz); } String schemaName = config.name(); if (schemaName == null || "".equals(schemaName)) { schemaName = clazz.getName(); } return schemaManager.getSchema(schemaName); } }
@Override public void unregister(Class<?>... configurable) { doLookup(); for (Class<?> clazz : configurable) { Schema schema = conversion.convert(clazz, Schema.class); schemaManager.removeSchema(schema.getName()); // ok to not have validation manager available if (validationManager != null) { validationManager.unregister(schema.getName()); } } }
@Override public List<Bean> list(String schemaName) { Preconditions.checkNotNull(schemaName); doLookup(); Map<BeanId, Bean> beans = beanManager.list(schemaName); core.setSchema(schemaManager.getSchemas(), beans); return new ArrayList<>(beans.values()); }
@Override public List<Bean> list(String schemaName) { Preconditions.checkNotNull(schemaName); doLookup(); Map<BeanId, Bean> beans = beanManager.list(schemaName); setSchema(schemaManager.getSchemas(), beans); return new ArrayList<Bean>(beans.values()); }
@Override public Optional<Bean> get(BeanId beanId) { Preconditions.checkNotNull(beanId); doLookup(); Optional<Bean> bean = beanManager.getEager(beanId); if (!bean.isPresent()) { return bean; } Map<String, Schema> schemas = schemaManager.getSchemas(); core.setSchema(bean.get(), schemas); setSingletonReferences(bean.get(), schemas); return bean; }
@Override public List<Bean> list(String schemaName, Collection<String> instanceIds) { Preconditions.checkNotNull(schemaName); if (instanceIds == null || instanceIds.isEmpty()) { return new ArrayList<Bean>(); } doLookup(); Map<BeanId, Bean> beans = beanManager.list(schemaName); Map<BeanId, Bean> result = new HashMap<BeanId, Bean>(); for (String instanceId : instanceIds) { Bean b = beans.get(BeanId.create(instanceId, schemaName)); result.put(b.getId(), b); } Map<String, Schema> schemas = schemaManager.getSchemas(); setSchema(schemas, result); return new ArrayList<Bean>(result.values()); }
@Override public List<Bean> list(String schemaName, Collection<String> instanceIds) { Preconditions.checkNotNull(schemaName); if (instanceIds == null || instanceIds.isEmpty()) { return new ArrayList<>(); } doLookup(); Map<BeanId, Bean> beans = beanManager.list(schemaName, instanceIds); Map<BeanId, Bean> result = new HashMap<>(); for (String instanceId : instanceIds) { Bean b = beans.get(BeanId.create(instanceId, schemaName)); result.put(b.getId(), b); } Map<String, Schema> schemas = schemaManager.getSchemas(); core.setSchema(schemas, result); return new ArrayList<>(result.values()); }
@Override public void delete(BeanId beanId) { Preconditions.checkNotNull(beanId); doLookup(); Bean bean = beanManager.delete(beanId); core.setSchema(schemaManager.getSchemas(), Arrays.asList(bean)); notificationManager.fireDelete(Lists.newArrayList(bean)); core.cacheRemove(beanId); }
private void validateMerge(Collection<Bean> mergebeans) { Map<BeanId, Bean> beansToValidate = beanManager.getBeanToValidate(mergebeans); core.setSchema(schemaManager.getSchemas(), beansToValidate); // since we are validating mergebean predecessors, we need to make sure // that they see a merged reference (not unmerged reference currently in storage) // before validation can proceed. for (Bean mergebean : mergebeans) { ArrayList<Bean> mergeBeanReferences = new ArrayList<>(); ArrayList<Bean> checked = new ArrayList<>(); findReferences(mergebean.getId(), beansToValidate.values(), mergeBeanReferences, checked); // merge list references merge(mergeBeanReferences, mergebean); } // ready to validate validator.get().validate(beansToValidate.values()); }
@Override public Bean get(BeanId beanId) { Preconditions.checkNotNull(beanId); doLookup(); Bean bean = beanManager.getEager(beanId); Map<String, Schema> schemas = schemaManager.getSchemas(); setSchema(bean, schemas); setSingletonReferences(bean, schemas); return bean; }
@Override public void delete(String name, Collection<String> instances) { Preconditions.checkNotNull(name); if (instances == null || instances.isEmpty()) { return; } doLookup(); Collection<Bean> beans = beanManager.delete(name, instances); core.setSchema(schemaManager.getSchemas(), beans); notificationManager.fireDelete(beans); core.cacheRemove(name, instances); }