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)
