rubick/ostack_validator/resource.py

import glob
import os.path
import json

from ostack_validator.common import Error, Version

class Resource(object):
  HOST = 'host'
  FILE = 'file'
  DIRECTORY = 'directory'
  SERVICE = 'service'

  def __init__(self, name):
    super(Resource, self).__init__()
    self.name = name

  def __str__(self):
    return self.name

  def __repr__(self):
    return '<%s name=%s>' % (str(self.__class__).split('.')[-1], self.name)

  def get_contents(self):
    raise Error, 'Not implemented'

class ResourceLocator(object):
  def find_resource(self, resource_type, name, host=None, **kwargs):
    return None

class HostResource(Resource):
  def __init__(self, name, resource_locator, interfaces=[]):
    super(HostResource, self).__init__(name)
    self.resource_locator = resource_locator
    self.interfaces = interfaces

  def find_resource(self, resource_type, name=None, **kwargs):
    return self.resource_locator.find_resource(resource_type, name, host=self, **kwargs)

class DirectoryResource(Resource):
  def __init__(self, name, owner=None, group=None, permissions=None):
    super(DirectoryResource, self).__init__(name)
    self.owner = owner
    self.group = group
    self.permissions = permissions

class FileResource(Resource):
  def __init__(self, name, path, owner=None, group=None, permissions=None):
    super(FileResource, self).__init__(name)
    self.path = path
    self.owner = owner
    self.group = group
    self.permissions = permissions

  def get_contents(self):
    with open(self.path) as f:
      return f.read()

class ServiceResource(Resource):
  def __init__(self, name, version, metadata={}):
    super(ServiceResource, self).__init__(name)
    self.version = Version(version)
    self.metadata = metadata


class FilesystemSnapshot(object):
  def __init__(self, path):
    super(FilesystemSnapshot, self).__init__()
    self.path = path
    self.basedir = os.path.join(os.path.dirname(self.path), 'root')
    self._parse_snapshot()

  def get_resource(self, path):
    if path in self._resources:
      return self._resources[path]

    return None

  def _parse_snapshot(self):
    self._resources = {}
    if not os.path.isfile(self.path): return
    with open(self.path) as f:
      for line in f.readlines():
        line = line.lstrip()
        if line == '' or line.startswith('#'): continue

        resource_type = line.split('|')[0]
        if resource_type == 'dir':
          source_path, owner, group, permissions = line.split('|')[1:]
          self._resources[source_path] = DirectoryResource(source_path, owner=owner, group=group, permissions=permissions)
        elif resource_type == 'file':
          source_path, local_path, owner, group, permissions = line.split('|')[1:]
          self._resources[source_path] = FileResource(os.path.basename(source_path), path=os.path.join(self.basedir, local_path), owner=owner, group=group, permissions=permissions)
        else:
          self.logger.warn('Unknown resource "%s" in line "%s"' % (resource_type, line))

class ConfigSnapshotResourceLocator(object):
  def __init__(self, basedir):
    super(ConfigSnapshotResourceLocator, self).__init__()
    self.basedir = basedir
    if not os.path.isdir(self.basedir):
      raise Error, 'Invalid argument: base directory does not exist'
    self._services = None
    self._filesystem_snapshots = {}

  def find_resource(self, resource_type, name=None, host=None, **kwargs):
    if resource_type == Resource.HOST:
      if name:
        host_path = os.path.join(self.basedir, name)
        if not os.path.isdir(host_path):
          return None
        return HostResource(name, self)
      else:
        return [HostResource(os.path.basename(host_path), self) for host_path in glob.glob(os.path.join(self.basedir, '*')) if os.path.isdir(host_path)]
    if resource_type == Resource.FILE:
      if not host:
        raise Error, 'Invalid argument: "host" need to be specified'

      if isinstance(host, HostResource):
        host = host.name

      if name:
        return self._get_filesystem_snapshot(host).get_resource(name)
      else:
        return []
    elif resource_type == Resource.SERVICE:
      if not host:
        raise Error, 'Invalid argument: "host" need to be specified'

      if isinstance(host, HostResource):
        host = host.name

      self._ensure_services_loaded()

      if name:
        if name in self._services:
          return self._services[host][name]
        else:
          return None
      else:
        return self._services[host].values()
    else:
      return None

  def _ensure_services_loaded(self):
    if self._services: return

    self._services = {}
    for host_path in glob.glob(os.path.join(self.basedir, '*')):
      if not os.path.isdir(host_path): continue

      services_json_path = os.path.join(host_path, 'services.json')
      if not os.path.isfile(services_json_path): continue

      host_name = os.path.basename(host_path)
      self._services[host_name] = {}
      with open(services_json_path) as f:
        for service_name, metadata in json.loads(f.read()).items():
          version = metadata.pop('version')
          self._services[host_name][service_name] = ServiceResource(service_name, str(version), metadata)

  def _get_filesystem_snapshot(self, host):
    if not host in self._filesystem_snapshots:
      self._filesystem_snapshots[host] = FilesystemSnapshot(os.path.join(self.basedir, host, 'filesystem'))
    return self._filesystem_snapshots[host]