def __init__(self, db_name="d", host = None, port = None): self.model_has_been_created = False try: if not host and not port: self.storage = ZODB.FileStorage.FileStorage(file_name=db_name, blob_dir='.blob') self.db = ZODB.DB(self.storage) else: self.storage = ClientStorage.ClientStorage((host,port)) self.db = ZODB.DB(self.storage) self.connection = self.db.open() self.root = self.connection.root() _init(self) self.users = self.root['users'] self.piadas = self.root['piadas'] self.admin = self.root['admin'] pass except Exception as e: raise Exception("Database Error - " + str(e))
def get_storage(): try: return _thread_data.zodb_storage except AttributeError: addr = '127.0.0.1', 5001 storage = _thread_data.zodb_storage = ClientStorage.ClientStorage(addr) return storage
def spojiSeNaServer(self): #self.spremnik = ClientStorage.ClientStorage(('localhost', 1981)) self.spremnik = ClientStorage.ClientStorage(('45.63.117.103', 1981)) self.spremnik.server_sync = True self.bp = DB(self.spremnik) self.veza = self.bp.open() self.root = self.veza.root()
def _get_db(self): """ Open the connection to the database based on the configuration file. """ return DB( ClientStorage.ClientStorage((self.server, self.port)) )
def __init__(self): self.query = self.exists #if not os.path.exists (self.default_database): #os.makedirs (os.path.dirname (self.default_database), exist_ok = True) #self.zodb_storage = ZODB.FileStorage.FileStorage (self.default_database) self.zodb_storage = ClientStorage.ClientStorage(self.default_database) self.zodb = ZODB.DB(self.zodb_storage)
def __init__(self, connectSpecs, root='pps_store'): storage = ClientStorage.ClientStorage(connectSpecs) db = ZODB.DB(storage) self.__conn = db.open() dbroot = self.__conn.root() if not dbroot.has_key(root): dbroot[root] = BTrees.OOBTree.OOBTree() get_transaction().commit() self.__db = dbroot[root]
def __init__(self, minfo): self.connection = None self.root = None self.storage = ClientStorage.ClientStorage( minfo.getRoomBookingDBConnectionParams(), username=minfo.getRoomBookingDBUserName(), password=minfo.getRoomBookingDBPassword(), realm=minfo.getRoomBookingDBRealm()) self.db = DB(self.storage)
def ZKClientStorage(zkaddr, path, *args, **kw): zk = zc.zk.ZooKeeper(zkaddr) ppath = path + PROVIDERS addresses = zk.children(ppath) blob_addresses = zk.children(path + '/blobs' + PROVIDERS) blob_servers = [] @blob_addresses def update_blob_servers(addrs): blob_servers[:] = ['http://%s/' % addr for addr in addrs] wait = kw.get('wait', kw.get('wait_for_server_on_startup', True)) # XXX lots of underware here client = ClientStorage( zc.zkzeo._client._wait_addresses( addresses, zc.zkzeo._client.parse_addr, zkaddr, ppath, wait), blob_servers, *args, **kw) client.zookeeper_blob_addresses = blob_addresses return zc.zkzeo._client._client(addresses, client, zkaddr, ppath)
def __init__(self, store_name = 'file:root.db', username='', passwd='', alt_connection=None): """Open the F2 object storage, returns the root_object. The store_name may have three forms: - file:<local pathname to file storage> - rpc:<host_address>:<port_number> - shared: In the 3rd case, a connection is already open on some storage, and is passed in parameter alt_connection. """ self.db = None self.connection = None self.db_root = None if store_name.find(':') < 0: store_name = 'file:'+store_name if store_name[:5] == 'file:' : storage = FileStorage.FileStorage(store_name[5:]) self.db = DB(storage) self.connection = self.db.open() elif store_name[:4] == 'rpc:' : server_addr = store_name[4:] if server_addr.find(':') >= 0 : serv_port = server_addr.split(':') serv_port[1] = int(serv_port[1]) if not serv_port[0]: serv_port[0] = '127.0.0.1' else: serv_port = [server_addr, 8080] storage = ClientStorage.ClientStorage(addr = tuple(serv_port), username = username, password = passwd) self.db = DB(storage) self.connection = self.db.open() elif store_name[:7] == 'shared:' : self.connection = alt_connection self.db = self.connection.db() else: # nothing known. raise F2StorageError('Unsupported storage type (file:, rpc:, or shared:).') self.db_root = self.connection.root() global currentOFFStore, db_root currentOFFStore = self # short circuit on current store for bootstrap db_root = self.db_root if 'F2_Signature' not in self.db_root: raise F2StorageError("Empty F2 storage, run the bootstrap process (bootf2.py) before usage.")
def __init__(self, directory=None, server=None): self.directory = directory if directory: if not os.path.isdir(directory): os.mkdir(directory) blobdir = os.path.join(directory, 'blobstorage') if not os.path.isdir(blobdir): os.mkdir(blobdir) storage = FileStorage(os.path.join(directory, 'zgraph.db'), blob_dir=blobdir) elif server: storage = ClientStorage.ClientStorage(server) else: raise Exception("Can't create storage") self.storage = storage self.db = ZODB.DB(self.storage, large_record_size=16777216 * 2) self.connection = self.db.open() self.root = self.connection.root if not getattr(self.root, '_initialized', False): print 'Initializing ZGraph in', self.directory self.root.nodes = IOBTree.IOBTree() self.root.edges = IOBTree.IOBTree() self.root._edgeid = Length() self.root._nodeid = Length() self.root.nodecatalog = Catalog(object_store=self.root.nodes) self.root.edgecatalog = Catalog(object_store=self.root.edges) self.root._initialized = True if not hasattr(self.root, 'typeids'): print 'adding Graphagus' self.addGraphagus() self.nodes = self.root.nodes self.edges = self.root.edges self._edgeid = self.root._edgeid self._nodeid = self.root._nodeid self.nodecatalog = self.root.nodecatalog self.edgecatalog = self.root.edgecatalog self.outbytype = self.root.outbytype self.inbytype = self.root.inbytype self.outbysource = self.root.outbysource self.inbytarget = self.root.inbytarget self._typeid = self.root._typeid self.typeids = self.root.typeids self.revtypes = self.root.revtypes
def client_storage(sock, *args, **kw): """ Storage client :param sock: UNIX or TCP socket :param cipher: Encryptor to use (see zerodb.crypto) :param bool debug: Output debug messages to the log :param transforming_storage: Wrapper-storage to use (TransformingStorage) :returns: Storage :rtype: TransformingStorage """ if six.PY2 and isinstance(sock, unicode): sock = str(sock) TransformingStorage = kw.pop('transforming_storage', transforming.TransformingStorage) debug = kw.pop("debug", False) return TransformingStorage(ClientStorage(sock, *args, **kw), debug=debug)
def __init__(self, logger, addr): self.logger = logger #storage = FileStorage.FileStorage(dbfile) self.storage = ClientStorage.ClientStorage(addr) self.db = DB(self.storage) self.conn = self.db.open() self.dbroot = self.conn.root() # Check whether database is initialized for name in [ 'program', 'ob', 'executed_ob', 'exposure', 'saved_state' ]: key = '%s_db' % name if key not in self.dbroot: tbl = OOBTree() self.dbroot[key] = tbl transaction.commit() if 'queue_mgmt' not in self.dbroot: self.dbroot['queue_mgmt'] = QueueMgmtRec() transaction.commit()
from ZEO import ClientStorage from ZODB.FileStorage import FileStorage from pathquery import PathQuery as pq runs = int(sys.argv[1]) dbtype = sys.argv[2] if dbtype.startswith('f'): storage = FileStorage('Data.fs') else: clientid = sys.argv[3] addr = ('localhost', 1234) #storage = ClientStorage.ClientStorage(addr,cache_size=2048*1024*1024,client='shm/p_gclient' +clientid) storage = ClientStorage.ClientStorage(addr, cache_size=512 * 1024 * 1024, client='querykmcache' + clientid) #storage = ClientStorage.ClientStorage(addr,cache_size=0) #storage = ClientStorage.ClientStorage(addr) #db = DB(storage,cache_size=1000000,cache_size_bytes=1024*1024*124) db = DB(storage, cache_size=200000, cache_size_bytes=1024 * 1024 * 124) #this uses 0.03 secs #db = DB(storage) connection = db.open() root = connection.root() g = root['graphdb'] fixedtarget = None maxnum = 1000
def patched_loadBlob(self, oid, serial): # Load a blob. If it isn't present and we have a shared blob # directory, then assume that it doesn't exist on the server # and return None. if self.fshelper is None: raise Unsupported("No blob cache directory is configured.") blob_filename = self.fshelper.getBlobFilename(oid, serial) if self.shared_blob_dir: if os.path.exists(blob_filename): return blob_filename else: # create empty file create_empty_blob(blob_filename) if os.path.exists(blob_filename): return blob_filename else: # We're using a server shared cache. If the file isn't # here, it's not anywhere. raise POSKeyError("No blob file", oid, serial) if os.path.exists(blob_filename): return ClientStorage._accessed(blob_filename) else: # create empty file create_empty_blob(blob_filename) if os.path.exists(blob_filename): return ClientStorage._accessed(blob_filename) # First, we'll create the directory for this oid, if it doesn't exist. self.fshelper.createPathForOID(oid) # OK, it's not here and we (or someone) needs to get it. We # want to avoid getting it multiple times. We want to avoid # getting it multiple times even accross separate client # processes on the same machine. We'll use file locking. lock = ClientStorage._lock_blob(blob_filename) try: # We got the lock, so it's our job to download it. First, # we'll double check that someone didn't download it while we # were getting the lock: if os.path.exists(blob_filename): return ClientStorage._accessed(blob_filename) # Ask the server to send it to us. When this function # returns, it will have been sent. (The recieving will # have been handled by the asyncore thread.) self._server.sendBlob(oid, serial) if os.path.exists(blob_filename): return ClientStorage._accessed(blob_filename) raise POSKeyError("No blob file", oid, serial) finally: lock.close()
import graphagus, sys, random, time, transaction from ZODB import DB from ZEO import ClientStorage from ZODB.FileStorage import FileStorage dbtype = sys.argv[1] if dbtype.startswith('f'): if len(sys.argv) > 2: filename = sys.argv[2] else: filename = 'Data.fs' storage = FileStorage(filename) else: if len(sys.argv) > 2: clientid = sys.argv[2] else: clientid = '1' addr = ('localhost', 1234) storage = ClientStorage.ClientStorage(addr, cache_size=1024 * 1024 * 1024, client='console_cache' + clientid) db = DB(storage) connection = db.open() root = connection.root() try: g = root['graphdb'] except: pass
def opendb(self): addr = (self.options.host, self.options.port) self._storage = ClientStorage.ClientStorage(addr) self.db = DB(self._storage) self.poollock = Lock()
def DB(*args, **kw): import ZODB return ZODB.DB(ClientStorage(*args, **kw))
from ZODB.FileStorage import FileStorage dbtype = sys.argv[1] if dbtype.startswith('f'): if len(sys.argv)>2: filename=sys.argv[2] else: filename='Test.fs' storage = FileStorage(filename) else: if len(sys.argv)>2: clientid=sys.argv[2] else: clientid='1' addr = ('localhost',1234) storage = ClientStorage.ClientStorage(addr,cache_size=1024*1024*1024,client='testcache' +clientid) db = DB(storage) connection = db.open() root = connection.root() if 1 or not root.has_key('graphdb'): root['graphdb']=p_g.GraphDB() g=root['graphdb'] g.node_catalog['name']=p_g.CatalogFieldIndex(p_g.get_key('name')) g.node_catalog['lastname']=p_g.CatalogFieldIndex(p_g.get_key('lastname')) likes = g.typeid('likes') alice = g.addNode(name='alice') bob = g.addNode(name='bob')
def __init__(self, addr=('localhost', 9100)): self.addr = addr self.storage = ClientStorage.ClientStorage(self.addr) self.db = DB(self.storage) self.conn = self.db.open() self.root = self.conn.root()
def __init__(self, storage_name=('localhost', 9100)): self.storage = ClientStorage.ClientStorage(storage_name) self.db = DB(self.storage) self.connection = self.open_connection(self.db) self.root = self.get_root(self.connection)
"""creates the battle log object. VERY DESTRUCTIVE.""" from ZEO import ClientStorage from ZODB import DB import transaction import persistent.mapping #from equanimity.world import wField, wPlayer, World addr = 'localhost', 9101 storage = ClientStorage.ClientStorage(addr) db = DB(storage) conn = db.open() logs = conn.root() #TODO: index logs by when and where the battle happened. def create(): logs['battle'] = persistent.mapping.PersistentMapping() transaction.commit()
# it if necessary. if not sessions.has_key(channelname): print 'Creating new session:', channelname sessions[channelname] = ChatSession(channelname) transaction.commit() session = sessions[channelname] return session if __name__ == '__main__': if len(sys.argv) != 2: print 'Usage: %s <channelname>' % sys.argv[0] sys.exit(0) storage = ClientStorage.ClientStorage(('localhost', 9672)) db = ZODB.DB(storage) conn = db.open() s = session = get_chat_session(conn, sys.argv[1]) messages = ['Hi.', 'Hello', 'Me too', "I'M 3L33T!!!!"] while 1: # Send a random message msg = random.choice(messages) session.add_message('%s: pid %i' % (msg, os.getpid())) # Display new messages for msg in session.new_messages(): print msg