/** * Recursively deletes a workspace and everything under it. * * <p>If the workspace does not exist, this method will do nothing rather than fail. * * <p>This method is intended to be called after system startup. Typically from {@link * #onSetUp(SystemTestData)} or a {@literal @}Before hook. * * @param name Name of the workspace. */ protected void removeWorkspace(String name) { Catalog cat = getCatalog(); WorkspaceInfo ws = cat.getWorkspaceByName(name); if (ws != null) { new CascadeDeleteVisitor(cat).visit(ws); } }
public void visit(LayerGroupInfo layerGroupToRemove) { // remove layerGroupToRemove references from other groups Filter associatedTo = Predicates.equal("layers.id", layerGroupToRemove.getId(), MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> it = catalog.list(LayerGroupInfo.class, associatedTo)) { while (it.hasNext()) { LayerGroupInfo group = it.next(); // parallel remove of layer and styles int index = getLayerGroupIndex(layerGroupToRemove, group); while (index != -1) { group.getLayers().remove(index); group.getStyles().remove(index); index = getLayerGroupIndex(layerGroupToRemove, group); } if (group.getLayers().size() == 0) { // if group is empty, delete it visit(group); } else { catalog.save(group); } } } // finally remove the group catalog.remove(layerGroupToRemove); }
private void removeStyleInLayerGroup(LayerGroupInfo group, StyleInfo style) { boolean dirty = false; // root layer style if (style.equals(group.getRootLayerStyle())) { group.setRootLayerStyle( getResourceDefaultStyle(group.getRootLayer().getResource(), style)); dirty = true; } // layer styles List<StyleInfo> styles = group.getStyles(); for (int i = 0; i < styles.size(); i++) { StyleInfo publishedStyle = styles.get(i); if (publishedStyle != null && publishedStyle.equals(style)) { // if publishedStyle is not null, we have a layer LayerInfo layer = (LayerInfo) group.getLayers().get(i); if (!layer.getDefaultStyle().equals(style)) { // use default style styles.set(i, layer.getDefaultStyle()); } else { styles.set(i, getResourceDefaultStyle(layer.getResource(), style)); } dirty = true; } } if (dirty) { catalog.save(group); } }
/** * Removes a workspace from the catalog. * * <p>The <tt>recursive</tt> flag controls whether objects linked to the workspace such as * stores should also be deleted. */ public void removeWorkspace(WorkspaceInfo workspace, boolean recursive) { if (recursive) { workspace.accept(new CascadeDeleteVisitor(catalog)); } else { catalog.remove(workspace); } }
public void visit(LayerInfo layer) { // first update the groups, remove the layer, and if no // other layers remained, remove the group as well Filter groupContainsLayer = Predicates.equal("layers.id", layer.getId(), MatchAction.ANY); try (CloseableIterator<LayerGroupInfo> groups = catalog.list(LayerGroupInfo.class, groupContainsLayer)) { while (groups.hasNext()) { LayerGroupInfo group = groups.next(); // parallel remove of layer and styles int index = group.getLayers().indexOf(layer); while (index != -1) { group.getLayers().remove(index); group.getStyles().remove(index); index = group.getLayers().indexOf(layer); } // either update or remove the group if (group.getLayers().size() == 0) { visit(catalog.getLayerGroup(group.getId())); } else { catalog.save(group); } } } // remove the layer and (for the moment) its resource as well // TODO: change this to just remove the resource once the // resource/publish split is done ResourceInfo resource = layer.getResource(); catalog.remove(layer); catalog.remove(resource); }
/** * Removes a resource from the catalog. * * <p>The <tt>recursive</tt> flag controls whether objects linked to the resource such as layers * should also be deleted. */ public void removeResource(ResourceInfo resource, boolean recursive) { if (recursive) { resource.accept(new CascadeDeleteVisitor(catalog)); } else { catalog.remove(resource); } }
@Override public void visit(LayerInfo layer) { StyleInfo style = layer.getDefaultStyle(); // remove the layer super.visit(layer); // NPE protection if (style == null) { return; } // is the style a core one? If so, don't remove Set<String> defaultStyles = new HashSet<String>(); defaultStyles.addAll(Arrays.asList(DEFAULT_LINE, DEFAULT_POINT, DEFAULT_POLYGON, DEFAULT_RASTER)); if (defaultStyles.contains(style.getName())) { return; } // remove the style (better than just removing directly, will take care of // fixing other layers that another admin might have linked to the new styles created by the importer // (the importer summary page can stay up for a long time with someone playign with CRS before it // may decide that he actually wants to undo it) visit(style); } }
@After public void clearLayerGroups() throws Exception { CascadeDeleteVisitor remover = new CascadeDeleteVisitor(catalog); for (LayerGroupInfo lg : catalog.getLayerGroups()) { if (catalog.getLayerGroup(lg.getId()) != null) { remover.visit(lg); } } }
/** * Removes a store from the catalog. * * <p>The <tt>recursive</tt> flag controls whether objects linked to the store such as resources * should also be deleted. */ public void removeStore(StoreInfo store, boolean recursive) { if (recursive) { store.accept(new CascadeDeleteVisitor(catalog)); } else { catalog.remove(store); } }
private void removeStyleInLayer(LayerInfo layer, StyleInfo style) { boolean dirty = false; // remove it from the associated styles if (layer.getStyles().remove(style)) { dirty = true; } // if it's the default style, choose an associated style or reset it to the default one StyleInfo ds = layer.getDefaultStyle(); if (ds != null && ds.equals(style)) { dirty = true; StyleInfo newDefaultStyle; if (layer.getStyles().size() > 0) { newDefaultStyle = layer.getStyles().iterator().next(); layer.getStyles().remove(newDefaultStyle); } else { newDefaultStyle = getResourceDefaultStyle(layer.getResource(), style); } layer.setDefaultStyle(newDefaultStyle); } if (dirty) { catalog.save(layer); } }
@Test public void testCascadeLayer() { Catalog catalog = getCatalog(); String name = toString(LAKES); LayerInfo layer = catalog.getLayerByName(name); assertNotNull(layer); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); visitor.visit(layer); LayerGroupInfo group = catalog.getLayerGroupByName(LAKES_GROUP); assertEquals(2, group.getLayers().size()); assertFalse(group.getLayers().contains(layer)); }
/** * Recursively deletes a store and everything under it. * * <p>If the store does not exist, this method will do nothing rather than fail. * * <p>This method is intended to be called after system startup. Typically from {@link * #onSetUp(SystemTestData)} or a {@literal @}Before hook. * * @param workspaceName Name of the workspace of the store. * @param name Name of the store. */ protected void removeStore(String workspaceName, String name) { Catalog cat = getCatalog(); StoreInfo store = cat.getStoreByName(workspaceName, name, StoreInfo.class); if (store == null) { return; } CascadeDeleteVisitor v = new CascadeDeleteVisitor(getCatalog()); store.accept(v); }
@Test public void testCascadeLayerGroup() { Catalog catalog = getCatalog(); LayerGroupInfo layerGroup = catalog.getLayerGroupByName(LAKES_GROUP); assertNotNull(layerGroup); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); visitor.visit(layerGroup); LayerGroupInfo nestedGroup = catalog.getLayerGroupByName(NEST_GROUP); assertNotNull(nestedGroup); assertEquals(1, nestedGroup.getLayers().size()); assertEquals(1, nestedGroup.getStyles().size()); }
/** * Recursively deletes a layer and every resource associated with it. * * <p>If the layer does not exist, this method will do nothing rather than fail. * * <p>This method is intended to be called after system startup. Typically from {@link * #onSetUp(SystemTestData)} or a {@literal @}Before hook. * * @param workspaceName Name of the workspace/namespace of the layer. * @param name Name of the layer. */ protected void removeLayer(String workspaceName, String name) { Catalog cat = getCatalog(); ResourceInfo resource = cat.getResourceByName(workspaceName, name, ResourceInfo.class); if (resource == null) { return; } CascadeDeleteVisitor v = new CascadeDeleteVisitor(getCatalog()); for (LayerInfo layer : cat.getLayers()) { if (resource.equals(layer.getResource())) { layer.accept(v); } } }
@Test public void testCascadeStyle() { Catalog catalog = getCatalog(); StyleInfo style = catalog.getStyleByName(LAKES.getLocalPart()); assertNotNull(style); new CascadeDeleteVisitor(catalog).visit(style); assertNull(catalog.getStyleByName(LAKES.getLocalPart())); LayerInfo layer = catalog.getLayerByName(getLayerId(LAKES)); assertEquals("polygon", layer.getDefaultStyle().getName()); } }
CascadeDeleteVisitor remover = new CascadeDeleteVisitor(catalog); ws.accept(remover); assertNull(catalog.getWorkspaceByName(ws.getName()));
@Test public void testCascadeLayerDuplicate() { Catalog catalog = getCatalog(); String name = toString(LAKES); LayerInfo layer = catalog.getLayerByName(name); assertNotNull(layer); LayerGroupInfo group = catalog.getLayerGroupByName(LAKES_GROUP); group.getLayers().add(layer); group.getStyles().add(null); catalog.save(group); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); visitor.visit(layer); group = catalog.getLayerGroupByName(LAKES_GROUP); assertEquals(2, group.getLayers().size()); assertFalse(group.getLayers().contains(layer)); }
public void delete(final String repoId) { List<DataStoreInfo> repoStores = findDataStores(repoId); CascadeDeleteVisitor deleteVisitor = new CascadeDeleteVisitor(this.catalog); for (DataStoreInfo storeInfo : repoStores) { storeInfo.accept(deleteVisitor); } try { this.configStore.delete(repoId); } finally { this.repoCache.invalidate(repoId); } }
@Test public void testAddRemoveNestedNamed() throws Exception { final String NESTED_NAMED = "nestedNamed"; LayerInfo neatline = catalog.getLayerByName(getLayerId(MockData.MAP_NEATLINE)); LayerInfo lakes = catalog.getLayerByName(getLayerId(MockData.LAKES)); // add, nest, and check containment LayerGroupInfo nestedNamed = addLayerGroup(NESTED_NAMED, Mode.NAMED, null, lakes, neatline); container.getLayers().add(nestedNamed); container.getStyles().add(null); catalog.save(container); assertThat( containerNamesForResource(MockData.LAKES), equalTo(set(CONTAINER_GROUP, NESTED_NAMED))); assertThat( containerNamesForResource(MockData.MAP_NEATLINE), equalTo(set(CONTAINER_GROUP, NESTED_NAMED))); assertThat(containerNamesForGroup(nestedNamed), equalTo(set(CONTAINER_GROUP))); // delete and check containment new CascadeDeleteVisitor(catalog).visit(nestedNamed); assertThat(containerNamesForResource(MockData.LAKES), equalTo(set(CONTAINER_GROUP))); assertThat(containerNamesForResource(MockData.MAP_NEATLINE), empty()); assertThat(containerNamesForGroup(nestedNamed), empty()); }
protected boolean onSubmit(AjaxRequestTarget target, Component contents) { // cascade delete the whole selection Catalog catalog = GeoServerApplication.get().getCatalog(); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); for (CatalogInfo ci : selection) { ci.accept(visitor); } // the deletion will have changed what we see in the page // so better clear out the selection catalogObjects.clearSelection(); return true; }