Merge branch 'master' of git.blender.org:blender-package-manager-addon

bpkg_manager/__init__.py

@@ -0,0 +1,268 @@
+"""
+Blender Package manager
+"""
+
+bl_info = {
+    'name': 'Package Manager',
+    'author': 'Sybren A. Stüvel',
+    'version': (0, 1, 0),
+    'blender': (2, 79, 0),
+    'location': 'Addon Preferences panel',
+    'description': 'Add-on package manager.',
+    'category': 'System',
+}
+
+import logging
+
+if 'bpy' in locals():
+    import importlib
+
+    subproc = importlib.reload(subproc)
+else:
+    from . import subproc
+
+import bpy
+
+
+class SubprocMixin:
+    """Mix-in class for things that need to be run in a subprocess."""
+
+    log = logging.getLogger(__name__ + '.SubprocMixin')
+    _state = 'INITIALIZING'
+    _abort_timeout = 0  # time at which we stop waiting for an abort response and just terminate the process
+
+    # Mapping from message type (see bpkg_manager.subproc) to handler function.
+    # Should be constructed before modal() gets called.
+    msg_handlers = {}
+
+    def execute(self, context):
+        return self.invoke(context, None)
+
+    def quit(self):
+        """Signals the state machine to stop this operator from running."""
+
+        self._state = 'QUIT'
+
+    def invoke(self, context, event):
+        import multiprocessing
+
+        self.log.info('Starting')
+
+        self.pipe_blender, self.pipe_subproc = multiprocessing.Pipe()
+
+        # The subprocess should just be terminated when Blender quits. Without this,
+        # Blender would hang while closing, until the subprocess terminates itself.
+        self.process = self.create_subprocess()
+        self.process.daemon = True
+        self.process.start()
+
+        self._state = 'RUNNING'
+
+        wm = context.window_manager
+        wm.modal_handler_add(self)
+        self.timer = wm.event_timer_add(0.1, context.window)
+
+        return {'RUNNING_MODAL'}
+
+    def modal(self, context, event):
+        import time
+
+        if event.type == 'ESC':
+            self.log.warning('Escape pressed, sending abort signal to subprocess')
+            self.abort()
+            return {'PASS_THROUGH'}
+
+        if event.type != 'TIMER':
+            return {'PASS_THROUGH'}
+
+        if self._state == 'ABORTING' and time.time() > self._abort_timeout:
+            self.log.error('No response from subprocess to abort request, terminating it.')
+            self.report({'ERROR'}, 'No response from subprocess to abort request, terminating it.')
+            self.process.terminate()
+            self._finish(context)
+            return {'CANCELLED'}
+
+        while self.pipe_blender.poll():
+            self.handle_received_data()
+
+        if self._state == 'QUIT':
+            self._finish(context)
+            return {'FINISHED'}
+
+        if not self.process.is_alive():
+            self.report_process_died()
+            self._finish(context)
+            return {'CANCELLED'}
+
+        return {'RUNNING_MODAL'}
+
+    def abort(self):
+        import time
+
+        # Allow the subprocess 10 seconds to repsond to our abort message.
+        self._abort_timeout = time.time() + 10
+        self._state = 'ABORTING'
+
+        self.pipe_blender.send(subproc.Abort())
+
+    def _finish(self, context):
+        import multiprocessing
+
+        global bpkg_operation_running
+
+        context.window_manager.event_timer_remove(self.timer)
+        bpkg_operation_running = False
+
+        if self.process and self.process.is_alive():
+            self.log.debug('Waiting for subprocess to quit')
+            try:
+                self.process.join(timeout=10)
+            except multiprocessing.TimeoutError:
+                self.log.warning('Subprocess is hanging, terminating it forcefully.')
+                self.process.terminate()
+            else:
+                self.log.debug('Subprocess stopped with exit code %i', self.process.exitcode)
+
+    def handle_received_data(self):
+        recvd = self.pipe_blender.recv()
+
+        self.log.info('Received message from subprocess: %s', recvd)
+        try:
+            handler = self.msg_handlers[type(recvd)]
+        except KeyError:
+            self.log.error('Unable to handle received message %s', recvd)
+            # Maybe we shouldn't show this to the user?
+            self.report({'WARNING'}, 'Unable to handle received message %s' % recvd)
+            return
+
+        handler(recvd)
+
+    def create_subprocess(self):
+        """Implement this in a subclass.
+
+        :rtype: multiprocessing.Process
+        """
+        raise NotImplementedError()
+
+    def report_process_died(self):
+        """Provides the user with sensible information when the process has died.
+
+        Implement this in a subclass.
+        """
+        raise NotImplementedError()
+
+
+class BPKG_OT_install(SubprocMixin, bpy.types.Operator):
+    bl_idname = 'bpkg.install'
+    bl_label = 'Install package'
+    bl_description = 'Downloads and installs a Blender add-on package'
+    bl_options = {'REGISTER'}
+
+    package_url = bpy.props.StringProperty(name='package_url', description='The URL of the file to download')
+
+    log = logging.getLogger(__name__ + '.BPKG_OT_install')
+
+    def invoke(self, context, event):
+        if not self.package_url:
+            self.report({'ERROR'}, 'Package URL not given')
+            return {'CANCELLED'}
+
+        return super().invoke(context, event)
+
+    def create_subprocess(self):
+        """Starts the download process.
+
+        Also registers the message handlers.
+
+        :rtype: multiprocessing.Process
+        """
+
+        import multiprocessing
+
+        self.msg_handlers = {
+            subproc.Progress: self._subproc_progress,
+            subproc.DownloadError: self._subproc_download_error,
+            subproc.Success: self._subproc_success,
+            subproc.Aborted: self._subproc_aborted,
+        }
+
+        proc = multiprocessing.Process(target=subproc.download_and_install,
+                                       args=(self.pipe_subproc, self.package_url,))
+        return proc
+
+    def _subproc_progress(self, progress: subproc.Progress):
+        self.log.info('Task progress at %i%%', progress.progress * 100)
+
+    def _subproc_download_error(self, error: subproc.DownloadError):
+        self.report({'ERROR'}, 'Unable to download package: %s' % error.description)
+        self.quit()
+
+    def _subproc_success(self, success: subproc.Success):
+        self.report({'INFO'}, 'Package downloaded successfully')
+        self.quit()
+
+    def _subproc_aborted(self, aborted: subproc.Aborted):
+        self.report({'ERROR'}, 'Package download aborted per your request')
+        self.quit()
+
+    def report_process_died(self):
+        if self.process.exitcode:
+            self.log.error('Process died without telling us! Exit code was %i', self.process.exitcode)
+            self.report({'ERROR'}, 'Error downloading package, exit code %i' % self.process.exitcode)
+        else:
+            self.log.error('Process died without telling us! Exit code was 0 though')
+            self.report({'WARNING'}, 'Error downloading package, but process finished OK. This is weird.')
+
+
+class BPKG_OT_hang(SubprocMixin, bpy.types.Operator):
+    bl_idname = 'bpkg.hang'
+    bl_label = 'Hang (debug)'
+    bl_description = 'Starts a process that hangs for an hour, for debugging purposes'
+    bl_options = {'REGISTER'}
+
+    log = logging.getLogger(__name__ + '.BPKG_OT_install')
+
+    def create_subprocess(self):
+        """Starts the download process.
+
+        Also registers the message handlers.
+
+        :rtype: multiprocessing.Process
+        """
+
+        import multiprocessing
+
+        proc = multiprocessing.Process(target=subproc.debug_hang)
+        return proc
+
+    def report_process_died(self):
+        self.report({'ERROR'}, 'Process died, exit code %s' % self.process.exitcode)
+
+
+class PackageManagerPreferences(bpy.types.AddonPreferences):
+    bl_idname = __package__
+
+    package_url = bpy.props.StringProperty(
+        name='Package URL',
+        description='Just a temporary place to store the URL of a package to download')
+
+    def draw(self, context):
+        layout = self.layout
+
+        temp_box = layout.box()
+        temp_box.label(text="Temporary stuff while we're developing")
+        temp_box.prop(self, 'package_url')
+        temp_box.operator(BPKG_OT_install.bl_idname).package_url = self.package_url
+        temp_box.operator(BPKG_OT_hang.bl_idname)
+
+
+def register():
+    bpy.utils.register_class(BPKG_OT_install)
+    bpy.utils.register_class(BPKG_OT_hang)
+    bpy.utils.register_class(PackageManagerPreferences)
+
+
+def unregister():
+    bpy.utils.unregister_class(BPKG_OT_install)
+    bpy.utils.unregister_class(BPKG_OT_hang)
+    bpy.utils.unregister_class(PackageManagerPreferences)

bpkg_manager/appdirs.py

@@ -0,0 +1,552 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <http://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version_info__ = (1, 4, 0)
+__version__ = '.'.join(map(str, __version_info__))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    """Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical user data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               same as user_data_dir
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by deafult "~/.config/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    """Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical user data directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system in ["win32", "darwin"]:
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname.lower().replace(' ', '-'))
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname, appauthor=None, version=None, roaming=False,
+                 multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernal.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir", "site_data_dir",
+             "user_config_dir", "site_config_dir",
+             "user_cache_dir", "user_log_dir")
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))

bpkg_manager/cache.py

@@ -0,0 +1,49 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  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 2
+#  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, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+
+import os
+import logging
+import pathlib
+
+from . import appdirs
+
+log = logging.getLogger(__name__)
+
+
+def cache_directory(*subdirs) -> pathlib.Path:
+    """Returns an OS-specifc cache location, and ensures it exists.
+
+    Should be replaced with a call to bpy.utils.user_resource('CACHE', ...)
+    once https://developer.blender.org/T47684 is finished.
+
+    :param subdirs: extra subdirectories inside the cache directory.
+
+    >>> cache_directory()
+    '.../blender_cloud/your_username'
+    >>> cache_directory('sub1', 'sub2')
+    '.../blender_cloud/your_username/sub1/sub2'
+    """
+
+    # TODO: use bpy.utils.user_resource('CACHE', ...)
+    # once https://developer.blender.org/T47684 is finished.
+    user_cache_dir = appdirs.user_cache_dir(appname='Blender', appauthor=False)
+    cache_dir = pathlib.Path(user_cache_dir) / 'blender_package_manager' / pathlib.Path(*subdirs)
+    cache_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+    return cache_dir

bpkg_manager/subproc.py

@@ -0,0 +1,134 @@
+"""
+All the stuff that needs to run in a subprocess.
+"""
+
+import logging
+import pathlib
+
+
+class Message:
+    """Superclass for all message sent over pipes."""
+
+
+class BlenderMessage(Message):
+    """Superclass for all messages sent from Blender to the subprocess."""
+
+
+class SubprocMessage(Message):
+    """Superclass for all messages sent from the subprocess to Blender."""
+
+
+class Abort(BlenderMessage):
+    """Sent when the user requests abortion of a task."""
+
+
+class Progress(SubprocMessage):
+    """Send from subprocess to Blender to report progress.
+
+    :ivar progress: the progress percentage, from 0-1.
+    """
+
+    def __init__(self, progress: float):
+        self.progress = progress
+
+
+class DownloadError(SubprocMessage):
+    """Sent when there was an error downloading something."""
+
+    def __init__(self, status_code: int, description: str):
+        self.status_code = status_code
+        self.description = description
+
+
+class Success(SubprocMessage):
+    """Sent when an operation finished sucessfully."""
+
+
+class Aborted(SubprocMessage):
+    """Sent as response to Abort message."""
+
+
+def _download(pipe_to_blender, package_url: str, download_dir: pathlib.Path) -> pathlib.Path:
+    """Downloads the given package
+
+    :returns: path to the downloaded file, or None in case of error.
+    """
+
+    import requests
+
+    log = logging.getLogger('%s.download' % __name__)
+    log.info('Going to download %s to %s', package_url, download_dir)
+    pipe_to_blender.send(Progress(0.0))
+
+    log.info('Downloading %s', package_url)
+    resp = requests.get(package_url, stream=True, verify=True)
+
+    try:
+        resp.raise_for_status()
+    except requests.HTTPError as ex:
+        log.error('Error downloading %s: %s', package_url, ex)
+        pipe_to_blender.send(DownloadError(resp.status_code, str(ex)))
+        return None
+
+    try:
+        # Use float so that we can also use infinity
+        content_length = float(resp.headers['content-length'])
+    except KeyError:
+        log.warning('Server did not send content length, cannot report progress.')
+        content_length = float('inf')
+
+    # TODO: get filename from Content-Disposition header, if available.
+    # TODO: use urllib.parse to parse the URL.
+    local_filename = package_url.split('/')[-1] or 'download.tmp'
+    local_fpath = download_dir / local_filename
+
+    downloaded_length = 0
+    with local_fpath.open('wb') as outfile:
+        for chunk in resp.iter_content(chunk_size=1024 ** 2):
+            # Handle abort messages from Blender
+            while pipe_to_blender.poll():
+                recvd = pipe_to_blender.recv()
+                if isinstance(recvd, Abort):
+                    log.warning('Aborting download of %s by request', package_url)
+                    pipe_to_blender.send(Aborted())
+                    return None
+                log.warning('Unknown message %s received, ignoring', recvd)
+
+            if not chunk:  # filter out keep-alive new chunks
+                continue
+
+            outfile.write(chunk)
+
+            downloaded_length += len(chunk)
+
+            # TODO: use multiplier for progress, so that we can count up to 70% and
+            # leave 30% "progress" for installation of the package.
+            pipe_to_blender.send(Progress(downloaded_length / content_length))
+
+    pipe_to_blender.send(Success())
+    return local_fpath
+
+
+def download_and_install(pipe_to_blender, package_url: str):
+    """Downloads and installs the given package."""
+
+    from . import cache
+
+    log = logging.getLogger('%s.download_and_install' % __name__)
+
+    cache_dir = cache.cache_directory('downloads')
+    downloaded = _download(pipe_to_blender, package_url, cache_dir)
+
+    if not downloaded:
+        log.debug('Download failed/aborted, not going to install anything.')
+        return
+
+    # TODO: actually install the package
+    log.warning('Installing is not actually implemented, install %s yourself.', downloaded)
+
+
+def debug_hang():
+    """Hangs for an hour. For testing purposes only."""
+
+    import time
+    time.sleep(3600)