#!/usr/bin/env python
#
# Copyright (c) 2016 Samsung Electronics.Co.Ltd.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; version 2 of the License
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# for more details.
#
"""
BuildMonitor APIs

1. Related files
  (1) gbs submit --------------- [job_submit.py]
  (2) [pre] packae build ------- [on OBS]
  (3) [pre] snapshot create ---- [job_pre_release_obs.py]
  (4) [pre] image creation  ---- [job_imager.py][job_post_imager.py]
  (5) SR accept or reject ------ [job_request.py]
  (6) [post] package build ----- [on OBS]
  (7) [post] snapshot creation - [job_create_snapshot.py]
  (8) [post] image creation ---- [job_imager.py]
  (9) Completed
  * pre : pre build / post : post build

2. function naming rules

[ACTION]_for_[TABLE]

ex) sr_submit_for_sr_status
ACTION : Submit
TABLE  : sr_status

3. db table list

[SR    parts] sr_stage | sr_status | sr_commit | sr_status_details
[BUILD parts] build_snapshot | build_snapshot_package | build_image
"""

import os
import sys
import datetime
import re

from time import sleep
from common import buildmonitor_db
from common.buildtrigger import trigger_info, trigger_next

class LocalError(Exception):
    """Local error exception."""
    pass

#===============================================================================
# for global variables

INVALID_ID = 0

#===============================================================================
# for info_stage_id

SR_SUBMIT  = 1
TRBS_BUILD = 2
TRBS_SNAP  = 3
TRBS_IMAGE = 4
PRE_BUILD  = 5
PRE_SNAP   = 6
PRE_IMAGE  = 7
SR_ACCEPT  = 8
POST_BUILD = 9
POST_SNAP  = 10
POST_IMAGE = 11

#===============================================================================
# connect & disconnect db

def bm_connect_db():
    buildmonitor_db.connect_db()

def bm_disconnect_db():
    buildmonitor_db.disconnect_db()

#===============================================================================
# [job_submit.py]

def get_src_proj_lst(bm_src_prj_lst):
    print '[%s] enter get_src_proj_lst\n' % (__file__)

    if not os.getenv("DROPPED_PRERELEASE_PROJECTS"):
        print '[%s] no DROPPED_PRERELEASE_PROJECTS!!\n' % (__file__)
        return bm_src_prj_lst

    prefix = 'home:prerelease:'
    dropped_prj_lst = os.getenv("DROPPED_PRERELEASE_PROJECTS").split(',')
    #print '[%s] dropped_prj_lst(%s)\n' % (__file__, dropped_prj_lst)

    print '[%s] bm_src_prj_lst (%s)\n' % (__file__, bm_src_prj_lst)
    removed_lst = []
    for each_src_proj in bm_src_prj_lst:
        for each_dropped_proj in dropped_prj_lst:
            #print '[%s] each_src_proj(%s), each_dropped_proj(%s)\n' \
            #      % (__file__, each_src_proj, each_dropped_proj)
            if each_src_proj.startswith(prefix + each_dropped_proj):
                removed_lst.append(each_src_proj)
                break

    # do remove
    print '[%s] removed_lst(%s), do remove!!\n' % (__file__, removed_lst)
    bm_src_prj_lst = [x for x in bm_src_prj_lst if x not in removed_lst]

    return bm_src_prj_lst

def truncate_msg(msg):
    MAX_MSG_LEN = int(os.getenv("BUILDMONITOR_MAX_MSG_LEN"))
    ret_msg = (msg[:MAX_MSG_LEN-2] + '..') if len(msg) > MAX_MSG_LEN else msg
    return ret_msg

def transform_date(date):
    # Currently, we just remove timezone part (e.g., '+0900')
    # Should we consider timezone in the future??
    dd = date.split(' ')
    return dd[0]+' '+dd[1]

def sr_submit_for_sr_status(bm_git_tag):
    print '[%s] enter sr_submit_for_sr_status\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    if curr_sr_status_id == INVALID_ID:
        query = "INSERT INTO sr_status (sr, status) VALUES(%s, %s)"
        query_data = (bm_git_tag, 'C')
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] Already existing sr_status_id(%s) skip INSERT sr_stage\n' \
                % (__file__, curr_sr_status_id)

def sr_submit_for_sr_commit(commit_date, commit_msg, submit_date, submit_msg,
                            submitter, git_tag, gerrit_project,
                            gerrit_newrev, gerrit_account_name):
    print '[%s] enter sr_submit_for_sr_commit\n' % (__file__)

    # get current_sr_status_id (should be here, after sr_submit_for_sr_status)
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    obs_pkg_name = os.path.basename(gerrit_project)
    bm_submitter = submitter.replace('<', '').replace('>', '')
    #print '[%s] bm_submitter(%s)' % (__file__, bm_submitter)

    query = "INSERT INTO sr_commit (sr_status_id, git_repository," \
            "obs_package_name, git_commit_id, git_commit_date, "   \
            "git_commit_message, git_committer, sr_submit_date, "  \
            "sr_submit_message, sr_submitter) " \
            "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, gerrit_project, obs_pkg_name,
                    gerrit_newrev, commit_date, commit_msg,
                    gerrit_account_name, submit_date, submit_msg,
                    bm_submitter)
    buildmonitor_db.do_query(query, query_data)

def start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                 bm_end_datetime, pre_build_project_id):
    print '[%s] enter start_pre_build_for_sr_stage\n' % (__file__)

    # get current_sr_status_id (should be here after sr_submit_for_sr_status)
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    ### [SR_SUBMIT] end stage : SR submit
    info_stage_id = SR_SUBMIT
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, 'S', curr_sr_status_id, info_stage_id, pre_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    ### [PRE_BUILD] start stage : [pre] package build
    bm_start_datetime = bm_end_datetime
    info_stage_id = PRE_BUILD
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime, 'R', pre_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                           bm_end_datetime, pre_build_project_id):
    print '[%s] enter sr_submit_for_sr_stage\n' % (__file__)

    ### [SR_SUBMIT] SR submit
    info_stage_id = SR_SUBMIT
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_end_time, stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime,
                  bm_end_datetime, 'S', pre_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def package_build_for_sr_detail_sr_stage(git_tag, bm_start_datetime,
                                         bm_end_datetime, bm_src_project_lst):
    print '[%s] enter package_build_for_sr_detail_sr_stage\n' % (__file__)

    # get current_sr_status_id (should be here after sr_submit_for_sr_status)
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    # Wait 60 seconds to find the info_project_id
    print '[%s] wait 60 sec\n' % (__file__)
    sleep(60)

    ### for sr_status_detail & sr_stage
    # bm_src_project_lst is needed for multi profile
    print '[%s] bm_src_project_lst(%s)\n' % (__file__, bm_src_project_lst)
    for bm_src_project in bm_src_project_lst:
        #print '[%s] bm_src_project(%s)\n' % (__file__, bm_src_project)

        # get info_project_id -> get pre_build_project_id
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_src_project,)
        info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (info_project_id,)
        pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] info_project_id(%s), pre_build_project_id(%s)\n' \
               % (__file__, info_project_id, pre_build_project_id)

        # defensive code for the duplicated build_project_id
        if pre_build_project_id == INVALID_ID:
            print '[%s] cannot find build_project_id!! Adding NOW!!\n' % (__file__)
            query = "INSERT INTO build_project (info_project_id, status) VALUES(%s, %s)"
            query_data = (info_project_id, 'C')
            buildmonitor_db.do_query(query, query_data)
            query = "SELECT id FROM build_project WHERE info_project_id = %s"
            query_data = (info_project_id,)
            pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
            print '[%s][After] info_project_id(%s), pre_build_project_id(%s)\n' \
                   % (__file__, info_project_id, pre_build_project_id)

        # get sr_status_detail_id for checking group submit
        query = "SELECT id FROM sr_status_detail WHERE sr_status_id = %s " \
                "AND pre_build_project_id = %s"
        query_data = (curr_sr_status_id, pre_build_project_id)
        sr_status_detail_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s] sr_status_detail_id(%s)\n' % (__file__, sr_status_detail_id)

        if sr_status_detail_id == INVALID_ID:
            # get pre_build_project_id
            query = "SELECT id FROM build_project WHERE info_project_id = %s"
            query_data = (info_project_id,)
            pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

            ### for sr_status_detail
            query = "INSERT INTO sr_status_detail (sr_status_id, pre_build_project_id) " \
                    "VALUES(%s, %s)"
            query_data = (curr_sr_status_id, pre_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            ### for sr_stage for multi profile
            # [1] start stage
            sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                                   bm_end_datetime, pre_build_project_id)
            # [1] end stage / [2] start stage
            start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                         bm_end_datetime, pre_build_project_id)
        else:
            # clear the existing tables (sr_stage & build_snapshot)
            print '[%s] Already existing sr_status_id(%s)!! clear the related tables\n' \
                  % (__file__, sr_status_detail_id)
            query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND build_project_id = %s"
            query_data = (curr_sr_status_id, pre_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            # get build_snapshot_id for deleting build_snapshot_package & build_image
            query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
            query_data = (pre_build_project_id,)
            build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)

            # delete build_snapshot & build_snapshot_package & build_image
            query = "DELETE FROM build_snapshot WHERE build_project_id = %s"
            query_data = (pre_build_project_id,)
            buildmonitor_db.do_query(query, query_data)
            query = "DELETE FROM build_snapshot_package WHERE build_snapshot_id = %s"
            query_data = (build_snapshot_id,)
            buildmonitor_db.do_query(query, query_data)
            query = "DELETE FROM build_image WHERE build_snapshot_id = %s"
            query_data = (build_snapshot_id,)
            buildmonitor_db.do_query(query, query_data)

            ### for sr_stage for multi profile
            # [1] start stage
            sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                                   bm_end_datetime, pre_build_project_id)
            # [1] end stage / [2] start stage
            start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                         bm_end_datetime, pre_build_project_id)

#===============================================================================
# [job_pre_release_obs.py]

def update_fail_status_for_sr_stage(project, bm_git_tag):
    print '[%s] enter update_fail_status_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id (%s)\n' % (__file__, curr_sr_status_id)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # Skip updating the fail status if Base project
    if 'base' in project.lower():
        sr_stage_status = 'S'

        ### [PRE_SNAP] stage end : update 'S' status
        info_stage_id = PRE_SNAP
        query = "UPDATE sr_stage SET stage_end_time = NOW(), stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (sr_stage_status, curr_sr_status_id, info_stage_id, curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### [PRE_IMAGE] stage end : insert 'S' status
        info_stage_id = PRE_IMAGE
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                "stage_end_time, stage_status, build_project_id) " \
                "VALUES(%s, %s, NOW(), NOW(), %s, %s)"
        query_data = (curr_sr_status_id, info_stage_id,
                      sr_stage_status, curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        print '[%s] This is [Base] project!! All stages are done\n' % (__file__)
    else:
        sr_stage_status = 'F'

        ### [PRE_SNAP] stage end : update 'F' status
        info_stage_id = PRE_SNAP
        query = "UPDATE sr_stage SET stage_end_time = NOW(), stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (sr_stage_status, curr_sr_status_id, info_stage_id, curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)

def start_pre_create_snapshot_for_sr_stage(project, bm_git_tag, bm_start_datetime, bBuildFail):
    print '[%s] enter start_pre_create_snapshot_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    print '[%s] bBuildFail(%s)\n' % (__file__, bBuildFail)
    if bBuildFail == True:
        info_stage_status = 'F'
    else:
        info_stage_status = 'S'

    ### [PRE_BUILD] stage end : [pre] package build
    info_stage_id = PRE_BUILD
    bm_end_datetime = bm_start_datetime
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, info_stage_status, curr_sr_status_id,
                  info_stage_id, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    if info_stage_status == 'S':
        ### [PRE_SNAP] stage start : [pre] snapshot creation
        info_stage_id = PRE_SNAP
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
        query_data = (curr_sr_status_id, info_stage_id,
                      bm_start_datetime, 'R', curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] Build failed!! skip [3] stage start\n' \
              % (__file__)

def start_pre_create_snapshot_for_build_snapshot(project, bm_git_tag, bm_start_datetime):
    print '[%s] enter start_pre_create_snapshot_for_build_snapshot\n' % (__file__)

    # get pre_info_project_id -> get pre_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    pre_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (pre_info_project_id,)
    pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] pre_info_project_id(%s), pre_build_project_id(%s)\n' \
    #      % (__file__, pre_info_project_id, pre_build_project_id)

    ### to check duplicate build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
    query_data = (pre_build_project_id,)
    pre_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    ### for build_snapshot
    if pre_build_snapshot_id == INVALID_ID:
        query = "INSERT INTO build_snapshot (build_project_id, start_time, status) " \
                "VALUES(%s, %s, %s)"
        query_data = (pre_build_project_id, bm_start_datetime, 'R')
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] duplicated build_snapshot_id!! skip insert & clear tables\n' \
              % (__file__)

        ### clear build_snapshot_package & build_image tables
        query = "DELETE FROM build_snapshot_package WHERE build_snapshot_id = %s"
        query_data = (pre_build_snapshot_id,)
        buildmonitor_db.do_query(query, query_data)
        query = "DELETE FROM build_image WHERE build_snapshot_id = %s"
        query_data = (pre_build_snapshot_id,)
        buildmonitor_db.do_query(query, query_data)

        # get curr_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        ### [PRE_SNAP] stage remove : [pre] snapshot creation
        info_stage_id = PRE_SNAP
        query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (curr_sr_status_id, info_stage_id, pre_build_project_id)
        buildmonitor_db.do_query(query, query_data)
        ### [PRE_IMAGE] stage remove : [pre] image creation
        info_stage_id = PRE_IMAGE
        query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (curr_sr_status_id, info_stage_id, pre_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### [PRE_SNAP] stage restart : [pre] snapshot creation
        info_stage_id = PRE_SNAP
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
        query_data = (curr_sr_status_id, info_stage_id,
                      bm_start_datetime, 'R', pre_build_project_id)
        buildmonitor_db.do_query(query, query_data)

def create_snapshot_packages_for_build_snapshot_package(project, bm_repo, bm_arch,
                                                        bm_pkg_url,
                                                        bm_pkg_name_lst,
                                                        bm_pkg_mdate_lst,
                                                        bm_pkg_size_lst,
                                                        bm_trg_count,
                                                        bm_pkg_count,
                                                        BM_PKG_LIMIT):
    print '[%s] enter create_snapshot_packages_for_build_snapshot_package\n' % (__file__)

    # get pre_info_project_id -> get pre_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    pre_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (pre_info_project_id,)
    pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] pre_info_project_id(%s), pre_build_project_id(%s)\n' \
    #      % (__file__, pre_info_project_id, pre_build_project_id)

    # get curr_build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
    query_data = (pre_build_project_id,)
    curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_build_snapshot_id(%s)\n' % (__file__, curr_build_snapshot_id)

    # bulk insert
    query = "INSERT INTO build_snapshot_package (build_snapshot_id, repository, " \
            "arch, package_name, created_date, package_size, package_url) " \
            "VALUES(%s, %s, %s, %s, %s, %s, %s)"

    query_list = []
    for each_pkg_name, each_pkg_mdate, each_pkg_size in zip(bm_pkg_name_lst, bm_pkg_mdate_lst, bm_pkg_size_lst):
        timestamp = datetime.datetime.fromtimestamp(each_pkg_mdate)
        #print '[%s] each_pkg_name(%s), timestamp(%s), each_pkg_size(%s)' \
        #      % (__file__, each_pkg_name, timestamp, each_pkg_size)
        query_list.append((curr_build_snapshot_id, bm_repo, bm_arch,
                           each_pkg_name, timestamp, each_pkg_size, bm_pkg_url))

    buildmonitor_db.do_many_query(query, query_list)

def end_pre_create_snapshot_for_sr_stage(project, bm_git_tag,
                                         bm_start_datetime, bm_end_datetime):
    print '[%s] enter end_pre_create_snapshot_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### [PRE_SNAP] stage end : [pre] snapshot creation
    sr_stage_status = 'S'
    info_stage_id = PRE_SNAP
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, sr_stage_status, curr_sr_status_id,
                  info_stage_id, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    if 'base' in project.lower():
        ### [PRE_IMAGE] stage end : [pre] image creation
        sr_stage_status = 'S'
        print '[%s] This is [Base] project!! sr_stage_status(%s)\n' \
              % (__file__, sr_stage_status)
    else:
        ### [PRE_IMAGE] stage start : [pre] image creation
        sr_stage_status = 'R'

    info_stage_id = PRE_IMAGE
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_end_datetime,
                  sr_stage_status, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def end_pre_create_snapshot_for_build_snapshot(project, bm_snapshot_name,
                                               bm_snapshot_url, bm_snapshot_num,
                                               bm_end_datetime):
    print '[%s] enter end_pre_create_snapshot_for_build_snapshot\n' % (__file__)

    # get pre_info_project_id -> get pre_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    pre_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (pre_info_project_id,)
    pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] pre_info_project_id(%s), pre_build_project_id(%s)\n' \
    #      % (__file__, pre_info_project_id, pre_build_project_id)

    ### for build_snapshot
    query = "UPDATE build_snapshot SET snapshot_name = %s, snapshot_url = %s, " \
            "snapshot_num = %s, end_time = %s, status = %s WHERE build_project_id = %s"
    query_data = (bm_snapshot_name, bm_snapshot_url, bm_snapshot_num,
                  bm_end_datetime, 'S', pre_build_project_id)
    buildmonitor_db.do_query(query, query_data)

#===============================================================================
# [job_imager.py]

def update_fail_create_image_for_sr_stage(fields, bm_start_datetime, bm_snapshot_name):
    print '[%s] enter update_fail_create_image_for_sr_stage\n' % (__file__)

    bm_prj_name = fields["project"]
    bm_split_data = fields["project"].split(':')[-1]
    bm_branch_name = fields["project"].split(':')[-2]
    #bm_git_tag = 'submit/tizen/' + bm_split_data
    bm_git_tag = 'submit/' + bm_branch_name + '/' + bm_split_data
    bm_url = os.path.join(fields.get('url_pub_base', ''),
                           fields['repo_path'], fields['images_path'])
    #print '[%s] bm_prj_name(%s), bm_split_data(%s), bm_git_tag(%s), bm_url(%s)\n' \
    #      % (__file__, bm_prj_name, bm_split_data, bm_git_tag, bm_url)

    bm_end_datetime = datetime.datetime.now()
    bm_repo = fields["repo"]
    bm_device_name = fields["name"]

    if not ((bm_url.find("prerelease")) == -1) or not ((bm_url.find("trbs")) == -1):
        # [pre_build] get current_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s][pre_build] info_stage_id(%s), query_data(%s), curr_sr_status_id(%s)\n' \
        #      % (__file__, info_stage_id, query_data, curr_sr_status_id)

        # get curr_info_project_id -> get curr_build_project_id for multi profile
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_prj_name,)
        curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (curr_info_project_id,)
        curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        ### [PRE_IMAGE] stage : update fail status for [pre] image creation
        info_stage_id = PRE_IMAGE
        query = "UPDATE sr_stage SET stage_start_time = %s, stage_end_time = %s, stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (bm_start_datetime, bm_end_datetime, 'F',
                      curr_sr_status_id, info_stage_id, curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### build_image : update fail status for [pre] image creation
        # get pre_build_snapshot_id
        query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
        query_data = (curr_build_project_id,)
        pre_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        # update fail status
        query = "UPDATE build_image SET end_time = %s, status = %s " \
                "WHERE build_snapshot_id = %s AND repository = %s AND device_name = %s"
        query_data = (bm_end_datetime, 'F',
                      pre_build_snapshot_id, bm_repo, bm_device_name)
        buildmonitor_db.do_query(query, query_data)
    else:
        # get post_build_project_id by using bm_snapshot_name
        query = "SELECT build_project_id FROM build_snapshot WHERE snapshot_name = %s"
        query_data = (bm_snapshot_name,)
        post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] post_build_project_id(%s)\n' % (__file__, post_build_project_id)

        # get multi_sr_status_id
        query = "SELECT sr_status_id FROM sr_status_detail WHERE post_build_project_id = %s"
        query_data = (post_build_project_id,)
        multi_sr_status_id = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
        #print '[%s] multi_sr_status_id(%s)\n' \
        #      % (__file__, multi_sr_status_id)

        ### [POST_IMAGE] stage end : [POST] image creation
        for each_sr_status_id in multi_sr_status_id:
            print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)

            ### [POST_IMAGE] stage : update fail status for [post] image creation
            info_stage_id = POST_IMAGE
            query = "UPDATE sr_stage SET stage_start_time = %s, stage_end_time = %s, stage_status = %s " \
                    "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
            query_data = (bm_start_datetime, bm_end_datetime, 'F',
                          each_sr_status_id[0], info_stage_id, post_build_project_id)
            buildmonitor_db.do_query(query, query_data)

def create_image_for_build_image(fields, bm_start_datetime,
                                 bm_end_datetime, bm_snapshot_name, bm_img_size):
    print '[%s] enter create_image_for_build_image\n' % (__file__)

    bm_repository = fields['repo']
    bm_device_name = fields['name']
    if fields['status'].lower() == 'failed':
        bm_status = 'F'
    else:
        bm_status = 'S'
    bm_url = fields['url']
    #print '[%s] bm_repository(%s), bm_device_name(%s), bm_status(%s), bm_url(%s)\n' \
    #      % (__file__, bm_repository, bm_device_name, bm_status, bm_url)

    # get curr_build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE snapshot_name = %s"
    query_data = (bm_snapshot_name,)
    curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_build_snapshot_id(%s)\n' % (__file__, curr_build_snapshot_id)

    ### for build_image
    query = "INSERT INTO build_image (build_snapshot_id, repository, device_name, " \
            "start_time, end_time, status, image_size, image_url) " \
            "VALUES(%s, %s, %s, %s, %s, %s, %s, %s)"
    query_data = (curr_build_snapshot_id, bm_repository, bm_device_name,
                  bm_start_datetime, bm_end_datetime,
                  bm_status, bm_img_size, bm_url)
    buildmonitor_db.do_query(query, query_data)

#===============================================================================
# [job_post_image.py]

def end_create_image_for_sr_stage(bm_start_datetime, project, bm_snapshot_name):
    print '[%s] enter end_create_image_for_sr_stage project(%s)\n' % (__file__, project)

    bm_end_datetime = datetime.datetime.now()

    if project.startswith("home:prerelease:") or project.startswith("home:trbs:"):
        bm_git_tag = project.split(":")[-3] + '/' + project.split(":")[-2] + '/' + project.split(":")[-1]
        #print '[%s] bm_git_tag(%s)\n' % (__file__, bm_git_tag)

        # [pre_build] get current_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s][pre_build] query_data(%s), curr_sr_status_id(%s)\n' \
        #      % (__file__, query_data, curr_sr_status_id)

        # get curr_info_project_id -> get curr_build_project_id for multi profile
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (project,)
        curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (curr_info_project_id,)
        curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        # get curr_build_snapshot_id
        query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
        query_data = (curr_build_project_id,)
        curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        # get multi_build_image_status
        query = "SELECT status FROM build_image WHERE build_snapshot_id = %s"
        query_data = (curr_build_snapshot_id,)
        multi_build_image_status = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
        print '[%s] multi_build_image_status(%s)\n' % (__file__, multi_build_image_status)

        isFailed = 0
        for each_build_image_status in multi_build_image_status:
            #print '[%s] each_build_image_status(%s)\n' % (__file__, each_build_image_status)
            if each_build_image_status[0] == 'F':
                isFailed = 1
                print '[%s] isFailed(%s)!! skip updating the sr_stage\n' % (__file__, isFailed)

        if isFailed == 0:
            ### [PRE_IMAGE] stage : [pre] image creation
            info_stage_id = PRE_IMAGE
            query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                    "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
            query_data = (bm_end_datetime, 'S',
                          curr_sr_status_id, info_stage_id, curr_build_project_id)
            buildmonitor_db.do_query(query, query_data)
    else:
        # get post_build_project_id by using bm_snapshot_name
        query = "SELECT build_project_id FROM build_snapshot WHERE snapshot_name = %s"
        query_data = (bm_snapshot_name,)
        post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] post_build_project_id(%s)\n' % (__file__, post_build_project_id)

        # get curr_build_snapshot_id
        query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
        query_data = (post_build_project_id,)
        curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        # get multi_build_image_status
        query = "SELECT status FROM build_image WHERE build_snapshot_id = %s"
        query_data = (curr_build_snapshot_id,)
        multi_build_image_status = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
        print '[%s] multi_build_image_status(%s)\n' % (__file__, multi_build_image_status)

        isFailed = 0
        for each_build_image_status in multi_build_image_status:
            #print '[%s] each_build_image_status(%s)\n' % (__file__, each_build_image_status)
            if each_build_image_status[0] == 'F':
                isFailed = 1
                print '[%s] isFailed(%s)!! skip updating the sr_stage\n' % (__file__, isFailed)

        if isFailed == 0:
            # get multi_sr_status_id
            query = "SELECT sr_status_id FROM sr_status_detail WHERE post_build_project_id = %s"
            query_data = (post_build_project_id,)
            multi_sr_status_id = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
            #print '[%s] curr_info_project_id(%s), post_build_project_id(%d), multi_sr_status_id(%s)\n' \
            #      % (__file__, curr_info_project_id, post_build_project_id, multi_sr_status_id)

            ### [POST_SNAP/POST_IMAGE] stage end : [POST] snapshot & image creation
            for each_sr_status_id in multi_sr_status_id:
                print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)

                info_stage_id = POST_SNAP
                query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                        "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
                query_data = (bm_end_datetime, 'S',
                              each_sr_status_id[0], info_stage_id, post_build_project_id)
                buildmonitor_db.do_query(query, query_data)

                info_stage_id = POST_IMAGE
                query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                        "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
                query_data = (bm_end_datetime, 'S',
                              each_sr_status_id[0], info_stage_id, post_build_project_id)
                buildmonitor_db.do_query(query, query_data)
#===============================================================================
# [job_request.py]

def sr_accept_for_sr_stage(bm_src_prj_name, bm_target_prj_name,
                           bm_start_datetime, bm_end_datetime, bm_git_tag):
    print '[%s] enter sr_accept_for_sr_stage\n' % (__file__)

    # get current_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (bm_src_prj_name,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### [SR_ACCEPT] stage : SR aceept
    info_stage_id = SR_ACCEPT
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, " \
            "stage_start_time, stage_end_time, stage_status, build_project_id) " \
            "VALUES(%s, %s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id,
                  bm_start_datetime, bm_end_datetime, 'S', curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    # get curr_info_project_id -> get post_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (bm_target_prj_name,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get last_bpid_of_build_snapshot
    query = "SELECT bp.id " \
            "FROM build_project bp, info_project ip, build_snapshot bs " \
            "WHERE ip.project_name = %s " \
            "AND ip.id = bp.info_project_id " \
            "AND bp.id = bs.build_project_id " \
            "ORDER BY id desc LIMIT 1"
    query_data = (bm_target_prj_name,)
    last_bpid_of_build_snapshot = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] last_bpid_of_build_snapshot(%s)\n' \
          % (__file__, last_bpid_of_build_snapshot)

    # get post_build_project_id
    query = "SELECT bp.id " \
            "FROM build_project bp " \
            "WHERE bp.info_project_id = %s " \
            "AND bp.id > %s " \
            "ORDER BY id LIMIT 1"
    query_data = (curr_info_project_id, last_bpid_of_build_snapshot)
    post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] post_build_project_id(%s)\n' \
          % (__file__, post_build_project_id)

    # use the prev last_bpid if there is no post_build_project_id
    if post_build_project_id == 0:
        print '[%s] post_build_project_id is (%s)!! use the previous last_bpid(%s)\n' % \
              (__file__, post_build_project_id, last_bpid_of_build_snapshot)
        post_build_project_id = last_bpid_of_build_snapshot

    ### [POST_BUILD] stage start : [post] package build
    info_stage_id = POST_BUILD
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, " \
            "stage_start_time, stage_status, build_project_id) " \
            "VALUES(%s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime,
                  'R', post_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def sr_reject_for_sr_stage(bm_src_prj_name, bm_start_datetime,
                           bm_end_datetime, bm_git_tag):
    print '[%s] enter sr_reject_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (bm_src_prj_name,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### [SR_ACCEPT] stage : SR reject
    info_stage_id = SR_ACCEPT
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_end_time, stage_status, build_project_id) " \
            "VALUES(%s, %s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime, bm_end_datetime,
                  'F', curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def sr_accept_reject_for_sr_status_detail(event_fields, bm_start_datetime,
                                          bm_end_datetime, bm_git_tag):
    print '[%s] enter sr_accept_reject_for_sr_status_detail\n' % (__file__)

    obs_req_no = event_fields['id']
    obs_req_comment = truncate_msg(event_fields['description'])
    obs_req_date = bm_end_datetime
    obs_req_status = event_fields['state']
    obs_req_status = obs_req_status.upper()
    bm_src_prj_name = event_fields['sourceproject']
    bm_target_prj_name = event_fields['targetproject']
    #print '[%s] obs_req_no(%s), obs_req_comment(%s), obs_req_date(%s), obs_req_status(%s)\n' \
    #      % (__file__, obs_req_no, obs_req_comment, obs_req_date, obs_req_status)
    #print '[%s] bm_src_prj_name(%s), bm_target_prj_name(%s), bm_git_tag(%s)\n' \
    #      % (__file__, bm_src_prj_name, bm_target_prj_name, bm_git_tag)

    if obs_req_status == 'ACCEPTED':
        print '[%s][ACCEPTED] obs_req_status(%s)\n' % (__file__, obs_req_status)

        # get pre_info_project_id -> get pre_build_project_id
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_src_prj_name,) # should use bm_src_prj_name
        pre_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (pre_info_project_id,)
        pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s] pre_info_project_id(%d), pre_build_project_id(%s)\n' \
        #      % (__file__, pre_info_project_id, pre_build_project_id)

        # get post_info_project_id
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_target_prj_name,)
        post_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        # get last_bpid_of_build_snapshot
        query = "SELECT bp.id " \
                "FROM build_project bp, info_project ip, build_snapshot bs " \
                "WHERE ip.project_name = %s " \
                "AND ip.id = bp.info_project_id " \
                "AND bp.id = bs.build_project_id " \
                "ORDER BY id desc LIMIT 1"
        query_data = (bm_target_prj_name,)
        last_bpid_of_build_snapshot = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] last_bpid_of_build_snapshot(%s)\n' \
              % (__file__, last_bpid_of_build_snapshot)

        # get post_build_project_id
        query = "SELECT bp.id " \
                "FROM build_project bp " \
                "WHERE bp.info_project_id = %s " \
                "AND bp.id > %s " \
                "ORDER BY id LIMIT 1"
        query_data = (post_info_project_id, last_bpid_of_build_snapshot)
        post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] post_build_project_id(%s)\n' \
              % (__file__, post_build_project_id)

        # use the prev last_bpid if there is no post_build_project_id
        if post_build_project_id == 0:
            print '[%s] post_build_project_id is (%s)!! use the previous last_bpid(%s)\n' % \
                  (__file__, post_build_project_id, last_bpid_of_build_snapshot)
            post_build_project_id = last_bpid_of_build_snapshot

        ### for sr_status_detail
        query = "UPDATE sr_status_detail SET post_build_project_id = %s, obs_request_no = %s, " \
                "obs_request_comment = %s, obs_request_date = %s, obs_request_status = %s " \
                "WHERE pre_build_project_id = %s"
        query_data = (post_build_project_id, obs_req_no, obs_req_comment,
                      obs_req_date, 'A', pre_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### for sr_stage (now can find the build_project_id of the target prj)
        sr_accept_for_sr_stage(bm_src_prj_name, bm_target_prj_name,
                               bm_start_datetime, bm_end_datetime, bm_git_tag)

    elif obs_req_status == 'DECLINED':
        print '[%s][DECLINED] obs_req_status(%s)\n' \
              % (__file__, obs_req_status)

        # get info_project_id -> get pre_build_project_id
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_src_prj_name,)
        info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (info_project_id,)
        pre_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        ### for sr_status_detail
        query = "UPDATE sr_status_detail SET obs_request_no = %s, " \
                "obs_request_comment = %s, obs_request_date = %s, obs_request_status = %s " \
                "WHERE pre_build_project_id = %s"
        query_data = (obs_req_no, obs_req_comment, obs_req_date,
                      'R', pre_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### for sr_stage
        sr_reject_for_sr_stage(bm_src_prj_name, bm_start_datetime,
                               bm_end_datetime, bm_git_tag)

#===============================================================================
# [job_create_snapshot.py]

def update_fail_create_snapshot_for_sr_stage(bm_snapshot_name):
    print '[%s] enter update_fail_create_snapshot_for_sr_stage\n' % (__file__)

    # get post_build_project_id by using bm_snapshot_name
    query = "SELECT build_project_id FROM build_snapshot WHERE snapshot_name = %s"
    query_data = (bm_snapshot_name,)
    post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] post_build_project_id(%s)\n' % (__file__, post_build_project_id)

    # get multi_sr_status_id
    query = "SELECT sr_status_id FROM sr_status_detail WHERE post_build_project_id = %s"
    query_data = (post_build_project_id,)
    multi_sr_status_id = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
    #print '[%s] multi_sr_status_id(%s)\n' \
    #      % (__file__, multi_sr_status_id)

    # Skip updating the fail status if Base project
    if 'base' in bm_snapshot_name.lower():
        sr_stage_status = 'S'

        for each_sr_status_id in multi_sr_status_id:
            print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)

            ### [POST_SNAP] stage end : update 'S' status
            info_stage_id = POST_SNAP
            query = "UPDATE sr_stage SET stage_end_time = NOW(), stage_status = %s " \
                    "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
            query_data = (sr_stage_status, each_sr_status_id[0], info_stage_id, post_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            ### [POST_IMAGE] stage end : insert 'S' status
            info_stage_id = POST_IMAGE
            query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                    "stage_end_time, stage_status, build_project_id) " \
                    "VALUES(%s, %s, NOW(), NOW(), %s, %s)"
            query_data = (each_sr_status_id[0], info_stage_id, sr_stage_status, post_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            print '[%s] This is [Base] project!! All stages are done\n' % (__file__)

    else:
        sr_stage_status = 'F'

        for each_sr_status_id in multi_sr_status_id:
            print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)

            ### [POST_SNAP] stage end : update 'F' status
            info_stage_id = POST_SNAP
            query = "UPDATE sr_stage SET stage_end_time = NOW(), stage_status = %s " \
                    "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
            query_data = (sr_stage_status, each_sr_status_id[0], info_stage_id, post_build_project_id)
            buildmonitor_db.do_query(query, query_data)

def start_create_snapshot_for_sr_stage(project, bm_start_datetime):
    print '[%s] enter start_create_snapshot_for_sr_stage\n' % (__file__)

    # get post_info_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    post_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get last_bpid_of_build_snapshot
    query = "SELECT bp.id " \
            "FROM build_project bp, info_project ip, build_snapshot bs " \
            "WHERE ip.project_name = %s " \
            "AND ip.id = bp.info_project_id " \
            "AND bp.id = bs.build_project_id " \
            "ORDER BY id desc LIMIT 1"
    query_data = (project,)
    last_bpid_of_build_snapshot = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] last_bpid_of_build_snapshot(%s)\n' \
          % (__file__, last_bpid_of_build_snapshot)

    # get post_build_project_id
    query = "SELECT bp.id " \
            "FROM build_project bp " \
            "WHERE bp.info_project_id = %s " \
            "AND bp.id > %s " \
            "ORDER BY id LIMIT 1"
    query_data = (post_info_project_id, last_bpid_of_build_snapshot)
    post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] post_build_project_id(%s)\n' \
          % (__file__, post_build_project_id)

    # use the prev last_bpid if there is no post_build_project_id
    if post_build_project_id == 0:
        print '[%s] post_build_project_id is (%s)!! use the previous last_bpid(%s)\n' % \
              (__file__, post_build_project_id, last_bpid_of_build_snapshot)
        post_build_project_id = last_bpid_of_build_snapshot

    # get multi_sr_status_id
    query = "SELECT sr_status_id FROM sr_status_detail WHERE post_build_project_id = %s"
    query_data = (post_build_project_id,)
    multi_sr_status_id = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
    #print '[%s] post_info_project_id(%s), post_build_project_id(%d), multi_sr_status_id(%s)\n' \
    #      % (__file__, post_info_project_id, post_build_project_id, multi_sr_status_id)

    ### [POST_BUILD] end / [POST_SNAP/POST_IMAGE] start : [post] snapshot creation
    for each_sr_status_id in multi_sr_status_id:
        print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)
        info_stage_id = POST_BUILD
        bm_end_datetime = datetime.datetime.now()
        query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (bm_end_datetime, 'S',
                      each_sr_status_id[0], info_stage_id, post_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        info_stage_id = POST_SNAP
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, " \
                "stage_start_time, stage_end_time, stage_status, build_project_id) " \
                "VALUES(%s, %s, %s, %s, %s, %s)"
        query_data = (each_sr_status_id[0], info_stage_id,
                      bm_start_datetime, bm_end_datetime, 'R', post_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        info_stage_id = POST_IMAGE
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, " \
                "stage_start_time, stage_end_time, stage_status, build_project_id) " \
                "VALUES(%s, %s, %s, %s, %s, %s)"
        query_data = (each_sr_status_id[0], info_stage_id,
                      bm_start_datetime, bm_end_datetime, 'R', post_build_project_id)
        buildmonitor_db.do_query(query, query_data)

def start_create_snapshot_for_post_build_snapshot(project, bm_snapshot_name,
                                                  bm_start_datetime):
    print '[%s] enter start_create_snapshot_for_post_build_snapshot\n' % (__file__)

    # get post_info_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    post_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get last_bpid_of_build_snapshot
    query = "SELECT bp.id " \
            "FROM build_project bp, info_project ip, build_snapshot bs " \
            "WHERE ip.project_name = %s " \
            "AND ip.id = bp.info_project_id " \
            "AND bp.id = bs.build_project_id " \
            "ORDER BY id desc LIMIT 1"
    query_data = (project,)
    last_bpid_of_build_snapshot = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] last_bpid_of_build_snapshot(%s)\n' \
          % (__file__, last_bpid_of_build_snapshot)

    # get post_build_project_id
    query = "SELECT bp.id " \
            "FROM build_project bp " \
            "WHERE bp.info_project_id = %s " \
            "AND bp.id > %s " \
            "ORDER BY id LIMIT 1"
    query_data = (post_info_project_id, last_bpid_of_build_snapshot)
    post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] post_build_project_id(%s)\n' \
          % (__file__, post_build_project_id)

    # use the prev last_bpid if there is no post_build_project_id
    if post_build_project_id == 0:
        print '[%s] post_build_project_id is (%s)!! use the previous last_bpid(%s)\n' % \
              (__file__, post_build_project_id, last_bpid_of_build_snapshot)
        post_build_project_id = last_bpid_of_build_snapshot

    # insert new post_build_project_id
    query = "INSERT INTO build_snapshot (build_project_id, snapshot_name, " \
            "start_time, status) VALUES(%s, %s, %s, %s)"
    query_data = (post_build_project_id, bm_snapshot_name, bm_start_datetime, 'R')
    buildmonitor_db.do_query(query, query_data)

def create_snapshot_packages_for_post_build_snapshot_package(bm_snapshot_name,
                                                             bm_repo, bm_arch,
                                                             bm_pkg_url,
                                                             bm_pkg_name_lst,
                                                             bm_pkg_mdate_lst,
                                                             bm_pkg_size_lst):
    print '[%s] enter create_snapshot_packages_for_post_build_snapshot_package\n' % (__file__)

    # get curr_build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE snapshot_name = %s"
    query_data = (bm_snapshot_name,)
    curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] curr_build_snapshot_id(%s)\n' % (__file__, curr_build_snapshot_id)


    # bulk insert
    query = "INSERT INTO build_snapshot_package (build_snapshot_id, repository, arch, " \
            "package_name, created_date, package_size, package_url) " \
            "VALUES(%s, %s, %s, %s, %s, %s, %s)"

    query_list = []
    for each_pkg_name, each_pkg_mdate, each_pkg_size in zip(bm_pkg_name_lst, bm_pkg_mdate_lst, bm_pkg_size_lst):
        timestamp = datetime.datetime.fromtimestamp(each_pkg_mdate)
        # post build
        #print '[%s] curr_build_snapshot_id(%s), each_pkg_name(%s), timestamp(%s), each_pkg_size(%s)\n' \
        #      % (__file__, curr_build_snapshot_id, each_pkg_name, timestamp, each_pkg_size)
        query_list.append((curr_build_snapshot_id, bm_repo, bm_arch,
                           each_pkg_name, timestamp, each_pkg_size, bm_pkg_url))

    buildmonitor_db.do_many_query(query, query_list)

def end_create_snapshot_create_images_for_sr_stage(bm_snapshot_name,
                                                   bm_start_datetime,
                                                   bm_end_datetime):
    print '[%s] enter end_create_snapshot_create_images_for_sr_stage\n' % (__file__)

    ### [POST_SNAP/POST_IMAGE] end : [post] snapshot creation / [post] image creation

    # get post_build_project_id by using bm_snapshot_name
    query = "SELECT build_project_id FROM build_snapshot WHERE snapshot_name = %s"
    query_data = (bm_snapshot_name,)
    post_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    print '[%s] post_build_project_id(%s)\n' % (__file__, post_build_project_id)

    # get multi_sr_status_id
    query = "SELECT sr_status_id FROM sr_status_detail WHERE post_build_project_id = %s"
    query_data = (post_build_project_id,)
    multi_sr_status_id = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
    #print '[%s] multi_sr_status_id(%s)\n' \
    #      % (__file__, multi_sr_status_id)

    for each_sr_status_id in multi_sr_status_id:
        print '[%s] each_sr_status_id(%s)\n' % (__file__, each_sr_status_id)

        ### [POST_SNAP] stage end : update 'S' status
        sr_stage_status = 'S'
        info_stage_id = POST_SNAP
        query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (bm_end_datetime, sr_stage_status,
                      each_sr_status_id[0], info_stage_id, post_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### [POST_IMAGE] stage end : update 'S' or 'R' status
        if 'base' in bm_snapshot_name.lower():
            sr_stage_status = 'S'
            print '[%s] This is [Base] project!! sr_stage_status(%s)\n' \
                  % (__file__, sr_stage_status)
        else:
            sr_stage_status = 'R'

        info_stage_id = POST_IMAGE
        query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (bm_end_datetime, sr_stage_status,
                      each_sr_status_id[0], info_stage_id, post_build_project_id)
        buildmonitor_db.do_query(query, query_data)

def end_create_snapshot_for_post_build_snapshot(bm_end_datetime,
                                                bm_snapshot_url,
                                                bm_snapshot_name):
    print '[%s] enter end_create_snapshot_for_post_build_snapshot\n' % (__file__)

    # update the build_snapshot data
    query = "UPDATE build_snapshot SET snapshot_url = %s, " \
            "end_time = %s, status = %s WHERE snapshot_name = %s"
    query_data = (bm_snapshot_url, bm_end_datetime, 'S', bm_snapshot_name)
    buildmonitor_db.do_query(query, query_data)

def update_sr_submit_log(sr_submit_log_id, sr_tag, status, status_reason):
    print "[%s] update_str_submit_log %s, %s, %s\n" % (__file__, sr_submit_log_id, sr_tag, status_reason)

    query = "UPDATE sr_submit_log SET status=%s,sr_tag=%s,reason=%s WHERE id=%s"
    query_data = (status, sr_tag, status_reason, sr_submit_log_id)
    buildmonitor_db.do_query(query, query_data)

def update_sr_submit_log_completed(git_tag):
    print "[%s] update_sr_submit_log_completed %s\n" % (__file__, git_tag)

    query = "UPDATE sr_submit_log SET status='Completed' WHERE sr_tag=%s ORDER BY id DESC LIMIT 1"
    query_data = (git_tag,)
    buildmonitor_db.do_query(query, query_data)

def update_repa(sr_tag, profile, status, status_reason):
    print "[%s] update_repa %s, %s, %s, %s\n", (__file__, sr_tag, profile, status, status_reason)

    query = "UPDATE sr_accept_log SET status=%s,status_reason=%s WHERE sr=%s AND profile=%s ORDER BY id DESC LIMIT 1"
    query_data = (status, status_reason, sr_tag, profile)
    buildmonitor_db.do_query(query, query_data)

def update_build_log(content):
    project = content.get('project')
    repo = content.get('repo')
    base_url = content.get('base_url')
    pkgs = content.get('pkgs')

    print "[%s] update build log %s %s %s\n" % (__file__, project, repo, base_url)
    query = "SELECT bt.id, ipa.id, bt.arch, ipa.package_name "+ \
        "FROM info_project ip, build_project bp, build_target bt, info_package ipa "+\
        "WHERE bp.info_project_id = ip.id "+ \
        "AND bt.build_project_id = bp.id "+\
        "AND ipa.info_project_id = ip.id "+\
        "AND ip.project_name = %s "+ \
        "AND bt.repository = %s ORDER BY bt.id"
    query_data = (project, repo)
    rows = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
    id_data = {}
    for row in rows:
        if len(row) == 1:
            raise LocalError("Got no data! exiting...\n")
        build_target_id = row[0]
        info_package_id = row[1]
        arch = row[2]
        package_name = row[3]

        if arch not in id_data:
            id_data[arch] = {}
        if package_name not in id_data[arch]:
            id_data[arch][package_name] = {}

        id_data[arch][package_name]['bt_id'] = build_target_id
        id_data[arch][package_name]['ipa_id'] = info_package_id

    for arch in pkgs.keys():
        for pkg in pkgs[arch].keys():
            build_log_url = os.path.join(base_url, pkgs[arch][pkg])
            print '[%s] build_log %s %s %s\n' % (__file__, arch, pkg, build_log_url)
            query = "UPDATE build_package SET build_log_url=%s WHERE build_target_id=%s AND info_package_id=%s"
            build_target_id = id_data[arch][pkg]['bt_id']
            info_package_id = id_data[arch][pkg]['ipa_id']
            query_data = (build_log_url, build_target_id, info_package_id)
            buildmonitor_db.do_query(query, query_data)

def update_release_snapshot(content):
    snapshot = content.get('snapshot_name')
    release_type = content.get('release_type')
    version = content.get('version')

    print "update snapshot %s as a %s release with version %s" % (snapshot, release_type, version)
    query = "UPDATE build_snapshot SET {release_type}=%s WHERE snapshot_name=%s".format(release_type=release_type)
    query_data = (version, snapshot)
    buildmonitor_db.do_query(query, query_data)

def update_unresolvable_broken_packages(project, unresolvable_broken_packages):

    if unresolvable_broken_packages is None:
        return

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s ORDER BY id DESC LIMIT 1"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    for repo in unresolvable_broken_packages:
        for arch in unresolvable_broken_packages[repo]:
            for p in unresolvable_broken_packages[repo][arch]:
                status = unresolvable_broken_packages[repo][arch][p]

                # INSERT build_target_id if not present
                query = "SELECT id FROM build_target WHERE build_project_id=%s AND repository=%s "\
                        "AND arch=%s ORDER BY id DESC LIMIT 1"
                query_data = (curr_build_project_id, repo, arch)
                curr_build_target_id = buildmonitor_db.get_value_from_query_data(query, query_data)

                if curr_build_target_id == INVALID_ID:
                    query = "INSERT INTO build_target (build_project_id, repository, arch, "\
                            "start_time, end_time, status, status_reason, last_flag) "\
                            "VALUES (%s, %s, %s, NOW(), NOW(), 'S', '', 'Y')"
                    query_data = (curr_build_project_id, repo, arch)
                    buildmonitor_db.do_query(query, query_data)

                    query = "SELECT id FROM build_target WHERE build_project_id=%s AND repository=%s "\
                            "AND arch=%s ORDER BY id DESC LIMIT 1"
                    query_data = (curr_build_project_id, repo, arch)
                    curr_build_target_id = buildmonitor_db.get_value_from_query_data(query, query_data)

                # INSERT package if package is not present.
                query = "SELECT id FROM info_package WHERE info_project_id=%s AND package_name=%s "\
                        "AND active_flag='Y' ORDER BY id DESC LIMIT 1"
                query_data = (curr_info_project_id, p)
                curr_info_package_id = buildmonitor_db.get_value_from_query_data(query, query_data)

                if curr_info_package_id == INVALID_ID:
                    query = "INSERT INTO info_package (info_project_id,package_name,description,"\
                            "latest_sr_status_id,active_flag) VALUES (%s, %s, %s, %s, %s)"
                    query_data = (curr_info_project_id, p, "", 0, 'Y')
                    buildmonitor_db.do_query(query, query_data)

                    query = "SELECT id FROM info_package WHERE info_project_id=%s AND package_name=%s "\
                            "AND active_flag='Y' ORDER BY id DESC LIMIT 1"
                    query_data = (curr_info_project_id, p)
                    curr_info_package_id = buildmonitor_db.get_value_from_query_data(query, query_data)

                query = "INSERT INTO build_package (build_target_id, info_package_id, start_time," \
                        "end_time, build_status) "\
                        "VALUES (%s, %s, NOW(), NOW(), %s)"
                query_data = (curr_build_target_id, curr_info_package_id, status)
                buildmonitor_db.do_query(query, query_data)

#===============================================================================
# [TRBS][job_submit.py]

def TRBS_start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                      bm_end_datetime, trbs_build_project_id):
    print '[%s] enter TRBS_start_pre_build_for_sr_stage\n' % (__file__)

    # get current_sr_status_id (should be here after sr_submit_for_sr_status)
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    ### [SR_SUBMIT] end stage : SR submit
    info_stage_id = SR_SUBMIT
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, 'S', curr_sr_status_id, info_stage_id, trbs_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    ### [TRBS_BUILD] start stage : [trbs] package build
    bm_start_datetime = bm_end_datetime
    info_stage_id = TRBS_BUILD
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime, 'R', trbs_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def TRBS_sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                           bm_end_datetime, trbs_build_project_id):
    print '[%s] enter TRBS_sr_submit_for_sr_stage\n' % (__file__)

    ### [SR_SUBMIT] SR submit
    info_stage_id = SR_SUBMIT
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_end_time, stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_start_datetime,
                  bm_end_datetime, 'S', trbs_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def TRBS_package_build_for_sr_detail_sr_stage(git_tag, bm_start_datetime,
                                         bm_end_datetime, bm_src_project_lst):
    print '[%s] enter TRBS_package_build_for_sr_detail_sr_stage\n' % (__file__)

    # get current_sr_status_id (should be here after sr_submit_for_sr_status)
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id(%s)\n' % (__file__, curr_sr_status_id)

    # Wait 60 seconds to find the info_project_id
    print '[%s] wait 60 sec\n' % (__file__)
    sleep(60)

    ### for sr_status_detail & sr_stage
    # bm_src_project_lst is needed for multi profile
    print '[%s] bm_src_project_lst(%s)\n' % (__file__, bm_src_project_lst)
    for bm_src_project in bm_src_project_lst:
        #print '[%s] bm_src_project(%s)\n' % (__file__, bm_src_project)

        # get info_project_id -> get trbs_build_project_id
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_src_project,)
        info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (info_project_id,)
        trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        print '[%s] info_project_id(%s), trbs_build_project_id(%s)\n' \
               % (__file__, info_project_id, trbs_build_project_id)

        # defensive code for the duplicated build_project_id
        if trbs_build_project_id == INVALID_ID:
            print '[%s] cannot find build_project_id!! Adding NOW!!\n' % (__file__)
            query = "INSERT INTO build_project (info_project_id, status) VALUES(%s, %s)"
            query_data = (info_project_id, 'C')
            buildmonitor_db.do_query(query, query_data)
            query = "SELECT id FROM build_project WHERE info_project_id = %s"
            query_data = (info_project_id,)
            trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
            print '[%s][After] info_project_id(%s), trbs_build_project_id(%s)\n' \
                   % (__file__, info_project_id, trbs_build_project_id)

        # get sr_status_detail_id for checking group submit
        query = "SELECT id FROM sr_status_detail WHERE sr_status_id = %s " \
                "AND trbs_build_project_id = %s"
        query_data = (curr_sr_status_id, trbs_build_project_id)
        sr_status_detail_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s] sr_status_detail_id(%s)\n' % (__file__, sr_status_detail_id)

        if sr_status_detail_id == INVALID_ID:
            # get trbs_build_project_id
            query = "SELECT id FROM build_project WHERE info_project_id = %s"
            query_data = (info_project_id,)
            trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

            ### for sr_status_detail
            query = "INSERT INTO sr_status_detail (sr_status_id, trbs_build_project_id) " \
                    "VALUES(%s, %s)"
            query_data = (curr_sr_status_id, trbs_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            ### for sr_stage for multi profile
            # [SR_SUBMIT] start stage
            TRBS_sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                                   bm_end_datetime, trbs_build_project_id)
            # [SR_SUBMIT] end stage / [TRBS_BUILD] start stage
            TRBS_start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                         bm_end_datetime, trbs_build_project_id)
        else:
            # clear the existing tables (sr_stage & build_snapshot)
            print '[%s] Already existing sr_status_id(%s)!! clear the related tables\n' \
                  % (__file__, sr_status_detail_id)
            query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND build_project_id = %s"
            query_data = (curr_sr_status_id, trbs_build_project_id)
            buildmonitor_db.do_query(query, query_data)

            # get build_snapshot_id for deleting build_snapshot_package & build_image
            query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
            query_data = (trbs_build_project_id,)
            build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)

            # delete build_snapshot & build_snapshot_package & build_image
            query = "DELETE FROM build_snapshot WHERE build_project_id = %s"
            query_data = (trbs_build_project_id,)
            buildmonitor_db.do_query(query, query_data)
            query = "DELETE FROM build_snapshot_package WHERE build_snapshot_id = %s"
            query_data = (build_snapshot_id,)
            buildmonitor_db.do_query(query, query_data)
            query = "DELETE FROM build_image WHERE build_snapshot_id = %s"
            query_data = (build_snapshot_id,)
            buildmonitor_db.do_query(query, query_data)

            ### for sr_stage for multi profile
            # [SR_SUBMIT] start stage
            TRBS_sr_submit_for_sr_stage(curr_sr_status_id, bm_start_datetime,
                                        bm_end_datetime, trbs_build_project_id)
            # [SR_SUBMIT] end stage / [TRBS_BUILD] start stage
            TRBS_start_pre_build_for_sr_stage(git_tag, bm_start_datetime,
                                              bm_end_datetime, trbs_build_project_id)

#===============================================================================
# [TRBS][job_pre_release_obs.py]

def TRBS_update_fail_status_for_sr_stage(project, bm_git_tag):
    print '[%s] enter TRBS_update_fail_status_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_sr_status_id (%s)\n' % (__file__, curr_sr_status_id)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### [TRBS_SNAP] stage end : update fail status [trbs] snapshot creation
    info_stage_id = TRBS_SNAP
    query = "UPDATE sr_stage SET stage_status = %s WHERE sr_status_id = %s " \
            "AND info_stage_id = %s AND build_project_id = %s"
    query_data = ('F', curr_sr_status_id, info_stage_id, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def TRBS_start_pre_create_snapshot_for_sr_stage(project, bm_git_tag, bm_start_datetime, bBuildFail):
    print '[%s] enter TRBS_start_pre_create_snapshot_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    print '[%s] bBuildFail(%s)\n' % (__file__, bBuildFail)
    if bBuildFail == True:
        info_stage_status = 'F'
    else:
        info_stage_status = 'S'

    ### [TRBS_BUILD] stage end : [trbs] package build
    info_stage_id = TRBS_BUILD
    bm_end_datetime = bm_start_datetime
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, info_stage_status, curr_sr_status_id,
                  info_stage_id, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    if info_stage_status == 'S':
        ### [TRBS_SNAP] stage start : [trbs] snapshot creation
        info_stage_id = TRBS_SNAP
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
        query_data = (curr_sr_status_id, info_stage_id,
                      bm_start_datetime, 'R', curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] Build failed!! skip [TRBS_SNAP] stage start\n' \
              % (__file__)

def TRBS_start_pre_create_snapshot_for_build_snapshot(project, bm_git_tag, bm_start_datetime):
    print '[%s] enter TRBS_start_pre_create_snapshot_for_build_snapshot\n' % (__file__)

    # get pre_info_project_id -> get trbs_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    pre_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (pre_info_project_id,)
    trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] pre_info_project_id(%s), trbs_build_project_id(%s)\n' \
    #      % (__file__, pre_info_project_id, trbs_build_project_id)

    ### to check duplicate build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
    query_data = (trbs_build_project_id,)
    trbs_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### for build_snapshot
    if trbs_build_snapshot_id == INVALID_ID:
        query = "INSERT INTO build_snapshot (build_project_id, start_time, status) " \
                "VALUES(%s, %s, %s)"
        query_data = (trbs_build_project_id, bm_start_datetime, 'R')
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] duplicated build_snapshot_id!! skip insert & clear tables\n' \
              % (__file__)

        ### clear build_snapshot_package & build_image tables
        query = "DELETE FROM build_snapshot_package WHERE build_snapshot_id = %s"
        query_data = (trbs_build_snapshot_id,)
        buildmonitor_db.do_query(query, query_data)
        query = "DELETE FROM build_image WHERE build_snapshot_id = %s"
        query_data = (trbs_build_snapshot_id,)
        buildmonitor_db.do_query(query, query_data)

        # get curr_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        ### [TRBS_SNAP] stage remove : [trbs] snapshot creation
        info_stage_id = TRBS_SNAP
        query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (curr_sr_status_id, info_stage_id, trbs_build_project_id)
        buildmonitor_db.do_query(query, query_data)
        ### [TRBS_IMAGE] stage remove : [trbs] image creation
        info_stage_id = TRBS_IMAGE
        query = "DELETE FROM sr_stage WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (curr_sr_status_id, info_stage_id, trbs_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### [TRBS_SNAP] stage restart : [trbs] snapshot creation
        info_stage_id = TRBS_SNAP
        query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
                "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
        query_data = (curr_sr_status_id, info_stage_id,
                      bm_start_datetime, 'R', trbs_build_project_id)
        buildmonitor_db.do_query(query, query_data)

def TRBS_create_snapshot_packages_for_build_snapshot_package(project, bm_repo, bm_arch,
                                                        bm_pkg_url,
                                                        bm_pkg_name_lst,
                                                        bm_pkg_mdate_lst,
                                                        bm_pkg_size_lst,
                                                        bm_trg_count,
                                                        bm_pkg_count,
                                                        BM_PKG_LIMIT):
    print '[%s] enter TRBS_create_snapshot_packages_for_build_snapshot_package\n' % (__file__)

    # get trbs_info_project_id -> get trbs_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    trbs_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (trbs_info_project_id,)
    trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] trbs_info_project_id(%s), trbs_build_project_id(%s)\n' \
    #      % (__file__, trbs_info_project_id, trbs_build_project_id)

    # get curr_build_snapshot_id
    query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
    query_data = (trbs_build_project_id,)
    curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] curr_build_snapshot_id(%s)\n' % (__file__, curr_build_snapshot_id)

    # bulk insert
    query = "INSERT INTO build_snapshot_package (build_snapshot_id, repository, " \
            "arch, package_name, created_date, package_size, package_url) " \
            "VALUES(%s, %s, %s, %s, %s, %s, %s)"

    query_list = []
    for each_pkg_name, each_pkg_mdate, each_pkg_size in zip(bm_pkg_name_lst, bm_pkg_mdate_lst, bm_pkg_size_lst):
        timestamp = datetime.datetime.fromtimestamp(each_pkg_mdate)
        #print '[%s] each_pkg_name(%s), timestamp(%s), each_pkg_size(%s)' \
        #      % (__file__, each_pkg_name, timestamp, each_pkg_size)
        query_list.append((curr_build_snapshot_id, bm_repo, bm_arch,
                           each_pkg_name, timestamp, each_pkg_size, bm_pkg_url))

    buildmonitor_db.do_many_query(query, query_list)

def TRBS_end_pre_create_snapshot_for_sr_stage(project, bm_git_tag,
                                         bm_start_datetime, bm_end_datetime):
    print '[%s] enter TRBS_end_pre_create_snapshot_for_sr_stage\n' % (__file__)

    # get curr_sr_status_id
    query = "SELECT id FROM sr_status WHERE sr = %s"
    query_data = (bm_git_tag,)
    curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    # get curr_info_project_id -> get curr_build_project_id for multi profile
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (curr_info_project_id,)
    curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

    ### [TRBS_SNAP] stage end : [trbs] snapshot creation
    info_stage_id = TRBS_SNAP
    query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
            "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
    query_data = (bm_end_datetime, 'S', curr_sr_status_id,
                  info_stage_id, curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

    ### [TRBS_IMAGE] stage start : [trbs] image creation
    info_stage_id = TRBS_IMAGE
    query = "INSERT INTO sr_stage (sr_status_id, info_stage_id, stage_start_time, " \
            "stage_status, build_project_id) VALUES(%s, %s, %s, %s, %s)"
    query_data = (curr_sr_status_id, info_stage_id, bm_end_datetime,
                  'R', curr_build_project_id)
    buildmonitor_db.do_query(query, query_data)

def TRBS_end_pre_create_snapshot_for_build_snapshot(project, bm_snapshot_name,
                                                    bm_snapshot_url, bm_snapshot_num,
                                                    bm_end_datetime):
    print '[%s] enter TRBS_end_pre_create_snapshot_for_build_snapshot\n' % (__file__)

    # get trbs_info_project_id -> get trbs_build_project_id
    query = "SELECT id FROM info_project WHERE project_name = %s"
    query_data = (project,)
    trbs_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    query = "SELECT id FROM build_project WHERE info_project_id = %s"
    query_data = (trbs_info_project_id,)
    trbs_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
    #print '[%s] trbs_info_project_id(%s), trbs_build_project_id(%s)\n' \
    #      % (__file__, trbs_info_project_id, trbs_build_project_id)

    ### for build_snapshot
    query = "UPDATE build_snapshot SET snapshot_name = %s, snapshot_url = %s, " \
            "snapshot_num = %s, end_time = %s, status = %s WHERE build_project_id = %s"
    query_data = (bm_snapshot_name, bm_snapshot_url, bm_snapshot_num,
                  bm_end_datetime, 'S', trbs_build_project_id)
    buildmonitor_db.do_query(query, query_data)

#===============================================================================
# [TRBS][job_imager.py]

def TRBS_update_fail_create_image_for_sr_stage(fields, bm_start_datetime):
    print '[%s] enter TRBS_update_fail_create_image_for_sr_stage\n' % (__file__)

    bm_prj_name = fields["project"]
    bm_split_data = fields["project"].split(':')[-1]
    bm_branch_name = fields["project"].split(':')[-2]
    bm_git_tag = 'submit/' + bm_branch_name + '/' + bm_split_data
    bm_url = os.path.join(fields.get('url_pub_base', ''),
                           fields['repo_path'], fields['images_path'])
    #print '[%s] bm_prj_name(%s), bm_split_data(%s), bm_git_tag(%s), bm_url(%s)\n' \
    #      % (__file__, bm_prj_name, bm_split_data, bm_git_tag, bm_url)

    bm_end_datetime = datetime.datetime.now()
    bm_repo = fields["repo"]
    bm_device_name = fields["name"]

    #if 'prerelease' in bm_url:
    if not ((bm_url.find("prerelease")) == -1) or not ((bm_url.find("trbs")) == -1):
        # [trbs_build] get current_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s][trbs_build] info_stage_id(%s), query_data(%s), curr_sr_status_id(%s)\n' \
        #      % (__file__, info_stage_id, query_data, curr_sr_status_id)

        # get curr_info_project_id -> get curr_build_project_id for multi profile
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (bm_prj_name,)
        curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (curr_info_project_id,)
        curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        ### [TRBS_IMAGE] stage : update fail status for [trbs] image creation
        info_stage_id = TRBS_IMAGE
        query = "UPDATE sr_stage SET stage_start_time = %s, stage_end_time = %s, stage_status = %s " \
                "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
        query_data = (bm_start_datetime, bm_end_datetime, 'F',
                      curr_sr_status_id, info_stage_id, curr_build_project_id)
        buildmonitor_db.do_query(query, query_data)

        ### build_image : update fail status for [trbs] image creation
        # get curr_build_snapshot_id
        query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
        query_data = (curr_build_project_id,)
        curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        # update fail status
        query = "UPDATE build_image SET end_time = %s, status = %s " \
                "WHERE build_snapshot_id = %s AND repository = %s AND device_name = %s"
        query_data = (bm_end_datetime, 'F',
                      curr_build_snapshot_id, bm_repo, bm_device_name)
        buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] There is no postrelease stage in TRBS system\n' \
              % (__file__)

#===============================================================================
# [TRBS][job_post_image.py]

def TRBS_end_create_image_for_sr_stage(bm_start_datetime, project):
    print '[%s] enter TRBS_end_create_image_for_sr_stage project(%s)\n' % (__file__, project)

    if project.startswith("home:prerelease:") or project.startswith("home:trbs:"):
        bm_end_datetime = datetime.datetime.now()
        bm_git_tag = project.split(":")[-3] + '/' + project.split(":")[-2] + '/' + project.split(":")[-1]
        #print '[%s] bm_git_tag(%s)\n' % (__file__, bm_git_tag)

        # [trbs_build] get current_sr_status_id
        query = "SELECT id FROM sr_status WHERE sr = %s"
        query_data = (bm_git_tag,)
        curr_sr_status_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        #print '[%s][trbs_build] query_data(%s), curr_sr_status_id(%s)\n' \
        #      % (__file__, query_data, curr_sr_status_id)

        # get curr_info_project_id -> get curr_build_project_id for multi profile
        query = "SELECT id FROM info_project WHERE project_name = %s"
        query_data = (project,)
        curr_info_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        query = "SELECT id FROM build_project WHERE info_project_id = %s"
        query_data = (curr_info_project_id,)
        curr_build_project_id = buildmonitor_db.get_value_from_query_data(query, query_data)

        # get curr_build_snapshot_id
        query = "SELECT id FROM build_snapshot WHERE build_project_id = %s"
        query_data = (curr_build_project_id,)
        curr_build_snapshot_id = buildmonitor_db.get_value_from_query_data(query, query_data)
        # get multi_build_image_status
        query = "SELECT status FROM build_image WHERE build_snapshot_id = %s"
        query_data = (curr_build_snapshot_id,)
        multi_build_image_status = buildmonitor_db.get_multi_values_from_query_data(query, query_data)
        print '[%s] multi_build_image_status(%s)\n' % (__file__, multi_build_image_status)

        isFailed = 0
        for each_build_image_status in multi_build_image_status:
            #print '[%s] each_build_image_status(%s)\n' % (__file__, each_build_image_status)
            if each_build_image_status[0] == 'F':
                isFailed = 1
                print '[%s] isFailed(%s)!! skip updating the sr_stage\n' % (__file__, isFailed)

        if isFailed == 0:
            ### [TRBS_IMAGE] stage : [trbs] image creation
            info_stage_id = TRBS_IMAGE
            query = "UPDATE sr_stage SET stage_end_time = %s, stage_status = %s " \
                    "WHERE sr_status_id = %s AND info_stage_id = %s AND build_project_id = %s"
            query_data = (bm_end_datetime, 'S',
                          curr_sr_status_id, info_stage_id, curr_build_project_id)
            buildmonitor_db.do_query(query, query_data)
    else:
        print '[%s] There is no postrelease stage in TRBS system\n' \
              % (__file__)

#==================================================================================
def main():
    """
    Script entry point.
    """
    bm_connect_db()

    # prevent base64 decoding error when triggered by the remote host
    trigger_info_data = os.getenv('TRIGGER_INFO').replace(' ', '+')

    if trigger_info_data:
        content = trigger_info(trigger_info_data)
    else:
        print '[%s] trigger_info_data is empty!!(%s)\n' \
              % (__file__, trigger_info_data)
        return 1

    bm_stage = content.get("bm_stage")

    #=======================================================
    # Add_Tag
    if bm_stage == "Add_Tag":
        print '[%s][Add_Tag]\n' % (__file__)
        sr_submit_log_id = content.get("sr_submit_log_id")
        sr_tag = content.get("sr_tag")
        status = content.get("status")
        status_reason = content.get("status_reason")

        update_sr_submit_log(sr_submit_log_id, sr_tag, status, status_reason)

    #=======================================================
    # Submit
    elif bm_stage == 'Submit' or bm_stage == '[TRBS]_Submit':
        print '[%s][Submit]\n' % (__file__)

        # get vars
        commit_date = transform_date(content.get("commit_date"))
        commit_msg = truncate_msg(content.get("commit_msg"))
        submit_date = transform_date(content.get("submit_date"))
        submit_msg = truncate_msg(content.get("submit_msg"))
        submitter = content.get("submitter")
        git_tag = content.get("git_tag")
        gerrit_project = content.get("gerrit_project")
        gerrit_newrev = content.get("gerrit_newrev")
        gerrit_account_name = content.get("gerrit_account_name")
        bm_start_datetime = content.get("bm_start_datetime")
        bm_end_datetime = content.get("bm_end_datetime")
        #bm_src_project_lst = get_src_proj_lst(content.get("bm_src_project_lst"))
        bm_src_project_lst = content.get("bm_src_project_lst")

        '''
        # empty check
        if not bm_src_project_lst:
            print '[%s] bm_src_project_lst is empty, skip Submit stage!!\n' \
                  % (__file__)
            return
        '''

        # func call
        ### sr_status -> sr_commit -> sr_stage & sr_status_detail
        sr_submit_for_sr_status(git_tag)
        sr_submit_for_sr_commit(commit_date, commit_msg, submit_date, submit_msg,
                                submitter, git_tag, gerrit_project,
                                gerrit_newrev, gerrit_account_name)

        if bm_stage == 'Submit':
            print '[%s][Submit]\n' % (__file__)
            package_build_for_sr_detail_sr_stage(git_tag, bm_start_datetime,
                                                 bm_end_datetime,
                                                 bm_src_project_lst)
        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Submit':
            print '[%s][[TRBS]_Submit]\n' % (__file__)
            TRBS_package_build_for_sr_detail_sr_stage(git_tag, bm_start_datetime,
                                                      bm_end_datetime,
                                                      bm_src_project_lst)

        update_sr_submit_log_completed(git_tag)

    #=======================================================
    # [PRE] Build
    #=======================================================
    # [PRE] Snap
    elif bm_stage == 'Pre_Snap_Start' or bm_stage == '[TRBS]_Pre_Snap_Start':
        print '[%s][Pre_Snap_Start]\n' % (__file__)

        # get vars
        project = content.get("project")
        bm_git_tag = content.get("bm_git_tag")
        bm_start_datetime = content.get("bm_start_datetime")
        bBuildFail = content.get("bBuildFail")
        unresolvable_broken_packages = content.get("unresolvable_broken_packages")

        # func call
        if bm_stage == 'Pre_Snap_Start':
            print '[%s][Pre_Snap_Start]\n' % (__file__)
            start_pre_create_snapshot_for_sr_stage(project, bm_git_tag, bm_start_datetime, bBuildFail)

        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Pre_Snap_Start':
            print '[%s][[TRBS]_Pre_Snap_Start]\n' % (__file__)
            TRBS_start_pre_create_snapshot_for_sr_stage(project, bm_git_tag, bm_start_datetime, bBuildFail)

        # if bBuildFail is True then skip Creating images
        if bBuildFail != True:
            if bm_stage == 'Pre_Snap_Start':
                start_pre_create_snapshot_for_build_snapshot(project, bm_git_tag, bm_start_datetime)

            # [17_0110] TRBS
            if bm_stage == '[TRBS]_Pre_Snap_Start':
                TRBS_start_pre_create_snapshot_for_build_snapshot(project, bm_git_tag, bm_start_datetime)
        else:
            print '[%s] Build failed!! skip insert build_snapshot_id\n' \
                  % (__file__)

        update_unresolvable_broken_packages(project, unresolvable_broken_packages)

    elif bm_stage == 'Pre_Snap_End' or bm_stage == '[TRBS]_Pre_Snap_End':
        print '[%s][Pre_Snap_End]\n' % (__file__)

        # get vars
        project = content.get("project")
        bm_git_tag = content.get("bm_git_tag")
        bm_start_datetime = content.get("bm_start_datetime")
        bm_end_datetime = content.get("bm_end_datetime")
        bm_snapshot_name = content.get("bm_snapshot_name")
        bm_snapshot_url = content.get("bm_snapshot_url")
        bm_snapshot_num = content.get("bm_snapshot_num")


        # func call
        if bm_stage == 'Pre_Snap_End':
            print '[%s][Pre_Snap_End]\n' % (__file__)
            end_pre_create_snapshot_for_sr_stage(project, bm_git_tag,
                                                          bm_start_datetime,
                                                          bm_end_datetime)
            end_pre_create_snapshot_for_build_snapshot(project,
                                                       bm_snapshot_name,
                                                       bm_snapshot_url,
                                                       bm_snapshot_num,
                                                       bm_end_datetime)

        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Pre_Snap_End':
            print '[%s][[TRBS]_Pre_Snap_End]\n' % (__file__)
            TRBS_end_pre_create_snapshot_for_sr_stage(project, bm_git_tag,
                                                               bm_start_datetime,
                                                               bm_end_datetime)
            TRBS_end_pre_create_snapshot_for_build_snapshot(project,
                                                            bm_snapshot_name,
                                                            bm_snapshot_url,
                                                            bm_snapshot_num,
                                                            bm_end_datetime)

    elif bm_stage == 'Pre_Snap_packages' or bm_stage == '[TRBS]_Pre_Snap_packages':
        print '[%s][Pre_Snap_packages]\n' % (__file__)

        # get vars
        project = content.get("project")
        bm_repo = content.get("bm_repo")
        bm_arch = content.get("bm_arch")
        bm_pkg_url = content.get("bm_pkg_url")
        bm_pkg_name_lst = content.get("bm_pkg_name_lst")
        bm_pkg_mdate_lst = content.get("bm_pkg_mdate_lst")
        bm_pkg_size_lst = content.get("bm_pkg_size_lst")
        bm_trg_count = content.get("bm_trg_count ")
        bm_pkg_count = content.get("bm_pkg_count")
        BM_PKG_LIMIT = content.get("BM_PKG_LIMIT ")

        # func call
        if bm_stage == 'Pre_Snap_packages':
            print '[%s][Pre_Snap_packages]\n' % (__file__)
            create_snapshot_packages_for_build_snapshot_package(project, bm_repo, bm_arch,
                                                                bm_pkg_url,
                                                                bm_pkg_name_lst,
                                                                bm_pkg_mdate_lst,
                                                                bm_pkg_size_lst,
                                                                bm_trg_count,
                                                                bm_pkg_count,
                                                                BM_PKG_LIMIT)
        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Pre_Snap_packages':
            print '[%s][[TRBS]_Pre_Snap_packages]\n' % (__file__)
            TRBS_create_snapshot_packages_for_build_snapshot_package(project, bm_repo, bm_arch,
                                                                     bm_pkg_url,
                                                                     bm_pkg_name_lst,
                                                                     bm_pkg_mdate_lst,
                                                                     bm_pkg_size_lst,
                                                                     bm_trg_count,
                                                                     bm_pkg_count,
                                                                     BM_PKG_LIMIT)

    elif bm_stage == 'Pre_Snap_Fail' or bm_stage == '[TRBS]_Pre_Snap_Fail':
        print '[%s][Pre_Snap_Fail]\n' % (__file__)

        # get vars
        project = content.get("project")
        bm_git_tag = content.get("bm_git_tag")

        # func call
        if bm_stage == 'Pre_Snap_Fail':
            print '[%s][Pre_Snap_Fail]\n' % (__file__)
            update_fail_status_for_sr_stage(project, bm_git_tag)

        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Pre_Snap_Fail':
            print '[%s][[TRBS]_Pre_Snap_Fail]\n' % (__file__)
            TRBS_update_fail_status_for_sr_stage(project, bm_git_tag)
    #=======================================================
    # [PRE]/[POST] Image
    elif bm_stage == 'Image' or bm_stage == '[TRBS]_Image':
        print '[%s][Image]\n' % (__file__)

        # get vars
        image_status = content.get("status")
        fields = content.get("fields")
        bm_start_datetime  = content.get("bm_start_datetime")
        bm_end_datetime = content.get("bm_end_datetime")
        bm_snapshot_name = content.get("build_id")
        bm_img_size = content.get("bm_img_size")
        #print '[%s] fields(%s), bm_start_datetime(%s), bm_snapshot_name(%s)\n' \
        #      % (__file__, fields, bm_start_datetime, bm_snapshot_name)

        create_image_for_build_image(fields, bm_start_datetime,
                                     bm_end_datetime, bm_snapshot_name, bm_img_size)

        if image_status == 'failed':
            if bm_stage == 'Image':
                print '[%s][Image]\n' % (__file__)
                update_fail_create_image_for_sr_stage(fields, bm_start_datetime, bm_snapshot_name)

            # [17_0110] TRBS]
            if bm_stage == '[TRBS]_Image':
                print '[%s][[TRBS]_Image]\n' % (__file__)
                TRBS_update_fail_create_image_for_sr_stage(fields, bm_start_datetime)
    #=======================================================
    # [PRE]/[POST] Post_Image
    elif bm_stage == 'Post_Image' or bm_stage == '[TRBS]_Post_Image':
        print '[%s][Post_Image]\n' % (__file__)

        # get vars
        bm_start_datetime = content.get("bm_start_datetime")
        project = content.get("project")

        # func call
        if bm_stage == 'Post_Image':
            print '[%s][Post_Image]\n' % (__file__)
            bm_snapshot_name = content.get("bm_snapshot_name")
            end_create_image_for_sr_stage(bm_start_datetime, project, bm_snapshot_name)

        # [17_0110] TRBS
        if bm_stage == '[TRBS]_Post_Image':
            print '[%s][[TRBS]_Post_Image]\n' % (__file__)
            TRBS_end_create_image_for_sr_stage(bm_start_datetime, project)
    #=======================================================
    # SR Accept or Reject
    elif bm_stage == 'SR_Accept':
        print '[%s][SR_Accept]\n' % (__file__)

        # get vars
        event_fields = content.get("event_fields")
        bm_start_datetime = content.get("bm_start_datetime")
        bm_end_datetime = content.get("bm_end_datetime")
        bm_git_tag = content.get("bm_git_tag")

        # func call
        sr_accept_reject_for_sr_status_detail(event_fields, bm_start_datetime,
                                              bm_end_datetime, bm_git_tag)
    #=======================================================
    # [POST] Build
    #=======================================================
    # [POST] Snap
    elif bm_stage == 'Post_Snap_Start':
        print '[%s][Post_Snap_Start]\n' % (__file__)

        # get vars
        project = content.get("project")
        bm_start_datetime = content.get("bm_start_datetime")
        unresolvable_broken_packages = content.get("unresolvable_broken_packages")

        # func call
        start_create_snapshot_for_sr_stage(project, bm_start_datetime)

        update_unresolvable_broken_packages(project, unresolvable_broken_packages)

    elif bm_stage == 'Post_Snap_snapshot':
        print '[%s][Post_Snap_snapshot]\n' % (__file__)
        project = content.get("project")
        bm_snapshot_name = content.get("bm_snapshot_name")
        bm_start_datetime = content.get("bm_start_datetime")
        start_create_snapshot_for_post_build_snapshot(project,
                                                      bm_snapshot_name,
                                                      bm_start_datetime)
    elif bm_stage == 'Post_Snap_packages':
        print '[%s][Post_Snap_packages]\n' % (__file__)

        # get vars
        bm_snapshot_name = content.get("bm_snapshot_name")
        bm_repo = content.get("bm_repo")
        bm_arch = content.get("bm_arch")
        bm_pkg_url = content.get("bm_pkg_url")
        bm_pkg_name_lst = content.get("bm_pkg_name_lst")
        bm_pkg_mdate_lst = content.get("bm_pkg_mdate_lst")
        bm_pkg_size_lst = content.get("bm_pkg_size_lst")

        # func call
        create_snapshot_packages_for_post_build_snapshot_package(bm_snapshot_name,
                                                                 bm_repo,
                                                                 bm_arch,
                                                                 bm_pkg_url,
                                                                 bm_pkg_name_lst,
                                                                 bm_pkg_mdate_lst,
                                                                 bm_pkg_size_lst)
    elif bm_stage == 'Post_Snap_End':
        print '[%s][Post_Snap_End]\n' % (__file__)

        # get vars
        bm_start_datetime = content.get("bm_start_datetime")
        bm_end_datetime = content.get("bm_end_datetime")
        bm_snapshot_url = content.get("bm_snapshot_url")
        bm_snapshot_name = content.get("bm_snapshot_name")

        # func call
        # for sr_stage & build_snapshot
        end_create_snapshot_create_images_for_sr_stage(bm_snapshot_name,
                                                       bm_start_datetime,
                                                       bm_end_datetime)
        end_create_snapshot_for_post_build_snapshot(bm_end_datetime,
                                                    bm_snapshot_url,
                                                    bm_snapshot_name)
    elif bm_stage == 'Post_Snap_Fail':
        print '[%s][Post_Snap_Fail]\n' % (__file__)
        bm_snapshot_name = content.get("bm_snapshot_name")
        update_fail_create_snapshot_for_sr_stage(bm_snapshot_name)

    elif bm_stage == 'REPA':
        print '[%s][REPA]\n' % (__file__)
        sr_tag = content.get("sr_tag")
        profile = content.get("profile")
        status = content.get("status")
        status_str = content.get("status_reason")

        update_repa(sr_tag, profile, status, status_str)

    elif bm_stage == "UPDATE_BUILD_LOG":
        print "[%s][UPDATE_BUILD_LOG]\n" % (__file__)
        update_build_log(content)

    elif bm_stage == "[TRBS]_UPDATE_BUILD_LOG":
        print "[%s][[TRBS]_UPDATE_BUILD_LOG]\n" % (__file__)
        update_build_log(content)

    elif bm_stage == "RELEASE_SNAPSHOT":
        print "[%s][%s]\n" % (__file__, bm_stage)
        update_release_snapshot(content)

    #=======================================================
    # [POST] Image / Post_Image => N/A
    #=======================================================
    else:
        print 'no bm_stage\n'

    bm_disconnect_db()

if __name__ == '__main__':
    try:
        sys.exit(main())
    except LocalError, err:
        print err
        bm_disconnect_db()
        sys.exit(1)
