xref: /external/chromium_org/chrome/common/extensions/docs/server2/content_providers.py

# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import os
import traceback

from chroot_file_system import ChrootFileSystem
from content_provider import ContentProvider
import environment
from extensions_paths import CONTENT_PROVIDERS, LOCAL_DEBUG_DIR
from future import Future
from local_file_system import LocalFileSystem
from third_party.json_schema_compiler.memoize import memoize


_IGNORE_MISSING_CONTENT_PROVIDERS = [False]


def IgnoreMissingContentProviders(fn):
  '''Decorates |fn| to ignore missing content providers during its run.
  '''
  def run(*args, **optargs):
    saved = _IGNORE_MISSING_CONTENT_PROVIDERS[0]
    _IGNORE_MISSING_CONTENT_PROVIDERS[0] = True
    try:
      return fn(*args, **optargs)
    finally:
      _IGNORE_MISSING_CONTENT_PROVIDERS[0] = saved
  return run


class ContentProviders(object):
  '''Implements the content_providers.json configuration; see
  chrome/common/extensions/docs/templates/json/content_providers.json for its
  current state and a description of the format.

  Returns ContentProvider instances based on how they're configured there.
  '''

  def __init__(self,
               object_store_creator,
               compiled_fs_factory,
               host_file_system,
               github_file_system_provider,
               gcs_file_system_provider):
    self._object_store_creator = object_store_creator
    self._compiled_fs_factory = compiled_fs_factory
    self._host_file_system = host_file_system
    self._github_file_system_provider = github_file_system_provider
    self._gcs_file_system_provider = gcs_file_system_provider
    self._cache = None

    # If running the devserver and there is a LOCAL_DEBUG_DIR, we
    # will read the content_provider configuration from there instead
    # of fetching it from SVN trunk or patch.
    if environment.IsDevServer() and os.path.exists(LOCAL_DEBUG_DIR):
      local_fs = LocalFileSystem(LOCAL_DEBUG_DIR)
      conf_stat = None
      try:
        conf_stat = local_fs.Stat(CONTENT_PROVIDERS)
      except:
        pass

      if conf_stat:
        logging.warn(("Using local debug folder (%s) for "
                      "content_provider.json configuration") % LOCAL_DEBUG_DIR)
        self._cache = compiled_fs_factory.ForJson(local_fs)

    if not self._cache:
      self._cache = compiled_fs_factory.ForJson(host_file_system)

  @memoize
  def GetByName(self, name):
    '''Gets the ContentProvider keyed by |name| in content_providers.json, or
    None of there is no such content provider.
    '''
    config = self._GetConfig().get(name)
    if config is None:
      logging.error('No content provider found with name "%s"' % name)
      return None
    return self._CreateContentProvider(name, config)

  @memoize
  def GetByServeFrom(self, path):
    '''Gets a (content_provider, serve_from, path_in_content_provider) tuple,
    where content_provider is the ContentProvider with the longest "serveFrom"
    property that is a subpath of |path|, serve_from is that property, and
    path_in_content_provider is the remainder of |path|.

    For example, if content provider A serves from "foo" and content provider B
    serves from "foo/bar", GetByServeFrom("foo/bar/baz") will return (B,
    "foo/bar", "baz").

    Returns (None, '', |path|) if no ContentProvider serves from |path|.
    '''
    serve_from_to_config = dict(
        (config['serveFrom'], (name, config))
        for name, config in self._GetConfig().iteritems())
    path_parts = path.split('/')
    for i in xrange(len(path_parts), -1, -1):
      name_and_config = serve_from_to_config.get('/'.join(path_parts[:i]))
      if name_and_config is not None:
        return (self._CreateContentProvider(name_and_config[0],
                                            name_and_config[1]),
                '/'.join(path_parts[:i]),
                '/'.join(path_parts[i:]))
    return None, '', path

  def _GetConfig(self):
    return self._cache.GetFromFile(CONTENT_PROVIDERS).Get()

  def _CreateContentProvider(self, name, config):
    default_extensions = config.get('defaultExtensions', ())
    supports_templates = config.get('supportsTemplates', False)
    supports_zip = config.get('supportsZip', False)

    if 'chromium' in config:
      chromium_config = config['chromium']
      if 'dir' not in chromium_config:
        logging.error('%s: "chromium" must have a "dir" property' % name)
        return None
      file_system = ChrootFileSystem(self._host_file_system,
                                     chromium_config['dir'])
    elif 'gcs' in config:
      gcs_config = config['gcs']
      if 'bucket' not in gcs_config:
        logging.error('%s: "gcs" must have a "bucket" property' % name)
        return None
      bucket = gcs_config['bucket']
      if not bucket.startswith('gs://'):
        logging.error('%s: bucket %s should start with gs://' % (name, bucket))
        return None
      bucket = bucket[len('gs://'):]
      file_system = self._gcs_file_system_provider.Create(bucket)
      if 'dir' in gcs_config:
        file_system = ChrootFileSystem(file_system, gcs_config['dir'])

    elif 'github' in config:
      github_config = config['github']
      if 'owner' not in github_config or 'repo' not in github_config:
        logging.error('%s: "github" must provide an "owner" and "repo"' % name)
        return None
      file_system = self._github_file_system_provider.Create(
          github_config['owner'], github_config['repo'])
      if 'dir' in github_config:
        file_system = ChrootFileSystem(file_system, github_config['dir'])

    else:
      logging.error('%s: content provider type not supported' % name)
      return None

    return ContentProvider(name,
                           self._compiled_fs_factory,
                           file_system,
                           self._object_store_creator,
                           default_extensions=default_extensions,
                           supports_templates=supports_templates,
                           supports_zip=supports_zip)

  def Cron(self):
    def safe(name, action, callback):
      '''Safely runs |callback| for a ContentProvider called |name| by
      swallowing exceptions and turning them into a None return value. It's
      important to run all ContentProvider Crons even if some of them fail.
      '''
      try:
        return callback()
      except:
        if not _IGNORE_MISSING_CONTENT_PROVIDERS[0]:
          logging.error('Error %s Cron for ContentProvider "%s":\n%s' %
                        (action, name, traceback.format_exc()))
        return None

    futures = [(name, safe(name,
                           'initializing',
                           self._CreateContentProvider(name, config).Cron))
               for name, config in self._GetConfig().iteritems()]
    return Future(callback=
        lambda: [safe(name, 'resolving', f.Get) for name, f in futures if f])