calculate
/
calculate-utils-3-console
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '24a86409e7'
${ noResults }
calculate-utils-3-console/console/application/function.py

464 lines
14 KiB
Raw Blame History

#-*- 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
import suds
from calculate.core.server.cert_cmd import getHwAddr, getIpLocal
from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('calculate_console',sys.modules[__name__])
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 myGetch():
# """ get one character without pressing Enter """
# fd = sys.stdin.fileno()
#
# oldterm = termios.tcgetattr(fd)
# newattr = termios.tcgetattr(fd)
# newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
# termios.tcsetattr(fd, termios.TCSANOW, newattr)
#
# oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
# fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)
#
# try:
# while 1:
# try:
# c = sys.stdin.read(1)
# break
# except IOError: pass
# finally:
# termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
# fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
# return c
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 create_obj(client, method_name):
""" create object indispensable for transfer to the server function """
sd_item = 0
num_port = 0
operation_from_port = 0
inf_param = 1
param_type = 0
ns_name = 0
ns_type = 1
param = 1
pref = ""
sd = client.sd[sd_item]
# get parameter type
operation = sd.ports[num_port][operation_from_port]
info = operation.methods.get(method_name)
if not info:
raise suds.MethodNotFound(method_name)
type_op = info.binding.input.param_defs(info)[param][inf_param]
str_type = type_op.__getattribute__('type')[param_type]
# get prefix
str_ns = type_op.__getattribute__('type')[ns_type]
client.wsdl.schema.root.normalizePrefixes()
nsprefix = sd.prefixes
# Find a match prefix
for pref_num in range (0, len(nsprefix)):
if str_ns == sd.prefixes[pref_num][ns_type]:
pref = sd.prefixes[pref_num][ns_name]
# Combine in a type
if not pref:
pref = sd.getprefix(str_ns)
for_factory = pref + ":" + str_type
NewType = client.factory.create(for_factory)
return NewType
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'), 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 callView(item, sid):
return
print "\n\n",item.message
try:
view = client.service[0][item.message] (sid)
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(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):
""" get entire frame, from beginning (if client disconnected) """
sid = get_sid(client.SID_FILE)
list_pid = client.service.list_pid(sid = sid)
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
percent = returnProgr.percent
while percent <= 100 and percent >= 0 :
if temp_progress != percent:
print_progress(returnProgr)
if percent == 100:
return
temp_progress = percent
time.sleep(1)
returnProgr = client.service.get_progress(sid, pid, id)
percent = returnProgr.percent
if percent < 0:
print_progress(returnProgr, True)
else:
print_progress(returnProgr)
def print_progress(returnProgr, error = False):
if error:
print _("Error task by") %(0 - returnProgr.percent) + ' %d%%'
elif returnProgr.long_message:
print '%s %d%%' %(returnProgr.long_message, returnProgr.percent)
elif returnProgr.short_message:
print '%s %d%%' %(returnProgr.short_message, returnProgr.percent)
else:
print '%d%%' %returnProgr.percent
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)
result = 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
Reference in new issue View Git Blame Copy Permalink