Exemple #1
0
# Connect to MySQL and set up Spiff Guard.
db    = create_engine(dbn)
guard = SpiffGuard.DB(db)

# Set up an environment for the package manager.
page_db = PageDB(guard)
page    = page_db.get('default')
request = DummyRequest()
api     = ExtensionApi(object,
                       guard     = guard,
                       page_db   = page_db,
                       request   = request)

# Init the package manager.
pm = PackageManager(guard, api, package = SpiffPackage)
pm.set_package_dir(config.package_dir)


def pkg_check_dependencies(pm, package):
    print "Checking dependencies of %s..." % package.get_name(),
    error = False
    for dependency in package.get_dependency_list():
        if pm.get_package_from_descriptor(dependency) is None:
            print "\nUnmet dependency:", dependency
            error = True
    if error:
        return False
    print "done."
    return True
Exemple #2
0
    def run(self):
        if not self._check_configured():
            return
        if not self._check_installer_deleted():
            return

        # Set up the session and database adapters.
        self.request.start_session()
        page_db = PageDB(self.get_guard())
        user_db = UserDB(self.get_guard())
        cache   = CacheDB(self, self.get_guard())
        self.bench.snapshot('set_up', 'Set-up time is %ss.')

        # Can not open some pages by addressing them directly.
        page_handle = self.request.get_data().get_str('page')
        if page_db.is_system_page_handle(page_handle):
            self.request.set_status(403)
            self.request.write('%s is a system page.' % repr(page_handle))
            return

        # Find the current page using the given cgi variables.
        # If the specific site is not found, attempt to find a parent that
        # handles content recursively.
        page = page_db.get_responsible_page(page_handle)
        self.bench.snapshot('page_find', 'Looked up the page in %ss.')

        # If we still have no page, give 404.
        if page is None:
            self.request.set_status(404)
            self.request.write('Default page not found.')
            return
        self.set_requested_page(page)
        self.bench.snapshot('page_open', 'Opened the page in %ss.')

        # If the output of ALL extensions is cached (combined), there is no need
        # to redraw the page, including headers and footer.
        # Note that the cache only returns pages corresponding to the permissions
        # of the current user, so this is safe.
        if not self.request.has_post_data():
            output = cache.get_page()
            self.bench.snapshot('cache_check', 'Spent %ss checking the cache.')
            if output is not None:
                self.request.write(output)
                self._render_footer()
                return
        self.bench.snapshot('cache_check', 'Spent %ss checking the cache.')

        # Set up the plugin manager (Integrator). Note that the constructor
        # of PackageManager also associates the api with a reference to the
        # PackageManager instance.
        api = ExtensionApi(self,
                           guard   = self.get_guard(),
                           page_db = page_db,
                           cache   = cache,
                           request = self.request)
        pm = PackageManager(self.get_guard(), api, package = SpiffPackage)
        pm.set_package_dir(config.package_dir)
        self.bench.snapshot('package_load', 'Package manager loaded in %ss.')

        # Ending up here the entire page was not cached.
        # Make sure that the caller has permission to retrieve this page.
        if page.get_attribute('private') and not self.current_user_may('view'):
            url = self.request.get_url(page     = 'admin/login',
                                       refer_to = self.get_requested_uri())
            return self.refer_to(url)
        self.bench.snapshot('permission_check', 'Permission checked in %ss.')

        # Render the HTML headers.
        self._render_head()
        self.bench.snapshot('render_header', 'Headers rendered in %ss.')

        # Render the layout. This also invokes the plugins.
        self.output += page.get_output(api)
        self.bench.snapshot('render_plugins', 'Plugins rendered in %ss.')

        # Cache the page (if it is cacheable).
        if page.is_cacheable() and len(self.request.get_headers()) == 0:
            cache.add_page(self.output)
        self.bench.snapshot('cache_add', 'Added to cache in %ss.')

        # Yippie.
        self.request.write(self.output)
        self._render_footer()