def get(self, request): path_info = request.path_info.split('/') service_name = path_info[2] path_info = '/%s' % '/'.join(path_info[3:]) cache_key = 'tilescache-%s' % service_name #theService = cache.get(cache_key) theService = SERVICE_CACHE.get(cache_key, None) if not theService: print 'rebuild service %s' % service_name service = get_object_or_404(Service, name=service_name) cfg = DjangoConfig() cfg.read_config(service) configs = [cfg] layers = TCService.LayerConfig() for conf in configs: layers.update(conf) theService = TCService(configs, layers) from TileCache.Caches.Disk import Disk theService.cache = Disk(base='/tmp/tilescache') #cache.set(cache_key, theService, 10) SERVICE_CACHE[cache_key] = theService fields = request.GET req_method = request.method host = request.META.get('HTTP_HOST', 'localhost') format, image = theService.dispatchRequest(fields, path_info, req_method, host) response = HttpResponse(image, content_type=format) return response
def wsgiApp(environ, start_response): global theService cfgs = cfgfiles if not theService: theService = Service.load(cfgs) return wsgiHandler(environ, start_response, theService)
def main(): usage = "usage: %prog <layer> [<zoom start> <zoom stop>]" parser = OptionParser(usage=usage, version="%prog $Id$") parser.add_option("-f","--force", action="store_true", dest="force", default = False, help="force recreation of tiles even if they are already in cache") parser.add_option("-b","--bbox",action="store", type="string", dest="bbox", default = None, help="restrict to specified bounding box") parser.add_option("-c","--config", action="store", type="string", dest="tilecacheconfig", help="path to configuration file") parser.add_option("-p","--padding",action="store", type="int", dest="padding", default = 0, help="extra margin tiles to seed around target area. Defaults to 0 "+ "(some edge tiles might be missing). A value of 1 ensures all tiles "+ "will be created, but some tiles may be wholly outside your bbox") parser.add_option("-r","--reverse", action="store_true", dest="reverse", default = False, help="Reverse order of seeding tiles") parser.add_option("-a", "--all", action="store_false", dest="skip_empty", default = True, help="Generate all the tiles, the default is to skip the empty tiles if the "+ "layer is a vector and mapserver layer.") parser.add_option("", "--data-projection", action="store", type="string", dest="dataProjectionString", default=None, help="Proj4 string to force the data projection.") parser.add_option("", "--tiles-projection", action="store", type="string", dest="tilesProjectionString", default=None, help="Proj4 string to force the tiles projection.") (options, args) = parser.parse_args() if len(args) > 3: parser.error("Incorrect number of arguments. bbox and padding are now options (-b and -p)") cfgs = cfgfiles if options.tilecacheconfig: cfgs = cfgs + (options.tilecacheconfig,) svc = Service.load(*cfgs) if options.bbox: bboxlist = map(float, options.bbox.split(",")) else: bboxlist = None if len(args) > 1: levels = map(int, args[1:3]) else: # not level given, generate all levels = None if len(args) == 0: parser.print_help() sys.exit(-1) for key in fnmatch.filter(svc.layers.keys(), args[0]): seed(svc, svc.layers[key], levels=levels, bbox=bboxlist, skip_empty=options.skip_empty, padding=options.padding, force = options.force, reverse = options.reverse, dataProjectionString = options.dataProjectionString, tilesProjectionString = options.tilesProjectionString) svc.teardown()
def __init__(self): TC_CONFIG = TC_CONFIG_IN[:-len(".in")] new_content = open(TC_CONFIG_IN).read().replace("@@DATA_PATH@@", DATA_PATH) f = open(TC_CONFIG, "w") f.write(new_content) f.close() self.tc_service = Service.load(TC_CONFIG)
def render_location_tile(location, layer='osm', version='1.0.0', zoom=17, extension='png', host='http://localhost'): latitude = location.geom.centroid.y longitude = location.geom.centroid.x service = Service.load(settings.TILECACHE_CONFIG) (xtile,ytile) = deg2num(latitude, longitude, zoom) #settings.TILE_ZOOM) path_info = '/%s/%s/%d/%d/%d.%s' % (version, layer, zoom, xtile, ytile, extension) tile = TMS(service).parse({}, path_info, host) return service.renderTile(tile)
def load_tilecache_config(settings): """ Load the TileCache config. This function calls ``TileCache.Service.Service.load`` and stores the return value in a private global variable. Arguments: * ``settings``: a dict with a ``tilecache.cfg`` key whose value provides the path to TileCache configuratio file. """ global _service _service = Service.load(settings.get('tilecache.cfg'))
def run(config_path="config.cfg", path_info=None, **kwargs): global template_lookup c = ConfigParser.ConfigParser() c.read(config_path) tc_path = c.get("config", "tilecache_config") s = Service.load(tc_path) template_path = c.get("config", "template_path") tilecache_location = None if c.has_option('config', "tilecache_location"): tilecache_location = c.get("config", "tilecache_location") template_lookup = TemplateLookup(directories=template_path.split(",")) additional_metadata = [] try: additional_metadata = [i[0] for i in c.items("properties")] except ConfigParser.NoSectionError: pass if s.metadata.has_key('exception'): data = [ "Current TileCache config is invalid.", "Exception: %s" % s.metadata['exception'], "Traceback: \n %s" % s.metadata['traceback'] ] return ['text/plain', "\n".join(data)] data = "" stripped = path_info.strip("/") stripped_split = stripped.split("/") if dispatch_urls.has_key(stripped_split[0]): data = dispatch_urls[stripped_split[0]]( s, parts=stripped_split[1:], additional_keys=additional_metadata, tilecache_location=tilecache_location, **kwargs) if isinstance(data, list) or isinstance(data, Response): return data return ['text/html', str(data)]
def run(config_path = "config.cfg", path_info = None, **kwargs): global template_lookup c = ConfigParser.ConfigParser() c.read(config_path) tc_path = c.get("config", "tilecache_config") s = Service.load(tc_path) template_path = c.get("config", "template_path") tilecache_location = None if c.has_option('config', "tilecache_location"): tilecache_location = c.get("config", "tilecache_location") template_lookup = TemplateLookup(directories=template_path.split(",")) additional_metadata = [] try: additional_metadata = [i[0] for i in c.items("properties")] except ConfigParser.NoSectionError: pass if s.metadata.has_key('exception'): data = [ "Current TileCache config is invalid.", "Exception: %s" % s.metadata['exception'], "Traceback: \n %s" % s.metadata['traceback'] ] return ['text/plain', "\n".join(data)] data = "" stripped = path_info.strip("/") stripped_split = stripped.split("/") if dispatch_urls.has_key(stripped_split[0]): data = dispatch_urls[stripped_split[0]](s, parts=stripped_split[1:], additional_keys = additional_metadata, tilecache_location = tilecache_location, **kwargs) if isinstance(data, list) or isinstance(data, Response): return data return ['text/html', str(data)]
def load_tilecache_config(settings): # pragma: no cover """ Load the TileCache config. This function calls ``TileCache.Service.Service.load`` and stores the return value in a private global variable. Arguments: * ``settings``: a dict with a ``tilecache.cfg`` key whose value provides the path to TileCache configuratio file. """ from TileCache.Service import Service global _service _service = Service.load(settings.get('tilecache.cfg')) if 'traceback' in _service.metadata: print 'Tilecache loading error: ' print _service.metadata['exception'] print _service.metadata['traceback']
def load_tilecache_config(settings): """ Load the TileCache config. This function calls ``TileCache.Service.Service.load`` and stores the return value in a private global variable. Arguments: * ``settings``: a dict with a ``tilecache.cfg`` key whose value provides the path to TileCache configuratio file. """ from TileCache.Service import Service global _service _service = Service.load(settings.get('tilecache.cfg')) if 'traceback' in _service.metadata: print 'Tilecache loading error: ' print _service.metadata['exception'] print _service.metadata['traceback']
class TilecacheController(BaseController): service = Service.load(config.get('tilecache.cfg')) def tilecache(self, environ, start_response): try: expiration = self.service.config.getint('cache', 'expire') except NoOptionError: expiration = DEFAULT_EXPIRATION # custom_start_response adds cache headers to the response def custom_start_response(status, headers, exc_info=None): headers.append( ('Cache-Control', 'public, max-age=%s' % expiration)) headers.append(('Expires', email.Utils.formatdate(time.time() + expiration, False, True))) return start_response(status, headers, exc_info) return wsgiHandler(environ, custom_start_response, self.service)
def get_eb_layer(name): # svc = Service.load(settings.TILECACHE_CONFIG) mapfile = r"/data/oceancolor/terra/L3m/2017/001/T2017001_L3m_DAY_NSST_sst_4km.map" svc = Service( Disk('/tmp/somecache'), # See "Cache Invalidation", below { "raster": MS.MapServer("basic", mapfile, layers="raster", srs='EPSG:4326', debug=False), }) ''' svc = Service( Disk('/tmp/somecache'), # See "Cache Invalidation", below { "raster": WMS.WMS("basic", r"http://localhost/cgi-bin/mapserv.cgi?map=/data/oceancolor/aqua/L3m/2017/001/A2017001.L3m_DAY_SST_sst_4km.map&mode=map&layer=raster", srs='EPSG:4326', width='256', height='256'), } ) ''' return svc.layers[name]
import mapnik # todo - remove <layername>, and remove 'foo' from url in static/treemap.js tile_request_pat = r'/(?P<version>\d{1,2}\.\d{1,3}\.\d{1,3})/(?P<layername>[a-z]{1,64})/(?P<z>\d{1,10})/(?P<x>\d{1,10})/(?P<y>\d{1,10})\.(?P<extension>(?:png|jpg|gif))' # hackish way to grab style obj and avoid parsing XML each request... m = mapnik.Map(1, 1) mapnik.load_map(m, settings.MAPNIK_STYLESHEET) style = m.find_style('style') del m srv = None if settings.CACHE_SEARCH_METHOD == 'mem': srv = Service( Memcached(), {}, # layers are dynamic ) else: srv = Service( Disk(settings.CACHE_SEARCH_DISK_PATH), {}, # layers are dynamic ) query_hash = {} class TileResponse(object): def __init__(self, tile_bytes): self.tile_bytes = tile_bytes def __call__(self, extension='png'):
def get_eb_layer(name): svc = Service.load(settings.TILECACHE_CONFIG) return svc.layers[name]
def application(environ, start_response): """Go service.""" if not theService["app"]: theService["app"] = Service.load(cfgfiles) return wsgiHandler(environ, start_response, theService["app"])