def _create_bulk_meta_tile(self, meta_tile): """ _create_bulk_meta_tile queries each tile of the meta tile in parallel (using concurrent_tile_creators). """ tile_size = self.grid.tile_size main_tile = Tile(meta_tile.main_tile_coord) with self.tile_mgr.lock(main_tile): if not all( self.is_cached(t) for t in meta_tile.tiles if t is not None): async_pool = async_.Pool( self.tile_mgr.concurrent_tile_creators) def query_tile(coord): try: query = MapQuery(self.grid.tile_bbox(coord), tile_size, self.grid.srs, self.tile_mgr.request_format, dimensions=self.dimensions) tile_image = self._query_sources(query) if tile_image is None: return None if self.tile_mgr.image_opts != tile_image.image_opts: # call as_buffer to force conversion into cache format tile_image.as_buffer(self.tile_mgr.image_opts) tile = Tile(coord, cacheable=tile_image.cacheable) tile.source = tile_image tile = self.tile_mgr.apply_tile_filter(tile) except BlankImage: return None else: return tile tiles = [] for tile_task in async_pool.imap( query_tile, [t for t in meta_tile.tiles if t is not None], use_result_objects=True, ): if tile_task.exception is None: tile = tile_task.result if tile is not None: tiles.append(tile) else: ex = tile_task.exception async_pool.shutdown(True) reraise(ex) self.cache.store_tiles([t for t in tiles if t.cacheable]) return tiles # else tiles = [Tile(coord) for coord in meta_tile.tiles] self.cache.load_tiles(tiles) return tiles
def render(self, layer_merger): render_layers = combined_layers(self.layers, self.query) if not render_layers: return async_pool = async_.Pool(size=min(len(render_layers), self.concurrent_rendering)) if self.raise_source_errors: return self._render_raise_exceptions(async_pool, render_layers, layer_merger) else: return self._render_capture_source_errors(async_pool, render_layers, layer_merger)
def _create_threaded(self, create_func, tiles): result = [] async_pool = async_.Pool(self.tile_mgr.concurrent_tile_creators) for new_tiles in async_pool.imap(create_func, tiles): result.extend(new_tiles) return result
def store_tiles(self, tiles): p = async_.Pool(min(self._concurrent_writer, len(tiles))) p.map(self.store_tile, tiles)
def load_tiles(self, tiles, with_metadata=True): p = async_.Pool(min(4, len(tiles))) return all(p.map(self.load_tile, tiles))