mirror of https://github.com/zulip/zulip.git
1880 lines
76 KiB
Python
1880 lines
76 KiB
Python
import datetime
|
|
from boto.s3.key import Key
|
|
from boto.s3.connection import S3Connection
|
|
from django.conf import settings
|
|
from django.db import connection
|
|
from django.forms.models import model_to_dict
|
|
from django.utils.timezone import make_aware as timezone_make_aware
|
|
from django.utils.timezone import utc as timezone_utc
|
|
from django.utils.timezone import is_naive as timezone_is_naive
|
|
from django.db.models.query import QuerySet
|
|
import glob
|
|
import logging
|
|
import os
|
|
import ujson
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
from zerver.lib.upload import random_name, sanitize_name
|
|
from zerver.lib.avatar_hash import user_avatar_hash, user_avatar_path_from_ids
|
|
from zerver.lib.upload import S3UploadBackend, LocalUploadBackend
|
|
from zerver.lib.create_user import random_api_key
|
|
from zerver.lib.bulk_create import bulk_create_users
|
|
from zerver.models import UserProfile, Realm, Client, Huddle, Stream, \
|
|
UserMessage, Subscription, Message, RealmEmoji, RealmFilter, \
|
|
RealmDomain, Recipient, DefaultStream, get_user_profile_by_id, \
|
|
UserPresence, UserActivity, UserActivityInterval, Reaction, \
|
|
CustomProfileField, CustomProfileFieldValue, \
|
|
get_display_recipient, Attachment, get_system_bot, email_to_username
|
|
from zerver.lib.parallel import run_parallel
|
|
from typing import Any, Callable, Dict, List, Optional, Set, Tuple, \
|
|
Iterable, Text
|
|
|
|
# Custom mypy types follow:
|
|
Record = Dict[str, Any]
|
|
TableName = str
|
|
TableData = Dict[TableName, List[Record]]
|
|
Field = str
|
|
Path = str
|
|
Context = Dict[str, Any]
|
|
FilterArgs = Dict[str, Any]
|
|
IdSource = Tuple[TableName, Field]
|
|
SourceFilter = Callable[[Record], bool]
|
|
|
|
# These next two types are callbacks, which mypy does not
|
|
# support well, because PEP 484 says "using callbacks
|
|
# with keyword arguments is not perceived as a common use case."
|
|
# CustomFetch = Callable[[TableData, Config, Context], None]
|
|
# PostProcessData = Callable[[TableData, Config, Context], None]
|
|
CustomFetch = Any # TODO: make more specific, see above
|
|
PostProcessData = Any # TODO: make more specific
|
|
|
|
# The keys of our MessageOutput variables are normally
|
|
# List[Record], but when we write partials, we can get
|
|
# lists of integers or a single integer.
|
|
# TODO: tighten this up with a union.
|
|
MessageOutput = Dict[str, Any]
|
|
|
|
realm_tables = [("zerver_defaultstream", DefaultStream, "defaultstream"),
|
|
("zerver_realmemoji", RealmEmoji, "realmemoji"),
|
|
("zerver_realmdomain", RealmDomain, "realmdomain"),
|
|
("zerver_realmfilter", RealmFilter, "realmfilter")] # List[Tuple[TableName, Any, str]]
|
|
|
|
|
|
ALL_ZERVER_TABLES = [
|
|
# TODO: get a linter to ensure that this list is actually complete.
|
|
'zerver_attachment',
|
|
'zerver_attachment_messages',
|
|
'zerver_client',
|
|
'zerver_defaultstream',
|
|
'zerver_huddle',
|
|
'zerver_message',
|
|
'zerver_preregistrationuser',
|
|
'zerver_preregistrationuser_streams',
|
|
'zerver_pushdevicetoken',
|
|
'zerver_realm',
|
|
'zerver_realmdomain',
|
|
'zerver_realmemoji',
|
|
'zerver_realmfilter',
|
|
'zerver_recipient',
|
|
'zerver_scheduledemail',
|
|
'zerver_stream',
|
|
'zerver_subscription',
|
|
'zerver_useractivity',
|
|
'zerver_useractivityinterval',
|
|
'zerver_usermessage',
|
|
'zerver_userpresence',
|
|
'zerver_userprofile',
|
|
'zerver_userprofile_groups',
|
|
'zerver_userprofile_user_permissions',
|
|
]
|
|
|
|
NON_EXPORTED_TABLES = [
|
|
# These are known to either be altogether obsolete or
|
|
# simply inappropriate for exporting (e.g. contains transient
|
|
# data).
|
|
'zerver_preregistrationuser',
|
|
'zerver_preregistrationuser_streams',
|
|
'zerver_pushdevicetoken',
|
|
'zerver_scheduledemail',
|
|
'zerver_userprofile_groups',
|
|
'zerver_userprofile_user_permissions',
|
|
]
|
|
assert set(NON_EXPORTED_TABLES).issubset(set(ALL_ZERVER_TABLES))
|
|
|
|
IMPLICIT_TABLES = [
|
|
# ManyToMany relationships are exported implicitly.
|
|
'zerver_attachment_messages',
|
|
]
|
|
assert set(IMPLICIT_TABLES).issubset(set(ALL_ZERVER_TABLES))
|
|
|
|
ATTACHMENT_TABLES = [
|
|
'zerver_attachment',
|
|
]
|
|
assert set(ATTACHMENT_TABLES).issubset(set(ALL_ZERVER_TABLES))
|
|
|
|
MESSAGE_TABLES = [
|
|
# message tables get special treatment, because they're so big
|
|
'zerver_message',
|
|
'zerver_usermessage',
|
|
]
|
|
|
|
DATE_FIELDS = {
|
|
'zerver_attachment': ['create_time'],
|
|
'zerver_message': ['last_edit_time', 'pub_date'],
|
|
'zerver_realm': ['date_created'],
|
|
'zerver_stream': ['date_created'],
|
|
'zerver_useractivity': ['last_visit'],
|
|
'zerver_useractivityinterval': ['start', 'end'],
|
|
'zerver_userpresence': ['timestamp'],
|
|
'zerver_userprofile': ['date_joined', 'last_login', 'last_reminder'],
|
|
} # type: Dict[TableName, List[Field]]
|
|
|
|
def sanity_check_output(data: TableData) -> None:
|
|
tables = set(ALL_ZERVER_TABLES)
|
|
tables -= set(NON_EXPORTED_TABLES)
|
|
tables -= set(IMPLICIT_TABLES)
|
|
tables -= set(MESSAGE_TABLES)
|
|
tables -= set(ATTACHMENT_TABLES)
|
|
|
|
for table in tables:
|
|
if table not in data:
|
|
logging.warning('??? NO DATA EXPORTED FOR TABLE %s!!!' % (table,))
|
|
|
|
def write_data_to_file(output_file: Path, data: Any) -> None:
|
|
with open(output_file, "w") as f:
|
|
f.write(ujson.dumps(data, indent=4))
|
|
|
|
def make_raw(query: Any, exclude: Optional[List[Field]]=None) -> List[Record]:
|
|
'''
|
|
Takes a Django query and returns a JSONable list
|
|
of dictionaries corresponding to the database rows.
|
|
'''
|
|
rows = []
|
|
for instance in query:
|
|
data = model_to_dict(instance, exclude=exclude)
|
|
"""
|
|
In Django 1.11.5, model_to_dict evaluates the QuerySet of
|
|
many-to-many field to give us a list of instances. We require
|
|
a list of primary keys, so we get the primary keys from the
|
|
instances below.
|
|
"""
|
|
for field in instance._meta.many_to_many:
|
|
value = data[field.name]
|
|
data[field.name] = [row.id for row in value]
|
|
|
|
rows.append(data)
|
|
|
|
return rows
|
|
|
|
def floatify_datetime_fields(data: TableData, table: TableName) -> None:
|
|
for item in data[table]:
|
|
for field in DATE_FIELDS[table]:
|
|
orig_dt = item[field]
|
|
if orig_dt is None:
|
|
continue
|
|
if timezone_is_naive(orig_dt):
|
|
logging.warning("Naive datetime:", item)
|
|
dt = timezone_make_aware(orig_dt)
|
|
else:
|
|
dt = orig_dt
|
|
utc_naive = dt.replace(tzinfo=None) - dt.utcoffset()
|
|
item[field] = (utc_naive - datetime.datetime(1970, 1, 1)).total_seconds()
|
|
|
|
class Config:
|
|
'''
|
|
A Config object configures a single table for exporting (and,
|
|
maybe some day importing as well.
|
|
|
|
You should never mutate Config objects as part of the export;
|
|
instead use the data to determine how you populate other
|
|
data structures.
|
|
|
|
There are parent/children relationships between Config objects.
|
|
The parent should be instantiated first. The child will
|
|
append itself to the parent's list of children.
|
|
|
|
'''
|
|
|
|
def __init__(self, table: Optional[str]=None,
|
|
model: Optional[Any]=None,
|
|
normal_parent: Optional['Config']=None,
|
|
virtual_parent: Optional['Config']=None,
|
|
filter_args: Optional[FilterArgs]=None,
|
|
custom_fetch: Optional[CustomFetch]=None,
|
|
custom_tables: Optional[List[TableName]]=None,
|
|
post_process_data: Optional[PostProcessData]=None,
|
|
concat_and_destroy: Optional[List[TableName]]=None,
|
|
id_source: Optional[IdSource]=None,
|
|
source_filter: Optional[SourceFilter]=None,
|
|
parent_key: Optional[Field]=None,
|
|
use_all: bool=False,
|
|
is_seeded: bool=False,
|
|
exclude: Optional[List[Field]]=None) -> None:
|
|
assert table or custom_tables
|
|
self.table = table
|
|
self.model = model
|
|
self.normal_parent = normal_parent
|
|
self.virtual_parent = virtual_parent
|
|
self.filter_args = filter_args
|
|
self.parent_key = parent_key
|
|
self.use_all = use_all
|
|
self.is_seeded = is_seeded
|
|
self.exclude = exclude
|
|
self.custom_fetch = custom_fetch
|
|
self.custom_tables = custom_tables
|
|
self.post_process_data = post_process_data
|
|
self.concat_and_destroy = concat_and_destroy
|
|
self.id_source = id_source
|
|
self.source_filter = source_filter
|
|
self.children = [] # type: List[Config]
|
|
|
|
if normal_parent is not None:
|
|
self.parent = normal_parent # type: Optional[Config]
|
|
else:
|
|
self.parent = None
|
|
|
|
if virtual_parent is not None and normal_parent is not None:
|
|
raise ValueError('''
|
|
If you specify a normal_parent, please
|
|
do not create a virtual_parent.
|
|
''')
|
|
|
|
if normal_parent is not None:
|
|
normal_parent.children.append(self)
|
|
elif virtual_parent is not None:
|
|
virtual_parent.children.append(self)
|
|
elif is_seeded is None:
|
|
raise ValueError('''
|
|
You must specify a parent if you are
|
|
not using is_seeded.
|
|
''')
|
|
|
|
if self.id_source is not None:
|
|
if self.virtual_parent is None:
|
|
raise ValueError('''
|
|
You must specify a virtual_parent if you are
|
|
using id_source.''')
|
|
if self.id_source[0] != self.virtual_parent.table:
|
|
raise ValueError('''
|
|
Configuration error. To populate %s, you
|
|
want data from %s, but that differs from
|
|
the table name of your virtual parent (%s),
|
|
which suggests you many not have set up
|
|
the ordering correctly. You may simply
|
|
need to assign a virtual_parent, or there
|
|
may be deeper issues going on.''' % (
|
|
self.table,
|
|
self.id_source[0],
|
|
self.virtual_parent.table))
|
|
|
|
|
|
def export_from_config(response: TableData, config: Config, seed_object: Optional[Any]=None,
|
|
context: Optional[Context]=None) -> None:
|
|
table = config.table
|
|
parent = config.parent
|
|
model = config.model
|
|
|
|
if context is None:
|
|
context = {}
|
|
|
|
if table:
|
|
exported_tables = [table]
|
|
else:
|
|
if config.custom_tables is None:
|
|
raise ValueError('''
|
|
You must specify config.custom_tables if you
|
|
are not specifying config.table''')
|
|
exported_tables = config.custom_tables
|
|
|
|
for t in exported_tables:
|
|
logging.info('Exporting via export_from_config: %s' % (t,))
|
|
|
|
rows = None
|
|
if config.is_seeded:
|
|
rows = [seed_object]
|
|
|
|
elif config.custom_fetch:
|
|
config.custom_fetch(
|
|
response=response,
|
|
config=config,
|
|
context=context
|
|
)
|
|
if config.custom_tables:
|
|
for t in config.custom_tables:
|
|
if t not in response:
|
|
raise Exception('Custom fetch failed to populate %s' % (t,))
|
|
|
|
elif config.concat_and_destroy:
|
|
# When we concat_and_destroy, we are working with
|
|
# temporary "tables" that are lists of records that
|
|
# should already be ready to export.
|
|
data = [] # type: List[Record]
|
|
for t in config.concat_and_destroy:
|
|
data += response[t]
|
|
del response[t]
|
|
logging.info('Deleted temporary %s' % (t,))
|
|
assert table is not None
|
|
response[table] = data
|
|
|
|
elif config.use_all:
|
|
assert model is not None
|
|
query = model.objects.all()
|
|
rows = list(query)
|
|
|
|
elif config.normal_parent:
|
|
# In this mode, our current model is figuratively Article,
|
|
# and normal_parent is figuratively Blog, and
|
|
# now we just need to get all the articles
|
|
# contained by the blogs.
|
|
model = config.model
|
|
assert parent is not None
|
|
assert parent.table is not None
|
|
assert config.parent_key is not None
|
|
parent_ids = [r['id'] for r in response[parent.table]]
|
|
filter_parms = {config.parent_key: parent_ids} # type: Dict[str, Any]
|
|
if config.filter_args is not None:
|
|
filter_parms.update(config.filter_args)
|
|
assert model is not None
|
|
query = model.objects.filter(**filter_parms)
|
|
rows = list(query)
|
|
|
|
elif config.id_source:
|
|
# In this mode, we are the figurative Blog, and we now
|
|
# need to look at the current response to get all the
|
|
# blog ids from the Article rows we fetched previously.
|
|
model = config.model
|
|
assert model is not None
|
|
# This will be a tuple of the form ('zerver_article', 'blog').
|
|
(child_table, field) = config.id_source
|
|
child_rows = response[child_table]
|
|
if config.source_filter:
|
|
child_rows = [r for r in child_rows if config.source_filter(r)]
|
|
lookup_ids = [r[field] for r in child_rows]
|
|
filter_parms = dict(id__in=lookup_ids)
|
|
if config.filter_args:
|
|
filter_parms.update(config.filter_args)
|
|
query = model.objects.filter(**filter_parms)
|
|
rows = list(query)
|
|
|
|
# Post-process rows (which won't apply to custom fetches/concats)
|
|
if rows is not None:
|
|
assert table is not None # Hint for mypy
|
|
response[table] = make_raw(rows, exclude=config.exclude)
|
|
if table in DATE_FIELDS:
|
|
floatify_datetime_fields(response, table)
|
|
|
|
if config.post_process_data:
|
|
config.post_process_data(
|
|
response=response,
|
|
config=config,
|
|
context=context
|
|
)
|
|
|
|
# Now walk our children. It's extremely important to respect
|
|
# the order of children here.
|
|
for child_config in config.children:
|
|
export_from_config(
|
|
response=response,
|
|
config=child_config,
|
|
context=context,
|
|
)
|
|
|
|
def get_realm_config() -> Config:
|
|
# This is common, public information about the realm that we can share
|
|
# with all realm users.
|
|
|
|
realm_config = Config(
|
|
table='zerver_realm',
|
|
is_seeded=True
|
|
)
|
|
|
|
Config(
|
|
table='zerver_defaultstream',
|
|
model=DefaultStream,
|
|
normal_parent=realm_config,
|
|
parent_key='realm_id__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_realmemoji',
|
|
model=RealmEmoji,
|
|
normal_parent=realm_config,
|
|
parent_key='realm_id__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_realmdomain',
|
|
model=RealmDomain,
|
|
normal_parent=realm_config,
|
|
parent_key='realm_id__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_realmfilter',
|
|
model=RealmFilter,
|
|
normal_parent=realm_config,
|
|
parent_key='realm_id__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_client',
|
|
model=Client,
|
|
virtual_parent=realm_config,
|
|
use_all=True
|
|
)
|
|
|
|
user_profile_config = Config(
|
|
custom_tables=[
|
|
'zerver_userprofile',
|
|
'zerver_userprofile_mirrordummy',
|
|
],
|
|
# set table for children who treat us as normal parent
|
|
table='zerver_userprofile',
|
|
virtual_parent=realm_config,
|
|
custom_fetch=fetch_user_profile,
|
|
)
|
|
|
|
Config(
|
|
custom_tables=[
|
|
'zerver_userprofile_crossrealm',
|
|
],
|
|
virtual_parent=user_profile_config,
|
|
custom_fetch=fetch_user_profile_cross_realm,
|
|
)
|
|
|
|
Config(
|
|
table='zerver_userpresence',
|
|
model=UserPresence,
|
|
normal_parent=user_profile_config,
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_useractivity',
|
|
model=UserActivity,
|
|
normal_parent=user_profile_config,
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
Config(
|
|
table='zerver_useractivityinterval',
|
|
model=UserActivityInterval,
|
|
normal_parent=user_profile_config,
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
# Some of these tables are intermediate "tables" that we
|
|
# create only for the export. Think of them as similar to views.
|
|
|
|
user_subscription_config = Config(
|
|
table='_user_subscription',
|
|
model=Subscription,
|
|
normal_parent=user_profile_config,
|
|
filter_args={'recipient__type': Recipient.PERSONAL},
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
Config(
|
|
table='_user_recipient',
|
|
model=Recipient,
|
|
virtual_parent=user_subscription_config,
|
|
id_source=('_user_subscription', 'recipient'),
|
|
)
|
|
|
|
#
|
|
stream_subscription_config = Config(
|
|
table='_stream_subscription',
|
|
model=Subscription,
|
|
normal_parent=user_profile_config,
|
|
filter_args={'recipient__type': Recipient.STREAM},
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
stream_recipient_config = Config(
|
|
table='_stream_recipient',
|
|
model=Recipient,
|
|
virtual_parent=stream_subscription_config,
|
|
id_source=('_stream_subscription', 'recipient'),
|
|
)
|
|
|
|
Config(
|
|
table='zerver_stream',
|
|
model=Stream,
|
|
virtual_parent=stream_recipient_config,
|
|
id_source=('_stream_recipient', 'type_id'),
|
|
source_filter=lambda r: r['type'] == Recipient.STREAM,
|
|
exclude=['email_token'],
|
|
post_process_data=sanity_check_stream_data
|
|
)
|
|
|
|
#
|
|
|
|
Config(
|
|
custom_tables=[
|
|
'_huddle_recipient',
|
|
'_huddle_subscription',
|
|
'zerver_huddle',
|
|
],
|
|
normal_parent=user_profile_config,
|
|
custom_fetch=fetch_huddle_objects,
|
|
)
|
|
|
|
# Now build permanent tables from our temp tables.
|
|
Config(
|
|
table='zerver_recipient',
|
|
virtual_parent=user_profile_config,
|
|
concat_and_destroy=[
|
|
'_user_recipient',
|
|
'_stream_recipient',
|
|
'_huddle_recipient',
|
|
],
|
|
)
|
|
|
|
Config(
|
|
table='zerver_subscription',
|
|
virtual_parent=user_profile_config,
|
|
concat_and_destroy=[
|
|
'_user_subscription',
|
|
'_stream_subscription',
|
|
'_huddle_subscription',
|
|
]
|
|
)
|
|
|
|
return realm_config
|
|
|
|
def sanity_check_stream_data(response: TableData, config: Config, context: Context) -> None:
|
|
|
|
if context['exportable_user_ids'] is not None:
|
|
# If we restrict which user ids are exportable,
|
|
# the way that we find # streams is a little too
|
|
# complex to have a sanity check.
|
|
return
|
|
|
|
actual_streams = set([stream.name for stream in Stream.objects.filter(
|
|
realm=response["zerver_realm"][0]['id'])])
|
|
streams_in_response = set([stream['name'] for stream in response['zerver_stream']])
|
|
|
|
if streams_in_response != actual_streams:
|
|
print(streams_in_response - actual_streams)
|
|
print(actual_streams - streams_in_response)
|
|
raise Exception('''
|
|
zerver_stream data does not match
|
|
Stream.objects.all().
|
|
|
|
Please investigate!
|
|
''')
|
|
|
|
def fetch_user_profile(response: TableData, config: Config, context: Context) -> None:
|
|
realm = context['realm']
|
|
exportable_user_ids = context['exportable_user_ids']
|
|
|
|
query = UserProfile.objects.filter(realm_id=realm.id)
|
|
exclude = ['password', 'api_key']
|
|
rows = make_raw(list(query), exclude=exclude)
|
|
|
|
normal_rows = [] # type: List[Record]
|
|
dummy_rows = [] # type: List[Record]
|
|
|
|
for row in rows:
|
|
if exportable_user_ids is not None:
|
|
if row['id'] in exportable_user_ids:
|
|
assert not row['is_mirror_dummy']
|
|
else:
|
|
# Convert non-exportable users to
|
|
# inactive is_mirror_dummy users.
|
|
row['is_mirror_dummy'] = True
|
|
row['is_active'] = False
|
|
|
|
if row['is_mirror_dummy']:
|
|
dummy_rows.append(row)
|
|
else:
|
|
normal_rows.append(row)
|
|
|
|
response['zerver_userprofile'] = normal_rows
|
|
response['zerver_userprofile_mirrordummy'] = dummy_rows
|
|
|
|
def fetch_user_profile_cross_realm(response: TableData, config: Config, context: Context) -> None:
|
|
realm = context['realm']
|
|
|
|
if realm.string_id == settings.SYSTEM_BOT_REALM:
|
|
response['zerver_userprofile_crossrealm'] = []
|
|
else:
|
|
response['zerver_userprofile_crossrealm'] = [dict(email=x.email, id=x.id) for x in [
|
|
get_system_bot(settings.NOTIFICATION_BOT),
|
|
get_system_bot(settings.EMAIL_GATEWAY_BOT),
|
|
get_system_bot(settings.WELCOME_BOT),
|
|
]]
|
|
|
|
def fetch_attachment_data(response: TableData, realm_id: int, message_ids: Set[int]) -> None:
|
|
filter_args = {'realm_id': realm_id}
|
|
query = Attachment.objects.filter(**filter_args)
|
|
response['zerver_attachment'] = make_raw(list(query))
|
|
floatify_datetime_fields(response, 'zerver_attachment')
|
|
|
|
'''
|
|
We usually export most messages for the realm, but not
|
|
quite ALL messages for the realm. So, we need to
|
|
clean up our attachment data to have correct
|
|
values for response['zerver_attachment'][<n>]['messages'].
|
|
'''
|
|
for row in response['zerver_attachment']:
|
|
filterer_message_ids = set(row['messages']).intersection(message_ids)
|
|
row['messages'] = sorted(list(filterer_message_ids))
|
|
|
|
'''
|
|
Attachments can be connected to multiple messages, although
|
|
it's most common to have just one message. Regardless,
|
|
if none of those message(s) survived the filtering above
|
|
for a particular attachment, then we won't export the
|
|
attachment row.
|
|
'''
|
|
response['zerver_attachment'] = [
|
|
row for row in response['zerver_attachment']
|
|
if row['messages']]
|
|
|
|
def fetch_huddle_objects(response: TableData, config: Config, context: Context) -> None:
|
|
|
|
realm = context['realm']
|
|
assert config.parent is not None
|
|
assert config.parent.table is not None
|
|
user_profile_ids = set(r['id'] for r in response[config.parent.table])
|
|
|
|
# First we get all huddles involving someone in the realm.
|
|
realm_huddle_subs = Subscription.objects.select_related("recipient").filter(
|
|
recipient__type=Recipient.HUDDLE, user_profile__in=user_profile_ids)
|
|
realm_huddle_recipient_ids = set(sub.recipient_id for sub in realm_huddle_subs)
|
|
|
|
# Mark all Huddles whose recipient ID contains a cross-realm user.
|
|
unsafe_huddle_recipient_ids = set()
|
|
for sub in Subscription.objects.select_related().filter(recipient__in=realm_huddle_recipient_ids):
|
|
if sub.user_profile.realm != realm:
|
|
# In almost every case the other realm will be zulip.com
|
|
unsafe_huddle_recipient_ids.add(sub.recipient_id)
|
|
|
|
# Now filter down to just those huddles that are entirely within the realm.
|
|
#
|
|
# This is important for ensuring that the User objects needed
|
|
# to import it on the other end exist (since we're only
|
|
# exporting the users from this realm), at the cost of losing
|
|
# some of these cross-realm messages.
|
|
huddle_subs = [sub for sub in realm_huddle_subs if sub.recipient_id not in unsafe_huddle_recipient_ids]
|
|
huddle_recipient_ids = set(sub.recipient_id for sub in huddle_subs)
|
|
huddle_ids = set(sub.recipient.type_id for sub in huddle_subs)
|
|
|
|
huddle_subscription_dicts = make_raw(huddle_subs)
|
|
huddle_recipients = make_raw(Recipient.objects.filter(id__in=huddle_recipient_ids))
|
|
|
|
response['_huddle_recipient'] = huddle_recipients
|
|
response['_huddle_subscription'] = huddle_subscription_dicts
|
|
response['zerver_huddle'] = make_raw(Huddle.objects.filter(id__in=huddle_ids))
|
|
|
|
def fetch_usermessages(realm: Realm,
|
|
message_ids: Set[int],
|
|
user_profile_ids: Set[int],
|
|
message_filename: Path) -> List[Record]:
|
|
# UserMessage export security rule: You can export UserMessages
|
|
# for the messages you exported for the users in your realm.
|
|
user_message_query = UserMessage.objects.filter(user_profile__realm=realm,
|
|
message_id__in=message_ids)
|
|
user_message_chunk = []
|
|
for user_message in user_message_query:
|
|
if user_message.user_profile_id not in user_profile_ids:
|
|
continue
|
|
user_message_obj = model_to_dict(user_message)
|
|
user_message_obj['flags_mask'] = user_message.flags.mask
|
|
del user_message_obj['flags']
|
|
user_message_chunk.append(user_message_obj)
|
|
logging.info("Fetched UserMessages for %s" % (message_filename,))
|
|
return user_message_chunk
|
|
|
|
def export_usermessages_batch(input_path: Path, output_path: Path) -> None:
|
|
"""As part of the system for doing parallel exports, this runs on one
|
|
batch of Message objects and adds the corresponding UserMessage
|
|
objects. (This is called by the export_usermessage_batch
|
|
management command)."""
|
|
with open(input_path, "r") as input_file:
|
|
output = ujson.loads(input_file.read())
|
|
message_ids = [item['id'] for item in output['zerver_message']]
|
|
user_profile_ids = set(output['zerver_userprofile_ids'])
|
|
del output['zerver_userprofile_ids']
|
|
realm = Realm.objects.get(id=output['realm_id'])
|
|
del output['realm_id']
|
|
output['zerver_usermessage'] = fetch_usermessages(realm, set(message_ids), user_profile_ids, output_path)
|
|
write_message_export(output_path, output)
|
|
os.unlink(input_path)
|
|
|
|
def write_message_export(message_filename: Path, output: MessageOutput) -> None:
|
|
write_data_to_file(output_file=message_filename, data=output)
|
|
logging.info("Dumped to %s" % (message_filename,))
|
|
|
|
def export_partial_message_files(realm: Realm,
|
|
response: TableData,
|
|
chunk_size: int=1000,
|
|
output_dir: Optional[Path]=None) -> Set[int]:
|
|
if output_dir is None:
|
|
output_dir = tempfile.mkdtemp(prefix="zulip-export")
|
|
|
|
def get_ids(records: List[Record]) -> Set[int]:
|
|
return set(x['id'] for x in records)
|
|
|
|
# Basic security rule: You can export everything either...
|
|
# - sent by someone in your exportable_user_ids
|
|
# OR
|
|
# - received by someone in your exportable_user_ids (which
|
|
# equates to a recipient object we are exporting)
|
|
#
|
|
# TODO: In theory, you should be able to export messages in
|
|
# cross-realm PM threads; currently, this only exports cross-realm
|
|
# messages received by your realm that were sent by Zulip system
|
|
# bots (e.g. emailgateway, notification-bot).
|
|
|
|
# Here, "we" and "us" refers to the inner circle of users who
|
|
# were specified as being allowed to be exported. "Them"
|
|
# refers to other users.
|
|
user_ids_for_us = get_ids(
|
|
response['zerver_userprofile']
|
|
)
|
|
recipient_ids_for_us = get_ids(response['zerver_recipient'])
|
|
|
|
ids_of_our_possible_senders = get_ids(
|
|
response['zerver_userprofile'] +
|
|
response['zerver_userprofile_mirrordummy'] +
|
|
response['zerver_userprofile_crossrealm'])
|
|
ids_of_non_exported_possible_recipients = ids_of_our_possible_senders - user_ids_for_us
|
|
|
|
recipients_for_them = Recipient.objects.filter(
|
|
type=Recipient.PERSONAL,
|
|
type_id__in=ids_of_non_exported_possible_recipients).values("id")
|
|
recipient_ids_for_them = get_ids(recipients_for_them)
|
|
|
|
# We capture most messages here, since the
|
|
# recipients we subscribe to are also the
|
|
# recipients of most messages we send.
|
|
messages_we_received = Message.objects.filter(
|
|
sender__in=ids_of_our_possible_senders,
|
|
recipient__in=recipient_ids_for_us,
|
|
).order_by('id')
|
|
|
|
# This should pick up stragglers; messages we sent
|
|
# where we the recipient wasn't subscribed to by any of
|
|
# us (such as PMs to "them").
|
|
messages_we_sent_to_them = Message.objects.filter(
|
|
sender__in=user_ids_for_us,
|
|
recipient__in=recipient_ids_for_them,
|
|
).order_by('id')
|
|
|
|
message_queries = [
|
|
messages_we_received,
|
|
messages_we_sent_to_them
|
|
]
|
|
|
|
all_message_ids = set() # type: Set[int]
|
|
dump_file_id = 1
|
|
|
|
for message_query in message_queries:
|
|
dump_file_id = write_message_partial_for_query(
|
|
realm=realm,
|
|
message_query=message_query,
|
|
dump_file_id=dump_file_id,
|
|
all_message_ids=all_message_ids,
|
|
output_dir=output_dir,
|
|
chunk_size=chunk_size,
|
|
user_profile_ids=user_ids_for_us,
|
|
)
|
|
|
|
return all_message_ids
|
|
|
|
def write_message_partial_for_query(realm: Realm, message_query: Any, dump_file_id: int,
|
|
all_message_ids: Set[int], output_dir: Path,
|
|
chunk_size: int, user_profile_ids: Set[int]) -> int:
|
|
min_id = -1
|
|
|
|
while True:
|
|
actual_query = message_query.filter(id__gt=min_id)[0:chunk_size]
|
|
message_chunk = make_raw(actual_query)
|
|
message_ids = set(m['id'] for m in message_chunk)
|
|
assert len(message_ids.intersection(all_message_ids)) == 0
|
|
|
|
all_message_ids.update(message_ids)
|
|
|
|
if len(message_chunk) == 0:
|
|
break
|
|
|
|
# Figure out the name of our shard file.
|
|
message_filename = os.path.join(output_dir, "messages-%06d.json" % (dump_file_id,))
|
|
message_filename += '.partial'
|
|
logging.info("Fetched Messages for %s" % (message_filename,))
|
|
|
|
# Clean up our messages.
|
|
table_data = {} # type: TableData
|
|
table_data['zerver_message'] = message_chunk
|
|
floatify_datetime_fields(table_data, 'zerver_message')
|
|
|
|
# Build up our output for the .partial file, which needs
|
|
# a list of user_profile_ids to search for (as well as
|
|
# the realm id).
|
|
output = {} # type: MessageOutput
|
|
output['zerver_message'] = table_data['zerver_message']
|
|
output['zerver_userprofile_ids'] = list(user_profile_ids)
|
|
output['realm_id'] = realm.id
|
|
|
|
# And write the data.
|
|
write_message_export(message_filename, output)
|
|
min_id = max(message_ids)
|
|
dump_file_id += 1
|
|
|
|
return dump_file_id
|
|
|
|
def export_uploads_and_avatars(realm: Realm, output_dir: Path) -> None:
|
|
uploads_output_dir = os.path.join(output_dir, 'uploads')
|
|
avatars_output_dir = os.path.join(output_dir, 'avatars')
|
|
|
|
for output_dir in (uploads_output_dir, avatars_output_dir):
|
|
if not os.path.exists(output_dir):
|
|
os.makedirs(output_dir)
|
|
|
|
if settings.LOCAL_UPLOADS_DIR:
|
|
# Small installations and developers will usually just store files locally.
|
|
export_uploads_from_local(realm,
|
|
local_dir=os.path.join(settings.LOCAL_UPLOADS_DIR, "files"),
|
|
output_dir=uploads_output_dir)
|
|
export_avatars_from_local(realm,
|
|
local_dir=os.path.join(settings.LOCAL_UPLOADS_DIR, "avatars"),
|
|
output_dir=avatars_output_dir)
|
|
else:
|
|
# Some bigger installations will have their data stored on S3.
|
|
export_files_from_s3(realm,
|
|
settings.S3_AVATAR_BUCKET,
|
|
output_dir=avatars_output_dir,
|
|
processing_avatars=True)
|
|
export_files_from_s3(realm,
|
|
settings.S3_AUTH_UPLOADS_BUCKET,
|
|
output_dir=uploads_output_dir)
|
|
|
|
def export_files_from_s3(realm: Realm, bucket_name: str, output_dir: Path,
|
|
processing_avatars: bool=False) -> None:
|
|
conn = S3Connection(settings.S3_KEY, settings.S3_SECRET_KEY)
|
|
bucket = conn.get_bucket(bucket_name, validate=True)
|
|
records = []
|
|
|
|
logging.info("Downloading uploaded files from %s" % (bucket_name))
|
|
|
|
avatar_hash_values = set()
|
|
user_ids = set()
|
|
if processing_avatars:
|
|
bucket_list = bucket.list()
|
|
for user_profile in UserProfile.objects.filter(realm=realm):
|
|
avatar_path = user_avatar_path_from_ids(user_profile.id, realm.id)
|
|
avatar_hash_values.add(avatar_path)
|
|
avatar_hash_values.add(avatar_path + ".original")
|
|
user_ids.add(user_profile.id)
|
|
else:
|
|
bucket_list = bucket.list(prefix="%s/" % (realm.id,))
|
|
|
|
if settings.EMAIL_GATEWAY_BOT is not None:
|
|
email_gateway_bot = get_system_bot(settings.EMAIL_GATEWAY_BOT) # type: Optional[UserProfile]
|
|
else:
|
|
email_gateway_bot = None
|
|
|
|
count = 0
|
|
for bkey in bucket_list:
|
|
if processing_avatars and bkey.name not in avatar_hash_values:
|
|
continue
|
|
key = bucket.get_key(bkey.name)
|
|
|
|
# This can happen if an email address has moved realms
|
|
if 'realm_id' in key.metadata and key.metadata['realm_id'] != str(realm.id):
|
|
if email_gateway_bot is None or key.metadata['user_profile_id'] != str(email_gateway_bot.id):
|
|
raise Exception("Key metadata problem: %s %s / %s" % (key.name, key.metadata, realm.id))
|
|
# Email gateway bot sends messages, potentially including attachments, cross-realm.
|
|
print("File uploaded by email gateway bot: %s / %s" % (key.name, key.metadata))
|
|
elif processing_avatars:
|
|
if 'user_profile_id' not in key.metadata:
|
|
raise Exception("Missing user_profile_id in key metadata: %s" % (key.metadata,))
|
|
if int(key.metadata['user_profile_id']) not in user_ids:
|
|
raise Exception("Wrong user_profile_id in key metadata: %s" % (key.metadata,))
|
|
elif 'realm_id' not in key.metadata:
|
|
raise Exception("Missing realm_id in key metadata: %s" % (key.metadata,))
|
|
|
|
record = dict(s3_path=key.name, bucket=bucket_name,
|
|
size=key.size, last_modified=key.last_modified,
|
|
content_type=key.content_type, md5=key.md5)
|
|
record.update(key.metadata)
|
|
|
|
# A few early avatars don't have 'realm_id' on the object; fix their metadata
|
|
user_profile = get_user_profile_by_id(record['user_profile_id'])
|
|
if 'realm_id' not in record:
|
|
record['realm_id'] = user_profile.realm_id
|
|
record['user_profile_email'] = user_profile.email
|
|
|
|
if processing_avatars:
|
|
dirname = output_dir
|
|
filename = os.path.join(dirname, key.name)
|
|
record['path'] = key.name
|
|
else:
|
|
fields = key.name.split('/')
|
|
if len(fields) != 3:
|
|
raise Exception("Suspicious key %s" % (key.name))
|
|
dirname = os.path.join(output_dir, fields[1])
|
|
filename = os.path.join(dirname, fields[2])
|
|
record['path'] = os.path.join(fields[1], fields[2])
|
|
|
|
if not os.path.exists(dirname):
|
|
os.makedirs(dirname)
|
|
key.get_contents_to_filename(filename)
|
|
|
|
records.append(record)
|
|
count += 1
|
|
|
|
if (count % 100 == 0):
|
|
logging.info("Finished %s" % (count,))
|
|
|
|
with open(os.path.join(output_dir, "records.json"), "w") as records_file:
|
|
ujson.dump(records, records_file, indent=4)
|
|
|
|
def export_uploads_from_local(realm: Realm, local_dir: Path, output_dir: Path) -> None:
|
|
|
|
count = 0
|
|
records = []
|
|
for attachment in Attachment.objects.filter(realm_id=realm.id):
|
|
local_path = os.path.join(local_dir, attachment.path_id)
|
|
output_path = os.path.join(output_dir, attachment.path_id)
|
|
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
|
subprocess.check_call(["cp", "-a", local_path, output_path])
|
|
stat = os.stat(local_path)
|
|
record = dict(realm_id=attachment.realm_id,
|
|
user_profile_id=attachment.owner.id,
|
|
user_profile_email=attachment.owner.email,
|
|
s3_path=attachment.path_id,
|
|
path=attachment.path_id,
|
|
size=stat.st_size,
|
|
last_modified=stat.st_mtime,
|
|
content_type=None)
|
|
records.append(record)
|
|
|
|
count += 1
|
|
|
|
if (count % 100 == 0):
|
|
logging.info("Finished %s" % (count,))
|
|
with open(os.path.join(output_dir, "records.json"), "w") as records_file:
|
|
ujson.dump(records, records_file, indent=4)
|
|
|
|
def export_avatars_from_local(realm: Realm, local_dir: Path, output_dir: Path) -> None:
|
|
|
|
count = 0
|
|
records = []
|
|
|
|
users = list(UserProfile.objects.filter(realm=realm))
|
|
users += [
|
|
get_system_bot(settings.NOTIFICATION_BOT),
|
|
get_system_bot(settings.EMAIL_GATEWAY_BOT),
|
|
get_system_bot(settings.WELCOME_BOT),
|
|
]
|
|
for user in users:
|
|
if user.avatar_source == UserProfile.AVATAR_FROM_GRAVATAR:
|
|
continue
|
|
|
|
avatar_path = user_avatar_path_from_ids(user.id, realm.id)
|
|
wildcard = os.path.join(local_dir, avatar_path + '.*')
|
|
|
|
for local_path in glob.glob(wildcard):
|
|
logging.info('Copying avatar file for user %s from %s' % (
|
|
user.email, local_path))
|
|
fn = os.path.relpath(local_path, local_dir)
|
|
output_path = os.path.join(output_dir, fn)
|
|
os.makedirs(str(os.path.dirname(output_path)), exist_ok=True)
|
|
subprocess.check_call(["cp", "-a", str(local_path), str(output_path)])
|
|
stat = os.stat(local_path)
|
|
record = dict(realm_id=realm.id,
|
|
user_profile_id=user.id,
|
|
user_profile_email=user.email,
|
|
s3_path=fn,
|
|
path=fn,
|
|
size=stat.st_size,
|
|
last_modified=stat.st_mtime,
|
|
content_type=None)
|
|
records.append(record)
|
|
|
|
count += 1
|
|
|
|
if (count % 100 == 0):
|
|
logging.info("Finished %s" % (count,))
|
|
|
|
with open(os.path.join(output_dir, "records.json"), "w") as records_file:
|
|
ujson.dump(records, records_file, indent=4)
|
|
|
|
def do_write_stats_file_for_realm_export(output_dir: Path) -> None:
|
|
stats_file = os.path.join(output_dir, 'stats.txt')
|
|
realm_file = os.path.join(output_dir, 'realm.json')
|
|
attachment_file = os.path.join(output_dir, 'attachment.json')
|
|
message_files = glob.glob(os.path.join(output_dir, 'messages-*.json'))
|
|
fns = sorted([attachment_file] + message_files + [realm_file])
|
|
|
|
logging.info('Writing stats file: %s\n' % (stats_file,))
|
|
with open(stats_file, 'w') as f:
|
|
for fn in fns:
|
|
f.write(os.path.basename(fn) + '\n')
|
|
payload = open(fn).read()
|
|
data = ujson.loads(payload)
|
|
for k in sorted(data):
|
|
f.write('%5d %s\n' % (len(data[k]), k))
|
|
f.write('\n')
|
|
|
|
avatar_file = os.path.join(output_dir, 'avatars/records.json')
|
|
uploads_file = os.path.join(output_dir, 'uploads/records.json')
|
|
|
|
for fn in [avatar_file, uploads_file]:
|
|
f.write(fn+'\n')
|
|
payload = open(fn).read()
|
|
data = ujson.loads(payload)
|
|
f.write('%5d records\n' % len(data))
|
|
f.write('\n')
|
|
|
|
def do_export_realm(realm: Realm, output_dir: Path, threads: int,
|
|
exportable_user_ids: Optional[Set[int]]=None) -> None:
|
|
response = {} # type: TableData
|
|
|
|
# We need at least one thread running to export
|
|
# UserMessage rows. The management command should
|
|
# enforce this for us.
|
|
if not settings.TEST_SUITE:
|
|
assert threads >= 1
|
|
|
|
assert os.path.exists("./manage.py")
|
|
|
|
realm_config = get_realm_config()
|
|
|
|
create_soft_link(source=output_dir, in_progress=True)
|
|
|
|
logging.info("Exporting data from get_realm_config()...")
|
|
export_from_config(
|
|
response=response,
|
|
config=realm_config,
|
|
seed_object=realm,
|
|
context=dict(realm=realm, exportable_user_ids=exportable_user_ids)
|
|
)
|
|
logging.info('...DONE with get_realm_config() data')
|
|
|
|
export_file = os.path.join(output_dir, "realm.json")
|
|
write_data_to_file(output_file=export_file, data=response)
|
|
|
|
sanity_check_output(response)
|
|
|
|
logging.info("Exporting uploaded files and avatars")
|
|
export_uploads_and_avatars(realm, output_dir)
|
|
|
|
# We (sort of) export zerver_message rows here. We write
|
|
# them to .partial files that are subsequently fleshed out
|
|
# by parallel processes to add in zerver_usermessage data.
|
|
# This is for performance reasons, of course. Some installations
|
|
# have millions of messages.
|
|
logging.info("Exporting .partial files messages")
|
|
message_ids = export_partial_message_files(realm, response, output_dir=output_dir)
|
|
logging.info('%d messages were exported' % (len(message_ids)))
|
|
|
|
# zerver_attachment
|
|
export_attachment_table(realm=realm, output_dir=output_dir, message_ids=message_ids)
|
|
|
|
# Start parallel jobs to export the UserMessage objects.
|
|
launch_user_message_subprocesses(threads=threads, output_dir=output_dir)
|
|
|
|
logging.info("Finished exporting %s" % (realm.string_id))
|
|
create_soft_link(source=output_dir, in_progress=False)
|
|
|
|
def export_attachment_table(realm: Realm, output_dir: Path, message_ids: Set[int]) -> None:
|
|
response = {} # type: TableData
|
|
fetch_attachment_data(response=response, realm_id=realm.id, message_ids=message_ids)
|
|
output_file = os.path.join(output_dir, "attachment.json")
|
|
logging.info('Writing attachment table data to %s' % (output_file,))
|
|
write_data_to_file(output_file=output_file, data=response)
|
|
|
|
def create_soft_link(source: Path, in_progress: bool=True) -> None:
|
|
is_done = not in_progress
|
|
in_progress_link = '/tmp/zulip-export-in-progress'
|
|
done_link = '/tmp/zulip-export-most-recent'
|
|
|
|
if in_progress:
|
|
new_target = in_progress_link
|
|
else:
|
|
subprocess.check_call(['rm', '-f', in_progress_link])
|
|
new_target = done_link
|
|
|
|
subprocess.check_call(["ln", "-nsf", source, new_target])
|
|
if is_done:
|
|
logging.info('See %s for output files' % (new_target,))
|
|
|
|
|
|
def launch_user_message_subprocesses(threads: int, output_dir: Path) -> None:
|
|
logging.info('Launching %d PARALLEL subprocesses to export UserMessage rows' % (threads,))
|
|
|
|
def run_job(shard: str) -> int:
|
|
subprocess.call(["./manage.py", 'export_usermessage_batch', '--path',
|
|
str(output_dir), '--thread', shard])
|
|
return 0
|
|
|
|
for (status, job) in run_parallel(run_job,
|
|
[str(x) for x in range(0, threads)],
|
|
threads=threads):
|
|
print("Shard %s finished, status %s" % (job, status))
|
|
|
|
def do_export_user(user_profile: UserProfile, output_dir: Path) -> None:
|
|
response = {} # type: TableData
|
|
|
|
export_single_user(user_profile, response)
|
|
export_file = os.path.join(output_dir, "user.json")
|
|
write_data_to_file(output_file=export_file, data=response)
|
|
logging.info("Exporting messages")
|
|
export_messages_single_user(user_profile, output_dir)
|
|
|
|
def export_single_user(user_profile: UserProfile, response: TableData) -> None:
|
|
|
|
config = get_single_user_config()
|
|
export_from_config(
|
|
response=response,
|
|
config=config,
|
|
seed_object=user_profile,
|
|
)
|
|
|
|
def get_single_user_config() -> Config:
|
|
|
|
# zerver_userprofile
|
|
user_profile_config = Config(
|
|
table='zerver_userprofile',
|
|
is_seeded=True,
|
|
exclude=['password', 'api_key'],
|
|
)
|
|
|
|
# zerver_subscription
|
|
subscription_config = Config(
|
|
table='zerver_subscription',
|
|
model=Subscription,
|
|
normal_parent=user_profile_config,
|
|
parent_key='user_profile__in',
|
|
)
|
|
|
|
# zerver_recipient
|
|
recipient_config = Config(
|
|
table='zerver_recipient',
|
|
model=Recipient,
|
|
virtual_parent=subscription_config,
|
|
id_source=('zerver_subscription', 'recipient'),
|
|
)
|
|
|
|
# zerver_stream
|
|
Config(
|
|
table='zerver_stream',
|
|
model=Stream,
|
|
virtual_parent=recipient_config,
|
|
id_source=('zerver_recipient', 'type_id'),
|
|
source_filter=lambda r: r['type'] == Recipient.STREAM,
|
|
exclude=['email_token'],
|
|
)
|
|
|
|
return user_profile_config
|
|
|
|
def export_messages_single_user(user_profile: UserProfile, output_dir: Path, chunk_size: int=1000) -> None:
|
|
user_message_query = UserMessage.objects.filter(user_profile=user_profile).order_by("id")
|
|
min_id = -1
|
|
dump_file_id = 1
|
|
while True:
|
|
actual_query = user_message_query.select_related(
|
|
"message", "message__sending_client").filter(id__gt=min_id)[0:chunk_size]
|
|
user_message_chunk = [um for um in actual_query]
|
|
user_message_ids = set(um.id for um in user_message_chunk)
|
|
|
|
if len(user_message_chunk) == 0:
|
|
break
|
|
|
|
message_chunk = []
|
|
for user_message in user_message_chunk:
|
|
item = model_to_dict(user_message.message)
|
|
item['flags'] = user_message.flags_list()
|
|
item['flags_mask'] = user_message.flags.mask
|
|
# Add a few nice, human-readable details
|
|
item['sending_client_name'] = user_message.message.sending_client.name
|
|
item['display_recipient'] = get_display_recipient(user_message.message.recipient)
|
|
message_chunk.append(item)
|
|
|
|
message_filename = os.path.join(output_dir, "messages-%06d.json" % (dump_file_id,))
|
|
logging.info("Fetched Messages for %s" % (message_filename,))
|
|
|
|
output = {'zerver_message': message_chunk}
|
|
floatify_datetime_fields(output, 'zerver_message')
|
|
|
|
write_message_export(message_filename, output)
|
|
min_id = max(user_message_ids)
|
|
dump_file_id += 1
|
|
|
|
# Code from here is the realm import code path
|
|
|
|
# id_maps is a dictionary that maps table names to dictionaries
|
|
# that map old ids to new ids. We use this in
|
|
# re_map_foreign_keys and other places.
|
|
#
|
|
# We explicity initialize id_maps with the tables that support
|
|
# id re-mapping.
|
|
#
|
|
# Code reviewers: give these tables extra scrutiny, as we need to
|
|
# make sure to reload related tables AFTER we re-map the ids.
|
|
id_maps = {
|
|
'client': {},
|
|
'user_profile': {},
|
|
'realm': {},
|
|
'stream': {},
|
|
'recipient': {},
|
|
'subscription': {},
|
|
'defaultstream': {},
|
|
'reaction': {},
|
|
'realmemoji': {},
|
|
'realmdomain': {},
|
|
'realmfilter': {},
|
|
'message': {},
|
|
'user_presence': {},
|
|
'useractivity': {},
|
|
'useractivityinterval': {},
|
|
'usermessage': {},
|
|
'customprofilefield': {},
|
|
'customprofilefield_value': {},
|
|
'attachment': {},
|
|
} # type: Dict[str, Dict[int, int]]
|
|
|
|
path_maps = {
|
|
'attachment_path': {},
|
|
} # type: Dict[str, Dict[str, str]]
|
|
|
|
def update_id_map(table: TableName, old_id: int, new_id: int) -> None:
|
|
if table not in id_maps:
|
|
raise Exception('''
|
|
Table %s is not initialized in id_maps, which could
|
|
mean that we have not thought through circular
|
|
dependencies.
|
|
''' % (table,))
|
|
id_maps[table][old_id] = new_id
|
|
|
|
def fix_datetime_fields(data: TableData, table: TableName) -> None:
|
|
for item in data[table]:
|
|
for field_name in DATE_FIELDS[table]:
|
|
if item[field_name] is not None:
|
|
item[field_name] = datetime.datetime.fromtimestamp(item[field_name], tz=timezone_utc)
|
|
|
|
def fix_upload_links(data: TableData, message_table: TableName) -> None:
|
|
"""
|
|
Because the URLs for uploaded files encode the realm ID of the
|
|
organization being imported (which is only determined at import
|
|
time), we need to rewrite the URLs of links to uploaded files
|
|
during the import process.
|
|
"""
|
|
for message in data[message_table]:
|
|
if message['has_attachment'] is True:
|
|
for key, value in path_maps['attachment_path'].items():
|
|
if key in message['content']:
|
|
message['content'] = message['content'].replace(key, value)
|
|
if message['rendered_content']:
|
|
message['rendered_content'] = message['rendered_content'].replace(key, value)
|
|
|
|
def current_table_ids(data: TableData, table: TableName) -> List[int]:
|
|
"""
|
|
Returns the ids present in the current table
|
|
"""
|
|
id_list = []
|
|
for item in data[table]:
|
|
id_list.append(item["id"])
|
|
return id_list
|
|
|
|
def idseq(model_class: Any) -> str:
|
|
if model_class == RealmDomain:
|
|
return 'zerver_realmalias_id_seq'
|
|
return '{}_id_seq'.format(model_class._meta.db_table)
|
|
|
|
def allocate_ids(model_class: Any, count: int) -> List[int]:
|
|
"""
|
|
Increases the sequence number for a given table by the amount of objects being
|
|
imported into that table. Hence, this gives a reserved range of ids to import the
|
|
converted slack objects into the tables.
|
|
"""
|
|
conn = connection.cursor()
|
|
sequence = idseq(model_class)
|
|
conn.execute("select nextval('%s') from generate_series(1,%s)" %
|
|
(sequence, str(count)))
|
|
query = conn.fetchall() # Each element in the result is a tuple like (5,)
|
|
conn.close()
|
|
# convert List[Tuple[int]] to List[int]
|
|
return [item[0] for item in query]
|
|
|
|
def convert_to_id_fields(data: TableData, table: TableName, field_name: Field) -> None:
|
|
'''
|
|
When Django gives us dict objects via model_to_dict, the foreign
|
|
key fields are `foo`, but we want `foo_id` for the bulk insert.
|
|
This function handles the simple case where we simply rename
|
|
the fields. For cases where we need to munge ids in the
|
|
database, see re_map_foreign_keys.
|
|
'''
|
|
for item in data[table]:
|
|
item[field_name + "_id"] = item[field_name]
|
|
del item[field_name]
|
|
|
|
def re_map_foreign_keys(data: TableData,
|
|
table: TableName,
|
|
field_name: Field,
|
|
related_table: TableName,
|
|
verbose: bool=False,
|
|
id_field: bool=False,
|
|
recipient_field: bool=False) -> None:
|
|
"""
|
|
This is a wrapper function for all the realm data tables
|
|
and only avatar and attachment records need to be passed through the internal function
|
|
because of the difference in data format (TableData corresponding to realm data tables
|
|
and List[Record] corresponding to the avatar and attachment records)
|
|
"""
|
|
re_map_foreign_keys_internal(data[table], table, field_name, related_table, verbose, id_field,
|
|
recipient_field)
|
|
|
|
def re_map_foreign_keys_internal(data_table: List[Record],
|
|
table: TableName,
|
|
field_name: Field,
|
|
related_table: TableName,
|
|
verbose: bool=False,
|
|
id_field: bool=False,
|
|
recipient_field: bool=False) -> None:
|
|
'''
|
|
We occasionally need to assign new ids to rows during the
|
|
import/export process, to accommodate things like existing rows
|
|
already being in tables. See bulk_import_client for more context.
|
|
|
|
The tricky part is making sure that foreign key references
|
|
are in sync with the new ids, and this fixer function does
|
|
the re-mapping. (It also appends `_id` to the field.)
|
|
'''
|
|
lookup_table = id_maps[related_table]
|
|
for item in data_table:
|
|
if recipient_field:
|
|
if related_table == "stream" and item['type'] == 2:
|
|
pass
|
|
elif related_table == "user_profile" and item['type'] == 1:
|
|
pass
|
|
else:
|
|
continue
|
|
old_id = item[field_name]
|
|
if old_id in lookup_table:
|
|
new_id = lookup_table[old_id]
|
|
if verbose:
|
|
logging.info('Remapping %s %s from %s to %s' % (table,
|
|
field_name + '_id',
|
|
old_id,
|
|
new_id))
|
|
else:
|
|
new_id = old_id
|
|
if not id_field:
|
|
item[field_name + "_id"] = new_id
|
|
del item[field_name]
|
|
else:
|
|
item[field_name] = new_id
|
|
|
|
def fix_bitfield_keys(data: TableData, table: TableName, field_name: Field) -> None:
|
|
for item in data[table]:
|
|
item[field_name] = item[field_name + '_mask']
|
|
del item[field_name + '_mask']
|
|
|
|
def fix_realm_authentication_bitfield(data: TableData, table: TableName, field_name: Field) -> None:
|
|
"""Used to fixup the authentication_methods bitfield to be a string"""
|
|
for item in data[table]:
|
|
values_as_bitstring = ''.join(['1' if field[1] else '0' for field in
|
|
item[field_name]])
|
|
values_as_int = int(values_as_bitstring, 2)
|
|
item[field_name] = values_as_int
|
|
|
|
def update_model_ids(model: Any, data: TableData, table: TableName, related_table: TableName) -> None:
|
|
old_id_list = current_table_ids(data, table)
|
|
allocated_id_list = allocate_ids(model, len(data[table]))
|
|
for item in range(len(data[table])):
|
|
update_id_map(related_table, old_id_list[item], allocated_id_list[item])
|
|
re_map_foreign_keys(data, table, 'id', related_table=related_table, id_field=True)
|
|
|
|
def bulk_import_model(data: TableData, model: Any, table: TableName,
|
|
dump_file_id: Optional[str]=None) -> None:
|
|
# TODO, deprecate dump_file_id
|
|
model.objects.bulk_create(model(**item) for item in data[table])
|
|
if dump_file_id is None:
|
|
logging.info("Successfully imported %s from %s." % (model, table))
|
|
else:
|
|
logging.info("Successfully imported %s from %s[%s]." % (model, table, dump_file_id))
|
|
|
|
# Client is a table shared by multiple realms, so in order to
|
|
# correctly import multiple realms into the same server, we need to
|
|
# check if a Client object already exists, and so we need to support
|
|
# remap all Client IDs to the values in the new DB.
|
|
def bulk_import_client(data: TableData, model: Any, table: TableName) -> None:
|
|
for item in data[table]:
|
|
try:
|
|
client = Client.objects.get(name=item['name'])
|
|
except Client.DoesNotExist:
|
|
client = Client.objects.create(name=item['name'])
|
|
update_id_map(table='client', old_id=item['id'], new_id=client.id)
|
|
|
|
def import_uploads_local(import_dir: Path, processing_avatars: bool=False,
|
|
processing_emojis: bool=False) -> None:
|
|
records_filename = os.path.join(import_dir, "records.json")
|
|
with open(records_filename) as records_file:
|
|
records = ujson.loads(records_file.read())
|
|
|
|
re_map_foreign_keys_internal(records, 'records', 'realm_id', related_table="realm",
|
|
id_field=True)
|
|
if not processing_emojis:
|
|
re_map_foreign_keys_internal(records, 'records', 'user_profile_id',
|
|
related_table="user_profile", id_field=True)
|
|
for record in records:
|
|
if processing_avatars:
|
|
# For avatars, we need to rehash the user ID with the
|
|
# new server's avatar salt
|
|
avatar_path = user_avatar_path_from_ids(record['user_profile_id'], record['realm_id'])
|
|
file_path = os.path.join(settings.LOCAL_UPLOADS_DIR, "avatars", avatar_path)
|
|
if record['s3_path'].endswith('.original'):
|
|
file_path += '.original'
|
|
else:
|
|
file_path += '.png'
|
|
elif processing_emojis:
|
|
# For emojis we follow the function 'upload_emoji_image'
|
|
emoji_path = RealmEmoji.PATH_ID_TEMPLATE.format(
|
|
realm_id=record['realm_id'],
|
|
emoji_file_name=record['file_name'])
|
|
file_path = os.path.join(settings.LOCAL_UPLOADS_DIR, "avatars", emoji_path)
|
|
else:
|
|
# Should be kept in sync with its equivalent in zerver/lib/uploads in the
|
|
# function 'upload_message_image'
|
|
s3_file_name = "/".join([
|
|
str(record['realm_id']),
|
|
random_name(18),
|
|
sanitize_name(os.path.basename(record['path']))
|
|
])
|
|
file_path = os.path.join(settings.LOCAL_UPLOADS_DIR, "files", s3_file_name)
|
|
path_maps['attachment_path'][record['path']] = s3_file_name
|
|
|
|
orig_file_path = os.path.join(import_dir, record['path'])
|
|
if not os.path.exists(os.path.dirname(file_path)):
|
|
subprocess.check_call(["mkdir", "-p", os.path.dirname(file_path)])
|
|
shutil.copy(orig_file_path, file_path)
|
|
|
|
if processing_avatars:
|
|
# Ensure that we have medium-size avatar images for every
|
|
# avatar. TODO: This implementation is hacky, both in that it
|
|
# does get_user_profile_by_id for each user, and in that it
|
|
# might be better to require the export to just have these.
|
|
upload_backend = LocalUploadBackend()
|
|
for record in records:
|
|
if record['s3_path'].endswith('.original'):
|
|
user_profile = get_user_profile_by_id(record['user_profile_id'])
|
|
avatar_path = user_avatar_path_from_ids(user_profile.id, record['realm_id'])
|
|
medium_file_path = os.path.join(settings.LOCAL_UPLOADS_DIR, "avatars",
|
|
avatar_path) + '-medium.png'
|
|
if os.path.exists(medium_file_path):
|
|
# We remove the image here primarily to deal with
|
|
# issues when running the import script multiple
|
|
# times in development (where one might reuse the
|
|
# same realm ID from a previous iteration).
|
|
os.remove(medium_file_path)
|
|
upload_backend.ensure_medium_avatar_image(user_profile=user_profile)
|
|
|
|
def import_uploads_s3(bucket_name: str, import_dir: Path, processing_avatars: bool=False,
|
|
processing_emojis: bool=False) -> None:
|
|
upload_backend = S3UploadBackend()
|
|
conn = S3Connection(settings.S3_KEY, settings.S3_SECRET_KEY)
|
|
bucket = conn.get_bucket(bucket_name, validate=True)
|
|
|
|
records_filename = os.path.join(import_dir, "records.json")
|
|
with open(records_filename) as records_file:
|
|
records = ujson.loads(records_file.read())
|
|
|
|
re_map_foreign_keys_internal(records, 'records', 'realm_id', related_table="realm",
|
|
id_field=True)
|
|
re_map_foreign_keys_internal(records, 'records', 'user_profile_id',
|
|
related_table="user_profile", id_field=True)
|
|
for record in records:
|
|
key = Key(bucket)
|
|
|
|
if processing_avatars:
|
|
# For avatars, we need to rehash the user's email with the
|
|
# new server's avatar salt
|
|
avatar_path = user_avatar_path_from_ids(record['user_profile_id'], record['realm_id'])
|
|
key.key = avatar_path
|
|
if record['s3_path'].endswith('.original'):
|
|
key.key += '.original'
|
|
if processing_emojis:
|
|
# For emojis we follow the function 'upload_emoji_image'
|
|
emoji_path = RealmEmoji.PATH_ID_TEMPLATE.format(
|
|
realm_id=record['realm_id'],
|
|
emoji_file_name=record['file_name'])
|
|
key.key = emoji_path
|
|
else:
|
|
# Should be kept in sync with its equivalent in zerver/lib/uploads in the
|
|
# function 'upload_message_image'
|
|
s3_file_name = "/".join([
|
|
str(record['realm_id']),
|
|
random_name(18),
|
|
sanitize_name(os.path.basename(record['path']))
|
|
])
|
|
key.key = s3_file_name
|
|
path_maps['attachment_path'][record['path']] = s3_file_name
|
|
|
|
user_profile_id = int(record['user_profile_id'])
|
|
# Support email gateway bot and other cross-realm messages
|
|
if user_profile_id in id_maps["user_profile"]:
|
|
logging.info("Uploaded by ID mapped user: %s!" % (user_profile_id,))
|
|
user_profile_id = id_maps["user_profile"][user_profile_id]
|
|
user_profile = get_user_profile_by_id(user_profile_id)
|
|
key.set_metadata("user_profile_id", str(user_profile.id))
|
|
key.set_metadata("realm_id", str(user_profile.realm_id))
|
|
key.set_metadata("orig_last_modified", record['last_modified'])
|
|
|
|
headers = {'Content-Type': record['content_type']}
|
|
|
|
key.set_contents_from_filename(os.path.join(import_dir, record['path']), headers=headers)
|
|
|
|
if processing_avatars:
|
|
# TODO: Ideally, we'd do this in a separate pass, after
|
|
# all the avatars have been uploaded, since we may end up
|
|
# unnecssarily resizing images just before the medium-size
|
|
# image in the export is uploaded. See the local uplods
|
|
# code path for more notes.
|
|
upload_backend.ensure_medium_avatar_image(user_profile=user_profile)
|
|
|
|
def import_uploads(import_dir: Path, processing_avatars: bool=False,
|
|
processing_emojis: bool=False) -> None:
|
|
if processing_avatars:
|
|
logging.info("Importing avatars")
|
|
elif processing_emojis:
|
|
logging.info("Importing emojis")
|
|
else:
|
|
logging.info("Importing uploaded files")
|
|
if settings.LOCAL_UPLOADS_DIR:
|
|
import_uploads_local(import_dir, processing_avatars=processing_avatars,
|
|
processing_emojis=processing_emojis)
|
|
else:
|
|
if processing_avatars or processing_emojis:
|
|
bucket_name = settings.S3_AVATAR_BUCKET
|
|
else:
|
|
bucket_name = settings.S3_AUTH_UPLOADS_BUCKET
|
|
import_uploads_s3(bucket_name, import_dir, processing_avatars=processing_avatars)
|
|
|
|
# Importing data suffers from a difficult ordering problem because of
|
|
# models that reference each other circularly. Here is a correct order.
|
|
#
|
|
# * Client [no deps]
|
|
# * Realm [-notifications_stream]
|
|
# * Stream [only depends on realm]
|
|
# * Realm's notifications_stream
|
|
# * Now can do all realm_tables
|
|
# * UserProfile, in order by ID to avoid bot loop issues
|
|
# * Huddle
|
|
# * Recipient
|
|
# * Subscription
|
|
# * Message
|
|
# * UserMessage
|
|
#
|
|
# Because the Python object => JSON conversion process is not fully
|
|
# faithful, we have to use a set of fixers (e.g. on DateTime objects
|
|
# and Foreign Keys) to do the import correctly.
|
|
def do_import_realm(import_dir: Path, subdomain: str) -> Realm:
|
|
logging.info("Importing realm dump %s" % (import_dir,))
|
|
if not os.path.exists(import_dir):
|
|
raise Exception("Missing import directory!")
|
|
|
|
realm_data_filename = os.path.join(import_dir, "realm.json")
|
|
if not os.path.exists(realm_data_filename):
|
|
raise Exception("Missing realm.json file!")
|
|
|
|
logging.info("Importing realm data from %s" % (realm_data_filename,))
|
|
with open(realm_data_filename) as f:
|
|
data = ujson.load(f)
|
|
|
|
update_model_ids(Stream, data, 'zerver_stream', 'stream')
|
|
re_map_foreign_keys(data, 'zerver_realm', 'notifications_stream', related_table="stream")
|
|
|
|
fix_datetime_fields(data, 'zerver_realm')
|
|
# Fix realm subdomain information
|
|
data['zerver_realm'][0]['string_id'] = subdomain
|
|
data['zerver_realm'][0]['name'] = subdomain
|
|
fix_realm_authentication_bitfield(data, 'zerver_realm', 'authentication_methods')
|
|
update_model_ids(Realm, data, 'zerver_realm', 'realm')
|
|
|
|
realm = Realm(**data['zerver_realm'][0])
|
|
if realm.notifications_stream_id is not None:
|
|
notifications_stream_id = int(realm.notifications_stream_id) # type: Optional[int]
|
|
else:
|
|
notifications_stream_id = None
|
|
realm.notifications_stream_id = None
|
|
realm.save()
|
|
bulk_import_client(data, Client, 'zerver_client')
|
|
|
|
# Email tokens will automatically be randomly generated when the
|
|
# Stream objects are created by Django.
|
|
fix_datetime_fields(data, 'zerver_stream')
|
|
re_map_foreign_keys(data, 'zerver_stream', 'realm', related_table="realm")
|
|
bulk_import_model(data, Stream, 'zerver_stream')
|
|
|
|
realm.notifications_stream_id = notifications_stream_id
|
|
realm.save()
|
|
|
|
re_map_foreign_keys(data, 'zerver_defaultstream', 'stream', related_table="stream")
|
|
re_map_foreign_keys(data, 'zerver_realmemoji', 'author', related_table="user_profile")
|
|
for (table, model, related_table) in realm_tables:
|
|
re_map_foreign_keys(data, table, 'realm', related_table="realm")
|
|
update_model_ids(model, data, table, related_table)
|
|
bulk_import_model(data, model, table)
|
|
|
|
# Remap the user IDs for notification_bot and friends to their
|
|
# appropriate IDs on this server
|
|
for item in data['zerver_userprofile_crossrealm']:
|
|
logging.info("Adding to ID map: %s %s" % (item['id'], get_system_bot(item['email']).id))
|
|
new_user_id = get_system_bot(item['email']).id
|
|
update_id_map(table='user_profile', old_id=item['id'], new_id=new_user_id)
|
|
|
|
# Merge in zerver_userprofile_mirrordummy
|
|
data['zerver_userprofile'] = data['zerver_userprofile'] + data['zerver_userprofile_mirrordummy']
|
|
del data['zerver_userprofile_mirrordummy']
|
|
data['zerver_userprofile'].sort(key=lambda r: r['id'])
|
|
|
|
# To remap foreign key for UserProfile.last_active_message_id
|
|
update_message_foreign_keys(import_dir)
|
|
|
|
fix_datetime_fields(data, 'zerver_userprofile')
|
|
update_model_ids(UserProfile, data, 'zerver_userprofile', 'user_profile')
|
|
re_map_foreign_keys(data, 'zerver_userprofile', 'realm', related_table="realm")
|
|
re_map_foreign_keys(data, 'zerver_userprofile', 'bot_owner', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_userprofile', 'default_sending_stream',
|
|
related_table="stream")
|
|
re_map_foreign_keys(data, 'zerver_userprofile', 'default_events_register_stream',
|
|
related_table="stream")
|
|
re_map_foreign_keys(data, 'zerver_userprofile', 'last_active_message_id',
|
|
related_table="message", id_field=True)
|
|
for user_profile_dict in data['zerver_userprofile']:
|
|
user_profile_dict['password'] = None
|
|
user_profile_dict['api_key'] = random_api_key()
|
|
# Since Zulip doesn't use these permissions, drop them
|
|
del user_profile_dict['user_permissions']
|
|
del user_profile_dict['groups']
|
|
|
|
user_profiles = [UserProfile(**item) for item in data['zerver_userprofile']]
|
|
for user_profile in user_profiles:
|
|
user_profile.set_unusable_password()
|
|
UserProfile.objects.bulk_create(user_profiles)
|
|
|
|
if 'zerver_huddle' in data:
|
|
bulk_import_model(data, Huddle, 'zerver_huddle')
|
|
|
|
re_map_foreign_keys(data, 'zerver_recipient', 'type_id', related_table="stream",
|
|
recipient_field=True, id_field=True)
|
|
re_map_foreign_keys(data, 'zerver_recipient', 'type_id', related_table="user_profile",
|
|
recipient_field=True, id_field=True)
|
|
update_model_ids(Recipient, data, 'zerver_recipient', 'recipient')
|
|
bulk_import_model(data, Recipient, 'zerver_recipient')
|
|
|
|
re_map_foreign_keys(data, 'zerver_subscription', 'user_profile', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_subscription', 'recipient', related_table="recipient")
|
|
update_model_ids(Subscription, data, 'zerver_subscription', 'subscription')
|
|
bulk_import_model(data, Subscription, 'zerver_subscription')
|
|
|
|
fix_datetime_fields(data, 'zerver_userpresence')
|
|
re_map_foreign_keys(data, 'zerver_userpresence', 'user_profile', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_userpresence', 'client', related_table='client')
|
|
update_model_ids(UserPresence, data, 'zerver_userpresence', 'user_presence')
|
|
bulk_import_model(data, UserPresence, 'zerver_userpresence')
|
|
|
|
fix_datetime_fields(data, 'zerver_useractivity')
|
|
re_map_foreign_keys(data, 'zerver_useractivity', 'user_profile', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_useractivity', 'client', related_table='client')
|
|
update_model_ids(UserActivity, data, 'zerver_useractivity', 'useractivity')
|
|
bulk_import_model(data, UserActivity, 'zerver_useractivity')
|
|
|
|
fix_datetime_fields(data, 'zerver_useractivityinterval')
|
|
re_map_foreign_keys(data, 'zerver_useractivityinterval', 'user_profile', related_table="user_profile")
|
|
update_model_ids(UserActivityInterval, data, 'zerver_useractivityinterval',
|
|
'useractivityinterval')
|
|
bulk_import_model(data, UserActivityInterval, 'zerver_useractivityinterval')
|
|
|
|
if 'zerver_customprofilefield' in data:
|
|
# As the export of Custom Profile fields is not supported, Zulip exported
|
|
# data would not contain this field.
|
|
# However this is supported in slack importer script
|
|
re_map_foreign_keys(data, 'zerver_customprofilefield', 'realm', related_table="realm")
|
|
update_model_ids(CustomProfileField, data, 'zerver_customprofilefield',
|
|
related_table="customprofilefield")
|
|
bulk_import_model(data, CustomProfileField, 'zerver_customprofilefield')
|
|
|
|
re_map_foreign_keys(data, 'zerver_customprofilefield_value', 'user_profile',
|
|
related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_customprofilefield_value', 'field',
|
|
related_table="customprofilefield")
|
|
update_model_ids(CustomProfileFieldValue, data, 'zerver_customprofilefield_value',
|
|
related_table="customprofilefield_value")
|
|
bulk_import_model(data, CustomProfileFieldValue, 'zerver_customprofilefield_value')
|
|
|
|
# Import uploaded files and avatars
|
|
import_uploads(os.path.join(import_dir, "avatars"), processing_avatars=True)
|
|
import_uploads(os.path.join(import_dir, "uploads"))
|
|
|
|
# We need to have this check as the emoji files are only present in the data
|
|
# importer from slack
|
|
# For Zulip export, this doesn't exist
|
|
if os.path.exists(os.path.join(import_dir, "emoji")):
|
|
import_uploads(os.path.join(import_dir, "emoji"), processing_emojis=True)
|
|
|
|
# Import zerver_message and zerver_usermessage
|
|
import_message_data(import_dir)
|
|
|
|
# Do attachments AFTER message data is loaded.
|
|
# TODO: de-dup how we read these json files.
|
|
fn = os.path.join(import_dir, "attachment.json")
|
|
if not os.path.exists(fn):
|
|
raise Exception("Missing attachment.json file!")
|
|
|
|
logging.info("Importing attachment data from %s" % (fn,))
|
|
with open(fn) as f:
|
|
data = ujson.load(f)
|
|
|
|
import_attachments(data)
|
|
return realm
|
|
|
|
# create_users and do_import_system_bots differ from their equivalent in
|
|
# zerver/management/commands/initialize_voyager_db.py because here we check if the bots
|
|
# don't already exist and only then create a user for these bots.
|
|
def do_import_system_bots(realm: Any) -> None:
|
|
internal_bots = [(bot['name'], bot['email_template'] % (settings.INTERNAL_BOT_DOMAIN,))
|
|
for bot in settings.INTERNAL_BOTS]
|
|
create_users(realm, internal_bots, bot_type=UserProfile.DEFAULT_BOT)
|
|
names = [(settings.FEEDBACK_BOT_NAME, settings.FEEDBACK_BOT)]
|
|
create_users(realm, names, bot_type=UserProfile.DEFAULT_BOT)
|
|
print("Finished importing system bots.")
|
|
|
|
def create_users(realm: Realm, name_list: Iterable[Tuple[Text, Text]],
|
|
bot_type: Optional[int]=None) -> None:
|
|
user_set = set()
|
|
for full_name, email in name_list:
|
|
short_name = email_to_username(email)
|
|
if not UserProfile.objects.filter(email=email):
|
|
user_set.add((email, full_name, short_name, True))
|
|
bulk_create_users(realm, user_set, bot_type)
|
|
|
|
def update_message_foreign_keys(import_dir: Path) -> None:
|
|
dump_file_id = 1
|
|
while True:
|
|
message_filename = os.path.join(import_dir, "messages-%06d.json" % (dump_file_id,))
|
|
if not os.path.exists(message_filename):
|
|
break
|
|
|
|
with open(message_filename) as f:
|
|
data = ujson.load(f)
|
|
|
|
update_model_ids(Message, data, 'zerver_message', 'message')
|
|
dump_file_id += 1
|
|
|
|
def import_message_data(import_dir: Path) -> None:
|
|
dump_file_id = 1
|
|
while True:
|
|
message_filename = os.path.join(import_dir, "messages-%06d.json" % (dump_file_id,))
|
|
if not os.path.exists(message_filename):
|
|
break
|
|
|
|
with open(message_filename) as f:
|
|
data = ujson.load(f)
|
|
|
|
logging.info("Importing message dump %s" % (message_filename,))
|
|
re_map_foreign_keys(data, 'zerver_message', 'sender', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_message', 'recipient', related_table="recipient")
|
|
re_map_foreign_keys(data, 'zerver_message', 'sending_client', related_table='client')
|
|
fix_datetime_fields(data, 'zerver_message')
|
|
# Parser to update message content with the updated attachment urls
|
|
fix_upload_links(data, 'zerver_message')
|
|
|
|
re_map_foreign_keys(data, 'zerver_message', 'id', related_table='message', id_field=True)
|
|
bulk_import_model(data, Message, 'zerver_message')
|
|
|
|
# Due to the structure of these message chunks, we're
|
|
# guaranteed to have already imported all the Message objects
|
|
# for this batch of UserMessage objects.
|
|
re_map_foreign_keys(data, 'zerver_usermessage', 'message', related_table="message")
|
|
re_map_foreign_keys(data, 'zerver_usermessage', 'user_profile', related_table="user_profile")
|
|
fix_bitfield_keys(data, 'zerver_usermessage', 'flags')
|
|
update_model_ids(UserMessage, data, 'zerver_usermessage', 'usermessage')
|
|
bulk_import_model(data, UserMessage, 'zerver_usermessage')
|
|
|
|
# As the export of Reactions is not supported, Zulip exported
|
|
# data would not contain this field.
|
|
# However this is supported in slack importer script
|
|
if 'zerver_reaction' in data:
|
|
re_map_foreign_keys(data, 'zerver_reaction', 'message', related_table="message")
|
|
re_map_foreign_keys(data, 'zerver_reaction', 'user_profile', related_table="user_profile")
|
|
for reaction in data['zerver_reaction']:
|
|
if reaction['reaction_type'] == Reaction.REALM_EMOJI:
|
|
re_map_foreign_keys(data, 'zerver_reaction', 'emoji_code',
|
|
related_table="realmemoji", id_field=True)
|
|
update_model_ids(Reaction, data, 'zerver_reaction', 'reaction')
|
|
bulk_import_model(data, Reaction, 'zerver_reaction')
|
|
|
|
dump_file_id += 1
|
|
|
|
def import_attachments(data: TableData) -> None:
|
|
|
|
# Clean up the data in zerver_attachment that is not
|
|
# relevant to our many-to-many import.
|
|
fix_datetime_fields(data, 'zerver_attachment')
|
|
re_map_foreign_keys(data, 'zerver_attachment', 'owner', related_table="user_profile")
|
|
re_map_foreign_keys(data, 'zerver_attachment', 'realm', related_table="realm")
|
|
|
|
# Configure ourselves. Django models many-to-many (m2m)
|
|
# relations asymmetrically. The parent here refers to the
|
|
# Model that has the ManyToManyField. It is assumed here
|
|
# the child models have been loaded, but we are in turn
|
|
# responsible for loading the parents and the m2m rows.
|
|
parent_model = Attachment
|
|
parent_db_table_name = 'zerver_attachment'
|
|
parent_singular = 'attachment'
|
|
child_singular = 'message'
|
|
child_plural = 'messages'
|
|
m2m_table_name = 'zerver_attachment_messages'
|
|
parent_id = 'attachment_id'
|
|
child_id = 'message_id'
|
|
|
|
update_model_ids(parent_model, data, parent_db_table_name, 'attachment')
|
|
# First, build our list of many-to-many (m2m) rows.
|
|
# We do this in a slightly convoluted way to anticipate
|
|
# a future where we may need to call re_map_foreign_keys.
|
|
|
|
m2m_rows = [] # type: List[Record]
|
|
for parent_row in data[parent_db_table_name]:
|
|
for fk_id in parent_row[child_plural]:
|
|
m2m_row = {} # type: Record
|
|
m2m_row[parent_singular] = parent_row['id']
|
|
m2m_row[child_singular] = id_maps['message'][fk_id]
|
|
m2m_rows.append(m2m_row)
|
|
|
|
# Create our table data for insert.
|
|
m2m_data = {m2m_table_name: m2m_rows} # type: TableData
|
|
convert_to_id_fields(m2m_data, m2m_table_name, parent_singular)
|
|
convert_to_id_fields(m2m_data, m2m_table_name, child_singular)
|
|
m2m_rows = m2m_data[m2m_table_name]
|
|
|
|
# Next, delete out our child data from the parent rows.
|
|
for parent_row in data[parent_db_table_name]:
|
|
del parent_row[child_plural]
|
|
|
|
# Update 'path_id' for the attachments
|
|
for attachment in data[parent_db_table_name]:
|
|
attachment['path_id'] = path_maps['attachment_path'][attachment['path_id']]
|
|
|
|
# Next, load the parent rows.
|
|
bulk_import_model(data, parent_model, parent_db_table_name)
|
|
|
|
# Now, go back to our m2m rows.
|
|
# TODO: Do this the kosher Django way. We may find a
|
|
# better way to do this in Django 1.9 particularly.
|
|
with connection.cursor() as cursor:
|
|
sql_template = '''
|
|
insert into %s (%s, %s) values(%%s, %%s);''' % (m2m_table_name,
|
|
parent_id,
|
|
child_id)
|
|
tups = [(row[parent_id], row[child_id]) for row in m2m_rows]
|
|
cursor.executemany(sql_template, tups)
|
|
|
|
logging.info('Successfully imported M2M table %s' % (m2m_table_name,))
|