ige.SQLiteDatabase.Database._delCacheItem() - Code Metrics - Inspection of "Merge pull request #211 from dahaic/small_fixes" - ospaceteam/outerspace - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cc2800...40418d )

by Marek

created 2018-07-01 18:48 UTC

ige.SQLiteDatabase.Database._delCacheItem() A

↳ Parent: ige.SQLiteDatabase

Complexity

Conditions

Size

Total Lines	6
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	5
nop	2
dl	0
loc	6
rs	10
c	0
b	0
f	0

#
#  Copyright 2001 - 2016 Ludek Smid [http://www.ospace.net/]
#
#  This file is part of Outer Space.
#
#  Outer Space is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  Outer Space is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with Outer Space; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#

import ige
import os.path, log, os, sys, time, types, binascii, bz2
import cPickle as pickle
import sqlite3

IDX_PREV = 0
IDX_NEXT = 1

class Database:

    dbSchema = "data(oid integer primary key asc, data blog not null)"
    keyMethod = int

    def __init__(self, directory, dbName, cache = 128):
        log.message("Opening database", dbName)
        self.dbName = dbName
        self.nextID = 10000
        self.cacheSize = cache
        #
        try:
            os.makedirs(directory)
        except OSError:
            pass
        # open db
        self.connection = sqlite3.connect(os.path.join(directory, "%s.sqlite" % dbName))
        # allow 8-bits strings to be handled correctly (default is unicode)
        self.connection.text_factory = str
        self.cursor = self.connection.cursor()
        self.cursor.execute("create table if not exists %s" % self.dbSchema)
        self.connection.commit()
        # cache
        self.cache = {}
        self.cacheLinks = {
            "__first__": [None, "__last__"],
            "__last__": ["__first__", None],
        }
        # stats
        self.statCount = 0
        self.statHit = 0
        self.statSwap = 0
        self.statMiss = 0
        self.statCleanSwap = 0

    def _moveExistingCacheItem(self, key):
        #@log.debug("Cache MOVE ITEM", key, self.cacheLinks[key])
        # optimalization
        cl = self.cacheLinks
        # move item to the end of the chain
        prev, next = cl[key]
        cl[prev][IDX_NEXT] = next
        cl[next][IDX_PREV] = prev
        last = cl["__last__"]
        prev = last[IDX_PREV]

        cl[key] = [prev, "__last__"]
        cl[prev][IDX_NEXT] = key
        last[IDX_PREV] = key
        # print chain
        #idx = "__first__"
        #result = []
        #while idx != None:
        #    item = self.cacheLinks[idx]
        #    result.append("%s:%s" % (idx, item))
        #    idx = item[IDX_NEXT]
        #log.debug("Cache CHAIN", " ".join(result))

    def _addNewCacheItem(self, key):
        #@log.debug("Cache ADD ITEM", key)
        # check cache size
        #@log.debug("Cache size", len(self.cache), self.cacheSize)
        if len(self.cache) > self.cacheSize:
            tries = len(self.cache)
            while len(self.cache) > self.cacheSize:
                # swap out oldest item
                current = self.cacheLinks["__first__"]
                oldKey = current[IDX_NEXT]

                tries -= 1
                if tries == 0:
                    # no room in the cache -> enlarge it
                    log.debug("NO ROOM IN THE CACHE", self.dbName, len(self.cache))
                    self.cacheSize += 100
                    break
                if sys.getrefcount(self.cache[oldKey]) > 2:
                    #@log.debug("CANNOT swap out", oldKey, "refs", sys.getrefcount(self.cache[oldKey]) - 2)
                    # try next element
                    self._moveExistingCacheItem(oldKey)
                    #@log.debug("Trying to swap out", current[IDX_NEXT])
                    continue
                else:
                    #@log.debug("Swapping out", oldKey)
                    self.statSwap += 1
                    #TODOif not self.cache[oldKey]._v_modified:
                    #TODO    self.statCleanSwap += 1
                    prev, next = self.cacheLinks[oldKey]
                    current[IDX_NEXT] = next
                    self.cacheLinks[next][IDX_PREV] = prev
                    self.put(oldKey, pickle.dumps(self.cache[oldKey], pickle.HIGHEST_PROTOCOL))
                    del self.cacheLinks[oldKey]
                    del self.cache[oldKey]
                    # found space
                    break
        # put item at the end of the chain
        last = self.cacheLinks["__last__"]
        prev = last[IDX_PREV]

        self.cacheLinks[prev][IDX_NEXT] = key
        self.cacheLinks[key] = [prev, "__last__"]
        last[IDX_PREV] = key
        # print chain
        #idx = "__first__"
        #result = []
        #while idx != None:
        #    item = self.cacheLinks[idx]
        #    result.append("%s:%s" % (idx, item))
        #    idx = item[IDX_NEXT]
        #log.debug("Cache CHAIN", " ".join(result))

    def _updateCacheItem(self, key):
        if key in self.cache:
            return self._moveExistingCacheItem(key)
        return self._addNewCacheItem(key)

    def _delCacheItem(self, key):
        #@log.debug("Cache DEL ITEM", key)
        prev, next = self.cacheLinks[key]
        self.cacheLinks[prev][IDX_NEXT] = next
        self.cacheLinks[next][IDX_PREV] = prev
        del self.cacheLinks[key]

    def __getitem__(self, key):
        key = self.keyMethod(key)
        self.statCount += 1
        if key in self.cache:
            self.statHit += 1
            self._moveExistingCacheItem(key)
            return self.cache[key]
        self.statMiss += 1
        self.cursor.execute("select * from data where oid = ?", (key,))
        row = self.cursor.fetchone()
        if row is None:
            raise ige.NoSuchObjectException(key)
        item = pickle.loads(str(row[1]))
        self._addNewCacheItem(key)
        self.cache[key] = item
        #TODOitem.setModified(0)
        return item

    def __setitem__(self, key, value):
        key = self.keyMethod(key)
        if type(value) == types.InstanceType:
            value.oid = key
        # set value
        self._updateCacheItem(key)
        self.cache[key] = value
        #value.setModified(0)
        # write through new objects
        if not self.has_key(key):
            raise ige.ServerException("'%s' created using set method" % key)

    def __delitem__(self, key):
        key = self.keyMethod(key)
        if key in self.cache:
            self._delCacheItem(key)
            del self.cache[key]
        self.cursor.execute("delete from data where oid = ?", (key,))

    def has_key(self, key):
        key = self.keyMethod(key)
        self.cursor.execute("select oid from data where oid = ?", (key,))
        return self.cursor.fetchone() is not None

    def keys(self):
        self.cursor.execute("select oid from data")
        return [row[0] for row in self.cursor]

    def getItemLength(self, key):
        key = self.keyMethod(key)
        self.cursor.execute("select * from data where oid = ?", (key,))
        row = self.cursor.fetchone()
        if row is None:
            raise ige.NoSuchObjectException(key)
        return len(str(row[1]))

    def checkpoint(self):
        log.debug('DB Checkpoint', self.dbName)
        log.debug("Storing all objects")
        for key, value in self.cache.iteritems():
            self.put(key, pickle.dumps(value, pickle.HIGHEST_PROTOCOL))
        # commit transaction
        log.debug("Commiting transaction")
        self.connection.commit()
        log.debug("Commit completed")
        # TODO clear cache?
        # self.cache.clear()
        # self.cacheLinks.clear()
        # stats TODO: reenable
        self.cursor.execute("select * from data")
        items = 0
        for i in self.cursor:
            items += 1
        if self.statCount > 0:
            log.debug("****** %s" % self.dbName)
            log.debug("Items: %10d" % items)
            log.debug("Count: %10d" % self.statCount)
            log.debug("Hit  : %10d [%02d %%]" % (self.statHit, int(self.statHit * 100 / self.statCount)))
            log.debug("Miss : %10d [%02d %%]" % (self.statMiss, int(self.statMiss * 100 / self.statCount)))
            log.debug("Swap : %10d [%02d %%]" % (self.statSwap, int(self.statSwap * 100 / self.statCount)))
            log.debug("CSwap: %10d [%02d %%]" % (self.statCleanSwap, int(self.statCleanSwap * 100 / self.statCount)))
            log.debug("******")
        # more stats
        self.statCount = 0
        self.statHit = 0
        self.statMiss = 0
        self.statSwap = 0
        self.statCleanSwap = 0

    def commit(self):
        pass
        #log.debug("COMMIT?")
        #self.txn.commit()
        #self.txn = dbEnv.txn_begin()

    def checkpointDatabase(self):
        # checkpoint db (TODO can be moved into the separate process?)
        log.debug("Metakit Checkpoint")

    def shutdown(self):
        log.message('DB Shutting down', self.dbName)
        self.checkpoint()
        del self.connection

    def clear(self):
        log.message("Deleting database", self.dbName)
        self.cursor.execute("delete from data")
        self.connection.commit()
        self.cache.clear()
        self.cacheLinks = {
            "__first__": [None, "__last__"],
            "__last__": ["__first__", None],
        }
        log.debug("Database is empty")

    def create(self, object, id = None):
        #@log.debug("Creating new object", id)
        if not id:
            id = self.nextID
            while self.has_key(id):
                id += 1
            self.nextID = id + 1
            id = self.keyMethod(id)
            object.oid = id
        elif hasattr(object, "oid") and object.oid != id:
            id = self.keyMethod(id)
            log.message("Object OID '%s' != forced OID '%s' - FIXING" % (object.oid, id))
            object.oid = id
        else:
            id = self.keyMethod(id)
        #@log.debug("OID =", id)
        if self.has_key(id):
            raise ige.ServerException("'%s' created twice" % id)
        self.cache[id] = object
        self._addNewCacheItem(id)
        self.put(id, pickle.dumps(object, pickle.HIGHEST_PROTOCOL))
        return id

    def delete(self, key):
        del self[key]

    def get(self, key, default = None):
        if self.has_key(key):
            return self[key]
        else:
            return default

    def put(self, key, data):
        self.cursor.execute("select oid from data where oid = ?", (key,))
        row = self.cursor.fetchone()
        if row:
            self.cursor.execute("update data set data = ? where oid = ?", (sqlite3.Binary(data), key))
        else:
            self.cursor.execute("insert into data (oid, data) values (?, ?)", (key, sqlite3.Binary(data)))
        #per put commits impacts performance significantly
        #self.connection.commit()

    def restore(self, filename):
        log.message("Restoring database from file", filename)
        fh = file(filename, "r")

        line = fh.readline().strip()
        if line != "IGE OUTER SPACE BACKUP VERSION 1":
            raise ige.ServerException("Incorrect header: %s" % line)
        while True:
            key = fh.readline().strip()
            if key == "END OF BACKUP":
                break
            data = fh.readline().strip()
            key = int(binascii.a2b_hex(key))
            data = binascii.a2b_hex(data)
            #@log.debug("Storing key", key)
            self.put(key, data)
        log.message("Database restored")

    def backup(self, basename):
        self.checkpoint()
        filename = "%s-%s.osbackup" % (basename, self.dbName)
        log.message("Creating backup", filename)
        fh = file(filename, "w") #bz2.BZ2File(filename, "w")

        fh.write("IGE OUTER SPACE BACKUP VERSION 1\n")
        for key in self.keys():
            fh.write(binascii.b2a_hex(str(key)))
            fh.write("\n")
            fh.write(binascii.b2a_hex(pickle.dumps(self[key], pickle.HIGHEST_PROTOCOL)))
            fh.write("\n")
        fh.write("END OF BACKUP\n")
        fh.close()
        log.message("Backup completed")

class DatabaseString(Database):

    dbSchema = "data(oid text primary key asc, data blog not null)"
    keyMethod = str

    def restore(self, filename, include = None):
        log.message("Restoring database from file", filename)
        fh = file(filename, "r")

        line = fh.readline().strip()
        if line != "IGE OUTER SPACE BACKUP VERSION 1":
            raise ige.ServerException("Incorrect header: %s" % line)
        imported = 0
        skipped = 0
        while True:
            key = fh.readline().strip()
            if key == "END OF BACKUP":
                break
            data = fh.readline().strip()
            key = binascii.a2b_hex(key)
            if include and not include(key):
                skipped += 1
                continue
            imported += 1
            data = binascii.a2b_hex(data)
            #@log.debug("Storing key", key)
            self.put(key, data)
        log.message("Database restored (%d imported, %d skipped)" % (imported, skipped))



1			#
2			# Copyright 2001 - 2016 Ludek Smid [http://www.ospace.net/]
3			#
4			# This file is part of Outer Space.
5			#
6			# Outer Space is free software; you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation; either version 2 of the License, or
9			# (at your option) any later version.
10			#
11			# Outer Space is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with Outer Space; if not, write to the Free Software
18			# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19			#
20
21			import ige
22			import os.path, log, os, sys, time, types, binascii, bz2
23			import cPickle as pickle
24			import sqlite3
25
26			IDX_PREV = 0
27			IDX_NEXT = 1
28
29			class Database:
30
31			dbSchema = "data(oid integer primary key asc, data blog not null)"
32			keyMethod = int
33
34			def __init__(self, directory, dbName, cache = 128):
35			log.message("Opening database", dbName)
36			self.dbName = dbName
37			self.nextID = 10000
38			self.cacheSize = cache
39			#
40			try:
41			os.makedirs(directory)
42			except OSError:
43			pass
44			# open db
45			self.connection = sqlite3.connect(os.path.join(directory, "%s.sqlite" % dbName))
46			# allow 8-bits strings to be handled correctly (default is unicode)
47			self.connection.text_factory = str
48			self.cursor = self.connection.cursor()
49			self.cursor.execute("create table if not exists %s" % self.dbSchema)
50			self.connection.commit()
51			# cache
52			self.cache = {}
53			self.cacheLinks = {
54			"__first__": [None, "__last__"],
55			"__last__": ["__first__", None],
56			}
57			# stats
58			self.statCount = 0
59			self.statHit = 0
60			self.statSwap = 0
61			self.statMiss = 0
62			self.statCleanSwap = 0
63
64			def _moveExistingCacheItem(self, key):
65			#@log.debug("Cache MOVE ITEM", key, self.cacheLinks[key])
66			# optimalization
67			cl = self.cacheLinks
68			# move item to the end of the chain
69			prev, next = cl[key]
70			cl[prev][IDX_NEXT] = next
71			cl[next][IDX_PREV] = prev
72			last = cl["__last__"]
73			prev = last[IDX_PREV]
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `IDX_PREV` does not seem to be defined. Loading history...
74			cl[key] = [prev, "__last__"]
75			cl[prev][IDX_NEXT] = key
76			last[IDX_PREV] = key
77			# print chain
78			#idx = "__first__"
79			#result = []
80			#while idx != None:
81			# item = self.cacheLinks[idx]
82			# result.append("%s:%s" % (idx, item))
83			# idx = item[IDX_NEXT]
84			#log.debug("Cache CHAIN", " ".join(result))
85
86			def _addNewCacheItem(self, key):
87			#@log.debug("Cache ADD ITEM", key)
88			# check cache size
89			#@log.debug("Cache size", len(self.cache), self.cacheSize)
90			if len(self.cache) > self.cacheSize:
91			tries = len(self.cache)
92			while len(self.cache) > self.cacheSize:
93			# swap out oldest item
94			current = self.cacheLinks["__first__"]
95			oldKey = current[IDX_NEXT]
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `IDX_NEXT` does not seem to be defined. Loading history...
96			tries -= 1
97			if tries == 0:
98			# no room in the cache -> enlarge it
99			log.debug("NO ROOM IN THE CACHE", self.dbName, len(self.cache))
100			self.cacheSize += 100
101			break
102			if sys.getrefcount(self.cache[oldKey]) > 2:
103			#@log.debug("CANNOT swap out", oldKey, "refs", sys.getrefcount(self.cache[oldKey]) - 2)
104			# try next element
105			self._moveExistingCacheItem(oldKey)
106			#@log.debug("Trying to swap out", current[IDX_NEXT])
107			continue
108			else:
109			#@log.debug("Swapping out", oldKey)
110			self.statSwap += 1
111			#TODOif not self.cache[oldKey]._v_modified:
112			#TODO self.statCleanSwap += 1
113			prev, next = self.cacheLinks[oldKey]
114			current[IDX_NEXT] = next
115			self.cacheLinks[next][IDX_PREV] = prev
116			self.put(oldKey, pickle.dumps(self.cache[oldKey], pickle.HIGHEST_PROTOCOL))
117			del self.cacheLinks[oldKey]
118			del self.cache[oldKey]
119			# found space
120			break
121			# put item at the end of the chain
122			last = self.cacheLinks["__last__"]
123			prev = last[IDX_PREV]
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `IDX_PREV` does not seem to be defined. Loading history...
124			self.cacheLinks[prev][IDX_NEXT] = key
125			self.cacheLinks[key] = [prev, "__last__"]
126			last[IDX_PREV] = key
127			# print chain
128			#idx = "__first__"
129			#result = []
130			#while idx != None:
131			# item = self.cacheLinks[idx]
132			# result.append("%s:%s" % (idx, item))
133			# idx = item[IDX_NEXT]
134			#log.debug("Cache CHAIN", " ".join(result))
135
136			def _updateCacheItem(self, key):
137			if key in self.cache:
138			return self._moveExistingCacheItem(key)
139			return self._addNewCacheItem(key)
140
141			def _delCacheItem(self, key):
142			#@log.debug("Cache DEL ITEM", key)
143			prev, next = self.cacheLinks[key]
144			self.cacheLinks[prev][IDX_NEXT] = next
145			self.cacheLinks[next][IDX_PREV] = prev
146			del self.cacheLinks[key]
147
148			def __getitem__(self, key):
149			key = self.keyMethod(key)
150			self.statCount += 1
151			if key in self.cache:
152			self.statHit += 1
153			self._moveExistingCacheItem(key)
154			return self.cache[key]
155			self.statMiss += 1
156			self.cursor.execute("select * from data where oid = ?", (key,))
157			row = self.cursor.fetchone()
158			if row is None:
159			raise ige.NoSuchObjectException(key)
160			item = pickle.loads(str(row[1]))
161			self._addNewCacheItem(key)
162			self.cache[key] = item
163			#TODOitem.setModified(0)
164			return item
165
166			def __setitem__(self, key, value):
167			key = self.keyMethod(key)
168			if type(value) == types.InstanceType:
169			value.oid = key
170			# set value
171			self._updateCacheItem(key)
172			self.cache[key] = value
173			#value.setModified(0)
174			# write through new objects
175			if not self.has_key(key):
176			raise ige.ServerException("'%s' created using set method" % key)
177
178			def __delitem__(self, key):
179			key = self.keyMethod(key)
180			if key in self.cache:
181			self._delCacheItem(key)
182			del self.cache[key]
183			self.cursor.execute("delete from data where oid = ?", (key,))
184
185			def has_key(self, key):
186			key = self.keyMethod(key)
187			self.cursor.execute("select oid from data where oid = ?", (key,))
188			return self.cursor.fetchone() is not None
189
190			def keys(self):
191			self.cursor.execute("select oid from data")
192			return [row[0] for row in self.cursor]
193
194			def getItemLength(self, key):
195			key = self.keyMethod(key)
196			self.cursor.execute("select * from data where oid = ?", (key,))
197			row = self.cursor.fetchone()
198			if row is None:
199			raise ige.NoSuchObjectException(key)
200			return len(str(row[1]))
201
202			def checkpoint(self):
203			log.debug('DB Checkpoint', self.dbName)
204			log.debug("Storing all objects")
205			for key, value in self.cache.iteritems():
206			self.put(key, pickle.dumps(value, pickle.HIGHEST_PROTOCOL))
207			# commit transaction
208			log.debug("Commiting transaction")
209			self.connection.commit()
210			log.debug("Commit completed")
211			# TODO clear cache?
212			# self.cache.clear()
213			# self.cacheLinks.clear()
214			# stats TODO: reenable
215			self.cursor.execute("select * from data")
216			items = 0
217			for i in self.cursor:
218			items += 1
219			if self.statCount > 0:
220			log.debug("****** %s" % self.dbName)
221			log.debug("Items: %10d" % items)
222			log.debug("Count: %10d" % self.statCount)
223			log.debug("Hit : %10d [%02d %%]" % (self.statHit, int(self.statHit * 100 / self.statCount)))
224			log.debug("Miss : %10d [%02d %%]" % (self.statMiss, int(self.statMiss * 100 / self.statCount)))
225			log.debug("Swap : %10d [%02d %%]" % (self.statSwap, int(self.statSwap * 100 / self.statCount)))
226			log.debug("CSwap: %10d [%02d %%]" % (self.statCleanSwap, int(self.statCleanSwap * 100 / self.statCount)))
227			log.debug("******")
228			# more stats
229			self.statCount = 0
230			self.statHit = 0
231			self.statMiss = 0
232			self.statSwap = 0
233			self.statCleanSwap = 0
234
235			def commit(self):
236			pass
237			#log.debug("COMMIT?")
238			#self.txn.commit()
239			#self.txn = dbEnv.txn_begin()
240
241			def checkpointDatabase(self):
242			# checkpoint db (TODO can be moved into the separate process?)
243			log.debug("Metakit Checkpoint")
244
245			def shutdown(self):
246			log.message('DB Shutting down', self.dbName)
247			self.checkpoint()
248			del self.connection
249
250			def clear(self):
251			log.message("Deleting database", self.dbName)
252			self.cursor.execute("delete from data")
253			self.connection.commit()
254			self.cache.clear()
255			self.cacheLinks = {
256			"__first__": [None, "__last__"],
257			"__last__": ["__first__", None],
258			}
259			log.debug("Database is empty")
260
261			def create(self, object, id = None):
262			#@log.debug("Creating new object", id)
263			if not id:
264			id = self.nextID
265			while self.has_key(id):
266			id += 1
267			self.nextID = id + 1
268			id = self.keyMethod(id)
269			object.oid = id
270			elif hasattr(object, "oid") and object.oid != id:
271			id = self.keyMethod(id)
272			log.message("Object OID '%s' != forced OID '%s' - FIXING" % (object.oid, id))
273			object.oid = id
274			else:
275			id = self.keyMethod(id)
276			#@log.debug("OID =", id)
277			if self.has_key(id):
278			raise ige.ServerException("'%s' created twice" % id)
279			self.cache[id] = object
280			self._addNewCacheItem(id)
281			self.put(id, pickle.dumps(object, pickle.HIGHEST_PROTOCOL))
282			return id
283
284			def delete(self, key):
285			del self[key]
286
287			def get(self, key, default = None):
288			if self.has_key(key):
289			return self[key]
290			else:
291			return default
292
293			def put(self, key, data):
294			self.cursor.execute("select oid from data where oid = ?", (key,))
295			row = self.cursor.fetchone()
296			if row:
297			self.cursor.execute("update data set data = ? where oid = ?", (sqlite3.Binary(data), key))
298			else:
299			self.cursor.execute("insert into data (oid, data) values (?, ?)", (key, sqlite3.Binary(data)))
300			#per put commits impacts performance significantly
301			#self.connection.commit()
302
303			def restore(self, filename):
304			log.message("Restoring database from file", filename)
305			fh = file(filename, "r")
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `file` does not seem to be defined. Loading history...
306			line = fh.readline().strip()
307			if line != "IGE OUTER SPACE BACKUP VERSION 1":
308			raise ige.ServerException("Incorrect header: %s" % line)
309			while True:
310			key = fh.readline().strip()
311			if key == "END OF BACKUP":
312			break
313			data = fh.readline().strip()
314			key = int(binascii.a2b_hex(key))
315			data = binascii.a2b_hex(data)
316			#@log.debug("Storing key", key)
317			self.put(key, data)
318			log.message("Database restored")
319
320			def backup(self, basename):
321			self.checkpoint()
322			filename = "%s-%s.osbackup" % (basename, self.dbName)
323			log.message("Creating backup", filename)
324			fh = file(filename, "w") #bz2.BZ2File(filename, "w")
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `file` does not seem to be defined. Loading history...
325			fh.write("IGE OUTER SPACE BACKUP VERSION 1\n")
326			for key in self.keys():
327			fh.write(binascii.b2a_hex(str(key)))
328			fh.write("\n")
329			fh.write(binascii.b2a_hex(pickle.dumps(self[key], pickle.HIGHEST_PROTOCOL)))
330			fh.write("\n")
331			fh.write("END OF BACKUP\n")
332			fh.close()
333			log.message("Backup completed")
334
335			class DatabaseString(Database):
336
337			dbSchema = "data(oid text primary key asc, data blog not null)"
338			keyMethod = str
339
340			def restore(self, filename, include = None):
341			log.message("Restoring database from file", filename)
342			fh = file(filename, "r")
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-13 22:14 UTC by Report Bug Copy Issue Report The variable `file` does not seem to be defined. Loading history...
343			line = fh.readline().strip()
344			if line != "IGE OUTER SPACE BACKUP VERSION 1":
345			raise ige.ServerException("Incorrect header: %s" % line)
346			imported = 0
347			skipped = 0
348			while True:
349			key = fh.readline().strip()
350			if key == "END OF BACKUP":
351			break
352			data = fh.readline().strip()
353			key = binascii.a2b_hex(key)
354			if include and not include(key):
355			skipped += 1
356			continue
357			imported += 1
358			data = binascii.a2b_hex(data)
359			#@log.debug("Storing key", key)
360			self.put(key, data)
361			log.message("Database restored (%d imported, %d skipped)" % (imported, skipped))
362
363

ospaceteam / outerspace

Push — master ( cc2800...40418d )

ige.SQLiteDatabase.Database._delCacheItem() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like