forum_modules/exporter/exporter.py

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