Python TimeStamp.TimeStamp类代码示例

def run(path, days, notPacked):
    f = open(path, "rb")
    f.seek(0, 2)
    now = datetime.date.today()

    #day->size
    stats = {}
    th = prev_txn(f)

    bool = True
    while bool:
        ts = TimeStamp(th.tid)
        then = datetime.date(int(ts.year()), int(ts.month()), int(ts.day()))
        delta = timedelta(days=int(days))
        if( not(now - then < delta)):
            bool = False
        th = th.prev_txn()

    reader = Reader()
    iterator = FileIterator(path, pos=th._pos)
    for i in iterator:
        object_types = {}
        for o in i:
            ot = reader.getIdentity(o.data)
            try:
                stats[ot] = stats[ot] + 1
            except KeyError:
                stats[ot] = 1
    f.close()

    for (o,n) in sorted(stats.items(), key=lambda (k,v): v, reverse=True):
        print "%6d: %s" % (n,o)

    def tpc_begin(self, transaction, tid=None, status=' '):
        if self._is_read_only:
            raise POSException.ReadOnlyError()
        self._lock_acquire()
        try:
            if self._transaction is transaction:
                return
            self._lock_release()
            self._commit_lock_acquire()
            self._lock_acquire()
            self._transaction = transaction
            self._clear_temp()

            user = transaction.user
            desc = transaction.description
            ext = transaction._extension
            if ext:
                ext = cPickle.dumps(ext, 1)
            else:
                ext = ""
            self._ude = user, desc, ext

            if tid is None:
                now = time.time()
                t = TimeStamp(*(time.gmtime(now)[:5] + (now % 60,)))
                self._ts = t = t.laterThan(self._ts)
                self._tid = `t`
            else:
                self._ts = TimeStamp(tid)
                self._tid = tid

            self._tstatus = status
            self._begin(self._tid, user, desc, ext)
        finally:
            self._lock_release()

def copy(source, dest, verbose=0):
    """Copy transactions from a source to a destination storage

    This is typically used for converting data from one storage to
    another.  `source` must have an .iterator() method.
    """
    _ts = None
    ok = 1
    preindex = {};
    preget = preindex.get
    # restore() is a new storage API method which has an identical
    # signature to store() except that it does not return anything.
    # Semantically, restore() is also identical to store() except that it
    # doesn't do the ConflictError or VersionLockError consistency
    # checks.  The reason to use restore() over store() in this method is
    # that store() cannot be used to copy transactions spanning a version
    # commit or abort, or over transactional undos.
    #
    # We'll use restore() if it's available, otherwise we'll fall back to
    # using store().  However, if we use store, then
    # copyTransactionsFrom() may fail with VersionLockError or
    # ConflictError.
    restoring = py2_hasattr(dest, 'restore')
    fiter = source.iterator()
    for transaction in fiter:
        tid = transaction.tid
        if _ts is None:
            _ts = TimeStamp(tid)
        else:
            t = TimeStamp(tid)
            if t <= _ts:
                if ok: print(('Time stamps out of order %s, %s' % (_ts, t)))
                ok = 0
                _ts = t.laterThan(_ts)
                tid = _ts.raw()
            else:
                _ts = t
                if not ok:
                    print(('Time stamps back in order %s' % (t)))
                    ok = 1

        if verbose:
            print(_ts)

        dest.tpc_begin(transaction, tid, transaction.status)
        for r in transaction:
            oid = r.oid
            if verbose:
                print(oid_repr(oid), r.version, len(r.data))
            if restoring:
                dest.restore(oid, r.tid, r.data, r.version,
                             r.data_txn, transaction)
            else:
                pre = preget(oid, None)
                s = dest.store(oid, pre, r.data, r.version, transaction)
                preindex[oid] = s

        dest.tpc_vote(transaction)
        dest.tpc_finish(transaction)

def newTimeStamp(old=None,
                 TimeStamp=TimeStamp,
                 time=time.time, gmtime=time.gmtime):
    t = time()
    ts = TimeStamp(gmtime(t)[:5]+(t%60,))
    if old is not None:
        return ts.laterThan(old)
    return ts

    def testMTime(self):
        obj = P()
        self.assertEqual(obj._p_mtime, None)

        t = int(time.time())
        ts = TimeStamp(*time.gmtime(t)[:6])
        obj._p_serial = ts.raw()
        self.assertEqual(obj._p_mtime, t)
        self.assertIsInstance(obj._p_mtime, float)

def get_timestamp(prev_ts=None):
    """Internal helper to return a unique TimeStamp instance.

    If the optional argument is not None, it must be a TimeStamp; the
    return value is then guaranteed to be at least 1 microsecond later
    the argument.
    """
    t = time.time()
    t = TimeStamp(*time.gmtime(t)[:5] + (t % 60,))
    if prev_ts is not None:
        t = t.laterThan(prev_ts)
    return t

    def checkFullTimeStamp(self):
        native_ts = int(time.time()) # fractional seconds get in the way
        t = time.gmtime(native_ts)   # the corresponding GMT struct tm
        ts = TimeStamp(*t[:6])

        # Seconds are stored internally via (conceptually) multiplying by
        # 2**32 then dividing by 60, ending up with a 32-bit integer.
        # While this gives a lot of room for cramming many distinct
        # TimeStamps into a second, it's not good at roundtrip accuracy.
        # For example, 1 second is stored as int(2**32/60) == 71582788.
        # Converting back gives 71582788*60.0/2**32 == 0.9999999962747097.
        # In general, we can lose up to 0.999... to truncation during
        # storing, creating an absolute error up to about 1*60.0/2**32 ==
        # 0.000000014 on the seconds value we get back.  This is so even
        # when we have an exact integral second value going in (as we
        # do in this test), so we can't expect equality in any comparison
        # involving seconds.  Minutes (etc) are stored exactly, so we
        # can expect equality for those.

        self.assert_(abs(ts.timeTime() - native_ts) < EPSILON)
        self.assertEqual(ts.year(), t[0])
        self.assertEqual(ts.month(), t[1])
        self.assertEqual(ts.day(), t[2])
        self.assertEquals(ts.hour(), t[3])
        self.assertEquals(ts.minute(), t[4])
        self.assert_(abs(ts.second() - t[5]) < EPSILON)

 def new_tid(self):
     #
     # Probably better off using a counter as a tid
     #
     now = time.time()
     t = TimeStamp(*(time.gmtime(now)[:5] + (now % 60,)))
     
     #get the latest timestamp from memcache
     key = '%s,tid' % self._prefix
     self.tid_lock.acquire()
     try:
         result = self._mc.get(key)
         if result:
             t = t.laterThan(result)
         tid = repr(t)
         result = self._mc.replace(key, tid)
         if not result:
             raise MemcacheError
         return tid
     finally:
         self.tid_lock.release()

    def _check_ymd(self, yr, mo, dy):
        ts = TimeStamp(yr, mo, dy)
        self.assertEqual(ts.year(), yr)
        self.assertEqual(ts.month(), mo)
        self.assertEqual(ts.day(), dy)

        self.assertEquals(ts.hour(), 0)
        self.assertEquals(ts.minute(), 0)
        self.assertEquals(ts.second(), 0)

        t = time.gmtime(ts.timeTime())
        self.assertEquals(yr, t[0])
        self.assertEquals(mo, t[1])
        self.assertEquals(dy, t[2])

    def tpc_begin(self, transaction, tid=None, status=' '):
        if self._is_read_only:
            raise POSException.ReadOnlyError()
        self._lock_acquire()
        try:
            if self._transaction is transaction:
                raise POSException.StorageTransactionError(
                    "Duplicate tpc_begin calls for same transaction")
            self._lock_release()
            self._commit_lock_acquire()
            self._lock_acquire()
            self._transaction = transaction
            self._clear_temp()

            user = transaction.user
            desc = transaction.description
            ext = transaction._extension
            if ext:
                ext = dumps(ext, _protocol)
            else:
                ext = ""

            self._ude = user, desc, ext

            if tid is None:
                now = time.time()
                t = TimeStamp(*(time.gmtime(now)[:5] + (now % 60,)))
                self._ts = t = t.laterThan(self._ts)
                self._tid = t.raw()
            else:
                self._ts = TimeStamp(tid)
                self._tid = tid

            self._tstatus = status
            self._begin(self._tid, user, desc, ext)
        finally:
            self._lock_release()

def recover(inp, outp, verbose=0, partial=False, force=False, pack=None):
    print("Recovering", inp, "into", outp)

    if os.path.exists(outp) and not force:
        die("%s exists" % outp)

    f = open(inp, "rb")
    if f.read(4) != ZODB.FileStorage.packed_version:
        die("input is not a file storage")

    f.seek(0,2)
    file_size = f.tell()

    ofs = ZODB.FileStorage.FileStorage(outp, create=1)
    _ts = None
    ok = 1
    prog1 = 0
    undone = 0

    pos = 4
    ltid = None
    while pos:
        try:
            npos, txn, tid = read_txn_header(f, pos, file_size, outp, ltid)
        except EOFError:
            break
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception as err:
            print("error reading txn header:", err)
            if not verbose:
                progress(prog1)
            pos = scan(f, pos)
            if verbose > 1:
                print("looking for valid txn header at", pos)
            continue
        ltid = tid

        if txn is None:
            undone = undone + npos - pos
            pos = npos
            continue
        else:
            pos = npos

        tid = txn.tid

        if _ts is None:
            _ts = TimeStamp(tid)
        else:
            t = TimeStamp(tid)
            if t <= _ts:
                if ok:
                    print(("Time stamps out of order %s, %s" % (_ts, t)))
                ok = 0
                _ts = t.laterThan(_ts)
                tid = _ts.raw()
            else:
                _ts = t
                if not ok:
                    print(("Time stamps back in order %s" % (t)))
                    ok = 1

        ofs.tpc_begin(txn, tid, txn.status)

        if verbose:
            print("begin", pos, _ts, end=' ')
            if verbose > 1:
                print()
            sys.stdout.flush()

        nrec = 0
        try:
            for r in txn:
                if verbose > 1:
                    if r.data is None:
                        l = "bp"
                    else:
                        l = len(r.data)

                    print("%7d %s %s" % (u64(r.oid), l))
                ofs.restore(r.oid, r.tid, r.data, '', r.data_txn,
                            txn)
                nrec += 1
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception as err:
            if partial and nrec:
                ofs._status = "p"
                ofs.tpc_vote(txn)
                ofs.tpc_finish(txn)
                if verbose:
                    print("partial")
            else:
                ofs.tpc_abort(txn)
            print("error copying transaction:", err)
            if not verbose:
                progress(prog1)
            pos = scan(f, pos)
            if verbose > 1:
#.........这里部分代码省略.........

def recover(inp, outp, verbose=0, partial=False, force=False, pack=None):
    print "Recovering", inp, "into", outp

    if os.path.exists(outp) and not force:
        die("%s exists" % outp)

    f = open(inp, "rb")
    if f.read(4) != ZODB.FileStorage.packed_version:
        die("input is not a file storage")

    f.seek(0,2)
    file_size = f.tell()

    ofs = ZODB.FileStorage.FileStorage(outp, create=1)
    _ts = None
    ok = 1
    prog1 = 0
    undone = 0

    pos = 4L
    ltid = None
    while pos:
        try:
            npos, txn, tid = read_txn_header(f, pos, file_size, outp, ltid)
        except EOFError:
            break
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception, err:
            print "error reading txn header:", err
            if not verbose:
                progress(prog1)
            pos = scan(f, pos)
            if verbose > 1:
                print "looking for valid txn header at", pos
            continue
        ltid = tid

        if txn is None:
            undone = undone + npos - pos
            pos = npos
            continue
        else:
            pos = npos

        tid = txn.tid

        if _ts is None:
            _ts = TimeStamp(tid)
        else:
            t = TimeStamp(tid)
            if t <= _ts:
                if ok:
                    print ("Time stamps out of order %s, %s" % (_ts, t))
                ok = 0
                _ts = t.laterThan(_ts)
                tid = _ts.raw()
            else:
                _ts = t
                if not ok:
                    print ("Time stamps back in order %s" % (t))
                    ok = 1

        ofs.tpc_begin(txn, tid, txn.status)

        if verbose:
            print "begin", pos, _ts,
            if verbose > 1:
                print
            sys.stdout.flush()

        nrec = 0
        try:
            for r in txn:
                if verbose > 1:
                    if r.data is None:
                        l = "bp"
                    else:
                        l = len(r.data)

                    print "%7d %s %s" % (u64(r.oid), l)
                ofs.restore(r.oid, r.tid, r.data, '', r.data_txn,
                            txn)
                nrec += 1
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception, err:
            if partial and nrec:
                ofs._status = "p"
                ofs.tpc_vote(txn)
                ofs.tpc_finish(txn)
                if verbose:
                    print "partial"
            else:
                ofs.tpc_abort(txn)
            print "error copying transaction:", err
            if not verbose:
                progress(prog1)
            pos = scan(f, pos)
            if verbose > 1:
#.........这里部分代码省略.........

 def checkLaterThan(self):
     t = time.gmtime()
     ts = TimeStamp(*t[:6])
     ts2 = ts.laterThan(ts)
     self.assert_(ts2 > ts)

def main():
    usage = "usage: %prog [options] filename"
    parser = OptionParser(usage=usage)
    parser.add_option("-n", "--number", dest="num",
                  help="display only the 'n' busiest days", default=20, type="int")
    parser.add_option("-f", "--file", dest="filename", action="store", type="string",
                  help="your FileStorage")
    parser.add_option("-d", "--date", dest="date", action="store", type="string",
                  help="show the stats only for the date d (format dd-mm-yyyy)")
    parser.add_option("-a", "--days", dest="days", action="store", default="0", type="string",
                  help="show the stats only for the last 'a' days")
    parser.add_option("-v", "--verbose", dest="verbose", action="store_false",
                  help="show percentage and time remaining")

    (options, args) = parser.parse_args()
    objectsToDisplay = options.num

    VERBOSE = False

    if options.filename:
        fname = options.filename
    else:
        print "You have to enter the filename, see --help for details"
        return 2

    if options.verbose != None:
        VERBOSE = True

    stats = {}
    start = time.time()
    size = os.stat(fname).st_size
    it = ZODB.FileStorage.FileIterator(fname)

    lastPercent = 0.0
    recordsCounter = 0
    interval = 0.005
    dataFound = False
    now = datetime.date.today()

    try:
        for t in it:

            #Format the date of the current transaction following dd-mm-yyyy
            ts = TimeStamp(t.tid)
            then = datetime.date(int(ts.year()), int(ts.month()), int(ts.day()))
            delta = timedelta(days=int(options.days))

            if((not int(options.days)) or (now - then < delta)):
                dateT = strftime("%d-%m-%Y", [int(ts.year()), int(ts.month()), int(ts.day()),1,1,1,1,1,1] )
                percent = float(it._file.tell())/float(size) * 100
                #Check if we found the searched date
                if options.date:
                    if str(dateT) == str(options.date):
                        dataFound = True
                    elif dataFound:
                        break

                #Show the percentage of the work completed and the remaining time
                if(percent - lastPercent > interval):
                    spentTime = time.time() - start
                    remainingTime = spentTime / float(it._file.tell()) * (float(size)) - spentTime
                    if VERBOSE:
                        sys.stderr.write("\r%f%% complete, time spent %s,  remaining time: %s, recordsCounter %d" % (percent,GetInHMS(time.time() - start, True),  GetInHMS(remainingTime, False), recordsCounter))

                    lastPercent = percent

                stat = stats.get(dateT)
                if stat is None:
                    stat = stats[dateT] = Stat()
                    stat.n = 1
                else:
                    stat.n += 1

                for r in t:
                    #need to reduce the time of the dictionary stats from time to time
                    if recordsCounter % (objectsToDisplay*100) == 0:
                        tmp = {}
                        for date, s in sorted(
                            stats.items(), key=lambda (k,v): v.n, reverse=True)[0: objectsToDisplay]:
                            tmp[date] = s
                        try:
                            tmp[dateT] = stats[dateT]
                        except KeyError:
                            pass

                        stats = tmp

                    if r.data:
                        mod, klass = get_pickle_metadata(r.data)
                        l = len(r.data)
                        stat = stats.get(dateT)
                        stat.records += 1
                    recordsCounter += 1

                stat = stats.get(dateT)
                if stat is not None:
                    stat.mean.append(TimeStamp(t.tid).timeTime())

    except KeyboardInterrupt:
        pass
#.........这里部分代码省略.........

def run(path, days, notPacked):
    f = open(path, "rb")
    f.seek(0, 2)
    size = os.path.getsize(path)

    now = datetime.date.today()

    notPackedDays = []

    for day in range(notPacked):
        notPackedDays.append(str(now - timedelta(days=day + 1)))

        # day->size
    stats = {}
    th = prev_txn(f)
    bool = True
    while bool:
        ts = TimeStamp(th.tid)
        then = datetime.date(int(ts.year()), int(ts.month()), int(ts.day()))
        delta = timedelta(days=int(days))

        if now - then < delta:
            dateT = strftime("%Y-%m-%d", [int(ts.year()), int(ts.month()), int(ts.day()), 1, 1, 1, 1, 1, 1])
            try:
                stats[dateT] = stats[dateT] + th.length
            except KeyError:
                stats[dateT] = th.length
        else:
            bool = False
        th = th.prev_txn()

    f.close()

    total = 0
    totalPacked = 0
    daysPacked = 0
    for (d, s) in sorted(stats.items(), key=lambda (k, v): v, reverse=True):
        print d, "size:", pretty_size(s),
        date = str(d)
        if date in notPackedDays or date == str(now):
            print "(not yet packed)"
        else:
            totalPacked = totalPacked + s
            daysPacked = daysPacked + 1
            print
        total = total + s

    if int(totalPacked):
        average = totalPacked / int(daysPacked)
    else:
        average = 0

    print "\n-- ALREADY PACKED DAYS--"
    print "The amount of data added in", daysPacked, "days is", pretty_size(totalPacked)
    print "Average", pretty_size(average), "per day"

    print "Following this trend, the size of the database will be:"
    print "\t", pretty_size(average * 365 + size), " in 1 year"
    print "\t", pretty_size(average * 365 * 2 + size), " in 2 years"
    print "\t", pretty_size(average * 365 * 10 + size), " in 10 years"

    print "\n-- ALL DAYS --"
    print "The amount of data added in", days, "days is", pretty_size(total)
    if int(total):
        print "Average", pretty_size(total / int(days)), "per day"
    else:
        print "Average 0bytes per day"