# Copyright (C) 2008-2009 Gianluca Montecchi <gian@grys.it>
# W. Trevor King <wking@drexel.edu>
#
# This program 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.
#
# This program 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 this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
Handle ID creation and parsing.
"""
import os.path
import re
import libbe
if libbe.TESTING == True:
import doctest
import sys
import unittest
try:
from uuid import uuid4 # Python >= 2.5
def uuid_gen():
id = uuid4()
idstr = id.urn
start = "urn:uuid:"
assert idstr.startswith(start)
return idstr[len(start):]
except ImportError:
import os
import sys
from subprocess import Popen, PIPE
def uuid_gen():
# Shell-out to system uuidgen
args = ['uuidgen', 'r']
try:
if sys.platform != "win32":
q = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
else:
# win32 don't have os.execvp() so have to run command in a shell
q = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE,
shell=True, cwd=cwd)
except OSError, e :
strerror = "%s\nwhile executing %s" % (e.args[1], args)
raise OSError, strerror
output, error = q.communicate()
status = q.wait()
if status != 0:
strerror = "%s\nwhile executing %s" % (status, args)
raise Exception, strerror
return output.rstrip('\n')
HIERARCHY = ['bugdir', 'bug', 'comment']
class MultipleIDMatches (ValueError):
def __init__(self, id, matches):
msg = ("More than one id matches %s. "
"Please be more specific.\n%s" % (id, matches))
ValueError.__init__(self, msg)
self.id = id
self.matches = matches
class NoIDMatches (KeyError):
def __init__(self, id, possible_ids):
msg = "No id matches %s.\n%s" % (id, possible_ids)
KeyError.__init__(self, msg)
self.id = id
self.possible_ids = possible_ids
def _assemble(*args):
args = list(args)
for i,arg in enumerate(args):
if arg == None:
args[i] = ''
return '/'.join(args)
def _split(id):
args = id.split('/')
for i,arg in enumerate(args):
if arg == '':
args[i] = None
return args
def _truncate(uuid, other_uuids, min_length=3):
chars = min_length
for id in other_uuids:
if id == uuid:
continue
while (id[:chars] == uuid[:chars]):
chars+=1
return uuid[:chars]
def _expand(truncated_id, other_ids):
matches = []
other_ids = list(other_ids)
for id in other_ids:
if id.startswith(truncated_id):
matches.append(id)
if len(matches) > 1:
raise MultipleIDMatches(truncated_id, matches)
if len(matches) == 0:
raise NoIDMatches(truncated_id, other_ids)
return matches[0]
class ID (object):
"""
IDs have several formats specialized for different uses.
In storage, all objects are represented by their uuid alone,
because that is the simplest globally unique identifier. You can
generate ids of this sort with the .storage() method. Because an
object's storage may be distributed across several chunks, and the
chunks may not have their own uuid, we generate chunk ids by
prepending the objects uuid to the chunk name. The user id types
do not support this chunk extension feature.
For users, the full uuids are a bit overwhelming, so we truncate
them while retaining local uniqueness (with regards to the other
objects currently in storage). We also prepend truncated parent
ids for two reasons:
(1) so that a user can locate the repository containing the
referenced object. It would be hard to find bug 'XYZ' if
that's all you knew. Much easier with 'ABC/XYZ', where ABC
is the bugdir. Each project can publish a list of bugdir-id
- to - location mappings, e.g.
ABC...(full uuid)...DEF https://server.com/projectX/be/
which is easier than publishing all-object-ids-to-location
mappings.
(2) because it's easier to generate and parse truncated ids if
you don't have to fetch all the ids in the storage
repository, but can restrict yourself to a specific branch.
You can generate ids of this sort with the .user() method,
although in order to preform the truncation, your object (and its
parents must define a .sibling_uuids() method.
While users can use the convenient short user ids in the short
term, the truncation will inevitably lead to name collision. To
avoid that, we provide a non-truncated form of the short user ids
via the .long_user() method. These long user ids should be
converted to short user ids by intelligent user interfaces.
Related tools:
* get uuids back out of the user ids:
parse_user()
* scan text for user ids & convert to long user ids:
short_to_long_user()
* scan text for long user ids & convert to short user ids:
long_to_short_user()
Supported types: 'bugdir', 'bug', 'comment'
"""
def __init__(self, object, type):
self._object = object
self._type = type
assert self._type in HIERARCHY, self._type
def storage(self, *args):
return _assemble(self._object.uuid, *args)
def _ancestors(self):
ret = [self._object]
index = HIERARCHY.index(self._type)
if index == 0:
return ret
o = self._object
for i in range(index, 0, -1):
parent_name = HIERARCHY[i-1]
o = getattr(o, parent_name, None)
ret.insert(0, o)
return ret
def long_user(self):
return _assemble(*[o.uuid for o in self._ancestors()])
def user(self):
ids = []
for o in self._ancestors():
if o == None:
ids.append(None)
else:
ids.append(_truncate(o.uuid, o.sibling_uuids()))
return _assemble(*ids)
def child_uuids(child_storage_ids):
"""
Extract uuid children from other children generated by the
ID.storage() method.
>>> list(child_uuids(['abc123/values', '123abc', '123def']))
['123abc', '123def']
"""
for id in child_storage_ids:
fields = _split(id)
if len(fields) == 1:
yield fields[0]
REGEXP = '#([-a-f0-9]*)(/[-a-g0-9]*)?(/[-a-g0-9]*)?#'
class IDreplacer (object):
def __init__(self, bugdirs, direction):
self.bugdirs = bugdirs
self.direction = direction
def __call__(self, match):
ids = [m.lstrip('/') for m in match.groups() if m != None]
ids = self.switch_ids(ids)
return '#' + '/'.join(ids) + '#'
def switch_id(self, id, sibling_uuids):
if id == None:
return None
if self.direction == 'long_to_short':
return _truncate(id, sibling_uuids)
return _expand(id, sibling_uuids)
def switch_ids(self, ids):
assert ids[0] != None, ids
if self.direction == 'long_to_short':
bugdir = [bd for bd in self.bugdirs if bd.uuid == ids[0]][0]
objects = [bugdir]
if len(ids) >= 2:
bug = bugdir.bug_from_uuid(ids[1])
objects.append(bug)
if len(ids) >= 3:
comment = bug.comment_from_uuid(ids[2])
objects.append(comment)
for i,obj in enumerate(objects):
ids[i] = self.switch_id(ids[i], obj.sibling_uuids())
else:
ids[0] = self.switch_id(ids[0], [bd.uuid for bd in self.bugdirs])
if len(ids) == 1:
return ids
bugdir = [bd for bd in self.bugdirs if bd.uuid == ids[0]][0]
ids[1] = self.switch_id(ids[1], bugdir.uuids())
if len(ids) == 2:
return ids
bug = bugdir.bug_from_uuid(ids[1])
ids[2] = self.switch_id(ids[2], bug.uuids())
return ids
def short_to_long_user(bugdirs, text):
return re.sub(REGEXP, IDreplacer(bugdirs, 'short_to_long'), text)
def long_to_short_user(bugdirs, text):
return re.sub(REGEXP, IDreplacer(bugdirs, 'long_to_short'), text)
def _parse_user(id):
"""
>>> _parse_user('ABC/DEF/GHI') == \\
... {'bugdir':'ABC', 'bug':'DEF', 'comment':'GHI', 'type':'comment'}
True
>>> _parse_user('ABC/DEF') == \\
... {'bugdir':'ABC', 'bug':'DEF', 'type':'bug'}
True
>>> _parse_user('ABC') == \\
... {'bugdir':'ABC', 'type':'bugdir'}
True
"""
ret = {}
args = _split(id)
assert len(args) > 0 and len(args) < 4, 'Invalid id "%s"' % id
for type,arg in zip(HIERARCHY, args):
assert len(arg) > 0, 'Invalid part "%s" of id "%s"' % (arg, id)
ret['type'] = type
ret[type] = arg
return ret
def parse_user(bugdir, id):
long_id = short_to_long_user([bugdir], '#%s#' % id).strip('#')
return _parse_user(long_id)
if libbe.TESTING == True:
class UUIDtestCase(unittest.TestCase):
def testUUID_gen(self):
id = uuid_gen()
self.failUnless(len(id) == 36, 'invalid UUID "%s"' % id)
class DummyObject (object):
def __init__(self, uuid, siblings=[]):
self.uuid = uuid
self._siblings = siblings
def sibling_uuids(self):
return self._siblings
class IDtestCase(unittest.TestCase):
def setUp(self):
self.bugdir = DummyObject('1234abcd')
self.bug = DummyObject('abcdef', ['a1234', 'ab9876'])
self.bug.bugdir = self.bugdir
self.comment = DummyObject('12345678', ['1234abcd', '1234cdef'])
self.comment.bug = self.bug
self.bd_id = ID(self.bugdir, 'bugdir')
self.b_id = ID(self.bug, 'bug')
self.c_id = ID(self.comment, 'comment')
def test_storage(self):
self.failUnless(self.bd_id.storage() == self.bugdir.uuid,
self.bd_id.storage())
self.failUnless(self.b_id.storage() == self.bug.uuid,
self.b_id.storage())
self.failUnless(self.c_id.storage() == self.comment.uuid,
self.c_id.storage())
self.failUnless(self.bd_id.storage('x','y','z') == \
'1234abcd/x/y/z', self.bd_id.storage())
def test_long_user(self):
self.failUnless(self.bd_id.long_user() == self.bugdir.uuid,
self.bd_id.long_user())
self.failUnless(self.b_id.long_user() == \
'/'.join([self.bugdir.uuid, self.bug.uuid]),
self.b_id.long_user())
self.failUnless(self.c_id.long_user() ==
'/'.join([self.bugdir.uuid, self.bug.uuid,
self.comment.uuid]),
self.c_id.long_user)
def test_user(self):
self.failUnless(self.bd_id.user() == '123',
self.bd_id.user())
self.failUnless(self.b_id.user() == '123/abc',
self.b_id.user())
self.failUnless(self.c_id.user() == '123/abc/12345',
self.c_id.user())
class ShortLongParseTestCase(unittest.TestCase):
def setUp(self):
self.bugdir = DummyObject('1234abcd')
self.bug = DummyObject('abcdef', ['a1234', 'ab9876'])
self.bug.bugdir = self.bugdir
self.bugdir.bug_from_uuid = lambda uuid: self.bug
self.bugdir.uuids = lambda : self.bug.sibling_uuids() + [self.bug.uuid]
self.comment = DummyObject('12345678', ['1234abcd', '1234cdef'])
self.comment.bug = self.bug
self.bug.comment_from_uuid = lambda uuid: self.comment
self.bug.uuids = lambda : self.comment.sibling_uuids() + [self.comment.uuid]
self.bd_id = ID(self.bugdir, 'bugdir')
self.b_id = ID(self.bug, 'bug')
self.c_id = ID(self.comment, 'comment')
self.short = 'bla bla #123/abc# bla bla #123/abc/12345# bla bla'
self.long = 'bla bla #1234abcd/abcdef# bla bla #1234abcd/abcdef/12345678# bla bla'
self.short_id = '123/abc'
def test_short_to_long(self):
self.failUnless(short_to_long_user([self.bugdir], self.short) == self.long,
'\n' + self.short + '\n' + short_to_long_user([self.bugdir], self.short) + '\n' + self.long)
def test_long_to_short(self):
self.failUnless(long_to_short_user([self.bugdir], self.long) == self.short,
'\n' + long_to_short_user([self.bugdir], self.long) + '\n' + self.short)
def test_parse_user(self):
self.failUnless(parse_user(self.bugdir, self.short_id) == \
{'bugdir':'1234abcd', 'bug':'abcdef', 'type':'bug'},
parse_user(self.bugdir, self.short_id))
unitsuite =unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
suite = unittest.TestSuite([unitsuite, doctest.DocTestSuite()])
