Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/de/intevation/flys/utils/MapfileGenerator.java @ 4654:861c47e0a8a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Refactor Mapserver mapfile generation. Prepares the existing mapfile generation code for a river axis mapfile generator. Removes unused asynchronous mapfile generation to reduce complexity.
author Christian Lins <christian.lins@intevation.de>
date Sat, 08 Dec 2012 00:19:29 +0100
parents c04db3178d09
children 442fbb290fa8
comparison
equal deleted inserted replaced
4653:a93699cb31eb 4654:861c47e0a8a0
1 package de.intevation.flys.utils; 1 package de.intevation.flys.utils;
2 2
3 import de.intevation.artifacts.CallContext;
4 import de.intevation.artifacts.common.utils.Config; 3 import de.intevation.artifacts.common.utils.Config;
5 import de.intevation.flys.artifacts.FLYSArtifact;
6 import de.intevation.flys.artifacts.model.LayerInfo; 4 import de.intevation.flys.artifacts.model.LayerInfo;
7 import de.intevation.flys.artifacts.model.RiverFactory;
8 import de.intevation.flys.artifacts.model.map.WMSDBLayerFacet;
9 import de.intevation.flys.artifacts.model.map.WMSLayerFacet;
10 import de.intevation.flys.artifacts.model.map.WSPLGENLayerFacet;
11 import de.intevation.flys.artifacts.resources.Resources;
12 import de.intevation.flys.model.River;
13 5
14 import java.io.File; 6 import java.io.File;
15 import java.io.FileNotFoundException; 7 import java.io.FileNotFoundException;
16 import java.io.FileWriter; 8 import java.io.FileWriter;
17 import java.io.FilenameFilter; 9 import java.io.FilenameFilter;
23 15
24 import org.apache.log4j.Logger; 16 import org.apache.log4j.Logger;
25 import org.apache.velocity.Template; 17 import org.apache.velocity.Template;
26 import org.apache.velocity.VelocityContext; 18 import org.apache.velocity.VelocityContext;
27 import org.apache.velocity.app.VelocityEngine; 19 import org.apache.velocity.app.VelocityEngine;
28 import org.geotools.data.shapefile.ShpFiles;
29 import org.geotools.data.shapefile.shp.ShapefileHeader;
30 import org.geotools.data.shapefile.shp.ShapefileReader;
31 20
32 /** 21 /**
33 * This class iterates over a bunch of directories, searches for meta 22 * This class iterates over a bunch of directories, searches for meta
34 * information coresponding to shapefiles and creates a mapfile which is used by 23 * information coresponding to shapefiles and creates a mapfile which is used by
35 * a <i>MapServer</i>. 24 * a <i>MapServer</i>.
36 * 25 *
37 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a> 26 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
38 */ 27 */
39 public class MapfileGenerator 28 public abstract class MapfileGenerator
40 extends Thread
41 { 29 {
42 public static final String WSPLGEN_RESULT_SHAPE = "wsplgen.shp"; 30 public static final String WSPLGEN_RESULT_SHAPE = "wsplgen.shp";
43 public static final String WSPLGEN_LINES_SHAPE = "barrier_lines.shp"; 31 public static final String WSPLGEN_LINES_SHAPE = "barrier_lines.shp";
44 public static final String WSPLGEN_POLYGONS_SHAPE = "barrier_polygons.shp"; 32 public static final String WSPLGEN_POLYGONS_SHAPE = "barrier_polygons.shp";
45 public static final String WSPLGEN_USER_SHAPE = "user-rgd.shp"; 33 public static final String WSPLGEN_USER_SHAPE = "user-rgd.shp";
54 public static final String MS_LINE_PREFIX = "lines-"; 42 public static final String MS_LINE_PREFIX = "lines-";
55 public static final String MS_POLYGONS_PREFIX = "polygons-"; 43 public static final String MS_POLYGONS_PREFIX = "polygons-";
56 public static final String MS_LAYER_PREFIX = "ms_layer-"; 44 public static final String MS_LAYER_PREFIX = "ms_layer-";
57 public static final String MS_USERSHAPE_PREFIX = "user-"; 45 public static final String MS_USERSHAPE_PREFIX = "user-";
58 46
59 protected static final long SLEEPTIME = 10 * 1000L; // 10 seconds
60
61 private static Logger logger = Logger.getLogger(MapfileGenerator.class); 47 private static Logger logger = Logger.getLogger(MapfileGenerator.class);
62 48
63 private static MapfileGenerator instance;
64
65 private File shapefileDirectory; 49 private File shapefileDirectory;
66 50
67 private VelocityEngine velocityEngine; 51 private VelocityEngine velocityEngine;
68 private final boolean lock[]; 52
69 53
70 54 protected MapfileGenerator() {
71 55 }
72 private MapfileGenerator() { 56
73 lock = new boolean[1];
74 }
75
76
77 /**
78 * A main method which can be used to create a mapfile without a running
79 * artifact server.<br>
80 * <b>NOTE:</b> This method is not implemented yet!
81 *
82 * @param args Arguments.
83 */
84 public static void main(String[] args) {
85 throw new Error("MapfileGenerator.main() is CURRENTLY NOT IMPLEMENTED!");
86 }
87
88
89 /**
90 * Returns the instance of this generator.
91 *
92 * @return the instance.
93 */
94 public static synchronized MapfileGenerator getInstance() {
95 if (instance == null) {
96 instance = new MapfileGenerator();
97 instance.setDaemon(true);
98 instance.start();
99 }
100
101 return instance;
102 }
103
104
105 /**
106 * Triggers the mapfile generation process.
107 */
108 public void update() {
109 synchronized (lock) {
110 logger.debug("update");
111 lock[0] = true;
112 lock.notify();
113 }
114 }
115
116
117 /**
118 * Thread to generate a mapfile.
119 */
120 @Override
121 public void run() {
122 logger.debug("Start MapfileGenerator thread...");
123 try {
124 for (;;) {
125 synchronized (lock) {
126 while (!lock[0]) {
127 lock.wait(SLEEPTIME);
128 }
129 lock[0] = false;
130 }
131
132 logger.debug("Start sync process now...");
133 generate();
134 }
135 }
136 catch (InterruptedException ie) {
137 logger.debug("MapfileGenerator thread got an interrupt.");
138 }
139 catch (FileNotFoundException fnfe) {
140 logger.debug("Error while mapfile creation: " + fnfe.getMessage());
141 }
142 catch (IOException ioe) {
143 logger.error(ioe, ioe);
144 }
145 finally {
146 logger.debug("THREAD END");
147 }
148 }
149 57
150 /** 58 /**
151 * Method to check the existance of a template file. 59 * Method to check the existance of a template file.
152 * 60 *
153 * @param templateID The name of a template. 61 * @param templateID The name of a template.
157 Template template = getTemplateByName(templateID); 65 Template template = getTemplateByName(templateID);
158 return template != null; 66 return template != null;
159 } 67 }
160 68
161 69
162 /** 70 protected abstract void generate() throws Exception;
163 * Method which starts searching for meta information file and mapfile
164 * generation.
165 */
166 protected void generate()
167 throws FileNotFoundException, IOException
168 {
169 File[] userDirs = getUserDirs();
170
171 List<String> layers = parseLayers(userDirs);
172
173 logger.info("Found " + layers.size() + " layers for user mapfile.");
174
175 writeMapfile(layers);
176 }
177
178
179 /**
180 * Generate river axis mapfile.
181 */
182 protected void generateRiverAxisMapfile() {
183 List<River> rivers = RiverFactory.getRivers();
184
185 for (River river : rivers) {
186 createRiverAxisLayer(
187 river.getName(),
188 river.getId(),
189 "41677",
190 "100,100,100,100");
191 }
192 }
193 71
194 72
195 /** 73 /**
196 * Returns the VelocityEngine used for the template mechanism. 74 * Returns the VelocityEngine used for the template mechanism.
197 * 75 *
377 255
378 return layers; 256 return layers;
379 } 257 }
380 258
381 259
382 /**
383 * Creates a layer file used for Mapserver's mapfile which represents the
384 * floodmap.
385 *
386 * @param flys The FLYSArtifact that owns <i>wms</i>.
387 * @param wms The WMSLayerFacet that contains information for the layer.
388 */
389 public void createUeskLayer(
390 FLYSArtifact flys,
391 WSPLGENLayerFacet wms,
392 String style,
393 CallContext context
394 ) throws FileNotFoundException, IOException
395 {
396 logger.debug("createUeskLayer");
397
398 LayerInfo layerinfo = new LayerInfo();
399 layerinfo.setName(MS_WSPLGEN_PREFIX + flys.identifier());
400 layerinfo.setType("POLYGON");
401 layerinfo.setDirectory(flys.identifier());
402 layerinfo.setData(WSPLGEN_RESULT_SHAPE);
403 layerinfo.setTitle(Resources.getMsg(Resources.getLocale(context.getMeta()),
404 "floodmap.uesk",
405 "Floodmap"));
406 layerinfo.setStyle(style);
407 layerinfo.setSrid(wms.getSrid());
408
409 String name = MS_LAYER_PREFIX + wms.getName();
410
411 Template template = getTemplateByName(WSPLGEN_LAYER_TEMPLATE);
412 if (template == null) {
413 logger.warn("Template '" + WSPLGEN_LAYER_TEMPLATE + "' found.");
414 return;
415 }
416
417 try {
418 File dir = new File(getShapefileBaseDir(), flys.identifier());
419 writeLayer(layerinfo, dir, name, template);
420 }
421 catch (FileNotFoundException fnfe) {
422 logger.error(fnfe, fnfe);
423 logger.warn("Unable to write layer: " + name);
424 }
425 }
426
427
428 /**
429 * Creates a layer file used for Mapserver's mapfile which represents the
430 * user defined barriers.
431 *
432 * @param flys The FLYSArtifact that owns <i>wms</i>.
433 * @param wms The WMSLayerFacet that contains information for the layer.
434 */
435 public void createBarriersLayer(FLYSArtifact flys, WMSLayerFacet wms)
436 throws FileNotFoundException, IOException
437 {
438 logger.debug("createBarriersLayer");
439
440 //String uuid = flys.identifier();
441 //File dir = new File(getShapefileBaseDir(), uuid);
442
443 createBarriersLineLayer(flys, wms);
444 createBarriersPolygonLayer(flys, wms);
445 }
446
447
448 protected void createBarriersLineLayer(
449 FLYSArtifact flys,
450 WMSLayerFacet wms
451 )
452 throws FileNotFoundException, IOException
453 {
454 String uuid = flys.identifier();
455 String group = MS_BARRIERS_PREFIX + uuid;
456 String groupTitle = "I18N_BARRIERS_TITLE";
457
458 File dir = new File(getShapefileBaseDir(), uuid);
459 File test = new File(dir, WSPLGEN_LINES_SHAPE);
460
461 if (!test.exists() || !test.canRead()) {
462 logger.debug("No barrier line layer existing.");
463 return;
464 }
465
466 LayerInfo lineInfo = new LayerInfo();
467 lineInfo.setName(MS_LINE_PREFIX + uuid);
468 lineInfo.setType("LINE");
469 lineInfo.setDirectory(uuid);
470 lineInfo.setData(WSPLGEN_LINES_SHAPE);
471 lineInfo.setTitle("I18N_LINE_SHAPE");
472 lineInfo.setGroup(group);
473 lineInfo.setGroupTitle(groupTitle);
474 lineInfo.setSrid(wms.getSrid());
475
476 String nameLines = MS_LAYER_PREFIX + wms.getName() + "-lines";
477
478 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
479 if (tpl == null) {
480 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
481 return;
482 }
483
484 try {
485 writeLayer(lineInfo, dir, nameLines, tpl);
486 }
487 catch (FileNotFoundException fnfe) {
488 logger.error(fnfe, fnfe);
489 logger.warn("Unable to write layer: " + nameLines);
490 }
491 }
492
493
494 protected void createRiverAxisLayer(String riverName, int riverID, String srid, String extend) {
495 LayerInfo layerInfo = new LayerInfo();
496 layerInfo.setName(riverName);
497 layerInfo.setSrid(srid);
498 layerInfo.setExtent(extend);
499 }
500
501
502 protected void createBarriersPolygonLayer(
503 FLYSArtifact flys,
504 WMSLayerFacet wms
505 )
506 throws FileNotFoundException, IOException
507 {
508 String uuid = flys.identifier();
509 String group = uuid + MS_BARRIERS_PREFIX;
510 String groupTitle = "I18N_BARRIERS_TITLE";
511
512 File dir = new File(getShapefileBaseDir(), uuid);
513 File test = new File(dir, WSPLGEN_POLYGONS_SHAPE);
514
515 if (!test.exists() || !test.canRead()) {
516 logger.debug("No barrier line layer existing.");
517 return;
518 }
519
520 LayerInfo polygonInfo = new LayerInfo();
521 polygonInfo.setName(MS_POLYGONS_PREFIX + uuid);
522 polygonInfo.setType("POLYGON");
523 polygonInfo.setDirectory(uuid);
524 polygonInfo.setData(WSPLGEN_POLYGONS_SHAPE);
525 polygonInfo.setTitle("I18N_POLYGON_SHAPE");
526 polygonInfo.setGroup(group);
527 polygonInfo.setGroupTitle(groupTitle);
528 polygonInfo.setSrid(wms.getSrid());
529
530 String namePolygons = MS_LAYER_PREFIX + wms.getName() + "-polygons";
531
532 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
533 if (tpl == null) {
534 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
535 return;
536 }
537
538 try {
539 writeLayer(polygonInfo, dir, namePolygons, tpl);
540 }
541 catch (FileNotFoundException fnfe) {
542 logger.error(fnfe, fnfe);
543 logger.warn("Unable to write layer: " + namePolygons);
544 }
545 }
546
547
548 /**
549 * Creates a layer file used for Mapserver's mapfile which represents the
550 * shape files uploaded by the user.
551 *
552 * @param flys The FLYSArtifact that owns <i>wms</i>.
553 * @param wms The WMSLayerFacet that contains information for the layer.
554 */
555 public void createUserShapeLayer(FLYSArtifact flys, WMSLayerFacet wms)
556 throws FileNotFoundException, IOException
557 {
558 logger.debug("createUserShapeLayer");
559
560 String uuid = flys.identifier();
561 File dir = new File(getShapefileBaseDir(), uuid);
562 File test = new File(dir, WSPLGEN_USER_SHAPE);
563
564 if (!test.exists() || !test.canRead()) {
565 logger.debug("No user layer existing.");
566 return;
567 }
568
569 File userShape = new File(dir, WSPLGEN_USER_SHAPE);
570 ShpFiles sf = new ShpFiles(userShape);
571 ShapefileReader sfr = new ShapefileReader(sf, true, false, null);
572 ShapefileHeader sfh = sfr.getHeader();
573
574 String group = uuid + MS_USERSHAPE_PREFIX;
575 String groupTitle = "I18N_USER_SHAPE_TITLE";
576
577 LayerInfo info = new LayerInfo();
578 info.setName(MS_USERSHAPE_PREFIX + uuid);
579 if (sfh.getShapeType().isLineType()) {
580 info.setType("LINE");
581 }
582 else if (sfh.getShapeType().isPolygonType()) {
583 info.setType("POLYGON");
584 }
585 else {
586 return;
587 }
588 info.setDirectory(uuid);
589 info.setData(WSPLGEN_USER_SHAPE);
590 info.setTitle("I18N_USER_SHAPE");
591 info.setGroup(group);
592 info.setGroupTitle(groupTitle);
593 info.setSrid(wms.getSrid());
594
595 String nameUser = MS_LAYER_PREFIX + wms.getName();
596
597 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
598 if (tpl == null) {
599 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
600 return;
601 }
602
603 try {
604 writeLayer(info, dir, nameUser, tpl);
605 }
606 catch (FileNotFoundException fnfe) {
607 logger.error(fnfe, fnfe);
608 logger.warn("Unable to write layer: " + nameUser);
609 }
610
611 }
612
613
614 /**
615 * Creates a layer file used for Mapserver's mapfile which represents
616 * geometries from database.
617 *
618 * @param flys The FLYSArtifact that owns <i>wms</i>.
619 * @param wms The WMSLayerFacet that contains information for the layer.
620 */
621 public void createDatabaseLayer(
622 FLYSArtifact flys,
623 WMSDBLayerFacet wms,
624 String style
625 )
626 throws FileNotFoundException, IOException
627 {
628 logger.debug("createDatabaseLayer");
629
630 LayerInfo layerinfo = new LayerInfo();
631 layerinfo.setName(wms.getName() + "-" + flys.identifier());
632 layerinfo.setType(wms.getGeometryType());
633 layerinfo.setFilter(wms.getFilter());
634 layerinfo.setData(wms.getData());
635 layerinfo.setTitle(wms.getDescription());
636 layerinfo.setStyle(style);
637 if(wms.getExtent() != null) {
638 layerinfo.setExtent(GeometryUtils.jtsBoundsToOLBounds(wms.getExtent()));
639 }
640 layerinfo.setConnection(wms.getConnection());
641 layerinfo.setConnectionType(wms.getConnectionType());
642 layerinfo.setLabelItem(wms.getLabelItem());
643 layerinfo.setSrid(wms.getSrid());
644
645 String name = MS_LAYER_PREFIX + wms.getName();
646
647 Template template = getTemplateByName(DB_LAYER_TEMPLATE);
648 if (template == null) {
649 logger.warn("Template '" + DB_LAYER_TEMPLATE + "' found.");
650 return;
651 }
652
653 try {
654 File dir = new File(getShapefileBaseDir(), flys.identifier());
655 writeLayer(layerinfo, dir, name, template);
656 }
657 catch (FileNotFoundException fnfe) {
658 logger.error(fnfe, fnfe);
659 logger.warn("Unable to write layer: " + name);
660 }
661 }
662 260
663 261
664 /** 262 /**
665 * Creates a layer snippet which might be included in the mapfile. 263 * Creates a layer snippet which might be included in the mapfile.
666 * 264 *
http://dive4elements.wald.intevation.org