#!/usr/bin/env python
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

"""
  gpversion.py:

  Contains GpVersion class for handling version comparisons.
"""

# ===========================================================
import sys, os, re

# Python version 2.6.2 is expected, must be between 2.5-3.0
if sys.version_info < (2, 5, 0) or sys.version_info >= (3, 0, 0):
    sys.stderr.write("Error: %s is supported on Python versions 2.5 or greater\n" 
                     "Please upgrade python installed on this machine." 
                     % os.path.split(__file__)[-1])
    sys.exit(1)


MAIN_VERSION = [2,0,99,99]    # version number for main


#============================================================
class GpVersion:
    '''
    The gpversion class is an abstraction of a given Greenplum release 
    version.  It exists in order to facilitate version comparisons,
    formating, printing, etc.
    
      x = GpVersion([3,2,0,4]) => Greenplum 3.2.0.4
      x = GpVersion('3.2')     => Greenplum 3.2 dev
      x = GpVersion('3.2 build dev') => Greenplum 3.2 dev
      x = GpVersion('main')    => Greenplum main 
      x.major()                => Major release, eg "3.2"
      x.isrelease('3.2')       => Major version comparison
    '''

    #------------------------------------------------------------
    def __init__(self, version):
        '''
        The initializer for GpVersion is complicated so that it can handle
        creation via several methods:
           x = GpVersion('3.2 dev')  => via string
           x = GpVersion([3,2])  => via tuple
           y = GpVersion(x)      => copy constructor

        If the input datatype is not recognised then it is first cast to
        a string and then converted.
        '''
        try:
            self.version = None
            self.build   = None

            # Local copy that we can safely manipulate
            v = version

            # Copy constructor
            if isinstance(v, GpVersion):
                self.version = v.version
                self.build   = v.build
                return

            # if version isn't a type we recognise then convert to a string
            # first
            if not (isinstance(v, str) or
                    isinstance(v, list) or
                    isinstance(v, tuple)):
                v = str(v)
            
            # Convert a string into the version components.
            # 
            # There are several version formats that we anticipate receiving:
            #
            # Versions from "postgres --gp-version":
            #    ".* (Greenplum Database) <VERSION> build <BUILD>"
            #
            # Version from sql "select version()"
            #    ".* (Greenplum Database <VERSION> build <BUILD>) .*"
            #
            # Versions from python code:
            #    "<VERSION>"
            #    "<VERSION> <BUILD>"
            #
            if isinstance(v, str):

                # See if it matches one of the two the long formats
                regex = r"\(HAWQ\)? ([^ ]+) build ([^ )]+)"
                m = re.search(regex, v)
                if m:
                    (v, self.build) = m.groups()   # (version, build)
                
                # Remove any surplus whitespace, if present
                v = v.strip()

                # We should have either "<VERSION> <BUILD>" or "VERSION" so 
                # split on whitespace.
                vlist = v.split(' ')
                if len(vlist) == 2:
                    (v, self.build) = vlist
                elif len(vlist) == 3 and vlist[1] == 'build':
                    (v, _, self.build) = vlist
                elif len(vlist) > 2:
                    raise StandardError("too many tokens in version")
                
                # We should now just have "<VERSION>"
                if v == 'main':
                    self.version = MAIN_VERSION
                    if not self.build:
                        self.build = 'dev'
                    return
                
                # Check if version contains any "special build" tokens
                # e.g. "3.4.0.0_EAP1" or "3.4.filerep".  
                #
                # For special builds we use the special value for <BUILD>
                # rather than any value calculated above.
                
                # <VERSION> consists of:
                #    2 digits for major version
                #    optionally another 2 digits for minor version
                #    optionally a string specifiying a "special build", eg:
                #        
                #        we ignore the usual build version and use the special
                #        vilue for "<BUILD>" instead.
                regex = r"[0123456789.]+\d"
                m = re.search(regex, v)
                if not m:
                    raise StandardError("unable to coerce to version")
                if m.end() < len(v):
                    self.build = v[m.end()+1:]
                v = v[m.start():m.end()]
                
                # version is now just the digits, split on '.' and fall
                # into the default handling of a list argument.
                v = v.split('.')

            # Convert a tuple to a list so that extend and slicing will work 
            # nicely
            if isinstance(v, tuple):
                v = list(v)

            # Any input we received should have been 
            if not isinstance(v, list):
                raise StandardError("Internal coding error")

            # Convert a list into a real version
            if len(v) < 2:
                raise StandardError("Version too short")
            if len(v) > 4:
                raise StandardError("Version too long")
            if len(v) < 4:
                v.extend([99,99])

            v = map(int, v)  # Convert to integers
            self.version = v[:4]  # If we extended beyond 4 cut it back down
            if not self.build:
                self.build = 'dev'


        # If part of the conversion process above failed, throw an error,
        except:
            raise StandardError("Unrecognised Greenplum Version '%s'" % 
                                str(version))

    #------------------------------------------------------------
    def __cmp__(self, other):
        '''
        One of the main reasons for this class is so that we can safely compare
        versions with each other.  This needs to be pairwise integer comparison
        of the tuples, not a string comparison, which is why we maintain the
        internal version as a list.       
        '''
        if isinstance(other, GpVersion):
            return cmp(self.version, other.version)
        else:
            return cmp(self, GpVersion(other))
    
    #------------------------------------------------------------
    def __str__(self):
        ''' 
        The other main reason for this class is that the display version is
        not the same as the internal version for main and development releases.
        '''
        if self.version == MAIN_VERSION:
            v = 'main'
        elif self.version[2] == 99 and self.version[3] == 99: 
            v = '.'.join(map(str,self.version[:2]))
        else:
            v = '.'.join(map(str,self.version[:4]))

        if self.build:
            return "%s build %s" % (v, self.build)
        else:
            return v

    #------------------------------------------------------------
    def getVersionBuild(self):
        '''
        Returns the build number portion of the version.
        '''
        return self.build

    #------------------------------------------------------------
    def getVersionRelease(self):
        '''
        Returns the major (first 2 values) portion of the version.
        '''
        return '.'.join(map(str,self.version[:2]))

    #------------------------------------------------------------
    def isVersionRelease(self, version):
        '''
        Returns true if the version matches a particular major release.
        '''
        other = GpVersion(version)
        return self.version[0:2] == other.version[0:2]

    #------------------------------------------------------------
    def isVersionCurrentRelease(self):
        '''
        Returns true if the version matches the current MAIN_VERSION
        '''
        return self.isVersionRelease(MAIN_VERSION)