harbor/tools/migration/mapprojects

#!/usr/bin/python
# -*- coding: utf-8 -*-

import json
import fileinput
from optparse import OptionParser
import os
import MySQLdb
import sys


class Parameters(object):

    def __init__(self):
        self.dbuser = ''
        self.dbpwd = ''
        self.mapprojectsfile = ''
        self.init_from_input()

    @staticmethod
    def parse_input():
        usage = \
            'usage: %prog [options] <dbuser> <dbpwd> <mapprojectsfile>'
        parser = OptionParser(usage)
        parser.add_option('-u', '--dbuser', dest='dbuser',
                          help='db user')
        parser.add_option('-p', '--dbpwd', dest='dbpwd',
                          help='db password')
        parser.add_option('-m', '--mapprojectsfile',
                          dest='mapprojectsfile',
                          help='the path of mapping projects file')

        (options, args) = parser.parse_args()
        return (options.dbuser, options.dbpwd, options.mapprojectsfile)

    def init_from_input(self):
        (self.dbuser, self.dbpwd, self.mapprojectsfile) = \
            Parameters.parse_input()


class AccessLog:

    def __init__(self, log_id, project_id):
        self.log_id = log_id
        self.project_id = project_id


class Repository:

    def __init__(self, repository_id, project_id):
        self.repository_id = repository_id
        self.project_id = project_id


class ReplicationPolicy:

    def __init__(self, replication_policy_id, project_id):
        self.replication_policy_id = replication_policy_id
        self.project_id = project_id


class Project:

    def __init__(
        self,
        project_id,
        name,
        index_id,
        ):

        self.project_id = project_id
        self.project_name = name
        self.index_id = index_id


class HarborUtil:

    def __init__(self, dbuser, dbpwd):
        self.serverName = 'localhost'
        self.user = dbuser
        self.password = dbpwd
        self.port = '3306'
        self.subDB = 'registry'
        self.db = None
        self.cursor = None

    def connect(self):
        try:
            self.db = MySQLdb.connect(host=self.serverName,
                    user=self.user, passwd=self.password, db=self.subDB)
            self.db.autocommit(False)
            self.cursor = self.db.cursor()
        except Exception, e:
            raise Exception(e)

    def close(self):
        try:
            self.db.commit()
            self.cursor.close()
            self.db.close()
        except Exception, e:
            print str(e)

    def enable_foreign_key_check(self):
        try:
            self.cursor.execute('SET FOREIGN_KEY_CHECKS=1')
        except Exception, e:
            print str(e)

    def disable_foreign_key_check(self):
        try:
            self.cursor.execute('SET FOREIGN_KEY_CHECKS=0')
        except Exception, e:
            print str(e)

    def get_index_id(self, projects, project_id):
        for project in projects:
            if project.project_id == project_id:
                return project.index_id
        return ''

    def update_access_log_table(self, projects):
        access_logs = []
        try:
            query_sccess_log = \
                'SELECT log_id, project_id from registry.access_log'
            self.cursor.execute(query_sccess_log)
            self.cursor.fetchall()
            for result in self.cursor:
                access_logs.append(AccessLog(result[0], result[1]))
        except Exception, e:
            raise Exception(e)

        for item in access_logs:
            index_id = self.get_index_id(projects, item.project_id)
            if index_id != '':
                try:
                    update_access_log_project_id = \
                        'UPDATE registry.access_log SET project_id=%s where log_id=%s' \
                        % (index_id, item.log_id)
                    self.cursor.execute(update_access_log_project_id)
                except Exception, e:
                    raise Exception(e)

    def update_repository_table(self, projects):
        repositories = []
        try:
            query_repository = \
                'SELECT repository_id, project_id from registry.repository'
            self.cursor.execute(query_repository)
            self.cursor.fetchall()
            for result in self.cursor:
                repositories.append(Repository(result[0], result[1]))
        except Exception, e:
            raise Exception(e)

        for item in repositories:
            index_id = self.get_index_id(projects, item.project_id)
            if index_id != '':
                try:
                    update_repository_project_id = \
                        'UPDATE registry.repository SET project_id=%s where repository_id=%s' \
                        % (index_id, item.repository_id)
                    self.cursor.execute(update_repository_project_id)
                except Exception, e:
                    raise Exception(e)

    def update_replication_policy_table(self, projects):
        replication_policies = []
        try:
            query_replication_policy = \
                'SELECT id, project_id from registry.replication_policy'
            self.cursor.execute(query_replication_policy)
            self.cursor.fetchall()
            for result in self.cursor:
                replication_policies.append(ReplicationPolicy(result[0],
                                    result[1]))
        except Exception, e:
            raise Exception(e)

        for item in replication_policies:
            index_id = self.get_index_id(projects, item.project_id)
            if index_id != '':
                try:
                    update_replication_policy_id = \
                        'UPDATE registry.replication_policy SET project_id=%s where id=%s' \
                        % (index_id, item.replication_policy_id)
                    self.cursor.execute(update_replication_policy_id)
                except Exception, e:
                    raise Exception(e)


def main():
    commandline_input = Parameters()
    harbor = HarborUtil(commandline_input.dbuser,
                        commandline_input.dbpwd)

    try:
        harbor.connect()
        harbor.disable_foreign_key_check()

        with open(commandline_input.mapprojectsfile, 'r') as \
            project_mapping_file:
            project_mapping_data = json.load(project_mapping_file)

        projects_mapping_list = []
        for item in project_mapping_data['map_projects']:
            projects_mapping_list.append(Project(item['project_id'],
                    item['project_name'], item['index_id']))

        harbor.update_access_log_table(projects_mapping_list)
        harbor.update_repository_table(projects_mapping_list)
        harbor.update_replication_policy_table(projects_mapping_list)
    except Exception, e:
        print e
        sys.exit(1)
    finally:
        harbor.enable_foreign_key_check()
        harbor.close()


if __name__ == '__main__':
    main()