calculate-utils-3-console/console/application/function.py

#-*- coding: utf-8 -*-

# Copyright 2012 Calculate Ltd. http://www.calculate-linux.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

import time, os, sys, re
import subprocess
from OpenSSL import crypto
import shlex
from sudsds import MethodNotFound
from calculate.core.server.cert_cmd import getHwAddr, getIpLocal

from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('calculate_console',sys.modules[__name__])
from calculate.core.client.function import create_obj

def _print (*args):
    print " ".join(map(lambda x:unicode(x).encode('utf-8'),args))

# get list of certificate and session id
def get_sid (SID_FILE):
    if not os.path.exists(SID_FILE):
        fi = open(SID_FILE, 'w')
        fi.write('0')
        fi.close()
        sid = 0
    else:
        fi = open(SID_FILE, 'r')
        sid = fi.read()
        fi.close()
    return sid

def clear ():
    """ delete caching suds file """
    try:
        import glob
        for filename in glob.glob("/tmp/suds/suds-*"):
            #print "delete", filename
            os.unlink (filename)
    except:
        print _("Clear Cache error! ")
        return 1
    
def get_ip_global():
    import urllib2

    strURL = 'http://api.wipmania.com/'
    f = urllib2.urlopen(urllib2.Request(strURL))
    response = f.read()
    outerIP = response.split("<br>")[0]
    f.close()
    return outerIP

def get_ip_mac_type(client_type = None):
    results = []
    #try:
    results.append ( getIpLocal() )
    #except:
        #results.append ('no_ip')
    #try:
    results.append ( getHwAddr())
    #except:
        #results.append ('no_mac')
    if client_type:
        results.append (client_type)
    else:
        results.append ('console')
    return results

def print_brief_group(Fields, group_name):
    if group_name:
        print group_name
    uncompatible_count = 0
    green = '\033[32m * \033[0m'
    red = '\033[31m * \033[0m'
    for field in Fields:
        if field.uncompatible:
            uncompatible_count += 1
            continue
        if field.element in ['input', 'openfile']:
            value = field.value if field.value else ''
            print green+'%s: %s' %(field.label, value)

        elif field.element in ['combo', 'comboEdit', 'radio', 'file']:
            if hasattr (field.comments, 'string') and field.value in \
                                                      field.choice.string:
                value = map(lambda x: field.comments.string[x] \
                        if len(field.comments.string) > x \
                        else field.choice.string[x], 
                            map(lambda x: field.choice.string.index(x), \
                                [field.value]))
                value = ', '.join(value)
            else:
                value = field.value if field.value else ''
            print green+'%s: %s' %(field.label, value)

        elif field.element in ['multichoice', 'multichoice_add',\
                                 'selecttable', 'selecttable_add']:
            if hasattr (field.comments, 'string') and \
                                    hasattr (field.listvalue, 'string'):
                value = map(lambda x: field.comments.string[x] \
                        if len(field.comments.string) > x \
                        else field.choice.string[x], 
                            map(lambda x: field.choice.string.index(x), \
                                field.listvalue.string))
                value = ', '.join(value)
            elif hasattr (field.listvalue, 'string'):
                value = ', '.join(field.listvalue.string)
            else:
                value = field.value if field.value else ''
            print green+'%s: %s' %(field.label, value)
#
#        elif field.element == 'label':
#            print field.label

        elif field.element == 'error':
            print red + 'Error: %s' %field.label

        elif field.element in ['check', 'check_tristate']:
            if field.value == 'on':
                value = _('yes')
            elif field.value == 'off':
                value = _('no')
            elif field.value == 'auto':
                value = _('auto')
            else:
                value = field.value
            print green+'%s: %s' %(field.label, value)

        elif field.element == 'table' and field.type != 'steps':
            if hasattr (field.tablevalue.head, 'string'):
                head = field.tablevalue.head.string
            else: head = None

            body = []
            if hasattr (field.tablevalue.body, 'stringArray'):
                for row in field.tablevalue.body.stringArray:
                    if hasattr(row, 'string'):
                        body.append(row.string)
            else: body = [[]]

            ChoiceValue = field.tablevalue.values.ChoiceValue
            for row in xrange(len(ChoiceValue)):
                if ChoiceValue[row].typefield in ['check', 'check_tristate']:
                    for i in xrange(len(body)):
                        if body[i][row] == 'on':
                            body[i][row] = _('yes')
                        if body[i][row] == 'off':
                            body[i][row] = _('no')
                        if body[i][row] == 'auto':
                            body[i][row] = _('auto')
                if ChoiceValue[row].typefield == 'password':
                    for i in xrange(len(body)):
                        if body[i][row]:
                            body[i][row] = '***'

            data = []
            for body_row in body:
                data.append(map(lambda x: x if x else '', body_row))

            print green+'%s: ' %(field.label)
            res = printTable(data, head)
            sys.stdout.flush()
            sys.stdout.write(res)

        else:
            uncompatible_count += 1

    if uncompatible_count == len (Fields) and group_name:
        print green + _('Not used')

def print_brief(view, brief_label):
    for Group in view.groups.GroupField:
        if Group.name:
            if not Group.fields:
                continue
        print_brief_group(Group.fields.Field, Group.name)

def listToArray (client, _list, _type = 'string'):
    Array = client.factory.create('%sArray' %_type)
    for i in _list:
        Array['%s' %_type].append(i)
    return Array
    
def listToArrayArray (client, _list, _type = 'string'):
    ArrayArray = client.factory.create('%sArrayArray' %_type)
    for i in _list:
        Array = client.factory.create('%sArray' %_type)
        for j in i:
            Array[_type].append(j)
        ArrayArray['%sArray' %_type].append(Array)
    return ArrayArray

class switch(object):
    def __init__(self, value):
        self.value = value
        self.fall = False

    def __iter__(self):
        """Return the match method once, then stop"""
        yield self.match
        raise StopIteration
    
    def match(self, *args):
        """Indicate whether or not to enter a case suite"""
        if self.fall or not args:
            return True
        elif self.value in args: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False

#################API FUNCTION###############################
def show_view(view):
    print "+====== show view! ======+"

def printTable(data, header=None ):
    res = []
    for row in data:
        encode_row = map(lambda x: x.encode('utf-8') if x else '', row)
        res.append(encode_row)
    data = res

    if type(header) == list:
        header = map(lambda x: x.encode('utf-8'), header)

    lens = [0]*len(data[0])
    for row in data:
        for numCol, column in enumerate(row):
            cLen = len(unicode(str(column).decode('utf-8')))
            if lens[numCol] < cLen:
                lens[numCol] = cLen
    res = ""
    spacer = lambda lenList: '+' + '+'.join( '-'*(x+2) for x in lenList ) + '+'
    drawRow = lambda lenList, valueList: '|' + "".join(
            ' %s ' % item + ' ' * (lenList[num] - \
            len(unicode(str(item).decode('utf-8')))) + '|'
            for num, item in enumerate(valueList) )
    if header:
        for numCol, column in enumerate(header):
            cLen = len(unicode(str(column).decode('utf-8')))
            if lens[numCol] < cLen:
                lens[numCol] = cLen
        res += spacer(lens)+ "\n"
        res += drawRow( lens, header )+ "\n"

    res+= spacer(lens) + "\n"
    for r in data:
        res += drawRow( lens, r )+ "\n"
    res+= spacer(lens)+ "\n"
    return res

def show_table(table, item):
    head = table.head.string if hasattr (table.head, 'string') else None
    data = []
    for line in table.body[0]:
        if hasattr (line, 'string'):
            data.append(line.string)

    res = printTable(data, head)
    sys.stdout.flush()
    sys.stdout.write(res)

#HEADER = '\033[95m'
    #OKBLUE = '\033[94m'
    #OKGREEN = '\033[92m'
    #ENDC = '\033[0m'
def show_error(item):
    FAIL = '\033[31m'
    ENDC = '\033[0m'
    print FAIL + _("Error")
    print FAIL + item.message
    print ENDC
    
def show_warning(item):
    WARNING = '\033[91m'
    print WARNING + _("Warning")
    print WARNING + item.message
    ENDC = '\033[0m'
    print ENDC
    
def show_group(item):
    print "Group"
    print item.message

def show_result(result):
    print "Result = ", result.message

def startTask(item):
    print "start Task"
    print item.message

def endTask(item):
    print item.message
    print "end Task\n\n"
    
def beginFrame(item):
    pass

def endFrame(item):
    pass

def startGroup(item):
    pass

def endGruop(item):
    pass

def _create_obj(client, method):
    try:
        view_params = create_obj(client, method)
    except MethodNotFound:
        if method.endswith('_view'):
            method = method[:-5]
        print _('Method not found: ') + method
        sys.exit(1)
    return view_params

def get_view_params(client, method, step = None, expert = None, brief = None):
    view_params = _create_obj(client, method)
    view_params.step = step
    view_params.expert = expert
    view_params.brief = brief
    return view_params

def callView(client, item, sid):
    return
    print "\n\n",item.message
    try:
        view_params = get_view_params(client, item.message, brief = True, \
                                      expert = True)
        view = client.service[0][item.message] (sid, view_params)
        show_view(view)
    except:
        pass

#################MESSAGE####################################

def analysis(client, sid, s):
    """ analysis of the bounced message method """
    messages = s[0]
    for mess in messages:
        if mess.type == 'pid':
            try:
                pid = int(mess.message)
            except:
                show_error(_('server send pid = ') + pid)
                return 1
            get_messages(client, sid, pid)
        elif mess.type == 'error':
            show_error(mess)
        elif mess.type == 'warning':
            show_warning(mess)

def get_message(client, item, sid, pid):
    """ get one message by its type """
    for case in switch(item.type):
        if case('normal'):
#            sys.stdout.flush()
#            sys.stdout.write('\x1b[1;33m' + item.message + '\033[0m')

            p = re.compile(r'<b>|</b>')
            print p.sub('', item.message)
#            print item.message
            return 1
        if case('progress'):
            get_Progress(client, sid, pid, item.id)
            return 1
        if case('error'):
            show_error(item)
            if item.message == "403 Forbidden":
                return 0
            return 1
        if case('warning'):
            show_warning(item)
            return 1
        if case('table'):
            get_Table(client, sid, pid, item)
            return 1
        if case('group'):
            show_group(client, sid, pid, item)
            return 1
        if case('question'):
            send_Message(client, sid, pid, item)
            return 1
        if case('password'):
            send_Password(client, sid, pid, item)
            return 1
        if case('startTask'):
            startTask(item)
            return 1
        if case('endTask'):
            endTask(item)
            return 1
        if case('beginFrame'):
            beginFrame(item)
            return 1
        if case('endFrame'):
            endFrame(item)
            return 0
        if case('startGroup'):
            startGroup(item)
            return 1
        if case('endGruop'):
            endGruop(item)
            return 1
        if case('briefParams'):
            callView(client, item, sid)
        if case(): # default, could also just omit condition or 'if True'
            return 1

def get_messages(client, sid, pid):
    """ get frame in a separate thread """
    #thread_messages = threading.Thread(target=get_Frame,\
                                       #args = (client, sid, pid))
    #thread_messages.start()
    get_Frame(client, sid, pid)


def get_Frame(client, sid, pid):
    """ get all messages, until type is not endFrame (or Error) """
    end_frame = 1
    while end_frame:
        current_frame = client.service[0].get_frame(sid, pid)
        while current_frame in [None, [], ""]:
            time.sleep(float(client.frame_period))
            current_frame = client.service[0].get_frame(sid, pid)
        for item in current_frame[0]:
            end_frame = get_message(client, item, sid, pid)
            
def get_entire_frame(client, pid):
    """ get entire frame, from beginning (if client disconnected) """
    sid = get_sid(client.SID_FILE)
    list_pid = client.service.list_pid(sid = sid)
    if hasattr (list_pid, 'integer'):
        if not pid in list_pid.integer:
            print _('Process not exist or not belong to your session')
#    if list_pid[0] == [0]:
#        return 0
#    for pid in list_pid[0]:
    end_frame = 1
    while end_frame:
        current_frame = client.service.get_entire_frame(sid, pid)
        while current_frame in [None, [], ""]:
            time.sleep(1)
            current_frame = client.service.get_frame(sid, pid)
        for item in current_frame[0]:
            end_frame = get_message(client, item, sid, pid)

def get_Progress(client, sid, pid, id):
    """ get progress for the current job """
    returnProgr = client.service.get_progress(sid, pid, id)
    temp_progress = -1
    last_message = ''
    percent = returnProgr.percent
    while percent <= 100 and percent >= 0 :
        if temp_progress != percent:
            last_message = print_progress(returnProgr, last_msg = last_message)
            if percent == 100:
                print
                return
            temp_progress = percent
        time.sleep(1)
        returnProgr = client.service.get_progress(sid, pid, id)
        percent = returnProgr.percent
    if percent < 0:
        print_progress(returnProgr, error = True)
    else:
        print_progress(returnProgr)

#def cout(string):
#    sys.stdout.write(string)
#    sys.stdout.flush()
#
#for perc in xrange(101):
#    cout ('\r' + str(perc / 1.0).rjust(5) + '% ')
#    time.sleep(.2)

def cout_progress(string):
    sys.stdout.write('\b\b\b\b\b\b' + string)
    sys.stdout.flush()

def cout(string):
    sys.stdout.write(string)
    sys.stdout.flush()

def print_progress(returnProgr, last_msg = None, error = False):
    if error:
        cout_progress ('\n'+_("Error task by %s") \
                            %str(0 - returnProgr.percent).rjust(5) + '%\n')
        return ''
    elif returnProgr.long_message:
        if last_msg == returnProgr.long_message:
            cout_progress('%s%%' %str(returnProgr.percent).rjust(5))
        else:
            if not last_msg:
                cout_progress('')
            else:
                cout_progress('OK'.rjust(6) + '\n')
            cout_progress('%s %s%%' %(returnProgr.long_message, \
                                   str(returnProgr.percent).rjust(5)))
        return returnProgr.long_message
    elif returnProgr.short_message:
        if last_msg == returnProgr.short_message:
            cout_progress('%s%%' %str(returnProgr.percent).rjust(5))
        else:
            if not last_msg:
                cout_progress('')
            else:
                cout_progress('OK'.rjust(6) + '\n')
            cout_progress('%s %s%%' %(returnProgr.short_message, \
                                   str(returnProgr.percent).rjust(5)))
        return returnProgr.short_message
    else:
#        print '%s' %str(returnProgr.percent).rjust(5) + '%'
        cout_progress ('%s' %str(returnProgr.percent).rjust(5) + '%')
        return ''

def get_Table(client, sid, pid, item):
    table = client.service.get_table(sid, pid, item.id)
    show_table(table, item)

def send_Message(client, sid, pid, item):
    """ send answer to the question """
    answer = raw_input (item.message)
    client.service.send_message(sid, pid, answer)
#    show_result(result)
    
def send_Password(client, sid, pid, item):
    """ send password """
    from getpass import getpass
    password = getpass(prompt=item.message)
    result = client.service.send_message(sid, pid, password)
    show_result(result)
    

def _return_revoked_serials(self, crlfile):
    try:
        serials = []
        crltext = open(crlfile, 'r').read()
        crl = crypto.load_crl(crypto.FILETYPE_PEM, crltext)
        revs = crl.get_revoked()
        for revoked in revs:
            serials.append(str(revoked.get_serial()))
        return serials
    except (ImportError, AttributeError):
        call = '/usr/bin/openssl crl -text -noout -in %s' % crlfile
        call = shlex.split(call)
        serials = []
        (res,err) = subprocess.Popen(call, stdout=subprocess.PIPE).communicate()
        for line in res.split('\n'):
            if line.find('Serial Number:') == -1:
                continue
            (crap, serial) = line.split(':')
            serial = serial.strip()
            serial = int(serial, 16)
            serials.append(serial)
        return serials