Java tutorial
/* (c) 2014 - 2016 Open Source Geospatial Foundation - all rights reserved * (c) 2001 - 2013 OpenPlans * This code is licensed under the GPL 2.0 license, available at the root * application directory. */ package org.geoserver.importer; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.TreeSet; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Level; import java.util.logging.Logger; import org.apache.commons.io.FilenameUtils; import org.geoserver.catalog.Catalog; import org.geoserver.catalog.CatalogBuilder; import org.geoserver.catalog.CoverageInfo; import org.geoserver.catalog.CoverageStoreInfo; import org.geoserver.catalog.DataStoreInfo; import org.geoserver.catalog.FeatureTypeInfo; import org.geoserver.catalog.LayerInfo; import org.geoserver.catalog.NamespaceInfo; import org.geoserver.catalog.ProjectionPolicy; import org.geoserver.catalog.ResourceInfo; import org.geoserver.catalog.SLDHandler; import org.geoserver.catalog.StoreInfo; import org.geoserver.catalog.StyleGenerator; import org.geoserver.catalog.StyleHandler; import org.geoserver.catalog.StyleInfo; import org.geoserver.catalog.Styles; import org.geoserver.catalog.WorkspaceInfo; import org.geoserver.config.GeoServer; import org.geoserver.config.util.XStreamPersister; import org.geoserver.config.util.XStreamPersister.CRSConverter; import org.geoserver.config.util.XStreamPersisterFactory; import org.geoserver.importer.ImportTask.State; import org.geoserver.importer.job.Job; import org.geoserver.importer.job.JobQueue; import org.geoserver.importer.job.ProgressMonitor; import org.geoserver.importer.job.Task; import org.geoserver.importer.mosaic.Mosaic; import org.geoserver.importer.transform.ImportTransform; import org.geoserver.importer.transform.RasterTransformChain; import org.geoserver.importer.transform.ReprojectTransform; import org.geoserver.importer.transform.TransformChain; import org.geoserver.importer.transform.VectorTransformChain; import org.geoserver.platform.ContextLoadedEvent; import org.geoserver.platform.GeoServerExtensions; import org.geoserver.security.GeoServerSecurityManager; import org.geoserver.util.EntityResolverProvider; import org.geotools.coverage.grid.io.HarvestedSource; import org.geotools.coverage.grid.io.StructuredGridCoverage2DReader; import org.geotools.data.DataStore; import org.geotools.data.DefaultTransaction; import org.geotools.data.FeatureReader; import org.geotools.data.FeatureSource; import org.geotools.data.FeatureStore; import org.geotools.data.FeatureWriter; import org.geotools.data.Transaction; import org.geotools.data.directory.DirectoryDataStore; import org.geotools.data.shapefile.ShapefileDataStore; import org.geotools.feature.FeatureCollection; import org.geotools.feature.collection.DecoratingFeatureCollection; import org.geotools.feature.simple.SimpleFeatureTypeBuilder; import org.geotools.geometry.GeneralEnvelope; import org.geotools.geometry.jts.ReferencedEnvelope; import org.geotools.jdbc.JDBCDataStore; import org.geotools.referencing.CRS; import org.geotools.styling.Style; import org.geotools.styling.StyledLayerDescriptor; import org.geotools.util.logging.Logging; import org.opengis.coverage.grid.GridCoverageReader; import org.opengis.feature.simple.SimpleFeature; import org.opengis.feature.simple.SimpleFeatureType; import org.opengis.feature.type.FeatureType; import org.opengis.filter.Filter; import org.opengis.referencing.crs.CoordinateReferenceSystem; import org.springframework.beans.factory.DisposableBean; import org.springframework.context.ApplicationEvent; import org.springframework.context.ApplicationListener; import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.web.context.request.RequestAttributes; import org.springframework.web.context.request.RequestContextHolder; import com.google.common.base.Predicate; import com.google.common.collect.Iterables; import com.google.common.collect.Iterators; import com.thoughtworks.xstream.XStream; import com.vividsolutions.jts.geom.Geometry; /** * Primary controller/facade of the import subsystem. * * @author Justin Deoliveira, OpenGeo * */ public class Importer implements DisposableBean, ApplicationListener { static Logger LOGGER = Logging.getLogger(Importer.class); /** catalog */ Catalog catalog; /** import context storage */ ImportStore contextStore; /** style generator */ StyleGenerator styleGen; /** style handler */ StyleHandler styleHandler = new SLDHandler(); /** job queue */ JobQueue jobs = new JobQueue(); ConcurrentHashMap<Long, ImportTask> currentlyProcessing = new ConcurrentHashMap<Long, ImportTask>(); public Importer(Catalog catalog) { this.catalog = catalog; this.styleGen = new StyleGenerator(catalog); } /** * Returns the style generator. */ public StyleGenerator getStyleGenerator() { return styleGen; } public StyleHandler getStyleHandler() { return styleHandler; } public void setStyleHandler(StyleHandler handler) { styleHandler = handler; } ImportStore createContextStore() { // check the spring context for an import store ImportStore store = null; String name = GeoServerExtensions.getProperty("org.geoserver.importer.store"); if (name == null) { //backward compatability check name = GeoServerExtensions.getProperty("org.opengeo.importer.store"); } if (name != null) { for (ImportStore bean : GeoServerExtensions.extensions(ImportStore.class)) { if (name.equals(bean.getName())) { store = bean; break; } } if (store == null) { LOGGER.warning("Invalid value for import store, no such store " + name); } } if (store == null) { store = new MemoryImportStore(); } LOGGER.info("Enabling import store: " + store.getName()); return store; } public ImportStore getStore() { return contextStore; } public ImportTask getCurrentlyProcessingTask(long contextId) { return currentlyProcessing.get(new Long(contextId)); } @Override public void onApplicationEvent(ApplicationEvent event) { // load the context store here to avoid circular dependency on creation of the importer if (event instanceof ContextLoadedEvent) { contextStore = createContextStore(); contextStore.init(); } } public Catalog getCatalog() { return catalog; } public GeoServer getGeoServer() { return GeoServerExtensions.bean(GeoServer.class); } public ImportContext getContext(long id) { ImportContext context = contextStore.get(id); return context != null ? reattach(context) : null; } public ImportContext reattach(ImportContext context) { //reload store and workspace objects from catalog so they are "attached" with // the proper references to the catalog initialized context.reattach(catalog); for (ImportTask task : context.getTasks()) { StoreInfo store = task.getStore(); if (store != null && store.getId() != null) { task.setStore(catalog.getStore(store.getId(), StoreInfo.class)); //((StoreInfoImpl) task.getStore()).setCatalog(catalog); // @todo remove if the above sets catalog } if (task.getLayer() != null) { LayerInfo l = task.getLayer(); if (l.getDefaultStyle() != null && l.getDefaultStyle().getId() != null) { l.setDefaultStyle(catalog.getStyle(l.getDefaultStyle().getId())); } if (l.getResource() != null) { ResourceInfo r = l.getResource(); r.setCatalog(catalog); if (r.getStore() == null && resourceMatchesStore(r, store)) { r.setStore(store); } } } } return context; } public Iterator<ImportContext> getContexts() { return contextStore.allNonCompleteImports(); } public Iterator<ImportContext> getContextsByUser(String user) { return contextStore.importsByUser(user); } public Iterator<ImportContext> getAllContexts() { return contextStore.iterator(); } public Iterator<ImportContext> getAllContextsByUpdated() { try { return contextStore.iterator("updated"); } catch (UnsupportedOperationException e) { //fallback TreeSet sorted = new TreeSet<ImportContext>(new Comparator<ImportContext>() { @Override public int compare(ImportContext o1, ImportContext o2) { Date d1 = o1.getUpdated(); Date d2 = o2.getUpdated(); return -1 * d1.compareTo(d2); } }); Iterators.addAll(sorted, contextStore.iterator()); return sorted.iterator(); } } public ImportContext createContext(ImportData data, WorkspaceInfo targetWorkspace) throws IOException { return createContext(data, targetWorkspace, null); } public ImportContext createContext(ImportData data, StoreInfo targetStore) throws IOException { return createContext(data, null, targetStore); } public ImportContext createContext(ImportData data) throws IOException { return createContext(data, null, null); } public ImportContext registerContext(Long id) throws IOException, IllegalArgumentException { ImportContext context = createContext(id); context.setState(org.geoserver.importer.ImportContext.State.INIT); return context; } /** * Create a context with the provided optional id. * The provided id must be higher than the current mark. * @param id optional id to use * @return Created ImportContext * @throws IOException * @throws IllegalArgumentException if the provided id is invalid */ public ImportContext createContext(Long id) throws IOException, IllegalArgumentException { ImportContext context = new ImportContext(); if (id != null) { Long retval = contextStore.advanceId(id); assert retval >= id; context.setId(retval); contextStore.save(context); } else { contextStore.add(context); } return context; } public ImportContext createContext(ImportData data, WorkspaceInfo targetWorkspace, StoreInfo targetStore) throws IOException { return createContext(data, targetWorkspace, targetStore, null); } public ImportContext createContext(ImportData data, WorkspaceInfo targetWorkspace, StoreInfo targetStore, ProgressMonitor monitor) throws IOException { ImportContext context = new ImportContext(); context.setProgress(monitor); context.setData(data); if (targetWorkspace == null && targetStore != null) { targetWorkspace = targetStore.getWorkspace(); } if (targetWorkspace == null) { targetWorkspace = catalog.getDefaultWorkspace(); } context.setTargetWorkspace(targetWorkspace); context.setTargetStore(targetStore); init(context); if (!context.progress().isCanceled()) { contextStore.add(context); } //JD: don't think we really need to maintain these, and they aren't persisted //else { // context.setState(ImportContext.State.CANCELLED); //} return context; } public Long createContextAsync(final ImportData data, final WorkspaceInfo targetWorkspace, final StoreInfo targetStore) throws IOException { return jobs.submit(new Job<ImportContext>() { @Override protected ImportContext call(ProgressMonitor monitor) throws Exception { return createContext(data, targetWorkspace, targetStore, monitor); } @Override public String toString() { return "Processing data " + data.toString(); } }); } /** * Performs an asynchronous initialization of tasks in the specified context, and eventually * saves the result in the {@link ImportStore} * * @param context * @param prepData * */ public Long initAsync(final ImportContext context, final boolean prepData) { return jobs.submit(new Job<ImportContext>() { @Override protected ImportContext call(ProgressMonitor monitor) throws Exception { try { init(context, prepData); } finally { changed(context); } return context; } @Override public String toString() { return "Initializing context " + context.getId(); } }); } public void init(ImportContext context) throws IOException { init(context, true); } public void init(ImportContext context, boolean prepData) throws IOException { context.reattach(catalog); try { ImportData data = context.getData(); if (data != null) { if (data instanceof RemoteData) { data = ((RemoteData) data).resolve(this); context.setData(data); } addTasks(context, data, prepData); } // switch from init to pending as needed context.setState(ImportContext.State.PENDING); } catch (Exception e) { LOGGER.log(Level.SEVERE, "Failed to init the context ", e); // switch to complete to make the error evident, since we // cannot attach it to a task context.setState(ImportContext.State.INIT_ERROR); context.setMessage(e.getMessage()); return; } } public List<ImportTask> update(ImportContext context, ImportData data) throws IOException { List<ImportTask> tasks = addTasks(context, data, true); //prep(context); changed(context); return tasks; } List<ImportTask> addTasks(ImportContext context, ImportData data, boolean prepData) throws IOException { if (data == null) { return Collections.emptyList(); } if (prepData) { data.prepare(context.progress()); } if (data instanceof FileData && ((FileData) data).getFile() != null) { if (data instanceof Mosaic) { return initForMosaic(context, (Mosaic) data); } else if (data instanceof Directory) { return initForDirectory(context, (Directory) data); } else { return initForFile(context, (FileData) data); } } else if (data instanceof Table) { } else if (data instanceof Database) { return initForDatabase(context, (Database) data); } throw new IllegalStateException(); /*for (ImportTask t : tasks) { context.addTask(t); } prep(context, prepData); return tasks;*/ } /** * Initializes the import for a mosaic. * <p> * Mosaics only support direct import (context.targetStore must be null) and * </p> */ List<ImportTask> initForMosaic(ImportContext context, Mosaic mosaic) throws IOException { if (context.getTargetStore() != null) { throw new IllegalArgumentException("ingest not supported for mosaics"); } return createTasks(mosaic, context); //tasks.add(createTask(mosaic, context, context.getTargetStore())); } List<ImportTask> initForDirectory(ImportContext context, Directory data) throws IOException { List<ImportTask> tasks = new ArrayList<ImportTask>(); //flatten out the directory into itself and all sub directories and process in order for (Directory dir : data.flatten()) { //ignore empty directories if (dir.getFiles().isEmpty()) continue; //group the contents of the directory by format Map<DataFormat, List<FileData>> map = new HashMap<DataFormat, List<FileData>>(); for (FileData f : dir.getFiles()) { DataFormat format = f.getFormat(); List<FileData> files = map.get(format); if (files == null) { files = new ArrayList<FileData>(); map.put(format, files); } files.add(f); } //handle case of importing a single file that we don't know the format of, in this // case rather than ignore it we wnat to rpocess it and ssets its state to "NO_FORMAT" boolean skipNoFormat = !(map.size() == 1 && map.containsKey(null)); // if no target store specified group the directory into pieces that can be // processed as a single task StoreInfo targetStore = context.getTargetStore(); if (targetStore == null) { //create a task for each "format" if that format can handle a directory for (DataFormat format : new ArrayList<DataFormat>(map.keySet())) { if (format != null && format.canRead(dir)) { List<FileData> files = map.get(format); if (files.size() == 1) { //use the file directly //createTasks(files.get(0), format, context, null)); tasks.addAll(createTasks(files.get(0), format, context)); } else { tasks.addAll(createTasks(dir.filter(files), format, context)); //tasks.addAll(createTasks(dir.filter(files), format, context, null)); } map.remove(format); } } //handle the left overs, each file gets its own task for (List<FileData> files : map.values()) { for (FileData file : files) { //tasks.add(createTask(file, context, null)); tasks.addAll(createTasks(file, file.getFormat(), context, skipNoFormat)); } } } else { for (FileData file : dir.getFiles()) { tasks.addAll(createTasks(file, file.getFormat(), context, skipNoFormat)); } } } return tasks; } List<ImportTask> initForFile(ImportContext context, FileData file) throws IOException { return createTasks(file, context); } List<ImportTask> initForDatabase(ImportContext context, Database db) throws IOException { //JD: we use check for direct vs non-direct in order to determine if there should be // one task with many items, or one task per table... can;t think of the use case for //many tasks //tasks.add(createTask(db, context, targetStore)); return createTasks(db, context); } List<ImportTask> createTasks(ImportData data, ImportContext context) throws IOException { return createTasks(data, data.getFormat(), context); } List<ImportTask> createTasks(ImportData data, DataFormat format, ImportContext context) throws IOException { return createTasks(data, format, context, true); } List<ImportTask> createTasks(ImportData data, DataFormat format, ImportContext context, boolean skipNoFormat) throws IOException { List<ImportTask> tasks = new ArrayList<ImportTask>(); boolean direct = false; StoreInfo targetStore = context.getTargetStore(); if (targetStore == null) { //direct import, use the format to create a store direct = true; if (format != null) { targetStore = format.createStore(data, context.getTargetWorkspace(), catalog); } if (targetStore == null) { //format unable to create store, switch to indirect import and use // default store from catalog targetStore = lookupDefaultStore(); direct = targetStore == null; } } if (format != null) { // create the set of tasks by having the format list the avialable items // from the input data for (ImportTask t : format.list(data, catalog, context.progress())) { //initialize transform chain based on vector vs raster if (t.getTransform() == null) { t.setTransform(format instanceof VectorFormat ? new VectorTransformChain() : new RasterTransformChain()); } t.setDirect(direct); t.setStore(targetStore); // in case of indirect import against a coverage store with no published // layers, do not use the granule name, but the store name if (!direct && targetStore instanceof CoverageStoreInfo) { t.getLayer().setName(targetStore.getName()); t.getLayer().getResource().setName(targetStore.getName()); if (!catalog.getCoveragesByStore((CoverageStoreInfo) targetStore).isEmpty()) { t.setUpdateMode(UpdateMode.APPEND); } } prep(t); tasks.add(t); } } else if (!skipNoFormat) { ImportTask t = new ImportTask(data); t.setDirect(direct); t.setStore(targetStore); prep(t); tasks.add(t); } for (ImportTask t : tasks) { context.addTask(t); } return tasks; } boolean prep(ImportTask task) { if (task.getState() == ImportTask.State.COMPLETE) { return true; } //check the format DataFormat format = task.getData().getFormat(); if (format == null) { task.setState(State.NO_FORMAT); return false; } //check the target if (task.getStore() == null) { task.setError(new Exception("No target store for task")); task.setState(State.ERROR); return false; } //check for a mismatch between store and format if (!formatMatchesStore(format, task.getStore())) { String msg = task.getStore() instanceof DataStoreInfo ? "Unable to import raster data into vector store" : "Unable to import vector data into raster store"; task.setError(new Exception(msg)); task.setState(State.BAD_FORMAT); return false; } if (task.getLayer() == null || task.getLayer().getResource() == null) { task.setError(new Exception("Task has no layer configuration")); task.setState(State.ERROR); return false; } LayerInfo l = task.getLayer(); ResourceInfo r = l.getResource(); //initialize resource references r.setStore(task.getStore()); r.setNamespace(catalog.getNamespaceByPrefix(task.getStore().getWorkspace().getName())); //style //assign a default style to the layer if not already done if (l.getDefaultStyle() == null) { try { StyleInfo style = null; // first check the case of a style file being uploaded via zip along with rest of files if (task.getData() instanceof SpatialFile) { SpatialFile file = (SpatialFile) task.getData(); if (file.getStyleFile() != null) { style = createStyleFromFile(file.getStyleFile(), task); } } if (style == null) { if (r instanceof FeatureTypeInfo) { //since this resource is still detached from the catalog we can't call // through to get it's underlying resource, so we depend on the "native" // type provided from the format FeatureType featureType = (FeatureType) task.getMetadata().get(FeatureType.class); if (featureType != null) { style = styleGen.createStyle(styleHandler, (FeatureTypeInfo) r, featureType); } else { throw new RuntimeException("Unable to compute style"); } } else if (r instanceof CoverageInfo) { style = styleGen.createStyle(styleHandler, (CoverageInfo) r); } else { throw new RuntimeException("Unknown resource type :" + r.getClass()); } } l.setDefaultStyle(style); } catch (Exception e) { task.setError(e); task.setState(ImportTask.State.ERROR); return false; } } //srs if (r.getSRS() == null) { task.setState(ImportTask.State.NO_CRS); return false; } else if (task.getState() == ImportTask.State.NO_CRS) { //changed after setting srs manually, compute the lat long bounding box try { computeLatLonBoundingBox(task, false); } catch (Exception e) { LOGGER.log(Level.WARNING, "Error computing lat long bounding box", e); task.setState(ImportTask.State.ERROR); task.setError(e); return false; } //also since this resource has no native crs set the project policy to force declared task.getLayer().getResource().setProjectionPolicy(ProjectionPolicy.FORCE_DECLARED); } else { task.getLayer().getResource().setProjectionPolicy(ProjectionPolicy.NONE); } //bounds if (r.getNativeBoundingBox() == null) { task.setState(ImportTask.State.NO_BOUNDS); return false; } task.setState(ImportTask.State.READY); return true; } boolean formatMatchesStore(DataFormat format, StoreInfo store) { if (format instanceof VectorFormat) { return store instanceof DataStoreInfo; } if (format instanceof GridFormat) { return store instanceof CoverageStoreInfo; } return false; } boolean resourceMatchesStore(ResourceInfo resource, StoreInfo store) { if (resource instanceof FeatureTypeInfo) { return store instanceof DataStoreInfo; } if (resource instanceof CoverageInfo) { return store instanceof CoverageStoreInfo; } return false; } public void run(ImportContext context) throws IOException { run(context, ImportFilter.ALL); } public void run(ImportContext context, ImportFilter filter) throws IOException { run(context, filter, null); } public void run(ImportContext context, ImportFilter filter, ProgressMonitor monitor) throws IOException { if (context.getState() == ImportContext.State.INIT) { throw new IllegalStateException("Importer is still initializing, cannot run it"); } context.setProgress(monitor); context.setState(ImportContext.State.RUNNING); if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Running import " + context.getId()); } for (ImportTask task : context.getTasks()) { if (!filter.include(task)) { continue; } if (!task.readyForImport()) { continue; } if (context.progress().isCanceled()) { break; } run(task); } context.updated(); contextStore.save(context); if (context.isArchive() && context.getState() == ImportContext.State.COMPLETE) { boolean canArchive = !Iterables.any(context.getTasks(), new Predicate<ImportTask>() { @Override public boolean apply(ImportTask input) { return input.isDirect(); } }); if (canArchive) { Directory directory = null; if (context.getData() instanceof Directory) { directory = (Directory) context.getData(); } else if (context.getData() instanceof SpatialFile) { directory = new Directory(((SpatialFile) context.getData()).getFile().getParentFile()); } if (directory != null) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Archiving directory " + directory.getFile().getAbsolutePath()); } try { directory.archive(getArchiveFile(context)); } catch (Exception ioe) { ioe.printStackTrace(); // this is not a critical operation, so don't make the whole thing fail LOGGER.log(Level.WARNING, "Error archiving", ioe); } } } } } void run(ImportTask task) throws IOException { if (task.getState() == ImportTask.State.COMPLETE) { return; } task.setState(ImportTask.State.RUNNING); if (task.isDirect()) { //direct import, simply add configured store and layers to catalog doDirectImport(task); } else { // indirect import, read data from the source and into the target store doIndirectImport(task); } } public File getArchiveFile(ImportContext context) throws IOException { //String archiveName = "import-" + task.getContext().getId() + "-" + task.getId() + "-" + task.getData().getName() + ".zip"; String archiveName = "import-" + context.getId() + ".zip"; File dir = getCatalog().getResourceLoader().findOrCreateDirectory("uploads", "archives"); return new File(dir, archiveName); } public void changed(ImportContext context) { context.updated(); contextStore.save(context); } public void changed(ImportTask task) { prep(task); changed(task.getContext()); } public Long runAsync(final ImportContext context, final ImportFilter filter, final boolean init) { // we store the current request spring context final RequestAttributes parentRequestAttributes = RequestContextHolder.getRequestAttributes(); final Authentication auth = SecurityContextHolder.getContext().getAuthentication(); Thread parentThread = Thread.currentThread(); // creating an asynchronous importer job return jobs.submit(new Job<ImportContext>() { @Override protected ImportContext call(ProgressMonitor monitor) throws Exception { final Authentication oldAuth = SecurityContextHolder.getContext().getAuthentication(); try { // set the parent request spring context, some interceptors like the security ones // for example may need to have access to the original request attributes RequestContextHolder.setRequestAttributes(parentRequestAttributes); SecurityContextHolder.getContext().setAuthentication(auth); if (init) { init(context, true); } run(context, filter, monitor); return context; } finally { if (Thread.currentThread() != parentThread) { // cleaning request spring context for the current thread RequestContextHolder.resetRequestAttributes(); SecurityContextHolder.getContext().setAuthentication(oldAuth); } } } @Override public String toString() { return "Processing import " + context.getId(); } }); } public Task<ImportContext> getTask(Long job) { return (Task<ImportContext>) jobs.getTask(job); } public List<Task<ImportContext>> getTasks() { return (List) jobs.getTasks(); } /* * an import that involves consuming a data source directly */ void doDirectImport(ImportTask task) throws IOException { //TODO: this needs to be transactional in case of errors along the way //add the store, may have been added in a previous iteration of this task if (task.getStore().getId() == null) { StoreInfo store = task.getStore(); //ensure a unique name store.setName(findUniqueStoreName(task.getStore())); //ensure a namespace connection parameter set matching workspace/namespace if (!store.getConnectionParameters().containsKey("namespace")) { WorkspaceInfo ws = task.getContext().getTargetWorkspace(); if (ws == null && task.getContext().getTargetStore() != null) { ws = task.getContext().getTargetStore().getWorkspace(); } if (ws != null) { NamespaceInfo ns = catalog.getNamespaceByPrefix(ws.getName()); if (ns != null) { store.getConnectionParameters().put("namespace", ns.getURI()); } } } catalog.add(task.getStore()); } task.setState(ImportTask.State.RUNNING); try { // set up transform chain TransformChain tx = task.getTransform(); // apply pre transform if (!doPreTransform(task, task.getData(), tx)) { return; } addToCatalog(task); if (task.getLayer().getResource() instanceof FeatureTypeInfo) { FeatureTypeInfo featureType = (FeatureTypeInfo) task.getLayer().getResource(); FeatureTypeInfo resource = getCatalog().getResourceByName(featureType.getQualifiedName(), FeatureTypeInfo.class); calculateBounds(resource); } // apply post transform if (!doPostTransform(task, task.getData(), tx)) { return; } task.setState(ImportTask.State.COMPLETE); } catch (Exception e) { LOGGER.log(Level.WARNING, "Task failed during import: " + task, e); task.setState(ImportTask.State.ERROR); task.setError(e); } } /* * an import that involves reading from the datastore and writing into a specified target store */ void doIndirectImport(ImportTask task) throws IOException { if (!task.getStore().isEnabled()) { task.getStore().setEnabled(true); } if (task.progress().isCanceled()) { return; } task.setState(ImportTask.State.RUNNING); //setup transform chain TransformChain tx = task.getTransform(); //pre transform if (!doPreTransform(task, task.getData(), tx)) { return; } boolean canceled = false; DataFormat format = task.getData().getFormat(); if (format instanceof VectorFormat) { try { currentlyProcessing.put(task.getContext().getId(), task); loadIntoDataStore(task, (DataStoreInfo) task.getStore(), (VectorFormat) format, (VectorTransformChain) tx); canceled = task.progress().isCanceled(); FeatureTypeInfo featureType = (FeatureTypeInfo) task.getLayer().getResource(); featureType.getAttributes().clear(); if (!canceled) { if (task.getUpdateMode() == UpdateMode.CREATE) { addToCatalog(task); } FeatureTypeInfo resource = getCatalog().getResourceByName(featureType.getQualifiedName(), FeatureTypeInfo.class); calculateBounds(resource); } } catch (Throwable th) { LOGGER.log(Level.SEVERE, "Error occured during import", th); Exception e = (th instanceof Exception) ? (Exception) th : new Exception(th); task.setError(e); task.setState(ImportTask.State.ERROR); return; } finally { currentlyProcessing.remove(task.getContext().getId()); } } else { // see if the store exposes a structured grid coverage reader StoreInfo store = task.getStore(); final String errorMessage = "Indirect raster import can only work against a structured grid coverage store (e.g., mosaic), this one is not: "; if (!(store instanceof CoverageStoreInfo)) { throw new IllegalArgumentException(errorMessage + store); } // this is a ResourcePool reader, we should not close it CoverageStoreInfo cs = (CoverageStoreInfo) store; GridCoverageReader reader = cs.getGridCoverageReader(null, null); if (!(reader instanceof StructuredGridCoverage2DReader)) { throw new IllegalArgumentException(errorMessage + store); } StructuredGridCoverage2DReader sr = (StructuredGridCoverage2DReader) reader; ImportData data = task.getData(); harvestImportData(sr, data); // check we have a target resource, if not, create it if (task.getUpdateMode() == UpdateMode.CREATE) { if (task.getLayer().getId() == null) { addToCatalog(task); } } } if (!canceled && !doPostTransform(task, task.getData(), tx)) { return; } task.setState(canceled ? ImportTask.State.CANCELED : ImportTask.State.COMPLETE); } /** * (Re)calculates the bounds for a FeatureTypeInfo. * Bounds will be calculated if: * <li> The native bounds of the resource are null or empty * <li> The resource has a metadata entry "recalculate-bounds"="true"<br><br> * * Otherwise, this method has no effect.<br><br> * * If the metadata entry "recalculate-bounds"="true" exists, * it will be removed after bounds are calculated.<br><br> * * This is currently used by csv / kml uploads that have a geometry that may be the result of a * transform, and by JDBC imports which wait to calculate bounds until after the layers that * will be imported have been chosen. * * @param resource The resource to calculate the bounds for */ protected void calculateBounds(FeatureTypeInfo resource) throws IOException { if (resource.getNativeBoundingBox() == null || resource.getNativeBoundingBox().isEmpty() || Boolean.TRUE.equals(resource.getMetadata().get("recalculate-bounds")) || "true".equals(resource.getMetadata().get("recalculate-bounds"))) { // force computation CatalogBuilder cb = new CatalogBuilder(getCatalog()); ReferencedEnvelope nativeBounds = cb.getNativeBounds(resource); resource.setNativeBoundingBox(nativeBounds); resource.setLatLonBoundingBox(cb.getLatLonBounds(nativeBounds, resource.getCRS())); getCatalog().save(resource); //Do not re-calculate on subsequent imports if (resource.getMetadata().get("recalculate-bounds") != null) { resource.getMetadata().remove("recalculate-bounds"); } } } private void checkSingleHarvest(List<HarvestedSource> harvests) throws IOException { for (HarvestedSource harvested : harvests) { if (!harvested.success()) { throw new IOException("Failed to harvest " + harvested.getSource() + ": " + harvested.getMessage()); } } } private void harvestDirectory(StructuredGridCoverage2DReader sr, Directory data) throws UnsupportedOperationException, IOException { for (FileData fd : data.getFiles()) { harvestImportData(sr, fd); } } private void harvestImportData(StructuredGridCoverage2DReader sr, ImportData data) throws IOException { if (data instanceof SpatialFile) { SpatialFile sf = (SpatialFile) data; List<HarvestedSource> harvests = sr.harvest(null, sf.getFile(), null); checkSingleHarvest(harvests); } else if (data instanceof Directory) { harvestDirectory(sr, (Directory) data); } else { unsupportedHarvestFileData(data); } } private void unsupportedHarvestFileData(ImportData fd) { throw new IllegalArgumentException( "Unsupported data type for raster harvesting (use SpatialFile or Directory): " + fd); } boolean doPreTransform(ImportTask task, ImportData data, TransformChain tx) { try { tx.pre(task, data); } catch (Exception e) { LOGGER.log(Level.SEVERE, "Error occured during pre transform", e); task.setError(e); task.setState(ImportTask.State.ERROR); return false; } return true; } boolean doPostTransform(ImportTask task, ImportData data, TransformChain tx) { try { tx.post(task, data); } catch (Exception e) { LOGGER.log(Level.SEVERE, "Error occured during post transform", e); task.setError(e); task.setState(ImportTask.State.ERROR); return false; } return true; } void loadIntoDataStore(ImportTask task, DataStoreInfo store, VectorFormat format, VectorTransformChain tx) throws Throwable { ImportData data = task.getData(); FeatureReader reader = null; // using this exception to throw at the end Throwable error = null; Transaction transaction = new DefaultTransaction(); try { SimpleFeatureType featureType = (SimpleFeatureType) task.getMetadata().get(FeatureType.class); final String featureTypeName = featureType.getName().getLocalPart(); DataStore dataStore = (DataStore) store.getDataStore(null); FeatureDataConverter featureDataConverter = FeatureDataConverter.DEFAULT; if (isShapefileDataStore(dataStore)) { featureDataConverter = FeatureDataConverter.TO_SHAPEFILE; } else if (isOracleDataStore(dataStore)) { featureDataConverter = FeatureDataConverter.TO_ORACLE; } else if (isPostGISDataStore(dataStore)) { featureDataConverter = FeatureDataConverter.TO_POSTGIS; } featureType = featureDataConverter.convertType(featureType, format, data, task); UpdateMode updateMode = task.getUpdateMode(); final String uniquifiedFeatureTypeName; if (updateMode == UpdateMode.CREATE) { // find a unique type name in the target store uniquifiedFeatureTypeName = findUniqueNativeFeatureTypeName(featureType, store); task.setOriginalLayerName(featureTypeName); if (!uniquifiedFeatureTypeName.equals(featureTypeName)) { // update the metadata task.getLayer().getResource().setName(uniquifiedFeatureTypeName); task.getLayer().getResource().setNativeName(uniquifiedFeatureTypeName); // retype SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(uniquifiedFeatureTypeName); typeBuilder.addAll(featureType.getAttributeDescriptors()); featureType = typeBuilder.buildFeatureType(); } // @todo HACK remove this at some point when timezone issues are fixed // this will force postgis to create timezone w/ timestamp fields if (dataStore instanceof JDBCDataStore) { JDBCDataStore ds = (JDBCDataStore) dataStore; // sniff for postgis (h2 is used in tests and will cause failure if this occurs) if (ds.getSqlTypeNameToClassMappings().containsKey("timestamptz")) { ds.getSqlTypeToSqlTypeNameOverrides().put(java.sql.Types.TIMESTAMP, "timestamptz"); } } // apply the feature type transform featureType = tx.inline(task, dataStore, featureType); dataStore.createSchema(featureType); } else { // @todo what to do if featureType transform is present? // @todo implement me - need to specify attribute used for id if (updateMode == UpdateMode.UPDATE) { throw new UnsupportedOperationException("updateMode UPDATE is not supported yet"); } uniquifiedFeatureTypeName = featureTypeName; } if (updateMode == UpdateMode.REPLACE) { FeatureStore fs = (FeatureStore) dataStore.getFeatureSource(featureTypeName); fs.setTransaction(transaction); fs.removeFeatures(Filter.INCLUDE); } // Move features if (format instanceof DataStoreFormat) { error = copyFromFeatureSource(data, task, (DataStoreFormat) format, dataStore, transaction, featureTypeName, uniquifiedFeatureTypeName, featureDataConverter, tx); } else { reader = format.read(data, task); error = copyFromFeatureReader(reader, task, format, dataStore, transaction, featureTypeName, uniquifiedFeatureTypeName, featureDataConverter, tx); } } finally { try { if (reader != null) { format.dispose(reader, task); // @hack catch _all_ Exceptions here - occassionally closing a shapefile // seems to result in an IllegalArgumentException related to not // holding the lock... } } catch (Exception e) { LOGGER.log(Level.WARNING, "Error closing reader", e); } transaction.commit(); // try to cleanup, but if an error occurs here and one hasn't already been set, set the error try { transaction.close(); } catch (Exception e) { if (error != null) { error = e; } LOGGER.log(Level.WARNING, "Error closing transaction", e); } } // finally, throw any error if (error != null) { throw error; } } private Throwable copyFromFeatureSource(ImportData data, ImportTask task, DataStoreFormat format, DataStore dataStoreDestination, Transaction transaction, String featureTypeName, String uniquifiedFeatureTypeName, FeatureDataConverter featureDataConverter, VectorTransformChain tx) throws IOException { Throwable error = null; ProgressMonitor monitor = task.progress(); try { long startTime = System.currentTimeMillis(); task.clearMessages(); task.setTotalToProcess(format.getFeatureCount(task.getData(), task)); LOGGER.fine("begining import - highlevel api"); FeatureSource fs = format.getFeatureSource(data, task); FeatureCollection fc = fs.getFeatures(); FeatureStore featureStore = (FeatureStore) dataStoreDestination .getFeatureSource(uniquifiedFeatureTypeName); featureStore.setTransaction(transaction); fc = new ImportTransformFeatureCollection(fc, featureDataConverter, featureStore.getSchema(), tx, task, dataStoreDestination); featureStore.addFeatures(fc); } catch (Throwable e) { error = e; } if (error != null || monitor.isCanceled()) { // all sub exceptions in this catch block should be logged, not thrown // as the triggering exception will be thrown // failure, rollback transaction try { transaction.rollback(); } catch (Exception e1) { LOGGER.log(Level.WARNING, "Unable to load data into " + uniquifiedFeatureTypeName + ", rolling back data insert:" + e1, e1); } // attempt to drop the type that was created as well try { dropSchema(dataStoreDestination, featureTypeName); } catch (Exception e1) { LOGGER.log(Level.WARNING, "Error dropping schema in rollback", e1); } } return error; } Throwable copyFromFeatureReader(FeatureReader reader, ImportTask task, VectorFormat format, DataStore dataStoreDestination, Transaction transaction, String featureTypeName, String uniquifiedFeatureTypeName, FeatureDataConverter featureDataConverter, VectorTransformChain tx) throws IOException { FeatureWriter writer = null; Throwable error = null; ProgressMonitor monitor = task.progress(); // @todo need better way to communicate to client int skipped = 0; int cnt = 0; // metrics long startTime = System.currentTimeMillis(); task.clearMessages(); task.setTotalToProcess(format.getFeatureCount(task.getData(), task)); LOGGER.fine("begining import - lowlevel api"); try { writer = dataStoreDestination.getFeatureWriterAppend(uniquifiedFeatureTypeName, transaction); while (reader.hasNext()) { if (monitor.isCanceled()) { break; } SimpleFeature feature = (SimpleFeature) reader.next(); SimpleFeature next = (SimpleFeature) writer.next(); // (JD) TODO: some formats will rearrange the geometry type (like shapefile) which // makes the geometry the first attribute regardless, so blindly copying over // attributes won't work unless the source type also has the geometry as the // first attribute in the schema featureDataConverter.convert(feature, next); // @hack #45678 - mask empty geometry or postgis will complain Geometry geom = (Geometry) next.getDefaultGeometry(); if (geom != null && geom.isEmpty()) { next.setDefaultGeometry(null); } // apply the feature transform next = tx.inline(task, dataStoreDestination, feature, next); if (next == null) { skipped++; } else { writer.write(); } task.setNumberProcessed(++cnt); } if (skipped > 0) { task.addMessage(Level.WARNING, skipped + " features were skipped."); } LOGGER.info("load to target took " + (System.currentTimeMillis() - startTime)); } catch (Throwable e) { error = e; } // no finally block, there is too much to do if (error != null || monitor.isCanceled()) { // all sub exceptions in this catch block should be logged, not thrown // as the triggering exception will be thrown // failure, rollback transaction try { transaction.rollback(); } catch (Exception e1) { LOGGER.log(Level.WARNING, "Error rolling back transaction", e1); } // attempt to drop the type that was created as well try { dropSchema(dataStoreDestination, featureTypeName); } catch (Exception e1) { LOGGER.log(Level.WARNING, "Error dropping schema in rollback", e1); } } return error; } StoreInfo lookupDefaultStore() { WorkspaceInfo ws = catalog.getDefaultWorkspace(); if (ws == null) { return null; } return catalog.getDefaultDataStore(ws); } void addToCatalog(ImportTask task) throws IOException { LayerInfo layer = task.getLayer(); ResourceInfo resource = layer.getResource(); resource.setStore(task.getStore()); //add the resource String name = findUniqueResourceName(resource); resource.setName(name); //JD: not setting a native name, it should actually already be set by this point and we // don't want to blindly set it to the same name as the resource name, which might have // changed to deal with name clashes //resource.setNativeName(name); resource.setEnabled(true); catalog.add(resource); //add the layer (and style) if (layer.getDefaultStyle().getId() == null) { catalog.add(layer.getDefaultStyle()); } layer.setEnabled(true); catalog.add(layer); } String findUniqueStoreName(StoreInfo store) { WorkspaceInfo workspace = store.getWorkspace(); //TODO: put an upper limit on how many times to try String name = store.getName(); if (catalog.getStoreByName(workspace, store.getName(), StoreInfo.class) != null) { int i = 0; name += i; while (catalog.getStoreByName(workspace, name, StoreInfo.class) != null) { name = name.replaceAll(i + "$", String.valueOf(i + 1)); i++; } } return name; } String findUniqueResourceName(ResourceInfo resource) throws IOException { //TODO: put an upper limit on how many times to try StoreInfo store = resource.getStore(); NamespaceInfo ns = catalog.getNamespaceByPrefix(store.getWorkspace().getName()); String name = resource.getName(); // make sure the name conforms to a legal layer name if (!Character.isLetter(name.charAt(0))) { name = "a_" + name; } // strip out any non-word characters name = name.replaceAll("\\W", "_"); if (catalog.getResourceByName(ns, name, ResourceInfo.class) != null) { int i = 0; name += i; while (catalog.getResourceByName(ns, name, ResourceInfo.class) != null) { name = name.replaceAll(i + "$", String.valueOf(i + 1)); i++; } } return name; } String findUniqueNativeFeatureTypeName(FeatureType featureType, DataStoreInfo store) throws IOException { return findUniqueNativeFeatureTypeName(featureType.getName().getLocalPart(), store); } private String findUniqueNativeFeatureTypeName(String name, DataStoreInfo store) throws IOException { DataStore dataStore = (DataStore) store.getDataStore(null); //hack for oracle, all names must be upper case //TODO: abstract this into FeatureConverter if (isOracleDataStore(dataStore)) { name = name.toUpperCase(); } //TODO: put an upper limit on how many times to try List<String> names = Arrays.asList(dataStore.getTypeNames()); if (names.contains(name)) { int i = 0; name += i; while (names.contains(name)) { name = name.replaceAll(i + "$", String.valueOf(i + 1)); i++; } } return name; } boolean isShapefileDataStore(DataStore dataStore) { return dataStore instanceof ShapefileDataStore || dataStore instanceof DirectoryDataStore; } boolean isOracleDataStore(DataStore dataStore) { return dataStore instanceof JDBCDataStore && "org.geotools.data.oracle.OracleDialect" .equals(((JDBCDataStore) dataStore).getSQLDialect().getClass().getName()); } boolean isPostGISDataStore(DataStore dataStore) { return dataStore instanceof JDBCDataStore && ((JDBCDataStore) dataStore).getSQLDialect().getClass() .getName().startsWith("org.geotools.data.postgis"); } /* * computes the lat/lon bounding box from the native bounding box and srs, optionally overriding * the value already set. */ boolean computeLatLonBoundingBox(ImportTask task, boolean force) throws Exception { ResourceInfo r = task.getLayer().getResource(); if (force || r.getLatLonBoundingBox() == null && r.getNativeBoundingBox() != null) { CoordinateReferenceSystem nativeCRS = CRS.decode(r.getSRS()); ReferencedEnvelope nativeBbox = new ReferencedEnvelope(r.getNativeBoundingBox(), nativeCRS); r.setLatLonBoundingBox(nativeBbox.transform(CRS.decode("EPSG:4326"), true)); return true; } return false; } //file location methods public File getImportRoot() { try { return catalog.getResourceLoader().findOrCreateDirectory("imports"); } catch (IOException e) { throw new RuntimeException(e); } } public File getUploadRoot() { try { return catalog.getResourceLoader().findOrCreateDirectory("uploads"); } catch (IOException e) { throw new RuntimeException(e); } } public void destroy() throws Exception { jobs.shutdown(); contextStore.destroy(); } public void delete(ImportContext importContext) throws IOException { delete(importContext, false); } public void delete(ImportContext importContext, boolean purge) throws IOException { if (purge) { importContext.delete(); } contextStore.remove(importContext); } private void dropSchema(DataStore ds, String featureTypeName) throws Exception { // @todo this needs implementation in geotools SimpleFeatureType schema = ds.getSchema(featureTypeName); if (schema != null) { try { ds.removeSchema(featureTypeName); } catch (Exception e) { LOGGER.warning("Unable to dropSchema " + featureTypeName + " from datastore " + ds.getClass()); } } else { LOGGER.warning( "Unable to dropSchema " + featureTypeName + " as it does not appear to exist in dataStore"); } } public XStreamPersister createXStreamPersisterXML() { return initXStreamPersister(new XStreamPersisterFactory().createXMLPersister()); } public XStreamPersister createXStreamPersisterJSON() { return initXStreamPersister(new XStreamPersisterFactory().createJSONPersister()); } public XStreamPersister initXStreamPersister(XStreamPersister xp) { xp.setCatalog(catalog); //xp.setReferenceByName(true); XStream xs = xp.getXStream(); //ImportContext xs.alias("import", ImportContext.class); //ImportTask xs.alias("task", ImportTask.class); xs.omitField(ImportTask.class, "context"); //ImportItem //xs.alias("item", ImportItem.class); //xs.omitField(ImportItem.class, "task"); //DataFormat xs.alias("dataStoreFormat", DataStoreFormat.class); //ImportData xs.alias("spatialFile", SpatialFile.class); xs.alias("database", org.geoserver.importer.Database.class); xs.alias("table", Table.class); xs.omitField(Table.class, "db"); xs.alias("vectorTransformChain", VectorTransformChain.class); xs.registerLocalConverter(ReprojectTransform.class, "source", new CRSConverter()); xs.registerLocalConverter(ReprojectTransform.class, "target", new CRSConverter()); xs.registerLocalConverter(ReferencedEnvelope.class, "crs", new CRSConverter()); xs.registerLocalConverter(GeneralEnvelope.class, "crs", new CRSConverter()); GeoServerSecurityManager securityManager = GeoServerExtensions.bean(GeoServerSecurityManager.class); xs.registerLocalConverter(RemoteData.class, "password", new EncryptedFieldConverter(securityManager)); // security xs.allowTypes(new Class[] { ImportContext.class, ImportTask.class, File.class }); xs.allowTypeHierarchy(TransformChain.class); xs.allowTypeHierarchy(DataFormat.class); xs.allowTypeHierarchy(ImportData.class); xs.allowTypeHierarchy(ImportTransform.class); return xp; } /** * Creates a style for the layer being imported from a resource that was included in the * directory or archive that the data is being imported from. */ StyleInfo createStyleFromFile(File styleFile, ImportTask task) { String ext = FilenameUtils.getExtension(styleFile.getName()); if (ext != null) { StyleHandler styleHandler = Styles.handler(ext); if (styleHandler != null) { try { StyledLayerDescriptor sld = styleHandler.parse(styleFile, null, null, new EntityResolverProvider(getGeoServer()).getEntityResolver()); Style style = Styles.style(sld); if (style != null) { StyleInfo info = catalog.getFactory().createStyle(); String styleName = styleGen.generateUniqueStyleName(task.getLayer().getResource()); info.setName(styleName); info.setFilename(styleName + "." + ext); info.setFormat(styleHandler.getFormat()); info.setFormatVersion(styleHandler.version(styleFile)); info.setWorkspace(task.getStore().getWorkspace()); try (InputStream in = new FileInputStream(styleFile)) { catalog.getResourcePool().writeStyle(info, in); } return info; } else { LOGGER.warning("Style file contained no styling: " + styleFile.getPath()); } } catch (Exception e) { LOGGER.log(Level.WARNING, "Error parsing style: " + styleFile.getPath(), e); } } else { LOGGER.warning("Unable to find style handler for file extension: " + ext); } } return null; } }