path: root/sugar_network/node/master.py

# Copyright (C) 2013-2014 Aleksey Lim
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os
import json
import logging
from urlparse import urlsplit
from os.path import join, exists

from sugar_network import toolkit
from sugar_network.model.post import Post
from sugar_network.model.report import Report
from sugar_network.node import model
from sugar_network.node.auth import Principal
from sugar_network.node.routes import NodeRoutes
from sugar_network.toolkit.router import route, ACL
from sugar_network.toolkit.coroutine import this
from sugar_network.toolkit.spec import format_version
from sugar_network.toolkit import http, packets, pylru, ranges, i18n, enforce


RESOURCES = (model.User, model.Context, Post, Report)

_logger = logging.getLogger('node.master')


class MasterRoutes(NodeRoutes):

    def __init__(self, master_api, **kwargs):
        NodeRoutes.__init__(self, urlsplit(master_api).netloc, **kwargs)
        self._pulls = pylru.lrucache(1024)
        self._auth = _Auth()
        self._pilot_releases = {}
        self._pilot_releases_mtime = -1

    @route('POST', cmd='sync', arguments={'accept_length': int})
    def sync(self, accept_length):
        return packets.encode(self._push() + (self._pull() or []),
                limit=accept_length, header={'from': self.guid},
                on_complete=this.cookie.clear)

    @route('POST', cmd='push')
    def push(self):
        return packets.encode(self._push(), header={'from': self.guid})

    @route('GET', cmd='pull', arguments={'accept_length': int})
    def pull(self, accept_length):
        reply = self._pull()
        if reply is None:
            return None
        return packets.encode(reply, limit=accept_length,
                header={'from': self.guid}, on_complete=this.cookie.clear)

    def status(self):
        result = NodeRoutes.status(self)
        result['mode'] = 'master'
        return result

    def _push(self):
        cookie = this.cookie
        reply = []

        for packet in packets.decode(
                this.request.content, this.request.content_length):
            sender = packet['from']
            enforce(packet['to'] == self.guid, http.BadRequest,
                    'Misaddressed packet')
            if packet.name == 'push':
                seqno, push_r = model.patch_volume(packet)
                ack_r = [] if seqno is None else [[seqno, seqno]]
                ack = {'ack': ack_r, 'ranges': push_r, 'to': sender}
                reply.append(('ack', ack, None))
                cookie.setdefault('ack', {}) \
                      .setdefault(sender, []) \
                      .append((push_r, ack_r))
            elif packet.name == 'pull':
                cookie.setdefault('ack', {}).setdefault(sender, [])
                ranges.include(cookie.setdefault('pull', []), packet['ranges'])
            elif packet.name == 'request':
                cookie.setdefault('request', []).append(packet.header)

        return reply

    def _pull(self):
        processed = this.cookie.get('id')
        if processed in self._pulls:
            cookie = this.cookie = self._pulls[processed]
            if not cookie:
                return None
        else:
            cookie = this.cookie
            cookie['id'] = toolkit.uuid()
            self._pulls[cookie['id']] = cookie

        pull_r = cookie.get('pull')
        if not pull_r:
            return []

        reply = []
        exclude = []
        acks = cookie.get('ack')
        if acks:
            acked = {}
            for req in cookie.get('request') or []:
                ack_r = None
                for push_r, ack_r in acks.get(req['origin']) or []:
                    if req['ranges'] == push_r:
                        break
                else:
                    continue
                ranges.include(acked.setdefault(req['from'], []), ack_r)
                reply.append(('ack', {'to': req['from'], 'ack': ack_r}, []))
            for node, ack_ranges in acks.items():
                acked_r = acked.setdefault(node, [])
                for __, i in ack_ranges:
                    ranges.include(acked_r, i)
            r = reduce(lambda x, y: ranges.intersect(x, y), acked.values())
            ranges.include(exclude, r)

        push = model.diff_volume(pull_r, exclude, one_way=True, files=[''])
        reply.append(('push', None, push))

        return reply

    @route('GET', cmd='info', mime_type='application/json')
    def info(self):
        documents = {}
        for name, directory in self.volume.items():
            documents[name] = {'mtime': 0}
        return {'guid': self.guid, 'documents': documents}

    @route('POST', ['user'], mime_type='application/json')
    def register(self):
        request = this.request
        for prop in ('color', 'machine_sn', 'machine_uuid'):
            if prop in request.content:
                del request.content[prop]
        user = request.environ.get('HTTP_SUGAR_USER')
        this.principal = Principal(user, 0xFF)
        request.content['guid'] = user
        self.create()

    @route('GET', ['feedback'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',)},
            mime_type='application/json')
    def find_feedback(self, reply, limit):
        this.request.resource = 'post'
        if 'type' not in this.request:
            this.request['type'] = ['question', 'problem', 'idea']
        if reply and 'content' in reply:
            reply.remove('content')
            reply.append('message')
        result = NodeRoutes.find(self, reply, limit)
        for item in result['result']:
            if 'message' in item:
                item['content'] = item.pop('message')
            if 'author' in item:
                item['author'] = _format_author(item)
        return result

    @route('GET', ['feedback', None], arguments={'reply': list},
            mime_type='application/json')
    def get_feedback(self, reply):
        this.request.resource = 'post'
        if reply and 'content' in reply:
            reply.remove('content')
            reply.append('message')
        result = NodeRoutes.get(self, reply)
        if 'message' in result:
            result['content'] = result.pop('message')
        if 'author' in result:
            result['author'] = _format_author(result)
        return result

    @route('GET', ['feedback', None, None], mime_type='application/json')
    def get_feedback_prop(self):
        this.request.resource = 'post'
        if this.request.prop == 'content':
            this.request.prop = 'message'
        return NodeRoutes.get_prop(self)

    @route('POST', ['feedback'], acl=ACL.AUTH, mime_type='application/json')
    def create_feedback(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        return self.create()

    @route('PUT', ['feedback', None], acl=ACL.AUTH | ACL.AUTHOR)
    def update_feedback(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        return self.update()

    @route('GET', ['review'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',)},
            mime_type='application/json')
    def find_review(self, reply, limit):
        this.request.resource = 'post'
        if reply and 'content' in reply:
            reply.remove('content')
            reply.append('message')
        this.request['type'] = 'review'
        result = NodeRoutes.find(self, reply, limit)
        for item in result['result']:
            if 'message' in item:
                item['content'] = item.pop('message')
            if 'author' in item:
                item['author'] = _format_author(item)
        return result

    @route('GET', ['review', None], arguments={'reply': list},
            mime_type='application/json')
    def get_review(self, reply):
        this.request.resource = 'post'
        if reply and 'content' in reply:
            reply.remove('content')
            reply.append('message')
        result = NodeRoutes.get(self, reply)
        if 'message' in result:
            result['content'] = result.pop('message')
        if 'author' in result:
            result['author'] = _format_author(result)
        return result

    @route('GET', ['review', None, None], mime_type='application/json')
    def get_review_prop(self):
        request = this.request
        request.resource = 'post'
        if request.prop == 'content':
            request.prop = 'message'
        return NodeRoutes.get_prop(self)

    @route('POST', ['review'], acl=ACL.AUTH, mime_type='application/json')
    def create_review(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        if 'rating' in request.content:
            request.content['vote'] = request.content.pop('rating')
        request.content['type'] = 'review'
        return self.create()

    @route('PUT', ['review', None], acl=ACL.AUTH | ACL.AUTHOR)
    def update_review(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        return self.update()

    @route('GET', ['solution'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',)},
            mime_type='application/json')
    def find_solution(self, reply, limit):
        request = this.request
        request.resource = 'post'
        if reply:
            if 'content' in reply:
                reply.remove('content')
                reply.append('message')
            if 'feedback' in reply:
                reply.remove('feedback')
                reply.append('topic')
        if 'feedback' in request:
            request['topic'] = request.pop('feedback')
        request['type'] = 'solution'
        result = NodeRoutes.find(self, reply, limit)
        for item in result['result']:
            if 'message' in item:
                item['content'] = item.pop('message')
            if 'topic' in item:
                item['feedback'] = item.pop('topic')
            if 'author' in item:
                item['author'] = _format_author(item)
        return result

    @route('GET', ['solution', None], arguments={'reply': list},
            mime_type='application/json')
    def get_solution(self, reply):
        this.request.resource = 'post'
        if reply:
            if 'content' in reply:
                reply.remove('content')
                reply.append('message')
            if 'feedback' in reply:
                reply.remove('feedback')
                reply.append('topic')
        result = NodeRoutes.get(self, reply)
        if 'message' in result:
            result['content'] = result.pop('message')
        if 'topic' in result:
            result['feedback'] = result.pop('topic')
        if 'author' in result:
            result['author'] = _format_author(result)
        return result

    @route('GET', ['solution', None, None], mime_type='application/json')
    def get_solution_prop(self):
        request = this.request
        request.resource = 'post'
        if request.prop == 'content':
            request.prop = 'message'
        if request.prop == 'feedback':
            request.prop = 'topic'
        return NodeRoutes.get_prop(self)

    @route('POST', ['solution'], acl=ACL.AUTH, mime_type='application/json')
    def create_solution(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        if 'feedback' in request.content:
            request.content['topic'] = request.content.pop('feedback')
        request.content['context'] = \
                this.volume['post'][request.content['topic']]['context']
        request.content['title'] = ''
        request.content['type'] = 'solution'
        return self.create()

    @route('PUT', ['solution', None], acl=ACL.AUTH | ACL.AUTHOR)
    def update_solution(self):
        request = this.request
        request.resource = 'post'
        if 'content' in request.content:
            request.content['message'] = request.content.pop('content')
        if 'feedback' in request.content:
            request.content['topic'] = request.content.pop('feedback')
        return self.update()

    @route('GET', ['artifact'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',)},
            mime_type='application/json')
    def find_artifact(self, reply, limit):
        this.request.resource = 'post'
        if reply:
            if 'description' in reply:
                reply.remove('description')
                reply.append('title')
        this.request['type'] = 'file'
        result = NodeRoutes.find(self, reply, limit)
        for item in result['result']:
            if 'title' in item:
                item['description'] = item['title']
            if 'author' in item:
                item['author'] = _format_author(item)
        return result

    @route('GET', ['artifact', None], arguments={'reply': list},
            mime_type='application/json')
    def get_artifact(self, reply):
        this.request.resource = 'post'
        if reply:
            if 'description' in reply:
                reply.remove('description')
                reply.append('title')
        result = NodeRoutes.get(self, reply)
        if 'title' in result:
            result['description'] = result['title']
        if 'author' in result:
            result['author'] = _format_author(result)
        return result

    @route('GET', ['artifact', None, None], mime_type='application/json')
    def get_artifact_prop(self):
        request = this.request
        request.resource = 'post'
        if request.prop == 'description':
            request.prop = 'title'
        elif request.prop == 'data':
            attachments = this.volume['post'][request.guid]['attachments']
            enforce(attachments, http.NotFound, 'No attachments')
            this.response.content_type = 'application/octet-stream'
            blob = this.volume.blobs.get(attachments.values()[0]['value'])
            return blob.iter_content()
        return NodeRoutes.get_prop(self)

    @route('POST', ['artifact'], acl=ACL.AUTH, mime_type='application/json')
    def create_artifact(self):
        request = this.request
        request.resource = 'post'
        if 'description' in request.content:
            request.content['title'] = request.content.pop('description')
        request.content['message'] = ''
        request.content['type'] = 'file'
        return self.create()

    @route('PUT', ['artifact', None], acl=ACL.AUTH | ACL.AUTHOR)
    def update_artifact(self):
        request = this.request
        request.resource = 'post'
        if 'description' in request.content:
            request.content['title'] = request.content.pop('description')
        return self.update()

    @route('PUT', ['artifact', None, None], acl=ACL.AUTH | ACL.AUTHOR)
    def update_artifact_prop(self):
        request = this.request
        request.resource = 'post'
        if request.prop == 'description':
            request.prop = 'title'
        elif request.prop == 'data':
            request.prop = 'attachments'
            request.method = 'POST'
            return self.insert_to_aggprop()
        return self.update_prop()

    @route('GET', ['comment'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',)},
            mime_type='application/json')
    def find_comment(self, reply, limit):
        request = this.request
        for prop in ('review', 'feedback', 'solution'):
            if prop in request:
                post = this.volume['post'][request[prop]]
                break
        else:
            return {'total': 0, 'result': []}
        result = []
        for key, agg in post['comments'].items():
            if 'value' not in agg:
                continue
            user, author = agg['author'].items()[0]
            author['guid'] = user
            result.append({
                'guid': '%s-%s' % (post.guid, key),
                'message': i18n.decode(agg['value'], request.accept_language),
                'context': post['context'],
                'author': [author],
                'ctime': agg['ctime'],
                'mtime': agg['ctime'],
                prop: post.guid,
                })
        return {'total': len(result), 'result': result}

    @route('GET', ['comment', None], arguments={'reply': list},
            mime_type='application/json')
    def get_comment(self, reply):
        request = this.request
        guid, key = request.guid.split('-')
        post = this.volume['post'][guid]
        agg = post['comments'][key]
        enforce(agg and 'value' in agg, http.NotFound, 'No such comment')
        return {'guid': request.guid,
                'message': i18n.decode(agg['value'], request.accept_language),
                'context': post['context'],
                'author': _format_author(agg),
                'ctime': agg['ctime'],
                'mtime': agg['ctime'],
                post['type']: post.guid,
                }

    @route('POST', ['comment'], acl=ACL.AUTH, mime_type='application/json')
    def create_comment(self):
        request = this.request
        request.resource = 'post'
        for prop in ('review', 'feedback', 'solution'):
            if prop in request.content:
                request.guid = request.content[prop]
                break
        else:
            raise http.BadRequest('No topic')
        request.prop = 'comments'
        request.method = 'POST'
        request.content = request.content['message']
        key = self.insert_to_aggprop()
        return '%s-%s' % (request.guid, key)

    @route('DELETE', ['comment', None], acl=ACL.AUTH | ACL.AUTHOR)
    def delete_comment(self):
        request = this.request
        request.resource = 'post'
        request.guid, request.key = request.guid.split('-')
        request.prop = 'comments'
        self.remove_from_aggprop()

    @route('GET', ['context'],
            arguments={'offset': int, 'limit': int, 'reply': ('guid',), 'type': list},
            mime_type='application/json')
    def find_context(self, reply, limit):
        if reply:
            if 'artifact_icon' in reply:
                reply.remove('artifact_icon')
                reply.append('artefact_icon')
            if 'preview' in reply:
                reply.remove('preview')
                reply.append('logo')
        type_ = this.request.setdefault('type', [])
        if 'project' in type_:
            type_.remove('project')
            type_.append('group')
        result = NodeRoutes.find(self, reply, limit)
        for item in result['result']:
            if item.get('type') == ['group']:
                item['type'] = ['project']
            if 'artefact_icon' in item:
                item['artifact_icon'] = item.pop('artefact_icon')
            if 'logo' in item:
                item['preview'] = item.pop('logo')
            if 'author' in item:
                item['author'] = _format_author(item)
        return result

    @route('GET', ['context', None], arguments={'reply': list},
            mime_type='application/json')
    def get_context(self, reply):
        if reply:
            if 'artifact_icon' in reply:
                reply.remove('artifact_icon')
                reply.append('artefact_icon')
            if 'preview' in reply:
                reply.remove('preview')
                reply.append('logo')
        result = NodeRoutes.get(self, reply)
        if result.get('type') == ['group']:
            result['type'] = ['project']
        if 'artefact_icon' in result:
            result['artifact_icon'] = result.pop('artefact_icon')
        if 'logo' in result:
            result['preview'] = result.pop('logo')
        if 'author' in result:
            result['author'] = _format_author(result)
        return result

    @route('GET', ['context', None, None], mime_type='application/json')
    def get_context_prop(self):
        if this.request.prop == 'artifact_icon':
            this.request.prop = 'artefact_icon'
        result = NodeRoutes.get_prop(self)
        if this.request.prop == 'type' and result == 'group':
            return 'project'
        return result

    @route('POST', ['context'], acl=ACL.AUTH, mime_type='application/json')
    def create_context(self):
        request = this.request
        if 'project' in request.content['type']:
            request.content['type'].remove('project')
            request.content['type'].append('group')
        if 'artifact_icon' in request.content:
            request.content['artefact_icon'] = request.content.pop('artifact_icon')
        return self.create()

    @route('GET', ['context', None], cmd='feed', mime_type='application/json')
    def feed(self, layer):
        context = this.volume['context'][this.request.guid]
        implementations = []
        for key, aggvalue in context['releases'].items():
            release = aggvalue['value']
            version = format_version(release['version'])
            print layer, context.guid, self._pilot_version(context.guid)
            print self._pilot_releases
            if layer == 'pilot' and \
                    self._pilot_version(context.guid) != version:
                continue
            implementations.append({
                'guid': release['bundles']['*-*']['blob'],
                'version': version,
                'arch': '*-*',
                'stability': release['stability'],
                'commands': release['commands'],
                'extract': release['extract'],
                })
        return {'name': i18n.decode(context['title'],
                    this.request.accept_language),
                'implementations': implementations,
                }

    @route('GET', ['implementation', None, 'data'])
    def get_implementation(self):
        return this.volume.blobs.get(this.request.guid)

    def _pilot_version(self, guid):
        path = join(this.volume.root, 'var', 'pilot-releases')
        if exists(path) and os.stat(path).st_mtime > self._pilot_releases_mtime:
            with file(path) as f:
                self._pilot_releases = json.load(f)
            self._pilot_releases_mtime = os.stat(path).st_mtime
        return self._pilot_releases.get(guid)


class _Auth(object):

    def __init__(self):
        self._authenticated = set()

    def logon(self, request):
        user = request.environ.get('HTTP_SUGAR_USER')
        enforce(user, http.Unauthorized, 'No credentials')

        if user not in self._authenticated:
            _logger.debug('Logging %r user', user)
            enforce(this.volume['user'][user].available, http.Unauthorized,
                    'Principal user does not exist')
            self._authenticated.add(user)

        return Principal(user, 0xFF)


def _format_author(value):
    result = []
    for guid, props in sorted(value['author'].items(),
            key=lambda x: '%016d%s' % (x[1]['role'], x[1].get('name', x[0]))):
        if 'name' not in props:
            props['name'] = guid
        props['guid'] = guid
        result.append(props)
    return result