Beispiel #1
0
def bootstrap():
    import sys
    from os import path
    from ConfigParser import ConfigParser, NoOptionError
    from document import open_document, demo_data
    from optparse import OptionParser

    global doc
    doc = None

    parser = OptionParser()
    parser.add_option('-q', '--quiet', action='store_true', dest='quiet')
    options, args = parser.parse_args()

    cfg_path = args[0]
    parser = ConfigParser()
    parser.read(cfg_path)
    dbfile = parser.get('cork', 'dbfile')

    raw_names = dict(parser.items('cork')).get('plugins', '').split('\n')
    for plugin_name in filter(None, (name.strip() for name in raw_names)):
        __import__(plugin_name)

    if len(args) > 1:
        cmd = args[1]
    else:
        cmd = 'serve'

    if cmd == 'init':
        doc = open_document(dbfile)
        demo_data(doc)

    elif cmd == 'serve':
        from werkzeug import run_simple, SharedDataMiddleware
        from server import CorkApp

        if options.quiet:
            from werkzeug.serving import BaseRequestHandler
            class QuietHandler(BaseRequestHandler):
                def log_request(self, *args, **kwargs):
                    pass
            handler = QuietHandler
        else:
            handler = None

        host = parser.get('testserver', 'host')
        port = parser.getint('testserver', 'port')

        def lazy_app(environ, start_response):
            """
            WSGI application that creates the real app in a lazy fashion,
            useful to prevent opening two DB connections when running
            with the Werkzeug reloader.
            """
            global doc, cork_app
            if doc is None:
                doc = open_document(dbfile)
                cork_app = CorkApp(doc)
            return cork_app(environ, start_response)

        run_simple(host, port, lazy_app, use_reloader=True, request_handler=handler)
        print # a blank line

    elif cmd == 'launchd':
        from wsginetd import serve
        from server import CorkApp
        sys.stderr = open('var/launchd.log', 'a')
        doc = open_document(dbfile)
        serve(CorkApp(doc))

    elif cmd == 'interact':
        import code
        doc = open_document(dbfile)
        code.interact(local={'doc': doc, '__name__': '__console__', '__doc__': None})

    elif cmd == 'packdb':
        doc = open_document(dbfile)
        doc._p_connection.pack()

    else:
        print>>sys.stderr, "Unknown command \"%s\"" % cmd

    if doc is not None:
        doc.close()
Beispiel #2
0
def main():

    usage = "usage: %prog config_file.ini"
    parser = OptionParser(usage=usage)
    (cmd_opt, args) = parser.parse_args()

    if len(args) == 1:
        config_files = [args[0]]
    else:
        config_files = ['download_ta_bdys.ini']

    parser = SafeConfigParser()
    found = parser.read(config_files)
    if not found:
        sys.exit('Could not load config ' + config_files[0])

    # set up logging
    logging.config.fileConfig(config_files[0],
                              defaults={'hostname': socket.gethostname()})
    logger = logging.getLogger()

    logger.info('Starting download TA boundaries')

    db_host = None
    db_rolename = None
    db_port = None
    db_user = None
    db_pass = None
    db_schema = 'public'
    layer_name = None
    layer_geom_column = None
    layer_output_srid = 4167
    create_grid = False
    grid_res = 0.05
    shift_geometry = False

    base_uri = parser.get('source', 'base_uri')
    db_name = parser.get('database', 'name')
    db_schema = parser.get('database', 'schema')

    if parser.has_option('database', 'rolename'):
        db_rolename = parser.get('database', 'rolename')
    if parser.has_option('database', 'host'):
        db_host = parser.get('database', 'host')
    if parser.has_option('database', 'port'):
        db_port = parser.get('database', 'port')
    if parser.has_option('database', 'user'):
        db_user = parser.get('database', 'user')
    if parser.has_option('database', 'password'):
        db_pass = parser.get('database', 'password')

    layer_name = parser.get('layer', 'name')
    layer_geom_column = parser.get('layer', 'geom_column')
    if parser.has_option('layer', 'output_srid'):
        layer_output_srid = parser.getint('layer', 'output_srid')
    if parser.has_option('layer', 'create_grid'):
        create_grid = parser.getboolean('layer', 'create_grid')
    if parser.has_option('layer', 'grid_res'):
        grid_res = parser.getfloat('layer', 'grid_res')
    if parser.has_option('layer', 'shift_geometry'):
        shift_geometry = parser.getboolean('layer', 'shift_geometry')

    try:
        output_srs = osr.SpatialReference()
        output_srs.ImportFromEPSG(layer_output_srid)
    except:
        logger.fatal("Output SRID %s is not valid" % (layer_output_srid))
        sys.exit(1)

    if create_grid and not grid_res > 0:
        logger.fatal("Grid resolution must be greater than 0")
        sys.exit(1)

    #
    # Determine TA layer and its year from REST service
    #

    logger.debug(base_uri + '?f=json')
    response = urllib2.urlopen(base_uri + '?f=json')
    capabilities = json.load(response)

    latest_service = None
    latest_year = None
    p = re.compile('((\d{4})\_Geographies)$', flags=re.UNICODE)
    for service in capabilities['services']:
        m = p.search(service['name'])
        if m:
            if not latest_year or m.group(2) > latest_year:
                latest_year = int(m.group(2))
                latest_service = m.group(1)

    logger.debug(base_uri + '/' + latest_service + '/MapServer?f=json')
    response = urllib2.urlopen(base_uri + '/' + latest_service +
                               '/MapServer?f=json')
    capabilities = json.load(response)

    ta_layer = None
    p = re.compile('^Territorial\sAuthorities\s\d{4}$', flags=re.UNICODE)
    for layer in capabilities['layers']:
        m = p.search(layer['name'])
        if m:
            ta_layer = layer
            break

    if not ta_layer:
        logger.fatal('Could not find the TA layer in ' + base_uri)
        sys.exit(1)

    feature_url = base_uri + '/' + latest_service + '/MapServer/' + str(ta_layer['id']) + \
        '/query?f=json&where=1=1&returnGeometry=true&outSR=' + str(layer_output_srid)

    geojson_drv = ogr.GetDriverByName('GeoJSON')
    if geojson_drv is None:
        logger.fatal('Could not load the OGR GeoJSON driver')
        sys.exit(1)

    #
    # Connect to the PostgreSQL database
    #

    pg_drv = ogr.GetDriverByName('PostgreSQL')
    if pg_drv is None:
        logger.fatal('Could not load the OGR PostgreSQL driver')
        sys.exit(1)

    pg_uri = 'PG:dbname=' + db_name
    if db_host:
        pg_uri = pg_uri + ' host=' + db_host
    if db_port:
        pg_uri = pg_uri + ' port=' + db_port
    if db_user:
        pg_uri = pg_uri + ' user='******' password='******'t open PG output database: " + str(e))
        sys.exit(1)
def main():

    usage = "usage: %prog config_file.ini"
    parser = OptionParser(usage=usage)
    (cmd_opt, args) = parser.parse_args()

    if len(args) == 1:
        config_files = [args[0]]
    else:
        config_files = ["download_ta_bdys.ini"]

    parser = SafeConfigParser()
    found = parser.read(config_files)
    if not found:
        sys.exit("Could not load config " + config_files[0])

    # set up logging
    logging.config.fileConfig(config_files[0], defaults={"hostname": socket.gethostname()})
    logger = logging.getLogger()

    logger.info("Starting download TA boundaries")

    db_host = None
    db_rolename = None
    db_port = None
    db_user = None
    db_pass = None
    db_schema = "public"
    layer_name = None
    layer_geom_column = None
    layer_output_srid = 4167
    create_grid = False
    grid_res = 0.05
    shift_geometry = False

    base_uri = parser.get("source", "base_uri")
    db_name = parser.get("database", "name")
    db_schema = parser.get("database", "schema")

    if parser.has_option("database", "rolename"):
        db_rolename = parser.get("database", "rolename")
    if parser.has_option("database", "host"):
        db_host = parser.get("database", "host")
    if parser.has_option("database", "port"):
        db_port = parser.get("database", "port")
    if parser.has_option("database", "user"):
        db_user = parser.get("database", "user")
    if parser.has_option("database", "password"):
        db_pass = parser.get("database", "password")

    layer_name = parser.get("layer", "name")
    layer_geom_column = parser.get("layer", "geom_column")
    if parser.has_option("layer", "output_srid"):
        layer_output_srid = parser.getint("layer", "output_srid")
    if parser.has_option("layer", "create_grid"):
        create_grid = parser.getboolean("layer", "create_grid")
    if parser.has_option("layer", "grid_res"):
        grid_res = parser.getfloat("layer", "grid_res")
    if parser.has_option("layer", "shift_geometry"):
        shift_geometry = parser.getboolean("layer", "shift_geometry")

    try:
        output_srs = osr.SpatialReference()
        output_srs.ImportFromEPSG(layer_output_srid)
    except:
        logger.fatal("Output SRID %s is not valid" % (layer_output_srid))
        sys.exit(1)

    if create_grid and not grid_res > 0:
        logger.fatal("Grid resolution must be greater than 0")
        sys.exit(1)

    #
    # Determine TA layer and its year from REST service
    #

    logger.debug(base_uri + "?f=json")
    response = urllib2.urlopen(base_uri + "?f=json")
    capabilities = json.load(response)

    latest_service = None
    latest_year = None
    p = re.compile("((\d{4})\_Geographies)$", flags=re.UNICODE)
    for service in capabilities["services"]:
        m = p.search(service["name"])
        if m:
            if not latest_year or m.group(2) > latest_year:
                latest_year = int(m.group(2))
                latest_service = m.group(1)

    logger.debug(base_uri + "/" + latest_service + "/MapServer?f=json")
    response = urllib2.urlopen(base_uri + "/" + latest_service + "/MapServer?f=json")
    capabilities = json.load(response)

    ta_layer = None
    p = re.compile("^Territorial\sAuthorities\s\d{4}$", flags=re.UNICODE)
    for layer in capabilities["layers"]:
        m = p.search(layer["name"])
        if m:
            ta_layer = layer
            break

    if not ta_layer:
        logger.fatal("Could not find the TA layer in " + base_uri)
        sys.exit(1)

    feature_url = (
        base_uri
        + "/"
        + latest_service
        + "/MapServer/"
        + str(ta_layer["id"])
        + "/query?f=json&where=1=1&returnGeometry=true&outSR="
        + str(layer_output_srid)
    )

    geojson_drv = ogr.GetDriverByName("GeoJSON")
    if geojson_drv is None:
        logger.fatal("Could not load the OGR GeoJSON driver")
        sys.exit(1)

    #
    # Connect to the PostgreSQL database
    #

    pg_drv = ogr.GetDriverByName("PostgreSQL")
    if pg_drv is None:
        logger.fatal("Could not load the OGR PostgreSQL driver")
        sys.exit(1)

    pg_uri = "PG:dbname=" + db_name
    if db_host:
        pg_uri = pg_uri + " host=" + db_host
    if db_port:
        pg_uri = pg_uri + " port=" + db_port
    if db_user:
        pg_uri = pg_uri + " user="******" password="******"Can't open PG output database: " + str(e))
        sys.exit(1)