Merge compass-tasks-osa and compass-tasks-k8s

JIRA: COMPASS-568

rename compass-tasks to compass-tasks-base.
add both osa and k8s support in compass-tasks

Change-Id: I438f5b17e509d4cb751ced0ffe640ec70899882f
Signed-off-by: Harry Huang <huangxiangyu5@huawei.com>

1 files changed, 0 insertions, 724 deletions

diff --git a/compass-tasks/db/v1/model.py b/compass-tasks/db/v1/model.py
deleted file mode 100644
index d74e355..0000000
--- a/compass-tasks/db/v1/model.py
+++ /dev/null
@@ -1,724 +0,0 @@
-# Copyright 2014 Huawei Technologies Co. Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""database model."""
-from datetime import datetime
-from hashlib import md5
-import logging
-import simplejson as json
-import uuid
-
-from sqlalchemy import Column, ColumnDefault, Integer, String
-from sqlalchemy import Float, Enum, DateTime, ForeignKey, Text, Boolean
-from sqlalchemy import UniqueConstraint
-from sqlalchemy.orm import relationship, backref
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.ext.hybrid import hybrid_property
-
-from compass.utils import util
-
-from flask.ext.login import UserMixin
-from itsdangerous import URLSafeTimedSerializer
-
-BASE = declarative_base()
-# TODO(grace) SECRET_KEY should be generated when installing compass
-# and save to a config file or DB
-SECRET_KEY = "abcd"
-
-# This is used for generating a token by user's ID and
-# decode the ID from this token
-login_serializer = URLSafeTimedSerializer(SECRET_KEY)
-
-
-class User(BASE, UserMixin):
-    """User table."""
-    __tablename__ = 'user'
-    id = Column(Integer, primary_key=True)
-    email = Column(String(80), unique=True)
-    password = Column(String(225), default='')
-    active = Column(Boolean, default=True)
-
-    def __init__(self, email, password, **kwargs):
-        self.email = email
-        self.password = self._set_password(password)
-
-    def __repr__(self):
-        return '<User name: %s>' % self.email
-
-    def _set_password(self, password):
-        return self._hash_password(password)
-
-    def get_password(self):
-        return self.password
-
-    def valid_password(self, password):
-        return self.password == self._hash_password(password)
-
-    def get_auth_token(self):
-        return login_serializer.dumps(self.id)
-
-    def is_active(self):
-        return self.active
-
-    def _hash_password(self, password):
-        return md5(password).hexdigest()
-
-
-class SwitchConfig(BASE):
-    """Swtich Config table.
-
-    :param id: The unique identifier of the switch config.
-    :param ip: The IP address of the switch.
-    :param filter_port: The port of the switch which need to be filtered.
-    """
-    __tablename__ = 'switch_config'
-    id = Column(Integer, primary_key=True)
-    ip = Column(String(80))
-    filter_port = Column(String(16))
-    __table_args__ = (UniqueConstraint('ip', 'filter_port', name='filter1'), )
-
-    def __init__(self, **kwargs):
-        super(SwitchConfig, self).__init__(**kwargs)
-
-
-class Switch(BASE):
-    """Switch table.
-
-    :param id: the unique identifier of the switch. int as primary key.
-    :param ip: the IP address of the switch.
-    :param vendor_info: the name of the vendor
-    :param credential_data: used for accessing and retrieving information
-                            from the switch. Store json format as string.
-    :param state: Enum.'initialized/repolling': polling switch not complete to
-                  learn all MAC addresses of devices connected to the switch;
-                  'unreachable': one of the final state, indicates that the
-                  switch is unreachable at this time, no MAC address could be
-                  retrieved from the switch.
-                  'notsupported': one of the final state, indicates that the
-                  vendor found is not supported yet, no MAC address will be
-                  retrieved from the switch.
-                  'error': one of the final state, indicates that something
-                           wrong happend.
-                  'under_monitoring': one of the final state, indicates that
-                  MAC addresses has been learned successfully from the switch.
-    :param err_msg: Error message when polling switch failed.
-    :param machines: refer to list of Machine connected to the switch.
-    """
-    __tablename__ = 'switch'
-
-    id = Column(Integer, primary_key=True)
-    ip = Column(String(80), unique=True)
-    credential_data = Column(Text)
-    vendor_info = Column(String(256), nullable=True)
-    state = Column(Enum('initialized', 'unreachable', 'notsupported',
-                        'repolling', 'error', 'under_monitoring',
-                        name='switch_state'),
-                   default='initialized')
-    err_msg = Column(Text)
-
-    def __init__(self, **kwargs):
-        super(Switch, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<Switch ip: %r, credential: %r, vendor: %r, state: %s>'\
-            % (self.ip, self.credential, self.vendor, self.state)
-
-    @hybrid_property
-    def vendor(self):
-        """vendor property getter"""
-        return self.vendor_info
-
-    @vendor.setter
-    def vendor(self, value):
-        """vendor property setter"""
-        self.vendor_info = value
-
-    @property
-    def credential(self):
-        """credential data getter.
-
-        :returns: python primitive dictionary object.
-        """
-        if self.credential_data:
-            try:
-                credential = json.loads(self.credential_data)
-                return credential
-            except Exception as error:
-                logging.error('failed to load credential data %s: %s',
-                              self.id, self.credential_data)
-                logging.exception(error)
-                raise error
-        else:
-            return {}
-
-    @credential.setter
-    def credential(self, value):
-        """credential property setter
-
-        :param value: dict of configuration data needed to update.
-        """
-        if value:
-            try:
-                credential = {}
-                if self.credential_data:
-                    credential = json.loads(self.credential_data)
-
-                credential.update(value)
-                self.credential_data = json.dumps(credential)
-
-            except Exception as error:
-                logging.error('failed to dump credential data %s: %s',
-                              self.id, value)
-                logging.exception(error)
-                raise error
-
-        else:
-            self.credential_data = json.dumps({})
-
-        logging.debug('switch now is %s', self)
-
-
-class Machine(BASE):
-    """Machine table.
-
-       .. note::
-          currently, we are taking care of management plane.
-          Therefore, we assume one machine is connected to one switch.
-
-    :param id: int, identity as primary key
-    :param mac: string, the MAC address of the machine.
-    :param switch_id: switch id that this machine connected on to.
-    :param port: nth port of the switch that this machine connected.
-    :param vlan: vlan id that this machine connected on to.
-    :param update_timestamp: last time this entry got updated.
-    :param switch: refer to the Switch the machine connects to.
-    """
-    __tablename__ = 'machine'
-
-    id = Column(Integer, primary_key=True)
-    mac = Column(String(24), default='')
-    port = Column(String(16), default='')
-    vlan = Column(Integer, default=0)
-    update_timestamp = Column(DateTime, default=datetime.now,
-                              onupdate=datetime.now)
-    switch_id = Column(Integer, ForeignKey('switch.id',
-                                           onupdate='CASCADE',
-                                           ondelete='SET NULL'))
-    __table_args__ = (UniqueConstraint('mac', 'switch_id',
-                                       name='unique_machine'),)
-    switch = relationship('Switch', backref=backref('machines',
-                                                    lazy='dynamic'))
-
-    def __init__(self, **kwargs):
-        super(Machine, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<Machine %r: port=%r vlan=%r switch=%r>' % (
-            self.mac, self.port, self.vlan, self.switch)
-
-
-class HostState(BASE):
-    """The state of the ClusterHost.
-
-    :param id: int, identity as primary key.
-    :param state: Enum. 'UNINITIALIZED': the host is ready to setup.
-                 'INSTALLING': the host is not installing.
-                 'READY': the host is setup.
-                 'ERROR': the host has error.
-    :param progress: float, the installing progress from 0 to 1.
-    :param message: the latest installing message.
-    :param severity: Enum, the installing message severity.
-                     ('INFO', 'WARNING', 'ERROR')
-    :param update_timestamp: the lastest timestamp the entry got updated.
-    :param host: refer to ClusterHost.
-    :param os_progress: float, the installing progress of OS from 0 to 1.
-    """
-    __tablename__ = "host_state"
-
-    id = Column(Integer, ForeignKey('cluster_host.id',
-                                    onupdate='CASCADE',
-                                    ondelete='CASCADE'),
-                primary_key=True)
-    state = Column(Enum('UNINITIALIZED', 'INSTALLING', 'READY', 'ERROR'),
-                   ColumnDefault('UNINITIALIZED'))
-    progress = Column(Float, ColumnDefault(0.0))
-    message = Column(Text)
-    severity = Column(Enum('INFO', 'WARNING', 'ERROR'), ColumnDefault('INFO'))
-    update_timestamp = Column(DateTime, default=datetime.now,
-                              onupdate=datetime.now)
-    host = relationship('ClusterHost', backref=backref('state',
-                                                       uselist=False))
-
-    os_progress = Column(Float, ColumnDefault(0.0))
-    os_message = Column(Text)
-    os_severity = Column(
-        Enum('INFO', 'WARNING', 'ERROR'),
-        ColumnDefault('INFO')
-    )
-    """
-    this is added by Lei for separating os and package progress purposes
-    os_state = Column(Enum('UNINITIALIZED', 'INSTALLING', 'OS_READY', 'ERROR'),
-                   ColumnDefault('UNINITIALIZED'))
-    """
-
-    def __init__(self, **kwargs):
-        super(HostState, self).__init__(**kwargs)
-
-    @hybrid_property
-    def hostname(self):
-        """hostname getter"""
-        return self.host.hostname
-
-    @hybrid_property
-    def fullname(self):
-        """fullname getter"""
-        return self.host.fullname
-
-    def __repr__(self):
-        return (
-            '<HostState %r: state=%r, progress=%s, '
-            'message=%s, severity=%s, os_progress=%s>'
-        ) % (
-            self.hostname, self.state, self.progress,
-            self.message, self.severity, self.os_progress
-        )
-
-
-class ClusterState(BASE):
-    """The state of the Cluster.
-
-    :param id: int, identity as primary key.
-    :param state: Enum, 'UNINITIALIZED': the cluster is ready to setup.
-                 'INSTALLING': the cluster is not installing.
-                 'READY': the cluster is setup.
-                 'ERROR': the cluster has error.
-    :param progress: float, the installing progress from 0 to 1.
-    :param message: the latest installing message.
-    :param severity: Enum, the installing message severity.
-                     ('INFO', 'WARNING', 'ERROR').
-    :param update_timestamp: the lastest timestamp the entry got updated.
-    :param cluster: refer to Cluster.
-    """
-    __tablename__ = 'cluster_state'
-    id = Column(Integer, ForeignKey('cluster.id',
-                                    onupdate='CASCADE',
-                                    ondelete='CASCADE'),
-                primary_key=True)
-    state = Column(Enum('UNINITIALIZED', 'INSTALLING', 'READY', 'ERROR'),
-                   ColumnDefault('UNINITIALIZED'))
-    progress = Column(Float, ColumnDefault(0.0))
-    message = Column(Text)
-    severity = Column(Enum('INFO', 'WARNING', 'ERROR'), ColumnDefault('INFO'))
-    update_timestamp = Column(DateTime, default=datetime.now,
-                              onupdate=datetime.now)
-    cluster = relationship('Cluster', backref=backref('state',
-                                                      uselist=False))
-
-    def __init__(self, **kwargs):
-        super(ClusterState, self).__init__(**kwargs)
-
-    @hybrid_property
-    def clustername(self):
-        """clustername getter"""
-        return self.cluster.name
-
-    def __repr__(self):
-        return (
-            '<ClusterState %r: state=%r, progress=%s, '
-            'message=%s, severity=%s>'
-        ) % (
-            self.clustername, self.state, self.progress,
-            self.message, self.severity
-        )
-
-
-class Cluster(BASE):
-    """Cluster configuration information.
-
-    :param id: int, identity as primary key.
-    :param name: str, cluster name.
-    :param mutable: bool, if the Cluster is mutable.
-    :param security_config: str stores json formatted security information.
-    :param networking_config: str stores json formatted networking information.
-    :param partition_config: string stores json formatted parition information.
-    :param adapter_id: the refer id in the Adapter table.
-    :param raw_config: str stores json formatted other cluster information.
-    :param adapter: refer to the Adapter.
-    :param state: refer to the ClusterState.
-    """
-    __tablename__ = 'cluster'
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String(80), unique=True)
-    mutable = Column(Boolean, default=True)
-    security_config = Column(Text)
-    networking_config = Column(Text)
-    partition_config = Column(Text)
-    adapter_id = Column(Integer, ForeignKey('adapter.id',
-                                            onupdate='CASCADE',
-                                            ondelete='SET NULL'),
-                        nullable=True)
-    raw_config = Column(Text)
-    adapter = relationship("Adapter", backref=backref('clusters',
-                                                      lazy='dynamic'))
-
-    def __init__(self, **kwargs):
-        if 'name' not in kwargs or not kwargs['name']:
-            kwargs['name'] = str(uuid.uuid4())
-
-        super(Cluster, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<Cluster %r: config=%r>' % (self.name, self.config)
-
-    @property
-    def partition(self):
-        """partition getter"""
-        if self.partition_config:
-            try:
-                return json.loads(self.partition_config)
-            except Exception as error:
-                logging.error('failed to load security config %s: %s',
-                              self.id, self.partition_config)
-                logging.exception(error)
-                raise error
-        else:
-            return {}
-
-    @partition.setter
-    def partition(self, value):
-        """partition setter"""
-        logging.debug('cluster %s set partition %s', self.id, value)
-        if value:
-            try:
-                self.partition_config = json.dumps(value)
-            except Exception as error:
-                logging.error('failed to dump partition config %s: %s',
-                              self.id, value)
-                logging.exception(error)
-                raise error
-        else:
-            self.partition_config = None
-
-    @property
-    def security(self):
-        """security getter"""
-        if self.security_config:
-            try:
-                return json.loads(self.security_config)
-            except Exception as error:
-                logging.error('failed to load security config %s: %s',
-                              self.id, self.security_config)
-                logging.exception(error)
-                raise error
-        else:
-            return {}
-
-    @security.setter
-    def security(self, value):
-        """security setter"""
-        logging.debug('cluster %s set security %s', self.id, value)
-        if value:
-            try:
-                self.security_config = json.dumps(value)
-            except Exception as error:
-                logging.error('failed to dump security config %s: %s',
-                              self.id, value)
-                logging.exception(error)
-                raise error
-        else:
-            self.security_config = None
-
-    @property
-    def networking(self):
-        """networking getter"""
-        if self.networking_config:
-            try:
-                return json.loads(self.networking_config)
-            except Exception as error:
-                logging.error('failed to load networking config %s: %s',
-                              self.id, self.networking_config)
-                logging.exception(error)
-                raise error
-        else:
-            return {}
-
-    @networking.setter
-    def networking(self, value):
-        """networking setter."""
-        logging.debug('cluster %s set networking %s', self.id, value)
-        if value:
-            try:
-                self.networking_config = json.dumps(value)
-            except Exception as error:
-                logging.error('failed to dump networking config %s: %s',
-                              self.id, value)
-                logging.exception(error)
-                raise error
-        else:
-            self.networking_config = None
-
-    @hybrid_property
-    def config(self):
-        """get config from security, networking, partition."""
-        config = {}
-        if self.raw_config:
-            try:
-                config = json.loads(self.raw_config)
-            except Exception as error:
-                logging.error('failed to load raw config %s: %s',
-                              self.id, self.raw_config)
-                logging.exception(error)
-                raise error
-
-        util.merge_dict(config, {'security': self.security})
-        util.merge_dict(config, {'networking': self.networking})
-        util.merge_dict(config, {'partition': self.partition})
-        util.merge_dict(config, {'clusterid': self.id,
-                                 'clustername': self.name})
-        return config
-
-    @config.setter
-    def config(self, value):
-        """set config to security, networking, partition."""
-        logging.debug('cluster %s set config %s', self.id, value)
-        if not value:
-            self.security = None
-            self.networking = None
-            self.partition = None
-            self.raw_config = None
-            return
-
-        self.security = value.get('security')
-        self.networking = value.get('networking')
-        self.partition = value.get('partition')
-
-        try:
-            self.raw_config = json.dumps(value)
-        except Exception as error:
-            logging.error('failed to dump raw config %s: %s',
-                          self.id, value)
-            logging.exception(error)
-            raise error
-
-
-class ClusterHost(BASE):
-    """ClusterHost information.
-
-    :param id: int, identity as primary key.
-    :param machine_id: int, the id of the Machine.
-    :param cluster_id: int, the id of the Cluster.
-    :param mutable: if the ClusterHost information is mutable.
-    :param hostname: str, host name.
-    :param config_data: string, json formatted config data.
-    :param cluster: refer to Cluster the host in.
-    :param machine: refer to the Machine the host on.
-    :param state: refer to HostState indicates the host state.
-    """
-    __tablename__ = 'cluster_host'
-
-    id = Column(Integer, primary_key=True)
-
-    machine_id = Column(Integer, ForeignKey('machine.id',
-                                            onupdate='CASCADE',
-                                            ondelete='CASCADE'),
-                        nullable=True, unique=True)
-
-    cluster_id = Column(Integer, ForeignKey('cluster.id',
-                                            onupdate='CASCADE',
-                                            ondelete='SET NULL'),
-                        nullable=True)
-
-    hostname = Column(String(80))
-    config_data = Column(Text)
-    mutable = Column(Boolean, default=True)
-    __table_args__ = (UniqueConstraint('cluster_id', 'hostname',
-                                       name='unique_host'),)
-
-    cluster = relationship("Cluster",
-                           backref=backref('hosts', lazy='dynamic'))
-    machine = relationship("Machine",
-                           backref=backref('host', uselist=False))
-
-    def __init__(self, **kwargs):
-        if 'hostname' not in kwargs or not kwargs['hostname']:
-            kwargs['hostname'] = str(uuid.uuid4())
-
-        super(ClusterHost, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<ClusterHost %r: cluster=%r machine=%r>' % (
-            self.hostname, self.cluster, self.machine)
-
-    @hybrid_property
-    def fullname(self):
-        return '%s.%s' % (self.hostname, self.cluster.id)
-
-    @property
-    def config(self):
-        """config getter."""
-        config = {}
-        try:
-            if self.config_data:
-                config.update(json.loads(self.config_data))
-
-            config.update({
-                'hostid': self.id,
-                'hostname': self.hostname,
-            })
-            if self.cluster:
-                config.update({
-                    'clusterid': self.cluster.id,
-                    'clustername': self.cluster.name,
-                    'fullname': self.fullname,
-                })
-
-            if self.machine:
-                util.merge_dict(
-                    config, {
-                        'networking': {
-                            'interfaces': {
-                                'management': {
-                                    'mac': self.machine.mac
-                                }
-                            }
-                        },
-                        'switch_port': self.machine.port,
-                        'vlan': self.machine.vlan,
-                    })
-                if self.machine.switch:
-                    util.merge_dict(
-                        config, {'switch_ip': self.machine.switch.ip})
-
-        except Exception as error:
-            logging.error('failed to load config %s: %s',
-                          self.hostname, self.config_data)
-            logging.exception(error)
-            raise error
-
-        return config
-
-    @config.setter
-    def config(self, value):
-        """config setter"""
-        if not self.config_data:
-            config = {
-            }
-            self.config_data = json.dumps(config)
-
-        if value:
-            try:
-                config = json.loads(self.config_data)
-                util.merge_dict(config, value)
-
-                self.config_data = json.dumps(config)
-            except Exception as error:
-                logging.error('failed to dump config %s: %s',
-                              self.hostname, value)
-                logging.exception(error)
-                raise error
-
-
-class LogProgressingHistory(BASE):
-    """host installing log history for each file.
-
-    :param id: int, identity as primary key.
-    :param pathname: str, the full path of the installing log file. unique.
-    :param position: int, the position of the log file it has processed.
-    :param partial_line: str, partial line of the log.
-    :param progressing: float, indicate the installing progress between 0 to 1.
-    :param message: str, str, the installing message.
-    :param severity: Enum, the installing message severity.
-                     ('ERROR', 'WARNING', 'INFO')
-    :param line_matcher_name: str, the line matcher name of the log processor.
-    :param update_timestamp: datetime, the latest timestamp the entry updated.
-    """
-    __tablename__ = 'log_progressing_history'
-    id = Column(Integer, primary_key=True)
-    pathname = Column(String(80), unique=True)
-    position = Column(Integer, ColumnDefault(0))
-    partial_line = Column(Text)
-    progress = Column(Float, ColumnDefault(0.0))
-    message = Column(Text)
-    severity = Column(Enum('ERROR', 'WARNING', 'INFO'), ColumnDefault('INFO'))
-    line_matcher_name = Column(String(80), ColumnDefault('start'))
-    update_timestamp = Column(DateTime, default=datetime.now,
-                              onupdate=datetime.now)
-
-    def __init__(self, **kwargs):
-        super(LogProgressingHistory, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return (
-            'LogProgressingHistory[%r: position %r,'
-            'partial_line %r,progress %r,message %r,'
-            'severity %r]'
-        ) % (
-            self.pathname, self.position,
-            self.partial_line,
-            self.progress,
-            self.message,
-            self.severity
-        )
-
-
-class Adapter(BASE):
-    """Table stores ClusterHost installing Adapter information.
-
-    :param id: int, identity as primary key.
-    :param name: string, adapter name, unique.
-    :param os: string, os name for installing the host.
-    :param target_system: string, target system to be installed on the host.
-    :param clusters: refer to the list of Cluster.
-    """
-    __tablename__ = 'adapter'
-    id = Column(Integer, primary_key=True)
-    name = Column(String(80), unique=True)
-    os = Column(String(80))
-    target_system = Column(String(80))
-    __table_args__ = (
-        UniqueConstraint('os', 'target_system', name='unique_adapter'),)
-
-    def __init__(self, **kwargs):
-        super(Adapter, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<Adapter %r: os %r, target_system %r>' % (
-            self.name, self.os, self.target_system
-        )
-
-
-class Role(BASE):
-    """The Role table stores avaiable roles of one target system.
-
-       .. note::
-          the host can be deployed to one or several roles in the cluster.
-
-    :param id: int, identity as primary key.
-    :param name: role name.
-    :param target_system: str, the target_system.
-    :param description: str, the description of the role.
-    """
-    __tablename__ = 'role'
-    id = Column(Integer, primary_key=True)
-    name = Column(String(80), unique=True)
-    target_system = Column(String(80))
-    description = Column(Text)
-
-    def __init__(self, **kwargs):
-        super(Role, self).__init__(**kwargs)
-
-    def __repr__(self):
-        return '<Role %r : target_system %r, description:%r>' % (
-            self.name, self.target_system, self.description)