Rename "pull" request to "list"

boards/management/commands/sync_with_server.py

@@ -1,85 +1,85 b''
 import re
 import xml.etree.ElementTree as ET
 
 import httplib2
 from django.core.management import BaseCommand
 
 from boards.models import GlobalId
 from boards.models.post.sync import SyncManager
 
 __author__ = 'neko259'
 
 
 REGEX_GLOBAL_ID = re.compile(r'(\w+)::([\w\+/]+)::(\d+)')
 
 
 class Command(BaseCommand):
     help = 'Send a sync or get request to the server.'
 
     def add_arguments(self, parser):
         parser.add_argument('url', type=str, help='Server root url')
         parser.add_argument('--global-id', type=str, default='',
                             help='Post global ID')
         parser.add_argument('--split-query', type=int,
                             help='Split GET query into separate by the given'
                                  ' number of posts in one')
 
     def handle(self, *args, **options):
         url = options.get('url')
 
-        pull_url = url + 'api/sync/pull/'
+        list_url = url + 'api/sync/list/'
         get_url = url + 'api/sync/get/'
         file_url = url[:-1]
 
         global_id_str = options.get('global_id')
         if global_id_str:
             match = REGEX_GLOBAL_ID.match(global_id_str)
             if match:
                 key_type = match.group(1)
                 key = match.group(2)
                 local_id = match.group(3)
 
                 global_id = GlobalId(key_type=key_type, key=key,
                                      local_id=local_id)
 
                 xml = GlobalId.objects.generate_request_get([global_id])
                 # body = urllib.parse.urlencode(data)
                 h = httplib2.Http()
                 response, content = h.request(get_url, method="POST", body=xml)
 
                 SyncManager.parse_response_get(content, file_url)
             else:
                 raise Exception('Invalid global ID')
         else:
             h = httplib2.Http()
-            xml = GlobalId.objects.generate_request_pull()
-            response, content = h.request(pull_url, method="POST", body=xml)
+            xml = GlobalId.objects.generate_request_list()
+            response, content = h.request(list_url, method="POST", body=xml)
 
             print(content.decode() + '\n')
 
             root = ET.fromstring(content)
             status = root.findall('status')[0].text
             if status == 'success':
                 ids_to_sync = list()
 
                 models = root.findall('models')[0]
                 for model in models:
                     global_id, exists = GlobalId.from_xml_element(model)
                     if not exists:
                         print(global_id)
                         ids_to_sync.append(global_id)
                 print()
 
                 if len(ids_to_sync) > 0:
                     limit = options.get('split_query', len(ids_to_sync))
                     for offset in range(0, len(ids_to_sync), limit):
                         xml = GlobalId.objects.generate_request_get(ids_to_sync[offset:offset+limit])
                         # body = urllib.parse.urlencode(data)
                         h = httplib2.Http()
                         response, content = h.request(get_url, method="POST", body=xml)
 
                         SyncManager.parse_response_get(content, file_url)
                 else:
                     print('Nothing to get, everything synced')
             else:
                 raise Exception('Invalid response status')

boards/models/post/sync.py

@@ -1,284 +1,284 b''
 import xml.etree.ElementTree as et
 
 from boards.models.attachment.downloaders import download
 from boards.utils import get_file_mimetype, get_file_hash
 from django.db import transaction
 from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 
 EXCEPTION_NODE = 'Sync node returned an error: {}'
 EXCEPTION_OP = 'Load the OP first'
 EXCEPTION_DOWNLOAD = 'File was not downloaded'
 EXCEPTION_HASH = 'File hash does not match attachment hash'
 EXCEPTION_SIGNATURE = 'Invalid model signature for {}'
 ENCODING_UNICODE = 'unicode'
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 TAG_TAGS = 'tags'
 TAG_TAG = 'tag'
 TAG_ATTACHMENT_REFS = 'attachment-refs'
 TAG_ATTACHMENT_REF = 'attachment-ref'
 TAG_TRIPCODE = 'tripcode'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 ATTR_REF = 'ref'
 ATTR_URL = 'url'
 ATTR_ID_TYPE = 'id-type'
 
 ID_TYPE_MD5 = 'md5'
 
 STATUS_SUCCESS = 'success'
 
 
 class SyncException(Exception):
     pass
 
 
 class SyncManager:
     @staticmethod
     def generate_response_get(model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             global_id = post.global_id
 
             images = post.images.all()
             attachments = post.attachments.all()
             if global_id.content:
                 model.append(et.fromstring(global_id.content))
                 if len(images) > 0 or len(attachments) > 0:
                     attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                     for image in images:
                         SyncManager._attachment_to_xml(
                             None, attachment_refs, image.image.file,
                             image.hash, image.image.url)
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             None, attachment_refs, file.file.file,
                             file.hash, file.file.url)
             else:
                 content_tag = et.SubElement(model, TAG_CONTENT)
 
                 tag_id = et.SubElement(content_tag, TAG_ID)
                 global_id.to_xml_element(tag_id)
 
                 title = et.SubElement(content_tag, TAG_TITLE)
                 title.text = post.title
 
                 text = et.SubElement(content_tag, TAG_TEXT)
                 text.text = post.get_sync_text()
 
                 thread = post.get_thread()
                 if post.is_opening():
                     tag_tags = et.SubElement(content_tag, TAG_TAGS)
                     for tag in thread.get_tags():
                         tag_tag = et.SubElement(tag_tags, TAG_TAG)
                         tag_tag.text = tag.name
                 else:
                     tag_thread = et.SubElement(content_tag, TAG_THREAD)
                     thread_id = et.SubElement(tag_thread, TAG_ID)
                     thread.get_opening_post().global_id.to_xml_element(thread_id)
 
                 pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
                 pub_time.text = str(post.get_pub_time_str())
 
                 if post.tripcode:
                     tripcode = et.SubElement(content_tag, TAG_TRIPCODE)
                     tripcode.text = post.tripcode
 
                 if len(images) > 0 or len(attachments) > 0:
                     attachments_tag = et.SubElement(content_tag, TAG_ATTACHMENTS)
                     attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
 
                     for image in images:
                         SyncManager._attachment_to_xml(
                             attachments_tag, attachment_refs, image.image.file,
                             image.hash, image.image.url)
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             attachments_tag, attachment_refs, file.file.file,
                             file.hash, file.file.url)
 
                 global_id.content = et.tostring(content_tag, ENCODING_UNICODE)
                 global_id.save()
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
             else:
                 key = KeyPair.objects.get(public_key=global_id.key)
                 signature = Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(global_id.content),
                     global_id=global_id,
                 )
                 signature.save()
                 signatures = [signature]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
                 signature_tag.set(ATTR_KEY, signature.key)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     @transaction.atomic
     def parse_response_get(response_xml, hostname):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root.find(TAG_STATUS)
         if STATUS_SUCCESS == tag_status.text:
             tag_models = tag_root.find(TAG_MODELS)
             for tag_model in tag_models:
                 tag_content = tag_model.find(TAG_CONTENT)
 
                 content_str = et.tostring(tag_content, ENCODING_UNICODE)
                 signatures = SyncManager._verify_model(content_str, tag_model)
 
                 tag_id = tag_content.find(TAG_ID)
                 global_id, exists = GlobalId.from_xml_element(tag_id)
 
                 if exists:
                     print('Post with same ID already exists')
                 else:
                     global_id.content = content_str
                     global_id.save()
                     for signature in signatures:
                         signature.global_id = global_id
                         signature.save()
 
                     title = tag_content.find(TAG_TITLE).text or ''
                     text = tag_content.find(TAG_TEXT).text or ''
                     pub_time = tag_content.find(TAG_PUB_TIME).text
                     tripcode_tag = tag_content.find(TAG_TRIPCODE)
                     if tripcode_tag is not None:
                         tripcode = tripcode_tag.text or ''
                     else:
                         tripcode = ''
 
                     thread = tag_content.find(TAG_THREAD)
                     tags = []
                     if thread:
                         thread_id = thread.find(TAG_ID)
                         op_global_id, exists = GlobalId.from_xml_element(thread_id)
                         if exists:
                             opening_post = Post.objects.get(global_id=op_global_id)
                         else:
                             raise SyncException(EXCEPTION_OP)
                     else:
                         opening_post = None
                         tag_tags = tag_content.find(TAG_TAGS)
                         for tag_tag in tag_tags:
                             tag, created = Tag.objects.get_or_create(
                                 name=tag_tag.text)
                             tags.append(tag)
 
                     # TODO Check that the replied posts are already present
                     # before adding new ones
 
                     files = []
                     tag_attachments = tag_content.find(TAG_ATTACHMENTS) or list()
                     tag_refs = tag_model.find(TAG_ATTACHMENT_REFS)
                     for attachment in tag_attachments:
                         tag_ref = tag_refs.find("{}[@ref='{}']".format(
                             TAG_ATTACHMENT_REF, attachment.text))
                         url = tag_ref.get(ATTR_URL)
                         attached_file = download(hostname + url)
                         if attached_file is None:
                             raise SyncException(EXCEPTION_DOWNLOAD)
 
                         hash = get_file_hash(attached_file)
                         if hash != attachment.text:
                             raise SyncException(EXCEPTION_HASH)
 
                         files.append(attached_file)
 
                     Post.objects.import_post(
                         title=title, text=text, pub_time=pub_time,
                         opening_post=opening_post, tags=tags,
                         global_id=global_id, files=files, tripcode=tripcode)
         else:
             raise SyncException(EXCEPTION_NODE.format(tag_status.text))
 
     @staticmethod
-    def generate_response_pull():
+    def generate_response_list():
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in Post.objects.prefetch_related('global_id').all():
             tag_id = et.SubElement(models, TAG_ID)
             post.global_id.to_xml_element(tag_id)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def _verify_model(content_str, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
         signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         for tag_signature in tag_signatures:
             signature_type = tag_signature.get(ATTR_TYPE)
             signature_value = tag_signature.get(ATTR_VALUE)
             signature_key = tag_signature.get(ATTR_KEY)
 
             signature = Signature(key_type=signature_type,
                                   key=signature_key,
                                   signature=signature_value)
 
             if not KeyPair.objects.verify(signature, content_str):
                 raise SyncException(EXCEPTION_SIGNATURE.format(content_str))
 
             signatures.append(signature)
 
         return signatures
 
     @staticmethod
     def _attachment_to_xml(tag_attachments, tag_refs, file, hash, url):
         if tag_attachments is not None:
             mimetype = get_file_mimetype(file)
             attachment = et.SubElement(tag_attachments, TAG_ATTACHMENT)
             attachment.set(ATTR_MIMETYPE, mimetype)
             attachment.set(ATTR_ID_TYPE, ID_TYPE_MD5)
             attachment.text = hash
 
         attachment_ref = et.SubElement(tag_refs, TAG_ATTACHMENT_REF)
         attachment_ref.set(ATTR_REF, hash)
         attachment_ref.set(ATTR_URL, url)

boards/models/signature.py

@@ -1,150 +1,150 b''
 import xml.etree.ElementTree as et
 from django.db import models
 from boards.models import KeyPair
 
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_ID = 'id'
 
 TYPE_GET = 'get'
-TYPE_PULL = 'pull'
+TYPE_LIST = 'list'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 
 ATTR_KEY = 'key'
 ATTR_KEY_TYPE = 'type'
 ATTR_LOCAL_ID = 'local-id'
 
 
 class GlobalIdManager(models.Manager):
     def generate_request_get(self, global_id_list: list):
         """
         Form a get request from a list of ModelId objects.
         """
 
         request = et.Element(TAG_REQUEST)
         request.set(ATTR_TYPE, TYPE_GET)
         request.set(ATTR_VERSION, '1.0')
 
         model = et.SubElement(request, TAG_MODEL)
         model.set(ATTR_VERSION, '1.0')
         model.set(ATTR_NAME, 'post')
 
         for global_id in global_id_list:
             tag_id = et.SubElement(model, TAG_ID)
             global_id.to_xml_element(tag_id)
 
         return et.tostring(request, 'unicode')
 
-    def generate_request_pull(self):
+    def generate_request_list(self):
         """
         Form a pull request from a list of ModelId objects.
         """
 
         request = et.Element(TAG_REQUEST)
-        request.set(ATTR_TYPE, TYPE_PULL)
+        request.set(ATTR_TYPE, TYPE_LIST)
         request.set(ATTR_VERSION, '1.0')
 
         model = et.SubElement(request, TAG_MODEL)
         model.set(ATTR_VERSION, '1.0')
         model.set(ATTR_NAME, 'post')
 
         return et.tostring(request, 'unicode')
 
     def global_id_exists(self, global_id):
         """
         Checks if the same global id already exists in the system.
         """
 
         return self.filter(key=global_id.key,
                            key_type=global_id.key_type,
                            local_id=global_id.local_id).exists()
 
 
 class GlobalId(models.Model):
     """
     Global model ID and cache.
     Key, key type and local ID make a single global identificator of the model.
     Content is an XML cache of the model that can be passed along between nodes
     without manual serialization each time.
     """
     class Meta:
         app_label = 'boards'
 
     objects = GlobalIdManager()
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'local_id' in kwargs:
             self.key = kwargs['key']
             self.key_type = kwargs['key_type']
             self.local_id = kwargs['local_id']
 
     key = models.TextField()
     key_type = models.TextField()
     local_id = models.IntegerField()
     content = models.TextField(blank=True, null=True)
 
     def __str__(self):
         return '%s::%s::%d' % (self.key_type, self.key, self.local_id)
 
     def to_xml_element(self, element: et.Element):
         """
         Exports global id to an XML element.
         """
 
         element.set(ATTR_KEY, self.key)
         element.set(ATTR_KEY_TYPE, self.key_type)
         element.set(ATTR_LOCAL_ID, str(self.local_id))
 
     @staticmethod
     def from_xml_element(element: et.Element):
         """
         Parses XML id tag and gets global id from it.
 
         Arguments:
         element -- the XML 'id' element
 
         Returns:
         global_id -- id itself
         exists -- True if the global id was taken from database, False if it
         did not exist and was created.
         """
 
         try:
             return GlobalId.objects.get(key=element.get(ATTR_KEY),
                                         key_type=element.get(ATTR_KEY_TYPE),
                                         local_id=int(element.get(
                                             ATTR_LOCAL_ID))), True
         except GlobalId.DoesNotExist:
             return GlobalId(key=element.get(ATTR_KEY),
                             key_type=element.get(ATTR_KEY_TYPE),
                             local_id=int(element.get(ATTR_LOCAL_ID))), False
 
     def is_local(self):
         """Checks fo the ID is local model's"""
         return KeyPair.objects.filter(
                 key_type=self.key_type, public_key=self.key).exists()
 
 
 class Signature(models.Model):
     class Meta:
         app_label = 'boards'
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'signature' in kwargs:
             self.key_type = kwargs['key_type']
             self.key = kwargs['key']
             self.signature = kwargs['signature']
 
     key_type = models.TextField()
     key = models.TextField()
     signature = models.TextField()
 
     global_id = models.ForeignKey('GlobalId')

boards/urls.py

@@ -1,99 +1,96 b''
 from django.conf.urls import url
-#from django.views.i18n import javascript_catalog
 
 import neboard
 
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags, feed
 from boards.views.authors import AuthorsView
 from boards.views.notifications import NotificationView
-from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.preview import PostPreviewView
-from boards.views.sync import get_post_sync_data, response_get, response_pull
+from boards.views.sync import get_post_sync_data, response_get, response_list
 from boards.views.random import RandomImageView
 from boards.views.tag_gallery import TagGalleryView
 from boards.views.translation import cached_javascript_catalog
 
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = [
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\d+)/$', views.thread.NormalThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.GalleryThreadView.as_view(),
         name='thread_gallery'),
     url(r'^thread/(?P<post_id>\d+)/mode/tree/$', views.thread.TreeThreadView.as_view(),
         name='thread_tree'),
     # /feed/
     url(r'^feed/$', views.feed.FeedView.as_view(), name='feed'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/(?P<query>\w+)?/?$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     url(r'^random/$', RandomImageView.as_view(), name='random'),
     url(r'^tag/(?P<tag_name>\w+)/gallery/$', TagGalleryView.as_view(), name='tag_gallery'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\d+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\d+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', cached_javascript_catalog, js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\d+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/$', api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
     url(r'^api/notifications/(?P<username>\w+)/$', api.api_get_notifications,
             name='api_notifications'),
     url(r'^api/preview/$', api.api_get_preview, name='preview'),
     url(r'^api/new_posts/$', api.api_get_new_posts, name='new_posts'),
 
     # Sync protocol API
-    url(r'^api/sync/pull/$', response_pull, name='api_sync_pull'),
-    url(r'^api/sync/get/$', response_get, name='api_sync_pull'),
-    # TODO 'get' request
+    url(r'^api/sync/list/$', response_list, name='api_sync_list'),
+    url(r'^api/sync/get/$', response_get, name='api_sync_get'),
 
     # Notifications
     url(r'^notifications/(?P<username>\w+)/$', NotificationView.as_view(), name='notifications'),
     url(r'^notifications/$', NotificationView.as_view(), name='notifications'),
 
     # Post preview
     url(r'^preview/$', PostPreviewView.as_view(), name='preview'),
     url(r'^post_xml/(?P<post_id>\d+)$', get_post_sync_data,
         name='post_sync_data'),
 ]
 
 # Search
 if 'haystack' in neboard.settings.INSTALLED_APPS:
     from boards.views.search import BoardSearchView
     urlpatterns.append(url(r'^search/$', BoardSearchView.as_view(), name='search'))
 

boards/views/sync.py

@@ -1,62 +1,62 b''
 import xml.etree.ElementTree as et
 import xml.dom.minidom
 
 from django.http import HttpResponse, Http404
 from boards.models import GlobalId, Post
 from boards.models.post.sync import SyncManager
 
 
-def response_pull(request):
+def response_list(request):
     request_xml = request.body
 
-    if request_xml is None:
+    if request_xml is None or len(request_xml) == 0:
         return HttpResponse(content='Use the API')
 
-    response_xml = SyncManager.generate_response_pull()
+    response_xml = SyncManager.generate_response_list()
 
     return HttpResponse(content=response_xml)
 
 
 def response_get(request):
     """
     Processes a GET request with post ID list and returns the posts XML list.
     Request should contain an 'xml' post attribute with the actual request XML.
     """
 
     request_xml = request.body
 
-    if request_xml is None:
+    if request_xml is None or len(request_xml) == 0:
         return HttpResponse(content='Use the API')
 
     posts = []
 
     root_tag = et.fromstring(request_xml)
     model_tag = root_tag[0]
     for id_tag in model_tag:
         global_id, exists = GlobalId.from_xml_element(id_tag)
         if exists:
             posts.append(Post.objects.get(global_id=global_id))
 
     response_xml = SyncManager.generate_response_get(posts)
 
     return HttpResponse(content=response_xml)
 
 
 def get_post_sync_data(request, post_id):
     try:
         post = Post.objects.get(id=post_id)
     except Post.DoesNotExist:
         raise Http404()
 
     xml_str = SyncManager.generate_response_get([post])
 
     xml_repr = xml.dom.minidom.parseString(xml_str)
     xml_repr = xml_repr.toprettyxml()
 
     content = '=Global ID=\n%s\n\n=XML=\n%s' \
               % (post.global_id, xml_repr)
 
     return HttpResponse(
         content_type='text/plain; charset=utf-8',
         content=content,
     )
  No newline at end of file

docs/dip-1.markdown

@@ -1,203 +1,203 b''
 # 0 Title #
 
 DIP-1 Common protocol description
 
 # 1 Intro #
 
 This document describes the Data Interchange Protocol (DIP), designed to
 exchange filtered data that can be stored as a graph structure between
 network nodes.
 
 # 2 Purpose #
 
 This protocol will be used to share the models (originally imageboard posts)
 across multiple servers. The main differnce of this protocol is that the node
 can specify what models it wants to get and from whom. The nodes can get
 models from a specific server, or from all except some specific servers. Also
 the models can be filtered by timestamps or tags.
 
 # 3 Protocol description #
 
 The node requests other node's changes list since some time (since epoch if
 this is the start). The other node sends a list of post ids or posts in the
 XML format.
 
 Protocol version is the version of the sync api. Model version is the version
 of data models. If at least one of them is different, the sync cannot be
 performed.
 
 The node signs the data with its keys. The receiving node saves the key at the
 first sync and checks it every time. If the key has changed, the info won't be
 saved from the node (or the node id must be changed). A model can be signed 
 with several keys but at least one of them must be the same as in the global 
 ID to verify the sender.
 
 Each node can have several keys. Nodes can have shared keys to serve as a pool
 (several nodes with the same key).
 
 Each post has an ID in the unique format: key-type::key::local-id
 
 All requests pass a request type, protocol and model versions, and a list of
 optional arguments used for filtering.
 
 Each request has its own version. Version consists of 2 numbers: first is
 incompatible version (1.3 and 2.0 are not compatible and must not be in sync)
 and the second one is minor and compatible (for example, new optional field
 is added which will be igroned by those who don't support it yet).
 
 Post edits and reflinks are not saved to the sync model. The replied post ID 
 can be got from the post text, and reflinks can be computed when loading 
 posts. The edit time is not saved because a foreign post can be 'edited' (new
 replies are added) but the signature must not change (so we can't update the
 content). The inner posts can be edited, and the signature will change then
 but the local-id won't, so the other node can detect that and replace the post
 instead of adding a new one.
 
 ## 3.1 Requests ##
 
 There is no constraint on how the server should calculate the request. The
 server can return any information by any filter and the requesting node is
 responsible for validating it.
 
 The server is required to return the status of request. See 3.2 for details.
 
-### 3.1.1 pull ###
+### 3.1.1 list ###
 
-"pull" request gets the desired model id list by the given filter (e.g. thread, tags,
+"list" request gets the desired model id list by the given filter (e.g. thread, tags,
 author)
 
 Sample request is as follows:
 
     <?xml version="1.1" encoding="UTF-8" ?>
-    <request version="1.0" type="pull">
+    <request version="1.0" type="list">
         <model version="1.0" name="post">
             <timestamp_from>0</timestamp_from>
             <timestamp_to>0</timestamp_to>
             <tags>
                 <tag>tag1</tag>
             </tags>
             <sender>
                 <allow>
                     <key>abcehy3h9t</key>
                     <key>ehoehyoe</key>
                 </allow>
                 <!-- There can be only allow block (all other are denied) or deny block (all other are allowed) -->
             </sender>
         </model>
     </request>
 
 Under the <model> tag there are filters. Filters for the "post" model can
 be found in DIP-2.
 
 Sample response:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <response>
         <status>success</status>
         <models>
             <id key="id1" type="ecdsa" local-id="1" />
             <id key="id1" type="ecdsa" local-id="2" />
             <id key="id2" type="ecdsa" local-id="1" />
             <id key="id2" type="ecdsa" local-id="5" />
         </models>
     </response>
 
 ### 3.1.2 get ###
 
 "get" gets models by id list.
 
 Sample request:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <request version="1.0" type="get">
         <model version="1.0" name="post">
             <id key="id1" type="ecdsa" local-id="1" />
             <id key="id1" type="ecdsa" local-id="2" />
         </model>
     </request>
 
 Id consists of a key, key type and local id. This key is used for signing and
 validating of data in the model content.
 
 Sample response:
 
     <?xml version="1.1" encoding="UTF-8" ?>
     <response>
         <!--
              Valid statuses are 'success' and 'error'.
         -->
         <status>success</status>
         <models>
             <model name="post">
                 <!--
                     Content tag is the data that is signed by signatures and must
                     not be changed for the post from other node.
                 -->
                 <content>
                     <id key="id1" type="ecdsa" local-id="1" />
                     <title>13</title>
                     <text>Thirteen</text>
                     <thread><id key="id1" type="ecdsa" local-id="2" /></thread>
                     <pub-time>12</pub-time>
                     <!--
                         Images are saved as attachments and included in the
                         signature.
                     -->
                     <attachments>
                         <attachment mimetype="image/png" id-type="md5">TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5I</attachment>
                     </attachments>
                 </content>
                 <!--
                     There can be several signatures for one model. At least one
                     signature must be made with the key used in global ID.
                  -->
                 <signatures>
                     <signature key="id1" type="ecdsa" value="dhefhtreh" />
                     <signature key="id45" type="ecdsa" value="dsgfgdhefhtreh" />
                 </signatures>
                 <attachment-refs>
                     <attachment-ref ref="TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0"
                         url="/media/images/12345.png" />
                 </attachment-refs>
             </model>
             <model name="post">
                 <content>
                     <id key="id1" type="ecdsa" local-id="id2" />
                     <title>13</title>
                     <text>Thirteen</text>
                     <pub-time>12</pub-time>
                     <edit-time>13</edit-time>
                     <tags>
                         <tag>tag1</tag>
                     </tags>
                 </content>
                 <signatures>
                     <signature key="id2" type="ecdsa" value="dehdfh" />
                 </signatures>
             </model>
         </models>
     </response>
 
 ### 3.1.3 put ###
 
 "put" gives a model to the given node (you have no guarantee the node takes
 it, consider you are just advising the node to take your post). This request
 type is useful in pool where all the nodes try to duplicate all of their data
 across the pool.
 
 ## 3.2 Responses ##
 
 ### 3.2.1 "not supported" ###
 
 If the request if completely not supported, a "not supported" status will be
 returned.
 
 ### 3.2.2 "success" ###
 
 "success" status means the request was processed and the result is returned.
 
 ### 3.2.3 "error" ###
 
 If the server knows for sure that the operation cannot be processed, it sends
 the "error" status. Additional tags describing the error may be <description>
 and <stack>.