def clean_resource_cache(tile):
# get the tile model's bounds
datatype_factory = DataTypeFactory()
nodegroup = models.NodeGroup.objects.get(pk=tile.nodegroup_id)
for node in nodegroup.node_set.all():
datatype = datatype_factory.get_instance(node.datatype)
if datatype.should_cache(node) and datatype.should_manage_cache(node):
bounds = datatype.get_bounds(tile, node)
if bounds is not None:
zooms = range(20)
config = TileStache.parseConfig(
get_tileserver_config(node.nodeid))
layer = config.layers[str(node.nodeid)]
mimetype, format = layer.getTypeByExtension('pbf')
lon1, lat1, lon2, lat2 = bounds
south, west = min(lat1, lat2), min(lon1, lon2)
north, east = max(lat1, lat2), max(lon1, lon2)
northwest = Location(north, west)
southeast = Location(south, east)
ul = layer.projection.locationCoordinate(northwest)
lr = layer.projection.locationCoordinate(southeast)
padding = 0
coordinates = generateCoordinates(ul, lr, zooms, padding)
for (offset, count, coord) in coordinates:
config.cache.remove(layer, coord, format)
for key, tile_list in tile.tiles.iteritems():
for child_tile in tile_list:
clean_resource_cache(child_tile)
def clean_resource_cache(tile):
# get the tile model's bounds
datatype_factory = DataTypeFactory()
nodegroup = models.NodeGroup.objects.get(pk=tile.nodegroup_id)
for node in nodegroup.node_set.all():
datatype = datatype_factory.get_instance(node.datatype)
if datatype.should_cache(node) and datatype.should_manage_cache(node):
bounds = datatype.get_bounds(tile, node)
if bounds is not None:
zooms = range(20)
config = TileStache.parseConfig(
get_tileserver_config(node.nodeid))
layer = config.layers[str(node.nodeid)]
mimetype, format = layer.getTypeByExtension('pbf')
lon1, lat1, lon2, lat2 = bounds
south, west = min(lat1, lat2), min(lon1, lon2)
north, east = max(lat1, lat2), max(lon1, lon2)
northwest = Location(north, west)
southeast = Location(south, east)
ul = layer.projection.locationCoordinate(northwest)
lr = layer.projection.locationCoordinate(southeast)
padding = 0
coordinates = generateCoordinates(ul, lr, zooms, padding)
for (offset, count, coord) in coordinates:
config.cache.remove(layer, coord, format)
for key, tile_list in tile.tiles.iteritems():
for child_tile in tile_list:
clean_resource_cache(child_tile)
def add_config(self, kernel_id, **kwargs):
cache = kwargs.get("cache", self.default_cache)
self._configs[kernel_id] = ts.parseConfig({
"cache": cache,
"layers": {}
})
def add_config(self, kernel_id, **kwargs):
cache = kwargs.get("cache", self.default_cache)
self._configs[kernel_id] = ts.parseConfig({
"cache": cache,
"layers": {}
})
def seed_resource_cache():
datatype_factory = DataTypeFactory()
zooms = range(settings.CACHE_SEED_MAX_ZOOM + 1)
extension = 'pbf'
lat1, lon1, lat2, lon2 = GeoUtils().get_bounds_from_geojson(settings.CACHE_SEED_BOUNDS)
south, west = min(lat1, lat2), min(lon1, lon2)
north, east = max(lat1, lat2), max(lon1, lon2)
northwest = Location(north, west)
southeast = Location(south, east)
padding = 0
datatypes = [
d.pk for d in models.DDataType.objects.filter(isgeometric=True)]
nodes = models.Node.objects.filter(
graph__isresource=True, datatype__in=datatypes)
for node in nodes:
datatype = datatype_factory.get_instance(node.datatype)
count = models.TileModel.objects.filter(
data__has_key=str(node.nodeid)).count()
if datatype.should_cache(node) and count > 0:
config = TileStache.parseConfig(get_tileserver_config(node.nodeid))
layer = config.layers[str(node.nodeid)]
ul = layer.projection.locationCoordinate(northwest)
lr = layer.projection.locationCoordinate(southeast)
coordinates = generateCoordinates(ul, lr, zooms, padding)
for (offset, count, coord) in coordinates:
path = '%s/%d/%d/%d.%s' % (layer.name(), coord.zoom,
coord.column, coord.row, extension)
progress = {"tile": path,
"offset": offset + 1,
"total": count}
attempts = 3
rendered = False
while not rendered:
print '%(offset)d of %(total)d...' % progress,
try:
mimetype, content = TileStache.getTile(
layer, coord, extension, True)
except:
attempts -= 1
print 'Failed %s, will try %s more.' % (progress['tile'], ['no', 'once', 'twice'][attempts])
if attempts == 0:
print 'Failed %(zoom)d/%(column)d/%(row)d, trying next tile.\n' % coord.__dict__
break
else:
rendered = True
progress['size'] = '%dKB' % (len(content) / 1024)
print '%(tile)s (%(size)s)' % progress
def seed_resource_cache():
zooms = range(settings.CACHE_SEED_MAX_ZOOM + 1)
extension = 'pbf'
lat1, lon1, lat2, lon2 = settings.CACHE_SEED_BOUNDS
south, west = min(lat1, lat2), min(lon1, lon2)
north, east = max(lat1, lat2), max(lon1, lon2)
northwest = Location(north, west)
southeast = Location(south, east)
padding = 0
datatypes = [
d.pk for d in models.DDataType.objects.filter(isgeometric=True)
]
nodes = models.Node.objects.filter(graph__isresource=True,
datatype__in=datatypes)
for node in nodes:
datatype = datatype_factory.get_instance(node.datatype)
count = models.TileModel.objects.filter(
data__has_key=str(node.nodeid)).count()
if datatype.should_cache(node) and count > 0:
config = TileStache.parseConfig(get_tileserver_config(node.nodeid))
layer = config.layers[str(node.nodeid)]
ul = layer.projection.locationCoordinate(northwest)
lr = layer.projection.locationCoordinate(southeast)
coordinates = generateCoordinates(ul, lr, zooms, padding)
for (offset, count, coord) in coordinates:
path = '%s/%d/%d/%d.%s' % (layer.name(), coord.zoom,
coord.column, coord.row, extension)
progress = {"tile": path, "offset": offset + 1, "total": count}
attempts = 3
rendered = False
while not rendered:
print '%(offset)d of %(total)d...' % progress,
try:
mimetype, content = TileStache.getTile(
layer, coord, extension, True)
except:
attempts -= 1
print 'Failed %s, will try %s more.' % (
progress['tile'], ['no', 'once', 'twice'
][attempts])
if attempts == 0:
print 'Failed %(zoom)d/%(column)d/%(row)d, trying next tile.\n' % coord.__dict__
break
else:
rendered = True
progress['size'] = '%dKB' % (len(content) / 1024)
print '%(tile)s (%(size)s)' % progress
def initialize(self, config=None, autoreload=False):
self.config = config
self.autoreload = autoreload
try:
self.tsconfig = TileStache.parseConfig(self.config)
except:
print "Error loading Tilestache config:"
raise
if options.include_paths:
for p in options.include_paths.split(':'):
path.insert(0, p)
import TileStache
try:
if options.config is None:
raise TileStache.Core.KnownUnknown(
'Missing required configuration (--config) parameter.')
if options.layer is None:
raise TileStache.Core.KnownUnknown(
'Missing required layer (--layer) parameter.')
config = TileStache.parseConfig(options.config)
if options.layer not in config.layers:
raise TileStache.Core.KnownUnknown(
'"%s" is not a layer I know about. Here are some that I do know about: %s.'
% (options.layer, ', '.join(sorted(config.layers.keys()))))
provider = Provider(config.layers[options.layer], options.verbose,
options.ignore_cached)
try:
outfile = args[0]
except IndexError:
raise BadComposure('Error: Missing output file.')
if options.center and options.extent:
(options, args) = parser.parse_args()
if options.include_paths:
for p in options.include_paths.split(':'):
path.insert(0, p)
import TileStache
try:
if options.config is None:
raise TileStache.Core.KnownUnknown('Missing required configuration (--config) parameter.')
if options.layer is None:
raise TileStache.Core.KnownUnknown('Missing required layer (--layer) parameter.')
config = TileStache.parseConfig(options.config)
if options.layer not in config.layers:
raise TileStache.Core.KnownUnknown('"%s" is not a layer I know about. Here are some that I do know about: %s.' % (options.layer, ', '.join(sorted(config.layers.keys()))))
provider = Provider(config.layers[options.layer], options.verbose, options.ignore_cached)
try:
outfile = args[0]
except IndexError:
raise BadComposure('Error: Missing output file.')
if options.center and options.extent:
raise BadComposure("Error: bad map coverage, center and extent can't both be set.")
elif options.extent and options.dimensions and options.zoom:
