def _unpublish_from_geoserver(resource, geoserver_context, logger): '''Contact Geoserver and unpublish a layer previously created as an ingested resource. ''' from geoserver.catalog import Catalog, FailedRequestError layer_name = None if resource['format'] == WMSResource.FORMAT: layer_name = resource['wms_layer'] else: layer_name = resource['wfs_layer'] try: api_url = geoserver_context['api_url'] cat = Catalog(api_url + '/rest', username=geoserver_context['username'], password=geoserver_context['password']) layer = cat.get_layer(resource['parent_resource_id'].lower()) cat.delete(layer) cat.reload() logger.info('Unpublished layer %s from Geoserver' % (layer_name)) except AttributeError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex)) except FailedRequestError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex))
def _unpublish_from_geoserver(resource, geoserver_context, logger): '''Contact Geoserver and unpublish a layer previously created as an ingested resource. ''' from geoserver.catalog import Catalog, FailedRequestError layer_name = None if resource['format'] == WMSResource.FORMAT: layer_name = resource['wms_layer'] else: layer_name = resource['wfs_layer'] try: api_url = geoserver_context['api_url'] cat = Catalog( api_url + '/rest', username=geoserver_context['username'], password=geoserver_context['password']) layer = cat.get_layer(resource['parent_resource_id'].lower()) cat.delete(layer) cat.reload() logger.info('Unpublished layer %s from Geoserver' % (layer_name)) except AttributeError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex)) except FailedRequestError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex))
def buildOverviews(): try: image=os.path.join(uploadfiles[0],'chaneltransformRPC.tif') gdal.AllRegister() TransformDS = gdal.Open(image.encode('utf-8').decode(), gdal.GA_ReadOnly) Width = TransformDS.RasterXSize Heigh = TransformDS.RasterYSize PixelNum = Width * Heigh TopNum = 4096 CurNum = PixelNum / 4 anLevels = [] nLevelCount = 0 while (CurNum > TopNum): anLevels.append(pow(2, nLevelCount + 2)) nLevelCount += 1 CurNum /= 4 TransformDS.BuildOverviews(overviewlist=anLevels) cat = Catalog(map_url,'admin', 'geoserver') wkspce = cat.get_workspace('Map') cat.create_coveragestore_external_geotiff(name=id, data='file://' + image.encode('utf-8').decode('utf-8'), workspace=wkspce) cat.reload() TransformDS = None except Exception as e: return Exception("上传失败,建立金字塔出错"+str(e))
def _unpublish_from_geoserver(resource_id, geoserver_context): geoserver_url = geoserver_context['geoserver_url'] geoserver_admin = geoserver_context['geoserver_admin'] geoserver_password = geoserver_context['geoserver_password'] cat = Catalog(geoserver_url + '/rest', username=geoserver_admin, password=geoserver_password) layer = cat.get_layer(resource_id.lower()) cat.delete(layer) cat.reload()
def _unpublish_from_geoserver(resource_id, geoserver_context): geoserver_url = geoserver_context['url'] cat = Catalog(geoserver_url.rstrip('/') + '/rest', username=geoserver_context['username'], password=geoserver_context['password']) layer = cat.get_layer(resource_id.lower()) cat.delete(layer) cat.reload()
def _unpublish_from_geoserver(resource_id, geoserver_context): geoserver_url = geoserver_context['geoserver_url'] geoserver_admin = geoserver_context['geoserver_admin'] geoserver_password = geoserver_context['geoserver_password'] cat = Catalog(geoserver_url + '/rest', username=geoserver_admin, password=geoserver_password) layer = cat.get_layer(resource_id.lower()) cat.delete(layer) cat.reload()
def rename_layers_old_postfix(): """ Rename the layers adding an _old suffix. """ # fixme it does not work, as name cannot be assigned with gsconfig # filing a bug cat = Catalog("%srest" % settings.GEOSERVER_URL) for l in layers_to_process: print 'Renaming layer %s' % l layer = cat.get_layer(l) layer.name = '%s_old' % l cat.save(layer) cat.reload()
def cleanup(): #Delete any existing folders existingDirs = os.path.join(appWorkspace.path, '') for dir in os.listdir(existingDirs): shutil.rmtree(os.path.join(existingDirs, dir), ignore_errors=True) #Delete stores from geoserver cat = Catalog(cfg.geoserver['rest_url'], username=cfg.geoserver['user'], password=cfg.geoserver['password']) stores = cat.get_stores(workspace=cfg.geoserver['workspace']) for store in stores: cat.delete(store, recurse=True) cat.reload()
def reload_config(instances): """Perform requests against GeoServer REST API to reload configurations on slaves Optional environment variables: GS_RELOAD_INTERVAL: time in seconds to delay between slave instance reloads GS_PROTOCOL: protocol prefix, should be set to 'HTTP' or 'HTTPS' GS_RELATIVE_URL: relative URL to GeoServer REST API :param instances: list of hostname:port requests :return: """ logging.info('Sending reload requests separated by %s second delay' % RELOAD_INTERVAL) for instance in instances: url = '%s://%s%s' % (PROTOCOL, instance, RELATIVE_URL) logging.info('Performing GeoServer configuration reload at: %s' % url) catalog = Catalog(url) result = catalog.reload() if result and result[0]: if 200 <= result[0].status < 300: logging.info('Successful configuration reload.') else: raise Exception( 'Failure processing reload with status %s and reason: %s' % (result[0].status, result[0].reason)) else: logging.error('No result received from reload request!') sleep(RELOAD_INTERVAL)
def reload_config(instances): """Perform requests against GeoServer REST API to reload configurations on slaves Optional environment variables: GS_RELOAD_INTERVAL: time in seconds to delay between slave instance reloads GS_PROTOCOL: protocol prefix, should be set to 'HTTP' or 'HTTPS' GS_RELATIVE_URL: relative URL to GeoServer REST API :param instances: list of hostname:port requests :return: """ logging.info('Sending reload requests separated by %s second delay' % RELOAD_INTERVAL) for instance in instances: url = '%s://%s%s' % (PROTOCOL, instance, RELATIVE_URL) logging.info('Performing GeoServer configuration reload at: %s' % url) catalog = Catalog(url) result = catalog.reload() if result and result[0]: if 200 <= result[0].status < 300: logging.info('Successful configuration reload.') else: raise Exception('Failure processing reload with status %s and reason: %s' % (result[0].status, result[0].reason)) else: logging.error('No result received from reload request!') sleep(RELOAD_INTERVAL)
def uploadGS(self): shpFile = os.path.join(self.tempFolder, 'diff_simplify') cat = Catalog("http://localhost:8080/geoserver/rest", username="******", password="******") gsWorkspace = cat.get_workspace("SJ") shapefileData = geoserver.util.shapefile_and_friends(shpFile) # TODO: 레이어명 구분이 필요 layerName = self.resId # layerName = time.strftime("%Y%m%d_%H%M%S") cat.create_featurestore(layerName, shapefileData, gsWorkspace) cat.reload() layer = cat.get_layer(layerName) diffStyle = cat.get_style('SJ:diff_style') if diffStyle is not None: layer._set_default_style('SJ:diff_style') cat.save(layer)
def save_mask(): try: ct=CoordTransform(SpatialReference('WGS84'), SpatialReference('4527')) label_path=os.path.join(uploadfiles[0],'labelRPC.tif') dataset = gdal.Open(label_path) GeoTransform = dataset.GetGeoTransform() if dataset == None: return im_width = dataset.RasterXSize # 栅格矩阵的列数 im_height = dataset.RasterYSize # 栅格矩阵的行数 cood_trans=lambda L,C:(GeoTransform[0] + C * GeoTransform[1] + L * GeoTransform[2],GeoTransform[3] + C * GeoTransform[4] + L * GeoTransform[5]) map_polygon=Polygon(LinearRing(cood_trans(0,0),cood_trans(0,im_width),cood_trans(im_height,im_width),cood_trans(im_height,0),cood_trans(0,0))) Bmap.objects.filter(id=id).update(polygon=map_polygon) im_data = dataset.ReadAsArray(0, 0, im_width, im_height) # 获取数据 dataset = None types = np.unique(im_data) for label_type in types: # if label_type in (0,): # continue mp = fit_by_contours((im_data == label_type).astype(np.uint8), GeoTransform) m = Mask(map=Bmap.objects.get(id=id),type_id=int(label_type), mask=mp,area=round(mp.transform(ct,clone=True).area/1000000,2)) m.save() # img[im_data == label_type]=127 # cv2.imwrite(str(label_type)+".jpg",img) if label_type!=0: payload = "<featureType><name>" + str(id) + '_' + str(m.type_id) + "</name><nativeName>myweb_mask</nativeName>"" \ ""<cqlFilter>type_id=" + str(m.type_id) + " and map_id=" + str(id) + "</cqlFilter></featureType>" headers = {'Content-type': 'text/xml'} resp = requests.post(mask_url, auth=('admin', 'geoserver'), data=payload, headers=headers) if resp.status_code != 201: raise Exception('Upload to geoserver error') else: cat = Catalog(map_url, 'admin', 'geoserver') layer = cat.get_layer('Mask:'+str(id)+'_'+str(m.type_id)) layer.default_style=cat.get_style(str(label_type), 'Mask') cat.save(layer) cat.reload() return "上传成功" except Exception as e: return Exception("上传失败,拟合图斑出错:"+str(e))
def delete_map(request): map_id = request.POST.get('map_id', False) cat = Catalog(map_url, 'admin', 'geoserver') if cat.get_layer('Map:' + map_id): cat.delete(cat.get_layer('Map:' + map_id)) cat.reload() for label_type in range(1, 8): if cat.get_layer('Mask:' + map_id + '_' + str(label_type)): cat.delete(cat.get_layer('Mask:' + map_id + '_' + str(label_type))) cat.reload() try: if cat.get_store(map_id): st = cat.get_store(map_id) cat.delete(st) cat.reload() except Exception: pass if Bmap.objects.filter(id=map_id): map_name = Bmap.objects.get(id=map_id).name dir_root = os.path.join(MAPBASEPATH, map_name) delete_files = (map_id + ".jpg", 'chaneltransform.tif', 'chaneltransform_rpc.txt', 'chaneltransformRPC.txt', 'chaneltransformRPC.tif.ovr', 'label.tif', 'label_rpc.txt', 'labelRPC.tif') for file in delete_files: if os.path.exists(file): os.remove(os.path.join(dir_root, file)) Bmap.objects.filter(id=map_id).delete() return HttpResponse("success")
def styles2sde_using_gsconfig(): """ Migrate the layers styles from postgis to sde using gsconfig. """ #geoserver_url = settings.GEOSERVER_URL # http://localhost:8080/geoserver/ geoserver_url = 'http://geonode.wfp.org/geoserver/' user = settings.OGC_SERVER['default']['USER'] pwd = settings.OGC_SERVER['default']['PASSWORD'] cat = Catalog("%srest" % geoserver_url, "admin", "zeeD4ies") for l in layers_to_process: print 'Processing layer %s' % l layer_old = cat.get_layer('%s_old' % l) layer = cat.get_layer(l) #import ipdb;ipdb.set_trace() print 'Copying stuff from %s to %s...' % (layer_old.name, layer.name) print 'Default style: %s' % layer_old.default_style # change default style layer.default_style = layer_old.default_style # associate styles layer.styles = layer_old.styles cat.save(layer) cat.reload() print 'You need to run updatelayers now!'
def remove_geoserver_layer(self, storename, layername): self.logger.debug("start removing the geoserver layer") last_charactor = self.geoServer[-1] if last_charactor == '/': geoserver_rest = self.geoServer + 'rest' else: geoserver_rest = self.geoServer + '/rest' cat = Catalog(geoserver_rest, username=self.gs_username, password=self.gs_password) # worksp = cat.get_workspace(gs_workspace) store = cat.get_store(storename) self.logger.debug("store name %s" % store) layer = cat.get_layer(layername) self.logger.debug("layer name %s" % layer) try: self.logger.debug("deleting the layer...") cat.delete(layer) cat.reload() self.logger.debug("deleting the store...") cat.delete(store) cat.reload except Exception: self.logger.error("Failed to remove from geoserver")
#~ print workspaces def geoserver_ws(ws): for workspace in workspaces: #set(ws): w = cat.get_workspace(workspace) if w is not None: cat.delete(w, True, True) cat.create_workspace(workspace, 'https://server.org/geoserver/' + workspace + '/') print '\033[1;34mDrop and create workspaces in GeoServer\033[1;m' geoserver_ws(workspaces) cat.reload() # Geoserver resources {{{ tmpl = '<?xml version="1.0"?>\ <coverageStore>\ <url>file://{file}</url>\ <type>GeoTIFF</type>\ <enabled>true</enabled>\ <name>{store}</name>\ <workspace>\ <name>{workspace}</name>\ </workspace>\ </coverageStore>' http = httplib2.Http(disable_ssl_certificate_validation=True) http.add_credentials(USERNAME, PASSWORD)
class CatalogTests(unittest.TestCase): def setUp(self): self.cat = Catalog(GSPARAMS['GSURL'], username=GSPARAMS['GSUSER'], password=GSPARAMS['GSPASSWORD']) def testAbout(self): about_html = self.cat.about() self.assertTrue( '<html xmlns="http://www.w3.org/1999/xhtml"' in str(about_html)) def testGSVersion(self): version = self.cat.gsversion() pat = re.compile('\d\.\d+(\.[\dx]|-SNAPSHOT)') self.assertTrue(pat.match('2.2.x')) self.assertTrue(pat.match('2.3.2')) self.assertTrue(pat.match('2.3-SNAPSHOT')) self.assertTrue(pat.match('2.10.1')) self.assertFalse(pat.match('2.3.y')) self.assertFalse(pat.match('233')) self.assertTrue(pat.match(version)) def testWorkspaces(self): self.assertEqual(7, len(self.cat.get_workspaces())) # marking out test since geoserver default workspace is not consistent # self.assertEqual("cite", self.cat.get_default_workspace().name) self.assertEqual("topp", self.cat.get_workspace("topp").name) self.assertEqual("topp", self.cat.get_workspaces("topp")[-1].name) self.assertEqual(2, len(self.cat.get_workspaces(names=['topp', 'sde']))) self.assertEqual(2, len(self.cat.get_workspaces(names='topp, sde'))) def testStores(self): self.assertEqual(0, len(self.cat.get_stores("nonexistentstore"))) topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") self.assertEqual(9, len(self.cat.get_stores())) self.assertEqual(2, len(self.cat.get_stores(workspace=topp))) self.assertEqual(2, len(self.cat.get_stores(workspace=sf))) self.assertEqual(2, len(self.cat.get_stores(workspace='sf'))) self.assertEqual( 2, len(self.cat.get_stores(names='states_shapefile, sfdem'))) self.assertEqual( 2, len(self.cat.get_stores(names=['states_shapefile', 'sfdem']))) self.assertEqual("sfdem", self.cat.get_stores("sfdem")[-1].name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile", topp).name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile").name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile", "topp").name) self.assertEqual("sfdem", self.cat.get_store("sfdem", sf).name) self.assertEqual("sfdem", self.cat.get_store("sfdem").name) def testResources(self): topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") states = self.cat.get_store("states_shapefile", topp) sfdem = self.cat.get_store("sfdem", sf) self.assertEqual(19, len(self.cat.get_resources())) self.assertEqual(1, len(self.cat.get_resources(states))) self.assertEqual(5, len(self.cat.get_resources(workspace=topp))) self.assertEqual(1, len(self.cat.get_resources(sfdem))) self.assertEqual(6, len(self.cat.get_resources(workspace=sf))) self.assertEqual("states", self.cat.get_resource("states", states).name) self.assertEqual("states", self.cat.get_resource("states", workspace=topp).name) self.assertEqual("states", self.cat.get_resource("states").name) states = self.cat.get_resource("states") fields = [ states.title, states.abstract, states.native_bbox, states.latlon_bbox, states.projection, states.projection_policy ] self.assertFalse(None in fields, str(fields)) self.assertFalse(len(states.keywords) == 0) self.assertFalse(len(states.attributes) == 0) self.assertTrue(states.enabled) self.assertEqual("sfdem", self.cat.get_resource("sfdem", sfdem).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem", workspace=sf).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem").name) def testResourcesUpdate(self): res_dest = self.cat.get_resources() count = 0 for rd in res_dest: # only wms layers if rd.resource_type != "wmsLayer": continue # looking for same name ro = self.cat.get_resource(rd.name) if ro is not None: rd.title = ro.title rd.abstract = ro.abstract rd.keywords = ro.keywords rd.projection = ro.projection rd.native_bbox = ro.native_bbox rd.latlon_bbox = ro.latlon_bbox rd.projection_policy = ro.projection_policy rd.enabled = ro.enabled rd.advertised = ro.advertised rd.metadata_links = ro.metadata_links or None self.cat.save(rd) self.cat.reload() # print "Updated layer: " + rd.name count += 1 # print "Total updated layers: " + str(count) def testLayers(self): expected = set([ "Arc_Sample", "Pk50095", "Img_Sample", "mosaic", "sfdem", "bugsites", "restricted", "streams", "archsites", "roads", "tasmania_roads", "tasmania_water_bodies", "tasmania_state_boundaries", "tasmania_cities", "states", "poly_landmarks", "tiger_roads", "poi", "giant_polygon" ]) actual = set(l.name for l in self.cat.get_layers()) missing = expected - actual extras = actual - expected message = "Actual layer list did not match expected! (Extras: %s) (Missing: %s)" % ( extras, missing) self.assertTrue(len(expected ^ actual) == 0, message) states = self.cat.get_layer("states") self.assertEqual("states", states.name) self.assertIsInstance(states.resource, ResourceInfo) self.assertEqual(set(s.name for s in states.styles), set(['pophatch', 'polygon'])) self.assertEqual(states.default_style.name, "population") def testLayerGroups(self): expected = set(["tasmania", "tiger-ny", "spearfish"]) actual = set(l.name for l in self.cat.get_layergroups()) missing = expected - actual extras = actual - expected message = "Actual layergroup list did not match expected! (Extras: %s) (Missing: %s)" % ( extras, missing) self.assertTrue(len(expected ^ actual) == 0, message) tas = self.cat.get_layergroup("tasmania") self.assertEqual("tasmania", tas.name) self.assertIsInstance(tas, LayerGroup) self.assertEqual(tas.layers, [ 'tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities' ], tas.layers) self.assertEqual(tas.styles, [None, None, None, None], tas.styles) # Try to create a new Layer Group into the "topp" workspace self.assertIsNotNone(self.cat.get_workspace("topp")) tas2 = self.cat.create_layergroup("tasmania_reloaded", tas.layers, workspace="topp") self.cat.save(tas2) self.assertIsNone(self.cat.get_layergroup("tasmania_reloaded")) self.assertIsNotNone( self.cat.get_layergroup("tasmania_reloaded", "topp")) tas2 = self.cat.get_layergroup("tasmania_reloaded", "topp") self.assertEqual("tasmania_reloaded", tas2.name) self.assertIsInstance(tas2, LayerGroup) self.assertEqual(tas2.workspace, "topp", tas2.workspace) self.assertEqual(tas2.layers, [ 'tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities' ], tas2.layers) self.assertEqual(tas2.styles, [None, None, None, None], tas2.styles) def testStyles(self): self.assertEqual("population", self.cat.get_style("population").name) self.assertEqual("popshade.sld", self.cat.get_style("population").filename) self.assertEqual("population", self.cat.get_style("population").sld_name) self.assertIsNone(self.cat.get_style('non-existing-style')) def testEscaping(self): # GSConfig is inconsistent about using exceptions vs. returning None # when a resource isn't found. # But the basic idea is that none of them should throw HTTP errors from # misconstructed URLS self.cat.get_style("best style ever") self.cat.get_workspace("best workspace ever") self.assertEqual( self.cat.get_store(workspace="best workspace ever", name="best store ever"), None) self.cat.get_layer("best layer ever") self.cat.get_layergroup("best layergroup ever") def testUnicodeUrl(self): """ Tests that the geoserver.support.url function support unicode strings. """ # Test the url function with unicode seg = [ 'workspaces', 'test', 'datastores', u'operaci\xf3n_repo', 'featuretypes.xml' ] u = url(base=self.cat.service_url, seg=seg) self.assertEqual( u, self.cat.service_url + "/workspaces/test/datastores/operaci%C3%B3n_repo/featuretypes.xml") # Test the url function with normal string seg = [ 'workspaces', 'test', 'datastores', 'test-repo', 'featuretypes.xml' ] u = url(base=self.cat.service_url, seg=seg) self.assertEqual( u, self.cat.service_url + "/workspaces/test/datastores/test-repo/featuretypes.xml")
class CatalogTests(unittest.TestCase): def setUp(self): self.cat = Catalog(GSPARAMS['GSURL'], username=GSPARAMS['GSUSER'], password=GSPARAMS['GSPASSWORD']) def testAbout(self): about_html = self.cat.about() self.assertTrue('<html xmlns="http://www.w3.org/1999/xhtml"' in about_html) def testGSVersion(self): version = self.cat.gsversion() pat = re.compile('\d\.\d(\.[\dx]|-SNAPSHOT)') self.assertTrue(pat.match('2.2.x')) self.assertTrue(pat.match('2.3.2')) self.assertTrue(pat.match('2.3-SNAPSHOT')) self.assertFalse(pat.match('2.3.y')) self.assertFalse(pat.match('233')) self.assertTrue(pat.match(version)) def testWorkspaces(self): self.assertEqual(7, len(self.cat.get_workspaces())) # marking out test since geoserver default workspace is not consistent # self.assertEqual("cite", self.cat.get_default_workspace().name) self.assertEqual("topp", self.cat.get_workspace("topp").name) def testStores(self): topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") self.assertEqual(9, len(self.cat.get_stores())) self.assertEqual(2, len(self.cat.get_stores(topp))) self.assertEqual(2, len(self.cat.get_stores(sf))) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile", topp).name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile").name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile").name) self.assertEqual("sfdem", self.cat.get_store("sfdem", sf).name) self.assertEqual("sfdem", self.cat.get_store("sfdem").name) def testResources(self): topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") states = self.cat.get_store("states_shapefile", topp) sfdem = self.cat.get_store("sfdem", sf) self.assertEqual(19, len(self.cat.get_resources())) self.assertEqual(1, len(self.cat.get_resources(states))) self.assertEqual(5, len(self.cat.get_resources(workspace=topp))) self.assertEqual(1, len(self.cat.get_resources(sfdem))) self.assertEqual(6, len(self.cat.get_resources(workspace=sf))) self.assertEqual("states", self.cat.get_resource("states", states).name) self.assertEqual("states", self.cat.get_resource("states", workspace=topp).name) self.assertEqual("states", self.cat.get_resource("states").name) states = self.cat.get_resource("states") fields = [ states.title, states.abstract, states.native_bbox, states.latlon_bbox, states.projection, states.projection_policy ] self.assertFalse(None in fields, str(fields)) self.assertFalse(len(states.keywords) == 0) self.assertFalse(len(states.attributes) == 0) self.assertTrue(states.enabled) self.assertEqual("sfdem", self.cat.get_resource("sfdem", sfdem).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem", workspace=sf).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem").name) def testResourcesUpdate(self): res_dest = self.cat.get_resources() count = 0 for rd in res_dest: # only wms layers if rd.resource_type != "wmsLayer": continue # looking for same name ro = self.cat.get_resource(rd.name) if ro is not None: rd.title = ro.title rd.abstract = ro.abstract rd.keywords = ro.keywords rd.projection = ro.projection rd.native_bbox = ro.native_bbox rd.latlon_bbox = ro.latlon_bbox rd.projection_policy = ro.projection_policy rd.enabled = ro.enabled rd.advertised = ro.advertised rd.metadata_links = ro.metadata_links or None self.cat.save(rd) self.cat.reload() # print "Updated layer: " + rd.name count += 1 # print "Total updated layers: " + str(count) def testLayers(self): expected = set(["Arc_Sample", "Pk50095", "Img_Sample", "mosaic", "sfdem", "bugsites", "restricted", "streams", "archsites", "roads", "tasmania_roads", "tasmania_water_bodies", "tasmania_state_boundaries", "tasmania_cities", "states", "poly_landmarks", "tiger_roads", "poi", "giant_polygon" ]) actual = set(l.name for l in self.cat.get_layers()) missing = expected - actual extras = actual - expected message = "Actual layer list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) states = self.cat.get_layer("states") self.assert_("states", states.name) self.assert_(isinstance(states.resource, ResourceInfo)) self.assertEqual(set(s.name for s in states.styles), set(['pophatch', 'polygon'])) self.assertEqual(states.default_style.name, "population") def testLayerGroups(self): expected = set(["tasmania", "tiger-ny", "spearfish"]) actual = set(l.name for l in self.cat.get_layergroups()) missing = expected - actual extras = actual - expected message = "Actual layergroup list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) tas = self.cat.get_layergroup("tasmania") self.assert_("tasmania", tas.name) self.assert_(isinstance(tas, LayerGroup)) self.assertEqual(tas.layers, ['tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities'], tas.layers) self.assertEqual(tas.styles, [None, None, None, None], tas.styles) # Try to create a new Layer Group into the "topp" workspace self.assert_(self.cat.get_workspace("topp") is not None) tas2 = self.cat.create_layergroup("tasmania_reloaded", tas.layers, workspace = "topp") self.cat.save(tas2) self.assert_(self.cat.get_layergroup("tasmania_reloaded") is None) self.assert_(self.cat.get_layergroup("tasmania_reloaded", "topp") is not None) tas2 = self.cat.get_layergroup("tasmania_reloaded", "topp") self.assert_("tasmania_reloaded", tas2.name) self.assert_(isinstance(tas2, LayerGroup)) self.assertEqual(tas2.workspace, "topp", tas2.workspace) self.assertEqual(tas2.layers, ['tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities'], tas2.layers) self.assertEqual(tas2.styles, [None, None, None, None], tas2.styles) def testStyles(self): self.assertEqual("population", self.cat.get_style("population").name) self.assertEqual("popshade.sld", self.cat.get_style("population").filename) self.assertEqual("population", self.cat.get_style("population").sld_name) self.assert_(self.cat.get_style('non-existing-style') is None) def testEscaping(self): # GSConfig is inconsistent about using exceptions vs. returning None # when a resource isn't found. # But the basic idea is that none of them should throw HTTP errors from # misconstructed URLS self.cat.get_style("best style ever") self.cat.get_workspace("best workspace ever") try: self.cat.get_store(workspace="best workspace ever", name="best store ever") self.fail('expected exception') except FailedRequestError, fre: self.assertEqual('No store found named: best store ever', fre.message) try: self.cat.get_resource(workspace="best workspace ever", store="best store ever", name="best resource ever") except FailedRequestError, fre: self.assertEqual('No store found named: best store ever', fre.message)
class GsConn: def __init__(self, host, login, password, debug=False): """ Geoserver connection """ self.host = host self.login = login self.password = password self.debug = debug # Connect to server self.cat = Catalog("http://%s/geoserver/rest" % host, login, password) if self.debug is True: print "Connected to geoserver" def crate_workspace(self, name, overwrite=False): """ Creates a workspace :param name: Workspace name. :param overwrite: If True, delete existing workspace. :return: None """ workspaces = [workspace.name for workspace in self.cat.get_workspaces()] if name in workspaces and overwrite is True: # ws2del = self.cat.get_workspace(name) # self.cat.delete(ws2del, purge=True, recurse=True) return None # NOTE: If we delete the workspace then all associated layers are lost. elif name in workspaces and overwrite is False: print "ERROR: Workspace %s already exists (use overwrite=True)." % name self.cat.create_workspace(name, "http://%s/%s" % (self.host, name)) if self.debug is True: print "Workspace %s available." % name ws = self.cat.get_workspace(name) ws.enabled = True def create_pg_store(self, name, workspace, host, port, login, password, dbname, schema, overwrite=False): """ Creates datastore. :param name: Name of the datastore. :param workspace: Name of the workspace to use. :param overwrite: If True replace datastore. :return: None """ stores = [store.name for store in self.cat.get_stores()] if name in stores and overwrite is True: # st2del = self.cat.get_store(name) # self.cat.delete(st2del, purge=True, recurse=True) # self.cat.reload() return None # NOTE: If we delete store, every layers associated with are lost. elif name in stores and overwrite is False: print "ERROR: Store %s already exists (use overwrite=True)." % name ds = self.cat.create_datastore(name, workspace) ds.connection_parameters.update( host=host, port=port, user=login, passwd=password, dbtype="postgis", database=dbname, schema=schema ) self.cat.save(ds) ds = self.cat.get_store(name) if ds.enabled is False: print "ERROR: Geoserver store %s not enabled" % name if self.debug is True: print "Datastore %s created." % name def publish_pg_layer(self, layer_table, layer_name, store, srid, overwrite=True): """ """ existing_lyr = self.cat.get_layer("ma_carte:%s" % layer_table) if existing_lyr is not None: print "Layer ma_carte:%s already exists, deleting it." % layer_table self.cat.delete(existing_lyr) self.cat.reload() ds = self.cat.get_store(store) ft = self.cat.publish_featuretype(layer_table, ds, "EPSG:%s" % srid, srs="EPSG:4326") ft.projection_policy = "REPROJECT_TO_DECLARED" ft.title = layer_name self.cat.save(ft) if ft.enabled is False: print "ERROR: Layer %s %s %s is not enabled."(ft.workspace.name, ft.store.name, ft.title) if self.debug is True: print "Layer %s>%s>%s published." % (ft.workspace.name, ft.store.name, ft.title) def create_style_from_sld(self, style_name, sld_file, workspace, overwrite=True): """ """ if self.cat.get_style(style_name) is not None: print "Style %s already exists, deleting it." % style_name style2del = self.cat.get_style(style_name) self.cat.delete(style2del) self.cat.create_style( style_name, open(sld_file).read(), overwrite=overwrite ) # FIXME: if ", workspace=workspace" specified can't delete style if self.debug is True: print "Style %s created in Geoserver" % style_name def apply_style_to_layer(self, layer_name, style_name): """ Apply a geoserver styler to a layer """ gs_layer = self.cat.get_layer(layer_name) gs_style = self.cat.get_style(style_name) # FIXME: Which works better? # gs_layer.default_style = gs_style / gs_layer._set_default_style(gs_style) # FIXME: Maybe indicate workspace when saving style then name the style as "workspace:style" gs_layer._set_default_style(gs_style) self.cat.save(gs_layer) if self.debug is True: print "Style applied to %s" % layer_name
class GsConn(): def __init__(self, host, login, password, debug=False): """ Geoserver connection """ self.host = host self.login = login self.password = password self.debug = debug # Connect to server self.cat = Catalog("http://%s/geoserver/rest" % host, login, password) if self.debug is True: print "Connected to geoserver" def crate_workspace(self, name, uri, overwrite=False): """ Creates a workspace :param name: Workspace name. :param overwrite: If True, delete existing workspace. :return: None """ workspaces = [ workspace.name for workspace in self.cat.get_workspaces() ] if name in workspaces and overwrite is True: # ws2del = self.cat.get_workspace(name) # self.cat.delete(ws2del, purge=True, recurse=True) return None # NOTE: If we delete the workspace then all associated layers are lost. elif name in workspaces and overwrite is False: print "ERROR: Workspace %s already exists (use overwrite=True)." % name self.cat.create_workspace(name, uri) if self.debug is True: print "Workspace %s available." % name ws = self.cat.get_workspace(name) ws.enabled = True def create_pg_store(self, name, workspace, host, port, login, password, dbname, schema, overwrite=False): """ Creates datastore. :param name: Name of the datastore. :param workspace: Name of the workspace to use. :param overwrite: If True replace datastore. :return: None """ stores = [store.name for store in self.cat.get_stores()] if name in stores and overwrite is True: # st2del = self.cat.get_store(name) # self.cat.delete(st2del, purge=True, recurse=True) # self.cat.reload() return None # NOTE: If we delete store, every layers associated with are lost. elif name in stores and overwrite is False: print "ERROR: Store %s already exists (use overwrite=True)." % name ds = self.cat.create_datastore(name, workspace) ds.connection_parameters.update(host=host, port=port, user=login, passwd=password, dbtype='postgis', database=dbname, schema=schema) self.cat.save(ds) ds = self.cat.get_store(name) if ds.enabled is False: print "ERROR: Geoserver store %s not enabled" % name if self.debug is True: print "Datastore %s created." % name def publish_pg_layer(self, layer_table, layer_name, store, srid, overwrite=True): """ """ existing_lyr = self.cat.get_layer("participatubes:%s" % layer_table) if existing_lyr is not None: print "Layer participatubes:%s already exists, deleting it." % layer_table self.cat.delete(existing_lyr) self.cat.reload() ds = self.cat.get_store(store) ft = self.cat.publish_featuretype(layer_table, ds, 'EPSG:%s' % srid, srs='EPSG:4326') ft.projection_policy = "REPROJECT_TO_DECLARED" ft.title = layer_name self.cat.save(ft) if ft.enabled is False: print "ERROR: Layer %s %s %s is not enabled." (ft.workspace.name, ft.store.name, ft.title) if self.debug is True: print "Layer %s>%s>%s published." % (ft.workspace.name, ft.store.name, ft.title) def create_style_from_sld(self, style_name, sld_file, workspace, overwrite=True): """ """ if self.cat.get_style(style_name) is not None: print "Style %s already exists, deleting it." % style_name style2del = self.cat.get_style(style_name) self.cat.delete(style2del) self.cat.create_style( style_name, open(sld_file).read(), overwrite=overwrite ) # FIXME: if ", workspace=workspace" specified can't delete style if self.debug is True: print "Style %s created in Geoserver" % style_name def apply_style_to_layer(self, layer_name, style_name): """ Apply a geoserver styler to a layer """ gs_layer = self.cat.get_layer(layer_name) gs_style = self.cat.get_style(style_name) # FIXME: Which works better? # gs_layer.default_style = gs_style / gs_layer._set_default_style(gs_style) # FIXME: Maybe indicate workspace when saving style then name the style as "workspace:style" gs_layer._set_default_style(gs_style) self.cat.save(gs_layer) if self.debug is True: print "Style applied to %s" % layer_name
class wrap_geoserver: """ Geoserver (gsconfig) wrapper """ def __init__(self, geoserver_name, username=username, password=password, easy=False): if geoserver_name in list(REST.keys()): self.path = REST[geoserver_name] else: self.path = geoserver_name self.wms = self.path.replace("rest/", "wms") self.name = geoserver_name self.catalog = Catalog(self.path, username, password) if not easy: self.layers = [] self.layer_names = [] for layer in self.catalog.get_layers(): self.layers.append(layer) self.layer_names.append(layer.name) self.stores = [store for store in self.catalog.get_stores()] self.store_names = [store.name for store in self.stores] styles = [] self.workspaces = [] self.workspace_names = [] for workspace in self.catalog.get_workspaces(): styles = styles + self.catalog.get_styles(workspace) self.workspace_names.append(workspace._name) self.workspaces.append(workspace) self.styles = styles + [ style for style in self.catalog.get_styles() ] self.style_names = [style.name for style in self.styles] def unpack(self, workspace_name, store_type="datastore"): layers_and_styles = {} features = [] workspace = self.get_workspace(workspace_name) if store_type == "datastore": store_url = workspace.datastore_url elif store_type == "coveragestore": store_url = workspace.coveragestore_url else: print("No correct store given") for datastore in tqdm(get(store_url, "name")): url = "{}workspaces/{}/datastores/{}".format( self.path, workspace.name, datastore) features = features + get(url, between_quotes=True) for feature in features: layer_name = os.path.basename(feature).split(".")[0] self.get_layer(self.get_slug(workspace.name, layer_name)) layers_and_styles[layer_name] = self.layer.default_style setattr(self, workspace_name + "_data", layers_and_styles) return layers_and_styles def get_layer(self, layer, easy=False): self.layer = self.catalog.get_layer(layer) if not easy: self.resource = self.layer.resource self.layer_name = self.layer.resource.name self.sld_name = self.layer.default_style.name self.sld_body = self.layer.default_style.sld_body self.layer_latlon_bbox = self.layer.resource.latlon_bbox self.layer_title = self.layer.resource.title self.layer_abstract = self.layer.resource.abstract def get_store(self, layer): self.store = self.layer.resource._store def get_resource(self): self.resource = self.catalog.get_resource(self.layer.name, self.store) def get_workspace(self, workspace_name): self.workspace = self.catalog.get_workspace(workspace_name) self.workspace_name = self.workspace._name return self.workspace def write_abstract(self, data, load_resource=True): if load_resource: self.get_resource() self.resource.abstract = data self.catalog.save(self.resource) def write_title(self, title): self.resource.title = title self.catalog.save(self.resource) def get_connection_parameters(self): self.get_resource() return self.resource.store.connection_parameters def create_workspace(self, workspace_name): workspace_exists = workspace_name in self.workspace_names if not workspace_exists: self.workspace = self.catalog.create_workspace(workspace_name) else: print("workspace already exists, using existing workspace") self.workspace = self.catalog.get_workspace(workspace_name) self.workspace_name = workspace_name def create_postgis_datastore(self, store_name, workspace_name, pg_data): try: self.store = self.catalog.get_store(store_name, self.workspace_name) print("store within workspace exists, using existing store") except Exception as e: print(e) ds = self.catalog.create_datastore(store_name, workspace_name) ds.connection_parameters.update( host=pg_data["host"], port=pg_data["port"], database=pg_data["database"], user=pg_data["username"], passwd=pg_data["password"], dbtype="postgis", schema="public", ) self.save(ds) self.store = self.catalog.get_store(store_name, self.workspace_name) self.store_name = store_name def publish_layer(self, layer_name, workspace_name, overwrite=False, epsg="3857", reload=False): layer_exists = layer_name in self.layer_names # if layer_name in self.workspace_layers[workspace_name]: slug = self.get_slug(workspace_name, layer_name) if overwrite and layer_exists: print("Layer exists, deleting layer") try: self.layer = self.catalog.get_layer(slug) self.delete(self.layer) self.reload() layer_exists = False except Exception as e: print(e) print("Layer does not exist in workspace") layer_exists = False if not layer_exists: feature_type = self.catalog.publish_featuretype( layer_name, self.store, "EPSG:{}".format(str(epsg)), srs="EPSG:{}".format(str(epsg)), ) self.save(feature_type) self.feature_type = feature_type else: print("layer already exists, using existing layer") if reload: self.get_layer(slug) self.layer_name = layer_name def publish_layergroup(self, name, layers, styles=(), bounds=None, workspace=None): layer_group = self.catalog.create_layergroup(name, layers, styles, bounds, workspace) self.save(layer_group) def save(self, save_object): return self.catalog.save(save_object) def close(self): self.catalog = None def delete(self, delete_object): self.catalog.delete(delete_object) def reload(self): self.catalog.reload() def upload_shapefile(self, layer_name, shapefile_path): path = shapefile_path.split(".shp")[0] shapefile = shapefile_and_friends(path) ft = self.catalog.create_featurestore(layer_name, shapefile, self.workspace) self.save(ft) def upload_sld(self, sld_name, workspace_name, sld, overwrite=True): style_exists = sld_name in self.style_names if overwrite and style_exists: print("Overwriting style") style = self.catalog.get_style(sld_name, workspace_name) self.delete(style) self.reload() style_exists = False if not style_exists: try: self.catalog.create_style(sld_name, sld, False, workspace_name, "sld11") except Exception as e: print(e) style = self.catalog.get_style(sld_name, workspace_name) self.delete(style) self.reload() self.catalog.create_style(sld_name, sld, False, workspace_name, "sld10") self.style_name = sld_name else: if style_exists: print("Style already exists, using current style") self.style_name = sld_name def set_sld_for_layer(self, workspace_name=None, style_name=None, use_custom=False): if not use_custom: workspace_name = self.workspace_name style_name = self.style_name self.style_slug = self.get_slug(workspace_name, style_name) else: if workspace_name is None: self.style_slug = style_name else: self.style_slug = self.get_slug(workspace_name, style_name) self.style = self.catalog.get_style(self.style_slug) print("Setting {} for {}".format(self.style.name, self.layer.name)) self.layer.default_style = self.style self.save(self.layer) def get_slug(self, workspace, name): return "{}:{}".format(workspace, name) def get_slug_data(self, slug): workspace_name = slug.split(":")[0] layer_name = slug.split(":")[1] return workspace_name, layer_name def get_sld(self, layer_slug=None): if layer_slug is None: self.style = self.catalog.get_style(self.layer_slug) else: self.style = self.catalog.get_style(layer_slug) self.sld_body = self.style.sld_body return self.sld_body def get_layer_workspace(self, layer_name): return self.catalog.get_layer(layer_name).resource.workspace.name
def processAlgorithm(self, parameters, context, model_feedback): """ Process the algorithm :param parameters: parameters of the process :param context: context of the process :param model_feedback: feedback instance for the process :return: """ # Use a multi-step feedback, so that individual child algorithm progress reports are adjusted for the # overall progress through the model self.xml_path = parameters["XML_PATH"] if not self.xml_path.lower().endswith(".xml"): feedback = QgsProcessingMultiStepFeedback(0, model_feedback) feedback.reportError( "XML Workspace Definition is not an XML file!", True) return {} db_name = parameters["DB_NAME"] db_params = self.get_db_params(db_name) store_name = parameters["GS_STORE"] wrk_name = parameters["GS_WORKSPACE"] dataset_list = [] datasets = self.getDatasets() for dataset in datasets: type = dataset.getElementsByTagName( TAG_DE_TYPE)[0].childNodes[0].data if type == "esriDTFeatureClass": ds_name = dataset.getElementsByTagName( TAG_DE_NAME)[0].childNodes[0].data dataset_list.append({ "name": ds_name.lower(), "srs": "EPSG:4326" }) feedback = QgsProcessingMultiStepFeedback(2 + len(dataset_list), model_feedback) feedback.pushInfo("Get GeoServer Catalog: " + parameters["GS_REST_URL"]) gs_catalogue = Catalog(parameters["GS_REST_URL"], parameters["GS_ADMIN"], parameters["GS_PASSWORD"]) # workspace if wrk_name == "" or wrk_name is None: wrk_name = db_name.lower() + "_ws" wrk_uri = "http://" + wrk_name feedback.pushInfo("GeoServer Workspace: " + wrk_name + " (" + wrk_uri + ")") workspace = gs_catalogue.get_workspace(wrk_name) if workspace is None: workspace = gs_catalogue.create_workspace(wrk_name, wrk_uri) feedback.setCurrentStep(1) # store if store_name == "" or store_name is None: store_name = db_name.lower() + "_ds" feedback.pushInfo("GeoServer Data Store: " + store_name) store = gs_catalogue.get_store(store_name, workspace) if store is None: store = gs_catalogue.create_datastore(store_name, workspace) store.connection_parameters.update(**db_params) gs_catalogue.save(store) feedback.setCurrentStep(2) step = 2 published_count = 0 layer_prefix = "v_" for ds_cur in dataset_list: layer_name = layer_prefix + ds_cur["name"] feedback.pushInfo("GeoServer Publish: " + layer_name + " (" + ds_cur["srs"] + ")") try: layer = gs_catalogue.get_layer(layer_name) if layer is not None: gs_catalogue.delete(layer) gs_catalogue.save() gs_catalogue.publish_featuretype(layer_name, store, ds_cur["srs"]) published_count += 1 except Exception as e: feedback.reportError("Error: " + str(e), False) step += 1 feedback.setCurrentStep(step) gs_catalogue.reload() layers = gs_catalogue.get_layers(store) feedback.pushInfo("-" * 80) feedback.pushInfo("Published layers: " + str(published_count)) for layer in layers: feedback.pushInfo(layer.name + " is published!") feedback.pushInfo("-" * 80) results = {} outputs = {} return results
from config import get_config from geoserver.catalog import Catalog geoserver = Catalog( get_config('geoserver.restUrl'), get_config('geoserver.user'), get_config('geoserver.password'), ) # create workspace if not exists, a workspace is mandatory to work with geoserver workspace_name = get_config('geoserver.workspace') workspace = geoserver.get_workspace(workspace_name) if workspace is None: geoserver.create_workspace( workspace_name, get_config('geoserver.hostUrl') + workspace_name) geoserver.reload() geoserver_connection = geoserver workspace_obj = workspace
class CatalogTests(unittest.TestCase): def setUp(self): self.cat = Catalog(GSPARAMS['GSURL'], username=GSPARAMS['GSUSER'], password=GSPARAMS['GSPASSWORD']) self.gs_version = self.cat.get_short_version() def testGSVersion(self): version = self.cat.get_version() pat = re.compile('\d\.\d+') self.assertTrue(pat.match('2.2.x')) self.assertTrue(pat.match('2.3.2')) self.assertTrue(pat.match('2.3-SNAPSHOT')) self.assertTrue(pat.match(version)) def testWorkspaces(self): self.assertEqual(7, len(self.cat.get_workspaces())) # marking out test since geoserver default workspace is not consistent # self.assertEqual("cite", self.cat.get_default_workspace().name) self.assertEqual("topp", self.cat.get_workspaces(names="topp")[-1].name) self.assertEqual(2, len(self.cat.get_workspaces(names=['topp', 'sde']))) self.assertEqual(2, len(self.cat.get_workspaces(names='topp, sde'))) self.assertEqual("topp", self.cat.get_workspace("topp").name) self.assertIsNone(self.cat.get_workspace("blahblah-")) def testStores(self): self.assertEqual(0, len(self.cat.get_stores(names="nonexistentstore"))) topp = self.cat.get_workspaces("topp")[0] sf = self.cat.get_workspaces("sf")[0] self.assertEqual(9, len(self.cat.get_stores())) self.assertEqual(2, len(self.cat.get_stores(workspaces=topp))) self.assertEqual(2, len(self.cat.get_stores(workspaces=sf))) self.assertEqual(2, len(self.cat.get_stores(workspaces='sf'))) self.assertEqual(2, len(self.cat.get_stores(names='states_shapefile, sfdem'))) self.assertEqual(2, len(self.cat.get_stores(names=['states_shapefile', 'sfdem']))) self.assertEqual("states_shapefile", self.cat.get_stores(names="states_shapefile", workspaces=topp.name)[0].name) self.assertEqual("states_shapefile", self.cat.get_stores(names="states_shapefile")[0].name) self.assertEqual("sfdem", self.cat.get_stores(names="sfdem", workspaces=sf.name)[0].name) self.assertEqual("sfdem", self.cat.get_stores(names="sfdem")[0].name) self.assertEqual("sfdem", self.cat.get_store("sfdem").name) self.assertIsNone(self.cat.get_store("blah+blah-")) def testResources(self): topp = self.cat.get_workspaces("topp")[0] sf = self.cat.get_workspaces("sf")[0] states = self.cat.get_stores(names="states_shapefile", workspaces=topp.name)[0] sfdem = self.cat.get_stores(names="sfdem", workspaces=sf.name)[0] self.assertEqual(19, len(self.cat.get_resources())) self.assertEqual(2, len(self.cat.get_resources(stores=[states.name, sfdem.name]))) self.assertEqual(11, len(self.cat.get_resources(workspaces=[topp.name, sf.name]))) self.assertEqual("states", self.cat.get_resources(names="states", stores=states.name)[0].name) self.assertEqual("states", self.cat.get_resources(names="states", workspaces=topp.name)[0].name) self.assertEqual("states", self.cat.get_resources(names="states")[0].name) self.assertEqual("states", self.cat.get_resource("states").name) self.assertIsNone(self.cat.get_resource("blah+1blah-2")) states = self.cat.get_resources(names="states")[0] fields = [ states.title, states.abstract, states.native_bbox, states.latlon_bbox, states.projection, states.projection_policy ] self.assertFalse(None in fields, str(fields)) self.assertFalse(len(states.keywords) == 0) self.assertFalse(len(states.attributes) == 0) self.assertTrue(states.enabled) self.assertEqual("sfdem", self.cat.get_resources(names="sfdem", stores=sfdem.name)[0].name) self.assertEqual("sfdem", self.cat.get_resources(names="sfdem", workspaces=sf.name)[0].name) self.assertEqual("sfdem", self.cat.get_resources(names="sfdem")[0].name) def testResourcesUpdate(self): res_dest = self.cat.get_resources() count = 0 for rd in res_dest: # only wms layers if rd.resource_type != "wmsLayer": continue # looking for same name ro = self.cat.get_resources(names=rd.name) if ro is not None: rd.title = ro.title rd.abstract = ro.abstract rd.keywords = ro.keywords rd.projection = ro.projection rd.native_bbox = ro.native_bbox rd.latlon_bbox = ro.latlon_bbox rd.projection_policy = ro.projection_policy rd.enabled = ro.enabled rd.advertised = ro.advertised rd.metadata_links = ro.metadata_links or None self.cat.save(rd) self.cat.reload() count += 1 def testLayers(self): if self.gs_version >= "2.13": expected = set([ 'sf:roads', 'sf:sfdem', 'nurc:mosaic', 'tiger:giant_polygon', 'sf:bugsites', 'topp:states', 'sf:streams', 'tiger:poly_landmarks', 'tiger:poi', 'topp:tasmania_water_bodies', 'tiger:tiger_roads', 'topp:tasmania_roads', 'nurc:Pk50095', 'topp:tasmania_cities', 'nurc:Img_Sample', 'sf:restricted', 'nurc:Arc_Sample', 'sf:archsites', 'topp:tasmania_state_boundaries' ]) else: expected = set([ "Arc_Sample", "Pk50095", "Img_Sample", "mosaic", "sfdem", "bugsites", "restricted", "streams", "archsites", "roads", "tasmania_roads", "tasmania_water_bodies", "tasmania_state_boundaries", "tasmania_cities", "states", "poly_landmarks", "tiger_roads", "poi", "giant_polygon" ]) actual = set(l.name for l in self.cat.get_layers()) missing = expected - actual extras = actual - expected message = "Actual layer list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) states = self.cat.get_layer("states") self.assert_("states", states.name) self.assert_(isinstance(states.resource, ResourceInfo)) self.assertEqual(set(s.name for s in states.styles), set(['pophatch', 'polygon'])) self.assertEqual(states.default_style.name, "population") def testLayerGroups(self): expected = set(["tasmania", "tiger-ny", "spearfish"]) actual = set(l.name for l in self.cat.get_layergroups(names=["tasmania", "tiger-ny", "spearfish"])) missing = expected - actual extras = actual - expected message = "Actual layergroup list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) tas = self.cat.get_layergroups(names="tasmania")[0] self.assert_("tasmania", tas.name) self.assert_(isinstance(tas, LayerGroup)) if self.gs_version >= "2.13": self.assertEqual(tas.layers, [ 'topp:tasmania_state_boundaries', 'topp:tasmania_water_bodies', 'topp:tasmania_roads', 'topp:tasmania_cities' ], tas.layers) else: self.assertEqual(tas.layers, [ 'tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities' ], tas.layers) self.assertEqual(tas.styles, [None, None, None, None], tas.styles) # Try to create a new Layer Group into the "topp" workspace self.assert_(self.cat.get_workspaces("topp")[0] is not None) tas2 = self.cat.create_layergroup("tasmania_reloaded", tas.layers, workspace = "topp") self.cat.save(tas2) self.assertEqual(1, len(self.cat.get_layergroups(names='tasmania_reloaded', workspaces="topp"))) tas2 = self.cat.get_layergroups(names='tasmania_reloaded', workspaces="topp")[0] self.assert_("tasmania_reloaded", tas2.name) self.assert_(isinstance(tas2, LayerGroup)) self.assertEqual(tas2.workspace, "topp", tas2.workspace) if self.gs_version >= "2.13": self.assertEqual(tas2.layers, [ 'topp:tasmania_state_boundaries', 'topp:tasmania_water_bodies', 'topp:tasmania_roads', 'topp:tasmania_cities' ], tas2.layers) else: self.assertEqual(tas2.layers, [ 'tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities' ], tas2.layers) self.assertEqual(tas2.styles, [None, None, None, None], tas2.styles) def testStyles(self): self.assertEqual("population", self.cat.get_styles("population")[0].name) self.assertEqual("popshade.sld", self.cat.get_styles("population")[0].filename) self.assertEqual("population", self.cat.get_styles("population")[0].sld_name) self.assertEqual("population", self.cat.get_style("population").sld_name) self.assertIsNone(self.cat.get_style("blah+#5blah-")) self.assertEqual(0, len(self.cat.get_styles('non-existing-style'))) def testEscaping(self): # GSConfig is inconsistent about using exceptions vs. returning None # when a resource isn't found. # But the basic idea is that none of them should throw HTTP errors from # misconstructed URLS self.cat.get_styles("best style ever") self.cat.get_workspaces("best workspace ever") self.assertEqual(0, len(self.cat.get_stores(workspaces="best workspace ever", names="best store ever"))) self.cat.get_layer("best layer ever") self.cat.get_layergroups("best layergroup ever") def testUnicodeUrl(self): """ Tests that the geoserver.support.url function support unicode strings. """ # Test the url function with unicode seg = ['workspaces', 'test', 'datastores', u'operaci\xf3n_repo', 'featuretypes.xml'] u = build_url(base=self.cat.service_url, seg=seg) self.assertEqual(u, self.cat.service_url + "/workspaces/test/datastores/operaci%C3%B3n_repo/featuretypes.xml") # Test the url function with normal string seg = ['workspaces', 'test', 'datastores', 'test-repo', 'featuretypes.xml'] u = build_url(base=self.cat.service_url, seg=seg) self.assertEqual(u, self.cat.service_url + "/workspaces/test/datastores/test-repo/featuretypes.xml")
class GeoserverLayers(object): def __init__(self, gs_apirest, username, password): try: self.__catalog = Catalog(gs_apirest, username=username, password=password) except Exception as err: print("Geoserver API Rest Error: {0}".format(err)) def __createSldStyle(self, sldpath, stylename, ovwrt=False): try: styles_list = [st.name for st in self.__catalog.get_styles()] if ovwrt or not stylename in styles_list: with open(sldpath) as f: self.__catalog.create_style(stylename, f.read(), overwrite=ovwrt) else: print("This style already exists...") except Exception as err: print("Geoserver API Rest Error creating new style: {0}".format(err)) def __rmvResources(self, rsrc): """ Removing resources """ self.__catalog.delete(rsrc) self.__catalog.reload() def rmvStyle(self, stylename): """ Remove style """ try: style = self.__catalog.get_style(stylename) self.__rmvResources(style) except Exception as err: print("Geoserver API Rest Error removing style: {0}".format(err)) def rmvDataStore(self, ds_store): """ Remove DataStore (with his layer) """ try: lay_rm = self.__catalog.get_layer(ds_store) self.__rmvResources(lay_rm) str_rm = self.__catalog.get_store(ds_store) self.__rmvResources(str_rm) except Exception as err: print("Geoserver API Rest Error removing data store: {0}".format(err)) def createGeoserverWMSLayer(self, data, ws_name, ds_name, stylename, sldpath, debug=False): """ Create Geoserver WMS layer Status codes: 2 : "Geoserver layer successfully created" -1 : "Workspace does not exist" -2 : "Datastore already exists" -3 : "Error creating Geoserver layer" -4 : "File missing" """ try: if not self.__catalog.get_workspace(ws_name): print("Workspace does not exist") return -1 ds_list = [i.name for i in self.__catalog.get_stores()] if ds_name in ds_list: print("Datastore already exists") return -2 ds = self.__catalog.create_datastore(ds_name, ws_name) ft = self.__catalog.create_featurestore(ds_name, workspace=ws_name,data=data) print("Geoserver layer successfully created...") self.__createSldStyle(sldpath, stylename) lyr = self.__catalog.get_layer(ds_name) lyr.enabled = True lyr.default_style = stylename self.__catalog.save(lyr) if debug: rsrc = self.__catalog.get_resource(ds_name, workspace=ws_name) print("Data Store XML: {}".format(rsrc.href)) return 2 except Exception as err: print("Geoserver API Rest Error creating new layer: {0}".format(err)) return -3
def preprogress(id): def getUploadFile(uploadfolder): try: uploadfiles = os.listdir(uploadfolder) # 上传的文件夹 while(len(uploadfiles)==1): uploadfolder=os.path.join(uploadfolder,uploadfiles[0]) uploadfiles=os.listdir(uploadfolder) for file in uploadfiles: if(file[-11:]=='_fusion.tif'):#融合图 fusionname=file capture_time=re.match('[\w\_\.]+_(\d{8})_',fusionname).group(1) Bmap.objects.filter(id=id).update(capture_time=time.strftime('%Y-%m-%d',time.strptime(capture_time,'%Y%m%d'))) # elif re.search(r'PAN\d.jpg',file):#缩略图 # thumbnailname=file # elif re.search(r'PAN\d.xml',file):#XML # XMLname=file elif re.search(r'_rpc.txt',file):#RPC rpcfile=file # elif re.search(r'MSS\d.rpb',file): # rpbfile=file return uploadfolder,fusionname,rpcfile except Exception as e: return Exception("上传失败,请检查地图名称!") ####转8比特三通道,生成缩略图 def chaneltransform(): try: fusionimage=os.path.join(uploadfiles[0],uploadfiles[1]) gdal.AllRegister() driver = gdal.GetDriverByName("GTiff") fusionimage = gdal.Open(fusionimage.encode('utf-8').decode(), gdal.GA_ReadOnly) im_width = fusionimage.RasterXSize im_height = fusionimage.RasterYSize transformimage = os.path.join(uploadfiles[0],"chaneltransform.tif") dstDS = driver.Create(transformimage, xsize=im_width, ysize=im_height, bands=3, eType=gdal.GDT_Byte) thumbnail=np.zeros(shape=(int(im_height*0.02),int(im_width*0.02),3)) for iband in range(1, 4): imgMatrix = fusionimage.GetRasterBand(iband).ReadAsArray(0, 0, im_width, im_height) zeros = np.size(imgMatrix) - np.count_nonzero(imgMatrix) minVal = np.percentile(imgMatrix, float(zeros / np.size(imgMatrix) * 100 + 0.15)) maxVal = np.percentile(imgMatrix, 99) idx1 = imgMatrix < minVal idx2 = imgMatrix > maxVal idx3 = ~idx1 & ~idx2 imgMatrix[idx1] = imgMatrix[idx1] * 20 / minVal imgMatrix[idx2] = 255 idx1=None idx2=None imgMatrix[idx3] = pow((imgMatrix[idx3] - minVal) / (maxVal - minVal), 0.9) * 255 if iband==1: dstDS.GetRasterBand(3).WriteArray(imgMatrix) dstDS.FlushCache() thumbnail[:, :, 2] = cv2.resize(src=imgMatrix, dsize=(thumbnail.shape[1], thumbnail.shape[0])) imgMatrix = None elif iband==2: dstDS.GetRasterBand(2).WriteArray(imgMatrix) dstDS.FlushCache() thumbnail[:, :, 1] = cv2.resize(src=imgMatrix, dsize=(thumbnail.shape[1], thumbnail.shape[0])) imgMatrix = None else: dstDS.GetRasterBand(1).WriteArray(imgMatrix) dstDS.FlushCache() thumbnail[:, :, 0] = cv2.resize(src=imgMatrix, dsize=(thumbnail.shape[1], thumbnail.shape[0])) imgMatrix = None fusionimage = None dstDS = None cv2.imwrite(os.path.join(uploadfiles[0],str(id)+'.jpg'),thumbnail) return transformimage except Exception as e: return Exception("上传失败,图像转换出错:"+str(e)) def RPCOrthorectification(Alpha=True,is_label=False): try: if not is_label: orginalimage=os.path.join(uploadfiles[0],'chaneltransform.tif') transform_rpc = os.path.join(uploadfiles[0], 'chaneltransform_rpc.txt') else: orginalimage=os.path.join(uploadfiles[0],'label.tif') transform_rpc=os.path.join(uploadfiles[0],'label_rpc.txt') origin_rpc=os.path.join(uploadfiles[0],uploadfiles[2]) shutil.copyfile(origin_rpc,transform_rpc) # with open(rpbfile,'r') as f: # for line in f.readlines(): # hoffLine=re.search(r'heightOffset = ([\+|\-|\d]\d+\.?\d+)',line) # if hoffLine: # hoff=hoffLine.group(1) # break # f.close() # RpcHeight="['RPC_HEIGHT="+str(hoff)+"]'" # transformerOptions=RpcHeight if Alpha: warpOP = gdal.WarpOptions(dstSRS='WGS84', rpc=True, multithread=True, errorThreshold=0.0,creationOptions=['Tiled=yes'], resampleAlg=gdal.gdalconst.GRIORA_Bilinear,dstAlpha=True) else: warpOP = gdal.WarpOptions(dstSRS='WGS84', rpc=True, multithread=True, errorThreshold=0.0,creationOptions=['Tiled=yes'], resampleAlg=gdal.gdalconst.GRIORA_Bilinear,dstNodata=0) image = gdal.Open(orginalimage.encode('utf-8'),gdal.GA_ReadOnly) RPCOrthImage = os.path.join(uploadfiles[0],os.path.basename(orginalimage).replace(".tif","RPC.tif")) srcDS = gdal.Warp(RPCOrthImage.encode('utf-8').decode(), image, options=warpOP) image=None srcDS=None return RPCOrthImage except Exception as e: return Exception("上传失败,RPC正射校正出错:"+str(e)) def buildOverviews(): try: image=os.path.join(uploadfiles[0],'chaneltransformRPC.tif') gdal.AllRegister() TransformDS = gdal.Open(image.encode('utf-8').decode(), gdal.GA_ReadOnly) Width = TransformDS.RasterXSize Heigh = TransformDS.RasterYSize PixelNum = Width * Heigh TopNum = 4096 CurNum = PixelNum / 4 anLevels = [] nLevelCount = 0 while (CurNum > TopNum): anLevels.append(pow(2, nLevelCount + 2)) nLevelCount += 1 CurNum /= 4 TransformDS.BuildOverviews(overviewlist=anLevels) cat = Catalog(map_url,'admin', 'geoserver') wkspce = cat.get_workspace('Map') cat.create_coveragestore_external_geotiff(name=id, data='file://' + image.encode('utf-8').decode('utf-8'), workspace=wkspce) cat.reload() TransformDS = None except Exception as e: return Exception("上传失败,建立金字塔出错"+str(e)) def fit_by_contours(img,geotransfrom): geo = np.array([[geotransfrom[1], geotransfrom[4]], [geotransfrom[2], geotransfrom[5]]]) off = np.array([geotransfrom[0], geotransfrom[3]]) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5)) img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel) img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel) img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel) img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel) contours, hierarchy = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)[1:] contours = list(map(np.squeeze, contours)) hierarchy = np.squeeze(hierarchy) contours = [LinearRing(np.dot(np.row_stack((single_contour, single_contour[0, :])), geo) + off) for single_contour in contours] hole_exclude_linering = defaultdict(list) for idx in np.argwhere(hierarchy[:, -1] == -1)[:, 0]: hole_exclude_linering[idx].append(contours[idx]) # external_contours=[(idx,contours[idx]) for idx in np.argwhere(hierarchy[:,-1]==-1)[:,0]] extern_linering_idx = np.argwhere(hierarchy[:, 2] != -1)[:, 0] hole_idx = [np.argwhere(hierarchy[:, -1] == idx)[:, 0] for idx in extern_linering_idx] for e_id, h_id in zip(extern_linering_idx, hole_idx): holes = [contours[h] for h in h_id] hole_exclude_linering[e_id].extend(holes) return MultiPolygon([Polygon(*linering) for linering in hole_exclude_linering.values()]) def save_mask(): try: ct=CoordTransform(SpatialReference('WGS84'), SpatialReference('4527')) label_path=os.path.join(uploadfiles[0],'labelRPC.tif') dataset = gdal.Open(label_path) GeoTransform = dataset.GetGeoTransform() if dataset == None: return im_width = dataset.RasterXSize # 栅格矩阵的列数 im_height = dataset.RasterYSize # 栅格矩阵的行数 cood_trans=lambda L,C:(GeoTransform[0] + C * GeoTransform[1] + L * GeoTransform[2],GeoTransform[3] + C * GeoTransform[4] + L * GeoTransform[5]) map_polygon=Polygon(LinearRing(cood_trans(0,0),cood_trans(0,im_width),cood_trans(im_height,im_width),cood_trans(im_height,0),cood_trans(0,0))) Bmap.objects.filter(id=id).update(polygon=map_polygon) im_data = dataset.ReadAsArray(0, 0, im_width, im_height) # 获取数据 dataset = None types = np.unique(im_data) for label_type in types: # if label_type in (0,): # continue mp = fit_by_contours((im_data == label_type).astype(np.uint8), GeoTransform) m = Mask(map=Bmap.objects.get(id=id),type_id=int(label_type), mask=mp,area=round(mp.transform(ct,clone=True).area/1000000,2)) m.save() # img[im_data == label_type]=127 # cv2.imwrite(str(label_type)+".jpg",img) if label_type!=0: payload = "<featureType><name>" + str(id) + '_' + str(m.type_id) + "</name><nativeName>myweb_mask</nativeName>"" \ ""<cqlFilter>type_id=" + str(m.type_id) + " and map_id=" + str(id) + "</cqlFilter></featureType>" headers = {'Content-type': 'text/xml'} resp = requests.post(mask_url, auth=('admin', 'geoserver'), data=payload, headers=headers) if resp.status_code != 201: raise Exception('Upload to geoserver error') else: cat = Catalog(map_url, 'admin', 'geoserver') layer = cat.get_layer('Mask:'+str(id)+'_'+str(m.type_id)) layer.default_style=cat.get_style(str(label_type), 'Mask') cat.save(layer) cat.reload() return "上传成功" except Exception as e: return Exception("上传失败,拟合图斑出错:"+str(e)) # # def makeDownload(): # try: # cwd = os.getcwd() # downloadpath=os.path.join(baseurl,str(id)+'.tar.gz')#前端下载路径 # downloadfile = tarfile.open(downloadpath, "w:gz") # os.chdir(uploadfiles[0]) # downloadfile.add(uploadfiles[4],recursive=False) # downloadfile.add(uploadfiles[5],recursive=False) # os.chdir(tempfolder) # for file in os.listdir(tempfolder): # if ".json" in file: # downloadfile.add(file,recursive=False) # if file=="chaneltransformRPC.tif": # downloadfile.add(file) # downloadfile.close() # os.chdir(cwd) # return downloadpath # except Exception: # # if os.path.exists(downloadpath): # # os.remove(downloadpath) # return "上传失败,无法创建压缩包" # if not os.path.exists(baseurl): # os.makedirs(baseurl) # uploadfiles=(os.path.join(MAPBASEPATH,'GF2_PMS2_E117.4_N39.1_20170510_L1A0002351826'),) # result = detection.detection(uploadfiles[0] + "/", uploadfiles[1], uploadfiles[0]) # if not isinstance(result, Exception): # result =save_mask() # if not isinstance(result, Exception): # result = save_mask() # if not isinstance(result, Exception): # # result=makeDownload() # return '上传成功' # buildOverviews() # RPCOrthorectification() #正式代码 # uploadfolder=os.path.join(MAPBASEPATH,'GF2_PMS2_E117.4_N39.1_20170510_L1A0002351826') # uploadfiles=getUploadFile(uploadfolder) # RPCOrthorectification(Alpha=False,is_label=True) uploadfolder =os.path.join(MAPBASEPATH,Bmap.objects.get(id=id).name) uploadfiles=getUploadFile(uploadfolder) result = uploadfiles if not isinstance(result, Exception): result=chaneltransform() if not isinstance(result,Exception): result=RPCOrthorectification() if not isinstance(result,Exception): result=buildOverviews() if not isinstance(result,Exception): result=detection.detection(uploadfiles[0]+"/",uploadfiles[1],uploadfiles[0]) if not isinstance(result,Exception): result=RPCOrthorectification(Alpha=False,is_label=True) if not isinstance(result,Exception): result=save_mask() if not isinstance(result,Exception): shutil.rmtree('./myweb/Detector/temp') return '上传成功' ####正式代码完 cat = Catalog(map_url, 'admin', 'geoserver') if cat.get_layer('Mask:'+str(id)): cat.delete(cat.get_layer('Mask:'+str(id))) cat.reload() for label_type in range(1,8): if cat.get_layer('Mask:' + str(id)+'_'+str(label_type)): cat.delete(cat.get_layer('Mask:' + str(id)+'_'+str(label_type))) cat.reload() try: if cat.get_store(name=str(id), workspace='Map'): cat.delete(cat.get_store(name=str(id), workspace='Map')) cat.reload() except Exception: pass if os.path.exists('./myweb/Detector/temp'): shutil.rmtree('./myweb/Detector/temp') Bmap.objects.filter(id=id).delete() return str(result)
class CatalogTests(unittest.TestCase): def setUp(self): self.cat = Catalog("http://localhost:8080/geoserver/rest") def testAbout(self): about_html = self.cat.about() self.assertTrue('<html xmlns="http://www.w3.org/1999/xhtml"' in about_html) def testGSVersion(self): version = self.cat.gsversion() pat = re.compile('\d\.\d(\.[\dx]|-SNAPSHOT)') self.assertTrue(pat.match('2.2.x')) self.assertTrue(pat.match('2.3.2')) self.assertTrue(pat.match('2.3-SNAPSHOT')) self.assertFalse(pat.match('2.3.y')) self.assertFalse(pat.match('233')) self.assertTrue(pat.match(version)) def testWorkspaces(self): self.assertEqual(7, len(self.cat.get_workspaces())) # marking out test since geoserver default workspace is not consistent # self.assertEqual("cite", self.cat.get_default_workspace().name) self.assertEqual("topp", self.cat.get_workspace("topp").name) def testStores(self): topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") self.assertEqual(9, len(self.cat.get_stores())) self.assertEqual(2, len(self.cat.get_stores(topp))) self.assertEqual(2, len(self.cat.get_stores(sf))) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile", topp).name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile").name) self.assertEqual("states_shapefile", self.cat.get_store("states_shapefile").name) self.assertEqual("sfdem", self.cat.get_store("sfdem", sf).name) self.assertEqual("sfdem", self.cat.get_store("sfdem").name) def testResources(self): topp = self.cat.get_workspace("topp") sf = self.cat.get_workspace("sf") states = self.cat.get_store("states_shapefile", topp) sfdem = self.cat.get_store("sfdem", sf) self.assertEqual(19, len(self.cat.get_resources())) self.assertEqual(1, len(self.cat.get_resources(states))) self.assertEqual(5, len(self.cat.get_resources(workspace=topp))) self.assertEqual(1, len(self.cat.get_resources(sfdem))) self.assertEqual(6, len(self.cat.get_resources(workspace=sf))) self.assertEqual("states", self.cat.get_resource("states", states).name) self.assertEqual("states", self.cat.get_resource("states", workspace=topp).name) self.assertEqual("states", self.cat.get_resource("states").name) states = self.cat.get_resource("states") fields = [ states.title, states.abstract, states.native_bbox, states.latlon_bbox, states.projection, states.projection_policy ] self.assertFalse(None in fields, str(fields)) self.assertFalse(len(states.keywords) == 0) self.assertFalse(len(states.attributes) == 0) self.assertTrue(states.enabled) self.assertEqual("sfdem", self.cat.get_resource("sfdem", sfdem).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem", workspace=sf).name) self.assertEqual("sfdem", self.cat.get_resource("sfdem").name) def testResourcesUpdate(self): res_dest = self.cat.get_resources() count = 0 for rd in res_dest: # only wms layers if rd.resource_type != "wmsLayer": continue # looking for same name ro = self.cat.get_resource(rd.name) if ro is not None: rd.title = ro.title rd.abstract = ro.abstract rd.keywords = ro.keywords rd.projection = ro.projection rd.native_bbox = ro.native_bbox rd.latlon_bbox = ro.latlon_bbox rd.projection_policy = ro.projection_policy rd.enabled = ro.enabled rd.advertised = ro.advertised rd.metadata_links = ro.metadata_links or None self.cat.save(rd) self.cat.reload() # print "Updated layer: " + rd.name count += 1 # print "Total updated layers: " + str(count) def testLayers(self): expected = set(["Arc_Sample", "Pk50095", "Img_Sample", "mosaic", "sfdem", "bugsites", "restricted", "streams", "archsites", "roads", "tasmania_roads", "tasmania_water_bodies", "tasmania_state_boundaries", "tasmania_cities", "states", "poly_landmarks", "tiger_roads", "poi", "giant_polygon" ]) actual = set(l.name for l in self.cat.get_layers()) missing = expected - actual extras = actual - expected message = "Actual layer list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) states = self.cat.get_layer("states") self.assert_("states", states.name) self.assert_(isinstance(states.resource, ResourceInfo)) self.assertEqual(set(s.name for s in states.styles), set(['pophatch', 'polygon'])) self.assertEqual(states.default_style.name, "population") def testLayerGroups(self): expected = set(["tasmania", "tiger-ny", "spearfish"]) actual = set(l.name for l in self.cat.get_layergroups()) missing = expected - actual extras = actual - expected message = "Actual layergroup list did not match expected! (Extras: %s) (Missing: %s)" % (extras, missing) self.assert_(len(expected ^ actual) == 0, message) tas = self.cat.get_layergroup("tasmania") self.assert_("tasmania", tas.name) self.assert_(isinstance(tas, LayerGroup)) self.assertEqual(tas.layers, ['tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities'], tas.layers) self.assertEqual(tas.styles, [None, None, None, None], tas.styles) # Try to create a new Layer Group into the "topp" workspace self.assert_(self.cat.get_workspace("topp") is not None) tas2 = self.cat.create_layergroup("tasmania_reloaded", tas.layers, workspace = "topp") self.cat.save(tas2) self.assert_(self.cat.get_layergroup("tasmania_reloaded") is None) self.assert_(self.cat.get_layergroup("tasmania_reloaded", "topp") is not None) tas2 = self.cat.get_layergroup("tasmania_reloaded", "topp") self.assert_("tasmania_reloaded", tas2.name) self.assert_(isinstance(tas2, LayerGroup)) self.assertEqual(tas2.workspace, "topp", tas2.workspace) self.assertEqual(tas2.layers, ['tasmania_state_boundaries', 'tasmania_water_bodies', 'tasmania_roads', 'tasmania_cities'], tas2.layers) self.assertEqual(tas2.styles, [None, None, None, None], tas2.styles) def testStyles(self): self.assertEqual("population", self.cat.get_style("population").name) self.assertEqual("popshade.sld", self.cat.get_style("population").filename) self.assertEqual("population", self.cat.get_style("population").sld_name) self.assert_(self.cat.get_style('non-existing-style') is None) def testEscaping(self): # GSConfig is inconsistent about using exceptions vs. returning None # when a resource isn't found. # But the basic idea is that none of them should throw HTTP errors from # misconstructed URLS self.cat.get_style("best style ever") self.cat.get_workspace("best workspace ever") try: self.cat.get_store(workspace="best workspace ever", name="best store ever") self.fail('expected exception') except FailedRequestError, fre: self.assertEqual('No store found named: best store ever', fre.message) try: self.cat.get_resource(workspace="best workspace ever", store="best store ever", name="best resource ever") except FailedRequestError, fre: self.assertEqual('No store found named: best store ever', fre.message)