forum_modules/exporter/exporter.py

   1 from __future__ import with_statement
   2
   3 import os, tarfile, datetime, logging, re, ConfigParser, shutil, zipfile
   4
   5 from django.core.cache import cache
   6 from django.utils.translation import ugettext as _
   7 from forum.models import *
   8 from forum.settings import APP_URL
   9 from forum.templatetags.extra_tags import diff_date
  10 import xml.etree.ElementTree
  11 from xml.etree import ElementTree as ET
  12 from xml.etree.ElementTree import Comment, _encode, ProcessingInstruction, QName, _escape_attrib, _escape_cdata, _namespace_map
  13 from forum import settings
  14 from django.conf import settings as djsettings
  15 import settings as selfsettings
  16 import string
  17
  18 try:
  19         from xml.etree.ElementTree import fixtag
  20 except ImportError:
  21         def fixtag(tag, namespaces):
  22                 # given a decorated tag (of the form {uri}tag), return prefixed
  23                 # tag and namespace declaration, if any
  24                 if isinstance(tag, QName):
  25                         tag = tag.text
  26                 namespace_uri, tag = string.split(tag[1:], "}", 1)
  27                 prefix = namespaces.get(namespace_uri)
  28                 if prefix is None:
  29                         prefix = _namespace_map.get(namespace_uri)
  30                         if prefix is None:
  31                                 prefix = "ns%d" % len(namespaces)
  32                         namespaces[namespace_uri] = prefix
  33                         if prefix == "xml":
  34                                 xmlns = None
  35                         else:
  36                                 xmlns = ("xmlns:%s" % prefix, namespace_uri)
  37                 else:
  38                         xmlns = None
  39                 return "%s:%s" % (prefix, tag), xmlns
  40
  41
  42 CACHE_KEY = "%s_exporter_state" % APP_URL
  43 EXPORT_STEPS = []
  44
  45 TMP_FOLDER = os.path.join(os.path.dirname(__file__), 'tmp')
  46
  47 DATE_AND_AUTHOR_INF_SECTION = 'DateAndAuthor'
  48 OPTIONS_INF_SECTION = 'Options'
  49 META_INF_SECTION = 'Meta'
  50
  51 DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
  52 DATE_FORMAT = "%Y-%m-%d"
  53
  54 def Etree_pretty__write(self, file, node, encoding, namespaces,
  55                         level=0, identator="    "):
  56     tag = node.tag
  57     if tag is Comment:
  58         file.write(level * identator + "<!-- %s -->" % _escape_cdata(node.text, encoding))
  59     elif tag is ProcessingInstruction:
  60         file.write("<?%s?>" % _escape_cdata(node.text, encoding))
  61     else:
  62         items = node.items()
  63         xmlns_items = [] # new namespaces in this scope
  64         try:
  65             if isinstance(tag, QName) or tag[:1] == "{":
  66                 tag, xmlns = fixtag(tag, namespaces)
  67                 if xmlns: xmlns_items.append(xmlns)
  68         except TypeError:
  69             raise #_raise_serialization_error(tag)
  70         file.write("\n" + level * identator + "<" + _encode(tag, encoding))
  71         if items or xmlns_items:
  72             items.sort() # lexical order
  73             for k, v in items:
  74                 try:
  75                     if isinstance(k, QName) or k[:1] == "{":
  76                         k, xmlns = fixtag(k, namespaces)
  77                         if xmlns: xmlns_items.append(xmlns)
  78                 except TypeError:
  79                     raise #_raise_serialization_error(k)
  80                 try:
  81                     if isinstance(v, QName):
  82                         v, xmlns = fixtag(v, namespaces)
  83                         if xmlns: xmlns_items.append(xmlns)
  84                 except TypeError:
  85                     raise #_raise_serialization_error(v)
  86                 file.write(u" %s=\"%s\"" % (_encode(k, encoding),
  87                                             _escape_attrib(v, encoding)))
  88             for k, v in xmlns_items:
  89                 file.write(u" %s=\"%s\"" % (_encode(k, encoding),
  90                                             _escape_attrib(v, encoding)))
  91         if node.text or len(node):
  92             file.write(">")
  93             if node.text:
  94                 file.write(_escape_cdata(node.text, encoding))
  95             for n in node:
  96                 self._write(file, n, encoding, namespaces, level + 1, identator)
  97             if node.text and len(node.text) < 125:
  98                 file.write("</" + _encode(tag, encoding) + ">")
  99             else:
 100                 file.write("\n" + level * identator + "</" + _encode(tag, encoding) + ">")
 101         else:
 102             file.write(" />")
 103         for k, v in xmlns_items:
 104             del namespaces[v]
 105     if node.tail:
 106         file.write(_escape_cdata(node.tail.replace("\n", (level * identator )+ "\n"), encoding))
 107
 108 def make_date(date, with_time=True):
 109     try:
 110         return date.strftime(with_time and DATETIME_FORMAT or DATE_FORMAT)
 111     except ValueError, e:
 112         return date.replace(year=1900).strftime(with_time and DATETIME_FORMAT or DATE_FORMAT)
 113
 114
 115 def ET_Element_add_tag(el, tag_name, content = None, **attrs):
 116     tag = ET.SubElement(el, tag_name)
 117
 118     if content:
 119         try:
 120             tag.text = unicode(content)
 121         except Exception, e:
 122             #logging.error('error converting unicode characters')
 123             #import traceback
 124             #logging.error(traceback.print_exc())
 125
 126             import string
 127             tag.text = unicode("".join([c for c in content if c in string.printable]))
 128
 129     for k, v in attrs.items():
 130         tag.set(k, unicode(v))
 131
 132     return tag
 133
 134 GOOD_TAG_NAME = re.compile("^\w+$")
 135
 136 def make_extra(el, v):
 137     if v is None:
 138         return
 139
 140
 141     if isinstance(v, (int, long, str, unicode, float, bool, dict, list, tuple)):
 142         if isinstance(v, tuple):
 143             t = 'list'
 144         else:
 145             t = v.__class__.__name__
 146     else:
 147         t = 'unknown'
 148
 149     value = el.add('value', type=t)
 150
 151     if isinstance(v, (list, tuple)):
 152         for i in v:
 153             item = value.add('item')
 154             make_extra(item, i)
 155
 156     elif isinstance(v, dict):
 157         for k, i in v.items():
 158             item = value.add('item', key=k)
 159             make_extra(item, i)
 160     else:
 161         value.text = unicode(v)
 162
 163 def write_to_file(root, tmp, filename):
 164     tree = ET.ElementTree(root)
 165     tree.write(os.path.join(tmp, filename), encoding='UTF-8')
 166
 167 def create_targz(tmp, files, start_time, options, user, state, set_state, file_format):
 168     now = datetime.datetime.now()
 169     domain = re.match('[\w-]+\.[\w-]+(\.[\w-]+)*', djsettings.APP_URL)
 170     if domain:
 171         domain = '_'.join(domain.get(0).split('.'))
 172     else:
 173         domain = 'localhost'
 174
 175     fname = "%s-%s" % (domain, now.strftime('%Y%m%d%H%M'))
 176     if file_format == 'zip':
 177         full_fname = "%s.zip" % fname
 178     else:
 179         full_fname = "%s.tar.gz" % fname
 180
 181     if file_format == 'zip':
 182         t = zipfile.ZipFile(os.path.join(selfsettings.EXPORTER_BACKUP_STORAGE, full_fname), 'w')
 183
 184         def add_to_file(f, a):
 185             t.write(f, a)
 186     else:
 187         t = tarfile.open(os.path.join(selfsettings.EXPORTER_BACKUP_STORAGE, full_fname), mode = 'w:gz')
 188
 189         def add_to_file(f, a):
 190             t.add(f, a)
 191
 192     state['overall']['status'] = _('Compressing xml files')
 193     set_state()
 194
 195     for f in files:
 196         add_to_file(os.path.join(tmp, f), "/%s" % f)
 197
 198     if options.get('uplodaded_files', False):
 199         state['overall']['status'] = _('Importing uploaded files')
 200         set_state()
 201         export_upfiles(t)
 202
 203     if options.get('import_skins_folder', False):
 204         state['overall']['status'] = _('Importing skins folder')
 205         set_state()
 206         export_skinsfolder(t)
 207
 208     state['overall']['status'] = _('Writing inf file.')
 209     set_state()
 210
 211     inf = ConfigParser.SafeConfigParser()
 212
 213     inf.add_section(DATE_AND_AUTHOR_INF_SECTION)
 214
 215     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'file-name', full_fname)
 216     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'author', unicode(user.id))
 217     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'site', djsettings.APP_URL)
 218     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'started', start_time.strftime(DATETIME_FORMAT))
 219     inf.set(DATE_AND_AUTHOR_INF_SECTION, 'finished', now.strftime(DATETIME_FORMAT))
 220
 221     inf.add_section(OPTIONS_INF_SECTION)
 222     inf.set(OPTIONS_INF_SECTION, 'anon-data', str(options.get('anon_data', False)))
 223     inf.set(OPTIONS_INF_SECTION, 'with-upfiles', str(options.get('uplodaded_files', False)))
 224     inf.set(OPTIONS_INF_SECTION, 'with-skins', str(options.get('import_skins_folder', False)))
 225
 226     inf.add_section(META_INF_SECTION)
 227
 228     for id, s in state.items():
 229         inf.set(META_INF_SECTION, id, str(s['count']))
 230
 231     with open(os.path.join(tmp, '%s.backup.inf' % fname), 'wb') as inffile:
 232         inf.write(inffile)
 233
 234     add_to_file(os.path.join(tmp, '%s.backup.inf' % fname), '/backup.inf')
 235     state['overall']['status'] = _('Saving backup file')
 236     set_state()
 237     t.close()
 238     return full_fname
 239
 240
 241 def export_upfiles(tf):
 242     folder = str(settings.UPFILES_FOLDER)
 243
 244     if os.path.exists(folder):
 245         tf.add(folder, arcname='/upfiles')
 246
 247
 248 def export_skinsfolder(tf):
 249     folder = djsettings.TEMPLATE_DIRS[0]
 250
 251     if os.path.exists(folder):
 252         tf.add(folder, arcname='/skins')
 253
 254
 255 def export(options, user):
 256     original__write = xml.etree.ElementTree.ElementTree._write
 257     xml.etree.ElementTree.ElementTree._write = Etree_pretty__write
 258     xml.etree.ElementTree._ElementInterface.add = ET_Element_add_tag
 259
 260     start_time = datetime.datetime.now()
 261     tmp = TMP_FOLDER
 262     anon_data = options.get('anon_data', False)
 263
 264     steps = [s for s in EXPORT_STEPS if not (anon_data and s['fn'].is_user_data())]
 265
 266     state = dict([(s['id'], {
 267         'status': _('Queued'), 'count': s['fn'].count(start_time), 'parsed': 0
 268     }) for s in steps] + [
 269         ('overall', {
 270             'status': _('Starting'), 'count': sum([s['fn'].count(start_time) for s in steps]), 'parsed': 0
 271         })
 272     ])
 273
 274     full_state = dict(running=True, state=state, time_started="")
 275
 276     def set_state():
 277         full_state['time_started'] = diff_date(start_time)
 278         cache.set(CACHE_KEY, full_state)
 279
 280     set_state()
 281
 282     def ping_state(name):
 283         state[name]['parsed'] += 1
 284         state['overall']['parsed'] += 1
 285         set_state()
 286
 287     def run(fn, name):
 288         def ping():
 289             ping_state(name)
 290
 291         state['overall']['status'] = _('Exporting %s') % s['name']
 292         state[name]['status'] = _('Exporting')
 293
 294         root, fname = fn(ping, start_time, anon_data)
 295
 296         state[name]['status'] = _('Writing temp file')
 297         state['overall']['status'] = _('Writing %s temp file') % s['name']
 298
 299         set_state()
 300
 301         write_to_file(root, tmp, fname)
 302         state[name]['status'] = _('Done')
 303
 304         set_state()
 305
 306         return fname
 307
 308     try:
 309         dump_files = []
 310
 311         for s in steps:
 312             dump_files.append(run(s['fn'], s['id']))
 313
 314         state['overall']['status'] = _('Compressing files')
 315         set_state()
 316
 317         fname = create_targz(tmp, dump_files, start_time, options, user, state, set_state, options['file_format'])
 318         full_state['running'] = False
 319         full_state['errors'] = False
 320         state['overall']['status'] = _('Done')
 321         state['overall']['fname'] = fname
 322
 323         set_state()
 324     except Exception, e:
 325         full_state['running'] = False
 326         full_state['errors'] = "%s: %s" % (e.__class__.__name__, unicode(e))
 327         set_state()
 328
 329         import traceback
 330         logging.error("Error executing xml backup: \n %s" % (traceback.format_exc()))
 331     finally:
 332         xml.etree.ElementTree.ElementTree._write = original__write
 333         del xml.etree.ElementTree._ElementInterface.add
 334
 335
 336 def exporter_step(queryset, root_tag_name, el_tag_name, name, date_lock=None, user_data=False):
 337
 338     def decorator(fn):
 339         def qs(lock):
 340             if date_lock:
 341                 return queryset.filter(**{"%s__lte" % date_lock: lock})
 342             return queryset
 343
 344         def decorated(ping, lock, anon_data):
 345             root = ET.Element(root_tag_name)
 346
 347             for item in qs(lock).order_by('id').select_related():
 348                 el = root.add(el_tag_name)
 349                 fn(item, el, anon_data)
 350                 ping()
 351
 352             return root, "%s.xml" % root_tag_name
 353
 354         def count(lock):
 355             return qs(lock).count()
 356
 357         def is_user_data():
 358             return user_data
 359
 360         decorated.count = count
 361         decorated.is_user_data = is_user_data
 362
 363         EXPORT_STEPS.append(dict(id=root_tag_name, name=name, fn=decorated))
 364
 365         return decorated
 366
 367     return decorator
 368
 369 @exporter_step(Tag.objects.all(), 'tags', 'tag', _('Tags'))
 370 def export_tags(t, el, anon_data):
 371     el.add('name', t.name)
 372     if not anon_data:
 373         el.add('author', t.created_by.id)
 374     el.add('used', t.used_count)
 375
 376
 377 @exporter_step(User.objects.all(), 'users', 'user', _('Users'), 'date_joined', True)
 378 def export_users(u, el, anon_data):
 379     el.add('id', u.id)
 380     el.add('username', u.username)
 381     el.add('password', u.password)
 382     el.add('email', u.email, validated=u.email_isvalid and 'true' or 'false')
 383     el.add('reputation', u.reputation)
 384     el.add('badges', bronze=u.bronze, silver=u.silver, gold=u.gold)
 385     el.add('joindate', make_date(u.date_joined))
 386     el.add('active', u.is_active and 'true' or 'false')
 387
 388     el.add('realname', u.real_name)
 389     el.add('bio', u.about)
 390     el.add('location', u.location)
 391     el.add('website', u.website)
 392     el.add('birthdate', u.date_of_birth and make_date(u.date_of_birth, with_time=False) or "")
 393
 394     roles = el.add('roles')
 395
 396     if u.is_superuser:
 397         roles.add('role', 'superuser')
 398
 399     if u.is_staff:
 400         roles.add('role', 'moderator')
 401
 402     auth = el.add('authKeys')
 403     for a in u.auth_keys.all():
 404         key = auth.add('key')
 405         key.add('provider', a.provider)
 406         key.add('key', a.key)
 407
 408
 409     ss = u.subscription_settings
 410
 411     notify = el.add('notifications', enabled=ss.enable_notifications and 'true' or 'false')
 412
 413     notify.add('notify', **dict([(t, ss.__dict__.get(t, 'n') == 'i' and 'true' or 'false') for t in ['member_joins', 'new_question', 'new_question_watched_tags', 'subscribed_questions']]))
 414
 415     notify.add('autoSubscribe', **dict([(t, ss.__dict__.get(t, False) and 'true' or 'false') for t in [
 416             'all_questions', 'all_questions_watched_tags', 'questions_asked', 'questions_answered', 'questions_commented', 'questions_viewed']]))
 417
 418     notify.add('notifyOnSubscribed', **dict([(t, ss.__dict__.get("notify_%s" % t, False) and 'true' or 'false') for t in [
 419             'answers', 'reply_to_comments', 'comments_own_post', 'comments', 'accepted']]))
 420
 421     notify.add('digest', ss.send_digest and 'on' or 'off')
 422
 423     watched = el.add('watchedTags')
 424     rejected = el.add('rejectedTags')
 425
 426     for m in u.tag_selections.all():
 427         if m.reason == 'good':
 428             watched.add('tag', m.tag.name)
 429         else:
 430             rejected.add('tag', m.tag.name)
 431
 432
 433
 434 @exporter_step(Node.objects.all(), 'nodes', 'node', _('Nodes'), 'added_at')
 435 def export_nodes(n, el, anon_data):
 436     el.add('id', n.id)
 437     el.add('type', n.node_type)
 438
 439     if not anon_data:
 440         el.add('author', n.author.id)
 441     el.add('date', make_date(n.added_at))
 442     el.add('parent', n.parent and n.parent.id or "")
 443     el.add('absparent', n.abs_parent and n.abs_parent.id or "")
 444
 445     act = el.add('lastactivity')
 446     act.add('by', n.last_activity_by and n.last_activity_by.id or "")
 447     act.add('at', n.last_activity_at and make_date(n.last_activity_at) or "")
 448
 449     el.add('title', n.title)
 450     el.add('body', n.body)
 451
 452     el.add('score', n.score)
 453
 454     tags = el.add('tags')
 455
 456     for t in n.tagname_list():
 457         tags.add('tag', t)
 458
 459     try:
 460         active = n.active_revision and n.active_revision.revision or n.revisions.order_by('revision')[0].revision
 461     except IndexError:
 462         active = 0
 463
 464     revs = el.add('revisions', active=active)
 465
 466     for r in n.revisions.order_by('revision'):
 467         rev = revs.add('revision')
 468         rev.add('number', r.revision)
 469         rev.add('summary', r.summary)
 470         if not anon_data:
 471             rev.add('author', r.author.id)
 472         rev.add('date', make_date(r.revised_at))
 473
 474         rev.add('title', r.title)
 475         rev.add('body', r.body)
 476         rev.add('tags', ", ".join(r.tagname_list()))
 477
 478     el.add('marked', n.marked and 'true' or 'false')
 479     el.add('wiki', n.nis.wiki and 'true' or 'false')
 480     el.add('extraRef', n.extra_ref and n.extra_ref.id or "")
 481     make_extra(el.add('extraData'), n.extra)
 482     el.add('extraCount', n.extra_count and n.extra_count or "")
 483
 484
 485 @exporter_step(Action.objects.all(), 'actions', 'action', _('Actions'), 'action_date')
 486 def export_actions(a, el, anon_data):
 487     el.add('id', a.id)
 488     el.add('type', a.action_type)
 489     el.add('date', make_date(a.action_date))
 490
 491     if not anon_data:
 492         el.add('user', a.user.id)
 493         el.add('realUser', a.real_user and a.real_user.id or "")
 494         el.add('ip', a.ip)
 495     el.add('node', a.node and a.node.id or "")
 496
 497     make_extra(el.add('extraData'), a.extra)
 498
 499     canceled = el.add('canceled', state=a.canceled and 'true' or 'false')
 500
 501     if a.canceled:
 502         if not anon_data:
 503             canceled.add('user', a.canceled_by.id)
 504             canceled.add('ip', a.canceled_ip)
 505
 506         canceled.add('date', make_date(a.canceled_at))
 507
 508     if not anon_data:
 509         reputes = el.add('reputes')
 510
 511         for r in a.reputes.all():
 512             repute = reputes.add('repute', byCanceled=r.by_canceled and 'true' or 'false')
 513             repute.add('user', r.user.id)
 514             repute.add('value', r.value)
 515
 516
 517 #@exporter_step(NodeState.objects.all(), 'states', 'state', _('Node states'), 'action__action_date')
 518 #def export_states(s, el, anon_data):
 519 #    el.add('type', s.state_type)
 520 #    el.add('node', s.node.id)
 521 #    el.add('trigger', s.action.id)
 522
 523
 524 #@exporter_step(Badge.objects.all(), 'badges', 'badge', _('Badges'), user_data=True)
 525 #def export_badges(b, el, anon_data):
 526 #    el.add('type', ["", 'gold', 'silver', 'bronze'][b.type])
 527 #    el.add('name', b.cls)
 528 #    el.add('count', b.awarded_count)
 529
 530
 531 @exporter_step(Award.objects.all(), 'awards', 'award', _('Awards'), 'awarded_at', True)
 532 def export_awards(a, el, anon_data):
 533     el.add('badge', a.badge.cls)
 534     el.add('user', a.user.id)
 535     el.add('node', a.node and a.node.id or "")
 536     el.add('trigger', a.trigger and a.trigger.id or "")
 537     el.add('action', a.action.id)
 538
 539 @exporter_step(KeyValue.objects.all(), 'settings', 'setting', _('Settings'))
 540 def export_settings(s, el, anon_data):
 541     el.add('key', s.key)
 542     make_extra(el.add('value'), s.value)