Beispiel #1
0
    def __init__ (self, base = None, umask = '002', limit = None, **kwargs):
        Cache.__init__(self, **kwargs)
        self.basedir = base
        self.umask = int(umask, 0)
        if sys.platform.startswith("java"):
            from java.io import File
            self.file_module = File
            self.platform = "jython"
        else:
            self.platform = "cpython"
        
        if not self.access(base, 'read'):
            self.makedirs(base)
        
        self.dbpath = os.path.join(base, 'cache.db')

        self.limit = None
        if limit is not None:
            self.limit = int(limit)

        #Create the database
        db = connect(self.dbpath).cursor()

        for create_table in _create_tables:
            db.execute(create_table)

        db.connection.close()
Beispiel #2
0
 def __init__(self, servers="127.0.0.1:11211", **kwargs):
     """Constructor"""
     Cache.__init__(self, **kwargs)
     if isinstance(servers, string_types):
         servers = [s.strip() for s in servers.split(",")]
     self.cache = memcache.Client(servers, debug=0)
     self.timeout = int(kwargs.get("timeout", 0))
Beispiel #3
0
 def __init__(self, access_key, secret_access_key, bucket_name, validate="false", is_secure="false", **kwargs):
     Cache.__init__(self, **kwargs)
     self.validate = validate.lower() in ["yes", "y", "t", "true"]
     self.is_secure = is_secure = is_secure.lower() in ["yes", "y", "t", "true"]
     self.credential = (access_key, secret_access_key)
     self.bucket_name = bucket_name
     self._bucket = None
     self.options = kwargs
Beispiel #4
0
 def __init__ (self, servers = ['127.0.0.1:9160'], keyspace = "TileCache", column_family = "TileCache", use_ttl="no", **kwargs):
     Cache.__init__(self, **kwargs)
     
     self.keyspace=keyspace
     self.column_family=column_family
     
     if type(servers) is str: 
         servers = map(str.strip, servers.split(","))
         
     self.client = pycassa.connect(keyspace, servers)
     self.cf = pycassa.ColumnFamily(self.client, column_family)
Beispiel #5
0
    def __init__ (self, memcache_servers = ['127.0.0.1:11211'], cassandra_nodes = ['127.0.0.1:9160'], keyspace = 'TileCache', **kwargs):
        Cache.__init__(self, **kwargs)
        import memcache
        import pycassa

        if type(memcache_servers) is str: memcache_servers = map(str.strip, memcache_servers.split(","))
        if type(cassandra_nodes) is str: cassandra_nodes = map(str.strip, cassandra_nodes.split(","))

        self.memcache = memcache.Client(memcache_servers, debug=0)
        self.pool = pycassa.ConnectionPool(keyspace=keyspace, server_list=cassandra_nodes, prefill=False)
        self.cf = pycassa.ColumnFamily(self.pool, "Tiles")
        self.pycassa = pycassa
    def __init__(self, base=None, umask='002', **kwargs):
        Cache.__init__(self, **kwargs)
        self.basedir = base
        self.umask = int(umask, 0)
        if sys.platform.startswith("java"):
            from java.io import File
            self.file_module = File
            self.platform = "jython"
        else:
            self.platform = "cpython"

        if not self.access(base, 'read'):
            self.makedirs(base)
 def __init__ (self, base = None, umask = '002', **kwargs):
     Cache.__init__(self, **kwargs)
     self.basedir = base
     self.umask = int(umask, 0)
     if sys.platform.startswith("java"):
         from java.io import File
         self.file_module = File
         self.platform = "jython"
     else:
         self.platform = "cpython"
     
     if not self.access(base, 'read'):
         self.makedirs(base)
Beispiel #8
0
 def __init__ (self, base = None, sendfile = False, umask = '002', **kwargs):
     Cache.__init__(self, **kwargs)
     self.basedir = base
     self.umask = int(umask, 0)
     self.sendfile = sendfile and sendfile.lower() in ["yes", "y", "t", "true"]
     if sys.platform.startswith("java"):
         from java.io import File
         self.file_module = File
         self.platform = "jython"
     else:
         self.platform = "cpython"
     
     if not self.access(base, 'read'):
         self.makedirs(base)
Beispiel #9
0
    def __init__ (self, access_key, secret_access_key, bucket_name=None, location='', policy=None, max_age=None, **kwargs):
        Cache.__init__(self, **kwargs)
        if policy in s3.acl.CannedACLStrings:
            self.policy = policy
        else:
            self.policy = 'private'
            
        self.bucket_name = bucket_name or "%s-tilecache" % access_key.lower() 
        self.cache = s3.connection.S3Connection(access_key, secret_access_key)
        self.bucket = self.cache.lookup(self.bucket_name)
        if not self.bucket:
            self.bucket = self.cache.create_bucket(self.bucket_name, location=location)
            self.bucket.set_acl(self.policy)

        if max_age is not None:
            self.cache_control = {"Cache-Control": "public, max-age=%d"%(int(max_age))}
        else:
            self.cache_control = {}
Beispiel #10
0
    def __init__ (self, base = None, umask = '002', use_tms_paths = "False", **kwargs):
        Cache.__init__(self, **kwargs)
        self.basedir = base
        self.umask = int(umask, 0)
        if sys.platform.startswith("java"):
            from java.io import File
            self.file_module = File
            self.platform = "jython"
        else:
            self.platform = "cpython"
        
        if not self.access(base, 'read'):
            self.makedirs(base)

        if use_tms_paths.lower() in ("true", "yes", "1"):
            use_tms_paths = True
        elif use_tms_paths.lower() == "flipped":
            use_tms_paths = "google"
        self.use_tms_paths = use_tms_paths
Beispiel #11
0
 def __init__ (self, access_key, secret_access_key, **kwargs):
     self.module = None
     try:
         import boto.s3
         self.s3 = boto.s3
         self.module = "boto"
     except ImportError, E:
         exceptions = [str(E)]
         try:
             import S3
             self.s3 = S3
             self.module = "amazon"
         except Exception, E:
             exceptions.append(str(E))
             raise Exception(self.import_error % ('\n * '.join(exceptions)))
     Cache.__init__(self, **kwargs)
     self.bucket_name = "%s-tilecache" % access_key.lower() 
     if self.module == "amazon":
         self.cache = self.s3.AWSAuthConnection(access_key, secret_access_key)
         self.cache.create_bucket(self.bucket_name)
     else:
         self.cache = self.s3.connection.S3Connection(access_key, secret_access_key)
         self.bucket = self.cache.create_bucket(self.bucket_name)
 
 def getBotoKey(self, key):
     boto_key = self.s3.key.Key(self.bucket)
     boto_key.key = key
     return boto_key
 
 def getKey(self, tile):
      return "-".join(map(str, [tile.layer.name, tile.z , tile.x, tile.y]))
Beispiel #12
0
 def __init__(self, servers=['127.0.0.1:11211'], **kwargs):
     Cache.__init__(self, **kwargs)
     import memcache
     if type(servers) is str: servers = map(str.strip, servers.split(","))
     raise Exception(servers)
     self.cache = memcache.Client(servers, debug=0)
Beispiel #13
0
            import boto.s3
            from connection import S3Connection as Connection
            from key import Key
            from bucket import Bucket
            self.s3 = boto.s3
            self.module = "boto"
        except ImportError, E:
            exceptions = [str(E)]
            try:
                import S3
                self.s3 = S3
                self.module = "amazon"
            except Exception, E:
                exceptions.append(str(E))
                raise Exception(self.import_error % ('\n * '.join(exceptions)))
        Cache.__init__(self, **kwargs)
        self.bucket_name = "%s-tilecache-%s" % (access_key.lower(), db)
        if use_tms_paths.lower() in ("true", "yes", "1"):
            use_tms_paths = True
        elif use_tms_paths.lower() == "flipped":
            use_tms_paths = "google"
        self.use_tms_paths = use_tms_paths
        if self.module == "amazon":
            self.cache = self.s3.AWSAuthConnection(access_key,
                                                   secret_access_key)
            self.cache.create_bucket(self.bucket_name)
        else:
            self.cache = self.s3.connection.S3Connection(
                access_key, secret_access_key)
            self.bucket = self.cache.create_bucket(self.bucket_name)
Beispiel #14
0
 def __init__(self, host, port, expiration=0, **kwargs):
     """Initialize redis"""
     Cache.__init__(self, **kwargs)
     import redis
     self.cache = redis.StrictRedis(host=host, port=port, db=0)
     self.expiration = int(expiration)
Beispiel #15
0
 def __init__(self, base=None, ext=None, umask='002', **kwargs):
     Cache.__init__(self, **kwargs)
     self.basedir = base
     self.ext = ext
Beispiel #16
0
 def __init__(self, url=None, referer='http://map.geo.admin.ch/', **kwargs):
     Cache.__init__(self, **kwargs)
     self.host = url
     self.readonly = True
     self.headers = {'Referer': referer}
Beispiel #17
0
 def __init__ (self, base = None, ext = None, umask = '002', **kwargs):
     Cache.__init__(self, **kwargs)
     self.basedir = base
     self.ext = ext
Beispiel #18
0
 def __init__ (self, **kwargs):
     Cache.__init__(self, **kwargs)
     # the Test cache is never readonly
     self.readonly = False
Beispiel #19
0
 def __init__ (self, username, api_key, container, **kwargs):
     Cache.__init__(self, **kwargs)
     connection = connect_cloudfiles(username, api_key)
     self.container = connection.get_container(container)
Beispiel #20
0
 def __init__(self, service):
     Cache.__init__(self)
     self.service = service
     self.basedir = self.get_tiles_path()
Beispiel #21
0
 def __init__(self, host, port, expiration=0, **kwargs):
     """Initialize redis"""
     Cache.__init__(self, **kwargs)
     import redis
     self.cache = redis.StrictRedis(host=host, port=port, db=0)
     self.expiration = int(expiration)
Beispiel #22
0
 def __init__ (self, servers = ['127.0.0.1:11211'], **kwargs):
     Cache.__init__(self, **kwargs)
     if type(servers) is str: servers = map(str.strip, servers.split(","))
     self.cache = memcache.Client(servers, debug=0)
Beispiel #23
0
 def __init__(self, servers=['127.0.0.1:11211'], **kwargs):
     Cache.__init__(self, **kwargs)
     if type(servers) is str:
         servers = map(str.strip, servers.split(","))
     self.cache = memcache.Client(servers, debug=0)
     self.timeout = int(kwargs.get('timeout', 0))