#============================================================================ 

#Name        : __init__.py 

#Part of     : Helium 

#Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

#All rights reserved.

#This component and the accompanying materials are made available

#under the terms of the License "Eclipse Public License v1.0"

#which accompanies this distribution, and is available

#at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

#Initial Contributors:

#Nokia Corporation - initial contribution.

#

#Contributors:

#

#Description:

#===============================================================================

""" CM/Synergy Python toolkit.

"""

import logging

import netrc

import os

import re

import subprocess

import sys

import threading

import fileutils

import nokia.gscm

# Uncomment this line to enable logging in this module, or configure logging elsewhere

_logger = logging.getLogger("ccm")

#logging.basicConfig(level=logging.DEBUG)

VALID_OBJECT_STATES = ('working', 'checkpoint', 'public', 'prep', 'integrate', 'sqa', 'test','released')

STATIC_OBJECT_STATES = ('integrate', 'sqa', 'test','released')

CCM_SESSION_LOCK = os.path.join(os.environ['TEMP'], "ccm_session.lock")

def _execute(command, timeout=None):

    """ Runs a command and returns the result data. """

    launcher = os.path.join(os.environ['HELIUM_HOME'], 'tools', 'common', 'python', 'scripts', 'timeout_launcher.py')

    targ = ""

    if timeout is not None:

        targ = "--timeout=%s" % timeout

    process = subprocess.Popen("python %s %s -- %s" % (launcher, targ, command), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)

    stdout = process.communicate()[0]

    process.wait()

    _logger.debug(stdout)

    _logger.debug("Return code: %s" % process.returncode)

    return (stdout, process.returncode)

class CCMException(Exception):

    """ Base exception that should be raised by methods of this framework. """

    def __init__(self, reason, result = None):

        Exception.__init__(self, reason)

        self.result = result

class Result(object):

    """Class that abstracts ccm call result handling.

    Subclass it to implement a new generic output parser.

    """

    def __init__(self, session):

        self._session = session

        self.status = None

        self._output = None

        self._output_str = None

    def _setoutput(self, output):

        self._output = output

    def __setoutput(self, output):

        """ Internal function to allow overloading, you must override _setoutput.

        """

        # the output is automatically converted to ascii before any treatment 

        if isinstance(output, unicode):

            self._output_str = output.encode('ascii', 'replace')

        else:

            self._output_str = output.decode('ascii', 'ignore')

        _logger.debug("output ---->")

        for line in self._output_str.splitlines():

            _logger.debug(line)

        _logger.debug("<----")

        self._setoutput(self._output_str)

    def _getoutput(self):

        """ Returns the content of _output. """

        return self._output

    def __str__(self):

        """ Synergy output log. """

        return self._output_str.encode('ascii', 'replace')

    output = property(_getoutput, __setoutput)

class ResultWithError(Result):

    def __init__(self, session):

        Result.__init__(self, session)

        self._error = None

        self._error_str = None    

    def _seterror(self, error):

        self._error = error

    def __seterror(self, error):

        """ Internal function to allow overloading, you must override _seterror.

        """

        # the error output is automatically converted to ascii before any treatment 

        if isinstance(error, unicode):

            self._error_str = error.encode('ascii', 'replace')

        else:

            self._error_str = error.decode('ascii', 'ignore')

        _logger.debug("error ---->")

        for line in self._error_str.splitlines():

            _logger.debug(line)

        _logger.debug("<----")

        self._seterror(self._error_str)

    def _geterror(self):

        """ Returns the content of _output. """

        _logger.debug("_geterror")

        return self._error

    error = property(_geterror, __seterror)

class ProjectCheckoutResult(Result):

    """ Project checkout output parser. 

        Sets project to the created project or None if failed.

    """

    def __init__(self, session, project):

        Result.__init__(self, session)

        self.__project = project

        self.__result_project = None

    def _setoutput(self, output):

        """ Parsing the output of the checkout command. """

        self._output = output

        for line in output.splitlines():

            mresult = re.match(r"Saved work area options for project: '(.+)'", line, re.I)

            #(?P<name>.+)-(?P<version>.+?)(:(?P<type>\S+):(?P<instance>\S+))?

            if mresult != None:

                #self.__project.name + "-" + mo.groupdict()['version'] + ":" + self.__project.type + ":" + self.__project.instance

                self.__result_project = self._session.create(mresult.group(1))

                _logger.debug("ProjectCheckoutResult: project: '%s'" % self.__result_project)

                return

    def __get_result_project(self):

        """ return the checked out project. """

        return self.__result_project

    project = property(__get_result_project)

class ProjectPurposeResult(Result):

    """ Parses purpose query output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        self._output = {}

        for line in output.splitlines():

            mresult = re.match(r"(?P<purpose>.+?)\s+(?P<member_status>\w+)\s+(?P<status>\w+)$", line)

            if mresult != None:

                data = mresult.groupdict()                

                if re.match(r'^\s+Purpose\s+Member$', data['purpose'], re.I) == None:

                    self._output[data['purpose'].strip()] = {'member_status' : data['member_status'].strip(),

                                                  'status' : data['status'].strip()

                                                  }

class ConflictsResult(Result):

    """ Parses purpose query output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        self._output = {}

        project = None

        for line in output.splitlines():            

            mresult = re.match(r"Project:\s*(.+)\s*$", line)

            if mresult != None:

                project = self._session.create(mresult.group(1))

                self._output[project] = []

            mresult = re.match(r"^(.*)\s+(\w+#\d+)\s+(.+)$", line)

            if mresult != None and project != None:

                self._output[project].append({'object': self._session.create(mresult.group(1)),

                                              'task': self._session.create("Task %s" % mresult.group(2)),

                                              'comment': mresult.group(3)})

            mresult = re.match(r"^(\w+#\d+)\s+(.+)$", line)

            if mresult != None and project != None:

                self._output[project].append({'task': self._session.create("Task %s" % mresult.group(1)),

                                              'comment': mresult.group(2)})

class FinduseResult(Result):

    """ Parses finduse query output. """

    def __init__(self, ccm_object):

        Result.__init__(self, ccm_object.session)

        self.__object = ccm_object

    def _setoutput(self, output):

        self._output = []

        for line in output.splitlines():

            _logger.debug("FinduseResult: ---->%s<----" % line)

            _logger.debug("FinduseResult: ---->%s-%s<----" % (self.__object.name, self.__object.version))

            # MCNaviscroll\NaviAnim-username7@MCNaviscroll-username6            

            mresult = re.match(r"^\s*(?P<path>.+)[\\/]%s-%s@(?P<project>.+)" % (self.__object.name, self.__object.version), line, re.I)

            if mresult != None:

                data = mresult.groupdict()

                _logger.debug("FinduseResult: %s" % data)               

                project = self._session.create(data['project'])

                self._output.append({'path' : data['path'], 'project' : project})

class UpdateTemplateInformation(Result):

    """ Parse update template information output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        """

Baseline Selection Mode: Latest Baseline Projects

Prep Allowed:            No

Versions Matching:       *abs.50*

Release Purposes:

Use by Default:          Yes

Modifiable in Database:  tr1s60

In Use For Release:      Yes

Folder Templates and Folders:

- Template assigned or completed tasks for %owner for release %release

- Template all completed tasks for release %release

- Folder   tr1s60#4844: All completed Xuikon/Xuikon_rel_X tasks

- Folder   tr1s60#4930: All tasks for release AppBaseDo_50        

        """

        self._output = {}

        for line in output.splitlines():

            rmo = re.match(r"^\s*(.+):\s*(.*)\s*", line)

            if rmo != None:

                if rmo.group(1) == "Baseline Selection Mode":

                    self._output['baseline_selection_mode'] = rmo.group(2) 

                elif rmo.group(1) == "Prep Allowed":

                    self._output['prep_allowed'] = (rmo.group(2) != "No") 

                elif rmo.group(1) == "Versions Matching":

                    self._output['version_matching'] = rmo.group(2) 

                elif rmo.group(1) == "Release Purposes":

                    self._output['release_purpose'] = rmo.group(2) 

                elif rmo.group(1) == "Use by Default":

                    self._output['default'] = (rmo.group(2) != "No") 

                elif rmo.group(1) == "Modifiable in Database":

                    self._output['modifiable_in_database'] = rmo.group(2).strip()

                elif rmo.group(1) == "In Use For Release":

                    self._output['in_use_for_release'] = (rmo.group(2) != "No") 

class UpdatePropertiesRefreshResult(Result):

    """ Parse update template refresh output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        self._output = {'added': [], 'removed': []}

        match_added = re.compile(r"^Added the following tasks")

        match_removed = re.compile(r"^Removed the following tasks")

        match_task_new = re.compile(r"^\s+(Task \S+#\d+)")        

        section = None

        for line in output.splitlines():

            res = match_added.match(line)

            if res != None:

                section = 'added'

                continue

            res = match_removed.match(line)

            if res != None:

                section = 'removed'

                continue

            if section is not None:

                res = match_task_new.match(line)

                if res != None:

                    self._output[section].append(self._session.create(res.group(1)))

                    continue

class UpdateResultSimple(Result):

    """ Parse update output. """

    def __init__(self, session):

        Result.__init__(self, session)

        self._success = True

    def _setoutput(self, output):

        self._output = output

        match_failed = re.compile(r"(Update failed)")        

        for line in output.splitlines():

            res = match_failed.match(line)

            if res != None:                

                self._success = False

    @property

    def successful(self):

        return self._success

class UpdateResult(UpdateResultSimple):

    """ Parse update output. """

    def __init__(self, session):

        UpdateResultSimple.__init__(self, session)

    def _setoutput(self, output):

        self._output = {"tasks":[], "modifications": [], "errors": [], "warnings": []}

        match_object_update = re.compile(r"^\s+'(.*)'\s+replaces\s+'(.*)'\s+under\s+'(.*)'\.")

        match_object_new = re.compile(r"^\s+(?:Subproject\s+)?'(.*)'\s+is now bound under\s+'(.*)'\.")

        match_task_new = re.compile(r"^\s+(Task \S+#\d+)")

        match_no_candidate = re.compile(r"^\s+(.+) in project (.+) had no candidates")

        match_update_failure = re.compile(r"^\s+Failed to use selected object\s+(.+)\s+under directory\s+(.+)\s+in project\s+(.+)\s+:\s+(.+)")

        match_warning = re.compile(r"^Warning:(.*)")

        match_failed = re.compile(r"(Update failed)")

        # TODO: cleanup the parsing to do that in a more efficient way.

        for line in output.splitlines():

            _logger.info(line)

            res = match_object_update.match(line)

            if res != None:

                self._output['modifications'].append({ "new": self._session.create(res.group(1)),

                                      "old": self._session.create(res.group(2)),

                                      "project": self._session.create(res.group(3))

                                    })

                continue

            res = match_object_new.match(line)

            if res != None:                

                self._output['modifications'].append({ "new": self._session.create(res.group(1)),

                                      "old": None,

                                      "project": self._session.create(res.group(2))

                                    })

                continue

            res = match_task_new.match(line)

            if res != None:                

                self._output['tasks'].append(self._session.create(res.group(1)))

                continue

            res = match_no_candidate.match(line)

            if res != None:                

                self._output['errors'].append({'family': res.group(1),

                                               'project': self._session.create(res.group(2)),

                                               'comment': "had no candidates",

                                               'line': line,

                                               })

                continue

            res = match_update_failure.match(line)

            if res != None:                

                self._output['errors'].append({'family': res.group(1),

                                               'dir': self._session.create(res.group(2)),

                                               'project': self._session.create(res.group(3)),

                                               'comment': res.group(4),

                                               'line': line,

                                               })

                continue

            res = match_warning.match(line)            

            if res != None:                

                self._output['warnings'].append({'family': None,

                                               'project': None,

                                               'comment': res.group(1),

                                               'line': line,

                                               })

                continue

            res = match_failed.match(line)

            if res != None:

                self._success = False

                self._output['errors'].append({'Serious': res.group(1),

                                               })

                continue

class WorkAreaInfoResult(Result):

    """ Parse work area info output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        """ Returns a dict with the following fields:

               * project: a ccm.Project instance

               * maintain: a boolean

               * copies: a boolean

               * relative: a boolean

               * time: a boolean

               * translate: a boolean

               * modify: a boolean

               * path: a string representing the project wa path

        """

        self._output = None

        for line in output.splitlines():

            mresult = re.match(r"(?P<project>.*)\s+(?P<maintain>TRUE|FALSE)\s+(?P<copies>TRUE|FALSE)\s+(?P<relative>TRUE|FALSE)\s+(?P<time>TRUE|FALSE)\s+(?P<translate>TRUE|FALSE)\s+(?P<modify>TRUE|FALSE)\s+'(?P<path>.*)'", line)            

            if mresult != None:

                data = mresult.groupdict()

                self._output = {'project': self._session.create(data['project']),

                                'maintain' : data['maintain'] == "TRUE",

                                'copies' : data['copies'] == "TRUE",

                                'relative' : data['relative'] == "TRUE",

                                'time' : data['time'] == "TRUE",

                                'translate' : data['translate'] == "TRUE",

                                'modify' : data['modify'] == "TRUE",

                                'path' : data['path']

                                }

                return

class CreateNewTaskResult(Result):

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        self._output = None

        for line in output.splitlines():

            mresult = re.match(r"Task\s+(?P<task>\S+\#\d+)\s+created\.", line)

            if mresult != None:

                self._output = self._session.create("Task " + mresult.groupdict()['task'])

                return

class AttributeNameListResult(Result):

    """ Class that abstract ccm call result handling.

        Subclass it to implement a new generic output parser.

    """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, obj):

        def _create(arg):

            mresult = re.match(r"^\s*(?P<name>\w+)", arg.strip())

            if mresult != None:

                return mresult.groupdict()['name']

            return None

        self._output = [_create(line) for line in obj.strip().splitlines()]

class ObjectListResult(Result):

    """ Parses an object list Synergy output. """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, obj):        

        self._output = []

        if re.match(r"^None|^No tasks|^Warning", obj, re.M) != None:

            return

        def _create(arg):

            arg = arg.strip()

            if arg != "":

                return self._session.create(arg)

            return None

        result = [_create(line) for line in obj.strip().splitlines()]

        for result_line in result:

            if result_line != None:

                self._output.append(result_line)

class DataMapperListResult(Result):

    """ Parses an object list Synergy output. """        

    dataconv = {'ccmobject': lambda x, y: x.create(y),

                'string': lambda x, y: y,

                'int': lambda x, y: int(y),

                'boolean': lambda x, y: (y.lower() == "true")}    

    def __init__(self, session, separator, keywords, datamodel):

        self._separator = separator

        self._keywords = keywords

        self._datamodel = datamodel

        Result.__init__(self, session)

    def format(self):

        formatted_keywords = ["%s%s%s%%%s" % (self._separator, x, self._separator, x) for x in self._keywords]

        return "".join(formatted_keywords) + self._separator

    def regex(self):

        regex_keywords = [r'%s%s%s(.*?)' % (self._separator, x, self._separator) for x in self._keywords]

        regex = r''.join(regex_keywords)

        regex = r"%s%s\s*\n" % (regex, self._separator)

        return re.compile(regex, re.MULTILINE | re.I | re.DOTALL | re.VERBOSE | re.U)

    def _setoutput(self, obj):

        self._output = []

        regex = self.regex()

        _logger.debug("Regex %s" % (regex.pattern))

        for match in regex.finditer(obj):

            _logger.debug("Found: %s" % (match))

            if match != None:

                output_line = {}

                for i in range(len(self._datamodel)):

                    _logger.debug("Found %d: %s" % (i, match.group(i + 1)))

                    model = self._datamodel[i]

                    output_line[self._keywords[i]] = self.dataconv[model](self._session, match.group(i + 1))

                    i += 1

                self._output.append(output_line)

class FolderCopyResult(Result):

    """ Parses a folder copy result """

    def __init__(self, session):

        Result.__init__(self, session)

    def _setoutput(self, output):

        self._output = None

        for line in output.splitlines():

            mo = re.match(r"appended to", line)

            if mo != None:

                self._output = self._session.create(line)

                return

CHECKOUT_LOG_RULES = [[r'^Derive failed for', logging.ERROR],

                      [r'^Serious:', logging.ERROR],

                      [r'^Warning: .* failed.', logging.ERROR],

                      [r'^WARNING:', logging.WARNING],

                      [r'^Warning:', logging.WARNING],]

UPDATE_LOG_RULES = [[r'^Update failed.', logging.ERROR],

                    [r'^Serious:', logging.ERROR],

                    [r'^\s+Failed to', logging.ERROR],

                    [r'^\d+ failures to', logging.ERROR],

                    [r"^Warning: This work area '.+' cannot be reused", logging.ERROR],