def modify_config(config_entity, layers, ignore_raster_layer=False, **kwargs):
    """
        Using the attributes of the given Layer objects, creates one or more TSLayer objects in the DB to be read by
         TileStache. Each layer instance is used to create a raster and selection (vector) layer for
         each configured attribute. These layers are keyed uniquely by the layer instance id, attribute, and layer type,
         so they will simply overwrite themselves in the config and accumulate.

    :param config_entity:
    :param layers:
    :return:
    """

    default_config = CACHES[getattr(settings, 'TILE_CACHE', "none")]
    Config.objects.get_or_create(name='default', defaults=dict(cache=default_config))
    for layer in layers:
        logger.info("Recreating cartocss & invalidating cache for layer {layer} of"
                    "DbEntity key {db_entity_key})".format(
                        layer=layer.full_name,
                        db_entity_key=layer.db_entity_key)
                    )
        subclassed_layer_style = layer.medium_subclassed

        if subclassed_layer_style:
            # Create a vector, raster, and vector selection layer for each attribute listed in the style attributes
            for style_attribute in subclassed_layer_style.style_attributes.all():
                style_attribute_id = style_attribute.id
                logger.info("Creating tilestache layers for layer %s, attribute %s" % (layer.full_name, style_attribute_id))

                tilestache_layers = create_layer_selection(config_entity, layer, style_attribute_id)

                if not ignore_raster_layer:
                    # generate the cartocss for each layer attribute that will be utilized by tilestach
                    cartocss = make_carto_css(layer, style_attribute)
                    tilestache_layers = [create_raster_layer(layer, style_attribute_id, cartocss)] + tilestache_layers

                for tilestache_layer in tilestache_layers:

                    tslayer, created = TSLayer.objects.get_or_create(
                        key=tilestache_layer.key,
                        defaults=dict(value=tilestache_layer.value)
                    )

                    updated = False
                    if not created:
                        if tslayer.value != tilestache_layer.value:
                            tslayer.value = tilestache_layer.value
                            tslayer.save()
                            updated = True

                    if created or updated or 'raster' in tslayer.key:
                        logger.info("invalidating tilestache layers for layer %s, attribute_id %s, tsLayerKey %s" %
                                    (layer.full_name, style_attribute_id, tilestache_layer.key))
                        invalidate_cache(tslayer.key)
Example #2
0
 def invalidate(self):
     logger.info("invalidating tilestache layers for layer {0}".format(
         self.full_name))
     for layer_key in self.keys:
         logger.info("\tkey: {0}".format(layer_key))
         invalidate_cache(layer_key)
def modify_config(config_entity, layers, ignore_raster_layer=False, **kwargs):
    """
        Using the attributes of the given Layer objects, creates one or more TSLayer objects in the DB to be read by
         TileStache. Each layer instance is used to create a raster and selection (vector) layer for
         each configured attribute. These layers are keyed uniquely by the layer instance id, attribute, and layer type,
         so they will simply overwrite themselves in the config and accumulate.

    :param config_entity:
    :param layers:
    :return:
    """

    default_config = CACHES[getattr(settings, 'TILE_CACHE', "none")]
    Config.objects.get_or_create(name='default',
                                 defaults=dict(cache=default_config))
    for layer in layers:
        logger.info(
            "Recreating cartocss & invalidating cache for layer {layer} of"
            "DbEntity key {db_entity_key})".format(
                layer=layer.full_name, db_entity_key=layer.db_entity_key))
        subclassed_layer_style = layer.medium_subclassed

        if subclassed_layer_style:
            # Create a vector, raster, and vector selection layer for each attribute listed in the style attributes
            for style_attribute in subclassed_layer_style.style_attributes.all(
            ):
                style_attribute_id = style_attribute.id
                logger.info(
                    "Creating tilestache layers for layer %s, attribute %s" %
                    (layer.full_name, style_attribute_id))

                tilestache_layers = create_layer_selection(
                    config_entity, layer, style_attribute_id)

                if not ignore_raster_layer:
                    # generate the cartocss for each layer attribute that will be utilized by tilestach
                    cartocss = make_carto_css(layer, style_attribute)
                    tilestache_layers = [
                        create_raster_layer(layer, style_attribute_id,
                                            cartocss)
                    ] + tilestache_layers

                for tilestache_layer in tilestache_layers:

                    tslayer, created = TSLayer.objects.get_or_create(
                        key=tilestache_layer.key,
                        defaults=dict(value=tilestache_layer.value))

                    updated = False
                    if not created:
                        if tslayer.value != tilestache_layer.value:
                            tslayer.value = tilestache_layer.value
                            tslayer.save()
                            updated = True

                    if created or updated or 'raster' in tslayer.key:
                        logger.info(
                            "invalidating tilestache layers for layer %s, attribute_id %s, tsLayerKey %s"
                            % (layer.full_name, style_attribute_id,
                               tilestache_layer.key))
                        invalidate_cache(tslayer.key)
Example #4
0
 def invalidate(self):
     logger.info("invalidating tilestache layers for layer {0}".format(self.full_name))
     for layer_key in self.keys:
         logger.info("\tkey: {0}".format(layer_key))
         invalidate_cache(layer_key)
    def handle(self, *args, **options):
        config = Config.objects.get().tilestache_config_object
        layers = config.layers.items()

        for key, value in layers:
            invalidate_cache(key)