@Override public void delete(String name, Collection<String> instances) { Preconditions.checkNotNull(name); if (instances == null || instances.isEmpty()) { return; } doLookup(); beanManager.delete(name, instances); }
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 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; }
@Test public void test_delete_default() { List<Bean> beans = generateBeans(2, 2); for (Bean bean : beans) { bean.setDefault(); } manager.create(beans); for (Bean bean : beans) { try { manager.delete(bean.getId()); fail("Should not be able to delete default instances"); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(CFG311)); } } } }
@Override public void merge(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); core.setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); // ok to not have validation manager available if (validator.isPresent()) { validateMerge(beans); } beanManager.merge(beans); notificationManager.fireUpdated(beans); for (Bean bean : beans) { // must refresh the bean from storage since it is merged. Optional<Bean> refreshed = beanManager.getEager(bean.getId()); if (refreshed.isPresent()) { core.cache(refreshed.get()); } } }
@Override public void create(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); core.setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validator.isPresent()) { initReferences(beans); validator.get().validate(beans); } beanManager.create(beans); notificationManager.fireCreate(beans); core.cache(beans); }
@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()); }
private void setSingletonReferences(Bean bean, Map<String, Schema> schemas) { Schema s = bean.getSchema(); for (SchemaPropertyRef ref : s.get(SchemaPropertyRef.class)) { if (ref.isSingleton()) { Schema singletonSchema = schemas.get(ref.getSchemaName()); Optional<Bean> singleton = beanManager.getSingleton(ref.getSchemaName()); if (singleton.isPresent()) { singleton.get().set(singletonSchema); BeanId singletonId = singleton.get().getId(); singletonId.setBean(singleton.get()); // recursive call. setSingletonReferences(singleton.get(), schemas); bean.setReference(ref.getName(), singletonId); } } } }
@Override public void set(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validationManager != null) { initReferences(beans); validateSet(beans); } beanManager.set(beans); }
Bean bean = cache.get(beanId); if (bean == null) { Optional<Bean> optional = beanManager.getLazy(beanId); if (!optional.isPresent()) { throw CFG301_MISSING_RUNTIME_REF(beanId);
@Override public void merge(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); // ok to not have validation manager available if (validationManager != null) { validateMerge(beans); } beanManager.merge(beans); }
@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 create(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validationManager != null) { initReferences(beans); validationManager.validate(beans); } beanManager.create(beans); }
@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()); }
private void setSingletonReferences(Bean bean, Map<String, Schema> schemas) { Schema s = bean.getSchema(); for (SchemaPropertyRef ref : s.get(SchemaPropertyRef.class)) { if (ref.isSingleton()) { Schema singletonSchema = schemas.get(ref.getSchemaName()); Optional<Bean> singleton = beanManager.getSingleton(ref.getSchemaName()); if (!singleton.isPresent()) { initFile(null); Bean fileBean = FILE_CONFIG.get(BeanId.createSingleton(ref.getSchemaName())); if (fileBean != null) { singleton = Optional.of(fileBean); } } if (!singleton.isPresent()) { singleton = Optional.of(Bean.create(BeanId.createSingleton(ref.getSchemaName()))); } singleton.get().set(singletonSchema); BeanId singletonId = singleton.get().getId(); singletonId.setBean(singleton.get()); // recursive call. setSingletonReferences(singleton.get(), schemas); bean.setReference(ref.getName(), singletonId); } } }
@Override public void set(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); core.setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validator.isPresent()) { initReferences(beans); validateSet(beans); } beanManager.set(beans); notificationManager.fireUpdated(beans); core.cache(beans); }
private void merge(List<Bean> sources, Bean mergeBean) { HashMap<BeanId, Bean> cache = new HashMap<BeanId, Bean>(); for (Bean source : sources) { for (String name : mergeBean.getPropertyNames()) { List<String> values = mergeBean.getValues(name); if (values == null || values.size() == 0) { continue; } source.setProperty(name, values); } for (String name : mergeBean.getReferenceNames()) { List<BeanId> refs = mergeBean.getReference(name); if (refs == null || refs.size() == 0) { source.setReferences(name, refs); continue; } for (BeanId beanId : refs) { Bean bean = cache.get(beanId); if (bean == null) { bean = beanManager.getLazy(beanId); setSchema(bean, schemaManager.getSchemas()); cache.put(beanId, bean); } beanId.setBean(bean); } source.setReferences(name, refs); } } }
@Override public <T> Optional<T> get(String id, Class<T> configurable) { doLookup(); Schema s = getSchema(configurable); Map<String, Schema> schemas = schemaManager.getSchemas(); BeanId beanId = BeanId.create(id, s.getName()); Optional<Bean> bean = beanManager.getEager(beanId); if (!bean.isPresent()) { initFile(configurable); Bean fileBean = FILE_CONFIG.get(beanId); if (fileBean != null) { bean = Optional.of(fileBean); } else { return Optional.absent(); } } core.setSchema(bean.get(), schemas); setSingletonReferences(bean.get(), schemas); T object = conversion.convert(bean.get(), configurable); core.cache(bean.get()); return Optional.of(object); }