path: root/src/jarabe/journal/webdavmanager.py

from gettext import gettext as _

import os
import sys

import gobject
import simplejson
import shutil

from webdav.Connection import AuthorizationError, WebdavError
from webdav.WebdavClient import CollectionStorer

def get_key_from_resource(resource):
    return resource.path

def ensure_correct_remote_webdav_hierarchy(remote_webdav_share_resources,
                                           remote_webdav_share_collections):
    pass
    #assert len(remote_webdav_share_collections.keys()) == 1

class WebDavUrlManager(gobject.GObject):
    """
    This class holds all data, relevant to a WebDavUrl.

    One thing must be noted, that a valid WebDavUrl is the one which
    may contain zero or more resources (files), or zero or more
    collections (directories).

    Thus, following are valid WebDavUrls ::

        dav://1.2.3.4/webdav
        dav://1.2.3.4/webdav/dir_1
        dav://1.2.3.4/webdav/dir_1/dir_2

    but following are not ::

        dav://1.2.3.4/webdav/a.txt
        dav://1.2.3.4/webdav/dir_1/b.jpg
        dav://1.2.3.4/webdab/dir_1/dir_2/c.avi
    """

    def __init__(self, WebDavUrl, username, password):
        self._WebDavUrl = WebDavUrl
        self._username = username
        self._password = password

    def _get_key_from_resource(self, resource):
        return resource.path.encode(sys.getfilesystemencoding())

    def _get_number_of_collections(self):
        return len(self._remote_webdav_share_collections)

    def _get_resources_dict(self):
        return self._remote_webdav_share_resources

    def _get_collections_dict(self):
        return self._remote_webdav_share_collections

    def _get_resource_by_key(self, key):
        return self._remote_webdav_share_resources[key]['resource']

    def _get_metadata_list(self):
        metadata_list = []
        for key in self._remote_webdav_share_resources.keys():
            metadata_list.append(self._remote_webdav_share_resources[key]['metadata'])
        return metadata_list

    def _get_live_properties(self, resource_key):
        resource_container = self._remote_webdav_share_resources[resource_key]
        return resource_container['webdav-properties']

    def _set_metadata_for_resource(self, key, metadata):
        self._remote_webdav_share_resources[key]['metadata'] = metadata

    def _fetch_resources_and_collections(self):
        webdavConnection = CollectionStorer(self._WebDavUrl, validateResourceNames=False)

        authFailures = 0
        while authFailures < 2:
            try:
                self._remote_webdav_share_resources = {}
                self._remote_webdav_share_collections = {}

                try:
                    self._collection_contents = webdavConnection.getCollectionContents()
                    for resource, properties in self._collection_contents:
                        try:
                            key = self._get_key_from_resource(resource)
                            selected_dict = None

                            if properties.getResourceType() == 'resource':
                                selected_dict = self._remote_webdav_share_resources
                            else:
                                selected_dict = self._remote_webdav_share_collections

                            selected_dict[key] = {}
                            selected_dict[key]['resource'] = resource
                            selected_dict[key]['webdav-properties'] = properties
                        except UnicodeEncodeError:
                            print("Cannot encode resource path or properties.")

                    return True

                except WebdavError, e:
                    # Note that, we need to deal with all errors,
                    # except "AuthorizationError", as that is not
                    # really an error from our perspective.
                    if not type(e) == AuthorizationError:
                        from jarabe.journal.journalactivity import get_journal

                        error_message = e
                        get_journal()._volume_error_cb(None, error_message,_('Error'))

                        # Simply return, in case of connection-not-available.
                        return False

                    else:
                    # If this indeed is an Authorization Error,
                    # re-raise it, so that it is caught by the outer
                    # "except" block.
                        raise e


            except AuthorizationError, e:
                if self._username is None or self._password is None:
                    raise Exception("WebDav username or password is None. Please specify appropriate values.")

                if e.authType == "Basic":
                    webdavConnection.connection.addBasicAuthorization(self._username, self._password)
                elif e.authType == "Digest":
                    info = parseDigestAuthInfo(e.authInfo)
                    webdavConnection.connection.addDigestAuthorization(self._username, self._password, realm=info["realm"], qop=info["qop"], nonce=info["nonce"])
                else:
                    raise
                authFailures += 1

        return False

webdav_manager = {}


def get_resource_by_ip_address_and_resource_key(ip_address, key):
    global webdav_manager

    if ip_address in webdav_manager.keys():
        root_webdav = webdav_manager[ip_address]
        resources_dict = root_webdav._get_resources_dict()
        resource_dict = resources_dict[key]
        resource = resource_dict['resource']

        return resource


def get_remote_webdav_share_metadata(ip_address):
    protocol = 'dav://'

    root_webdav_url = '/webdav'

    complete_root_url = protocol + ip_address + root_webdav_url

    root_webdav = WebDavUrlManager(complete_root_url, 'test', 'olpc')
    if root_webdav._fetch_resources_and_collections() is False:
        # Return empty metadata list.
        return []

    # Keep reference to the "WebDavUrlManager", keyed by IP-Address.
    global webdav_manager
    webdav_manager[ip_address] = root_webdav


    # Assert that the number of collections is only one at this url
    # (i.e. only ".Sugar-Metadata" is present).
    assert root_webdav._get_number_of_collections() == 1

    root_sugar_metadata_url = root_webdav_url + '/.Sugar-Metadata'

    complete_root_sugar_metadata_url = protocol + ip_address + root_sugar_metadata_url
    root_webdav_sugar_metadata = WebDavUrlManager(complete_root_sugar_metadata_url, 'test', 'olpc')
    if root_webdav_sugar_metadata._fetch_resources_and_collections() is False:
        # Return empty metadata list.
        return []

    # assert that the number of collections is zero at this url.
    assert root_webdav_sugar_metadata._get_number_of_collections() == 0

    # Now. associate sugar-metadata with each of the "root-webdav"
    # resource.
    root_webdav_resources = root_webdav._get_resources_dict()
    root_webdav_sugar_metadata_resources = root_webdav_sugar_metadata._get_resources_dict()

    # Prepare the metadata-download folder.
    downloaded_data_root_dir = '/tmp/' + ip_address
    downloaded_metadata_file_dir = downloaded_data_root_dir + '/.Sugar-Metadata'
    if os.path.isdir(downloaded_data_root_dir):
        shutil.rmtree(downloaded_data_root_dir)
    os.makedirs(downloaded_metadata_file_dir)

    for root_webdav_resource_name in root_webdav_resources.keys():
        """
        root_webdav_resource_name is of the type ::

            /webdav/a.txt
        """
        split_tokens_array = root_webdav_resource_name.split('/')

        # This will provide us with "a.txt"
        basename = split_tokens_array[len(split_tokens_array) - 1]

        # This will provide us with "a.txt.metadata"
        sugar_metadata_basename = basename + '.metadata'

        # Thus will provide us with "/webdav/.Sugar-Metadata/a.txt.metadata"
        sugar_metadata_url = root_sugar_metadata_url + '/' + sugar_metadata_basename

        # Ensure that "sugar_metadata_url" is present as one of the
        # keys in "root_webdav_sugar_metadata_resources"
        assert sugar_metadata_url in root_webdav_sugar_metadata_resources.keys()

        # Now download the metadata file, read its contents, and store
        # the metadata in memory.
        # It is assumed that the metadata-file is small enough to be
        # read in one call to "read".

        downloaded_metadata_file_path = downloaded_metadata_file_dir + '/' + sugar_metadata_basename
        metadata_resource = root_webdav_sugar_metadata._get_resource_by_key(sugar_metadata_url)
        metadata_resource.downloadFile(downloaded_metadata_file_path)

        file_pointer = open(downloaded_metadata_file_path)
        metadata = eval(file_pointer.read())
        file_pointer.close()

        # Very critical.
        # 1. CRITICAL ONE:
        #    Fill in the uid.
        #    Note that the file is not physically present.
        metadata['uid'] = downloaded_data_root_dir + '/' + basename

        # 2. CRITICAL TWO:
        #    Fill in the properties, that can only be done by reading
        #    in the webdav-properties.
        live_properties = root_webdav._get_live_properties(root_webdav_resource_name)
        metadata['filesize'] = live_properties.getContentLength()
        metadata['timestamp'] = live_properties.getLastModified()
        metadata['creation_time'] = live_properties.getCreationDate()

        # Now, write this to the metadata-file, so that
        # webdav-properties get gelled into sugar-metadata.

        file_pointer = open(downloaded_metadata_file_path, 'w')
        file_pointer.write(simplejson.dumps(metadata))
        file_pointer.close()

        root_webdav._set_metadata_for_resource(root_webdav_resource_name,
                                               metadata)

    return root_webdav._get_metadata_list()