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); }
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); }
/** * 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); } }
@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); } } }
@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)); }
@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()); }
@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()); } }
@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)); }
@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()); }
@Test public void testWorkspaceRemoveAndReadd() { // remove all workspaces Catalog catalog = getCatalog(); NamespaceInfo defaultNamespace = catalog.getDefaultNamespace(); WorkspaceInfo defaultWs = catalog.getDefaultWorkspace(); List<WorkspaceInfo> workspaces = catalog.getWorkspaces(); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); for (WorkspaceInfo ws : workspaces) { visitor.visit(ws); } assertEquals(0, catalog.getWorkspaces().size()); assertEquals(0, catalog.getNamespaces().size()); // add back one (this would NPE) catalog.add(defaultNamespace); catalog.add(defaultWs); assertEquals(1, catalog.getWorkspaces().size()); assertEquals(1, catalog.getNamespaces().size()); // get back by name (this would NPE too) assertNotNull(catalog.getNamespaceByURI(defaultNamespace.getURI())); }
@Test public void testDropCoverageStore() throws Exception { // build the store Catalog cat = getCatalog(); CatalogBuilder cb = new CatalogBuilder(cat); CoverageStoreInfo store = cb.buildCoverageStore("dem"); store.setURL(MockData.class.getResource("tazdem.tiff").toExternalForm()); store.setType("GeoTIFF"); cat.add(store); // build the coverage cb.setStore(store); CoverageInfo ci = cb.buildCoverage(); cat.add(ci); // build the layer LayerInfo layer = cb.buildLayer(ci); cat.add(layer); // grab a reader just to inizialize the code ci.getGridCoverage(null, null); ci.getGridCoverageReader(null, GeoTools.getDefaultHints()); // now drop the store CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(cat); visitor.visit(store); // and reload (GEOS-4782 -> BOOM!) getGeoServer().reload(); }
@Test public void testCascadeWorkspace() { Catalog catalog = getCatalog(); WorkspaceInfo ws = catalog.getWorkspaceByName(CITE_PREFIX); new CascadeDeleteVisitor(catalog).visit(ws); // check the namespace is also gone assertNull(catalog.getNamespaceByPrefix(CITE_PREFIX)); // that workspace actually holds all layers, so check we got empty assertEquals(0, catalog.count(LayerInfo.class, Filter.INCLUDE)); assertEquals(0, catalog.count(ResourceInfo.class, Filter.INCLUDE)); assertEquals(0, catalog.count(StoreInfo.class, Filter.INCLUDE)); assertEquals(0, catalog.count(LayerGroupInfo.class, Filter.INCLUDE)); // the workspace specific style is also gone assertEquals(0, catalog.getStylesByWorkspace(CITE_PREFIX).size()); assertNull(catalog.getStyleByName(WS_STYLE)); }
@Test public void testCascadeStore() { Catalog catalog = getCatalog(); DataStoreInfo store = (DataStoreInfo) catalog.getLayerByName(getLayerId(LAKES)).getResource().getStore(); new CascadeDeleteVisitor(catalog).visit(store); // that store actually holds all layers, so check we got empty assertEquals(0, catalog.count(LayerInfo.class, Filter.INCLUDE)); assertEquals(0, catalog.count(ResourceInfo.class, Filter.INCLUDE)); assertEquals(0, catalog.count(StoreInfo.class, Filter.INCLUDE)); List<LayerGroupInfo> groups = catalog.getLayerGroups(); assertEquals(0, catalog.count(LayerGroupInfo.class, Filter.INCLUDE)); }
@DeleteMapping(value = "/{storeName}") public void wmsStoreDelete( @PathVariable String workspaceName, @PathVariable String storeName, @RequestParam(name = "recurse", required = false, defaultValue = "false") boolean recurse) throws IOException { WMSStoreInfo cs = getExistingWMSStore(workspaceName, storeName); if (!recurse) { if (!catalog.getResourcesByStore(cs, WMSLayerInfo.class).isEmpty()) { throw new RestException("wmsstore not empty", HttpStatus.UNAUTHORIZED); } catalog.remove(cs); } else { new CascadeDeleteVisitor(catalog).visit(cs); } clear(cs); LOGGER.info("DELETE wms store " + workspaceName + ":s" + workspaceName); }
@Override protected void handleObjectDelete() throws Exception { String l = getAttribute("layer"); boolean recurse = getQueryStringValue("recurse", Boolean.class, false); LayerInfo layer = (LayerInfo) catalog.getLayerByName(l); if (!recurse) { catalog.remove(layer); } else { new CascadeDeleteVisitor(catalog).visit(layer); } LOGGER.info( "DELETE layer " + l); }
@Override protected void handleObjectDelete() throws Exception { String workspace = getAttribute("workspace"); String wmsstore = getAttribute("wmsstore"); boolean recurse = getQueryStringValue("recurse", Boolean.class, false); WMSStoreInfo wms = catalog.getStoreByName(workspace, wmsstore, WMSStoreInfo.class); if (!recurse) { if ( !catalog.getResourcesByStore(wms, WMSLayerInfo.class).isEmpty() ) { throw new RestletException( "store not empty", Status.CLIENT_ERROR_FORBIDDEN); } catalog.remove( wms ); } else { new CascadeDeleteVisitor(catalog).visit(wms); } LOGGER.info( "DELETE wms store " + workspace + "," + wmsstore ); }
@Override protected void handleObjectDelete() throws Exception { String workspace = getAttribute("workspace"); String coveragestore = getAttribute("coveragestore"); boolean recurse = getQueryStringValue("recurse", Boolean.class, false); CoverageStoreInfo cs = catalog.getCoverageStoreByName(workspace, coveragestore); if (!recurse) { if ( !catalog.getCoveragesByCoverageStore(cs).isEmpty() ) { throw new RestletException( "coveragestore not empty", Status.CLIENT_ERROR_UNAUTHORIZED); } catalog.remove( cs ); } else { new CascadeDeleteVisitor(catalog).visit(cs); } clear(cs); LOGGER.info( "DELETE coverage store " + workspace + "," + coveragestore ); }
@After public void cleanupTestWorkspace() throws Exception { Catalog catalog = getCatalog(); CascadeDeleteVisitor remover = new CascadeDeleteVisitor(catalog); WorkspaceInfo ws = catalog.getWorkspaceByName("test"); if (ws != null) { remover.visit(ws); } }
@Before public void cleanupTestCollectionPublishing() throws IOException { Catalog catalog = getCatalog(); CascadeDeleteVisitor visitor = new CascadeDeleteVisitor(catalog); CoverageStoreInfo store = catalog.getStoreByName("gs", "test123", CoverageStoreInfo.class); if (store != null) { visitor.visit(store); } StyleInfo style = catalog.getStyleByName("gs", "test123"); if (style != null) { visitor.visit(style); } Resource data = catalog.getResourceLoader().get("data/gs/test123"); if (data != null && Resources.exists(data)) { data.delete(); } }
@Before public void addDataStores() throws IOException { // the store configuration gets ruined by tests in more than one way, let's recreate it DataStoreInfo sfStore = getCatalog().getDataStoreByName("sf"); if (sfStore != null) { CascadeDeleteVisitor remover = new CascadeDeleteVisitor(getCatalog()); remover.visit(sfStore); } getTestData().addVectorLayer(SystemTestData.PRIMITIVEGEOFEATURE, catalog); getTestData().addVectorLayer(SystemTestData.AGGREGATEGEOFEATURE, catalog); getTestData().addVectorLayer(SystemTestData.GENERICENTITY, catalog); }