general code improvements, fixed restore backup

pym/core/backup.py

@@ -121,7 +121,7 @@ class Backup(MethodsInterface):
                 # исключить из переноса файлы, которые принадлежат пакетам,
                 # которые не установлены в системе
                 contents = f.extractfile(f.getmember(contents_name))
-                pkg_file = [x.split()[:3:2] for x in contents]
+                pkg_file = [x.decode("UTF-8").split()[:3:2] for x in contents]
                 not_installed_files = [
                     x for x in pkg_file
                     if not any(getInstalledAtom(x[0].partition(":")[0]))]
@@ -162,7 +162,7 @@ class Backup(MethodsInterface):
                                 data_system = readFile(fn_system)
                                 extr_file = f.extractfile(ti)
                                 if extr_file:
-                                    data_ti = extr_file.read()
+                                    data_ti = extr_file.read().decode("UTF-8")
                                     if self.is_equal_files(data_system,
                                                            data_ti):
                                         continue

pym/core/server/baseClass.py

@@ -24,7 +24,6 @@ from spyne import rpc
 from spyne import Service
 from spyne import String, Integer, Array
 
-from .core_interfaces import CoreServiceInterface
 from calculate.lib.utils.files import readFile
 
 _ = lambda x: x
@@ -44,8 +43,7 @@ from . import send_cert
 
 String.Attributes.encoding = "utf-8"
 
-# class Basic(CoreServiceInterface):
-class Basic(Service, CoreServiceInterface):
+class Basic(Service):
     """ Basic server class """
    
     SERV_VERS = 0.11

pym/core/server/cl_server.py

@@ -236,28 +236,23 @@ def main(*args, **keywords):
     pack = "calculate.core.server"
     import importlib
 
-    func_metaclass = importlib.import_module('%s.func_metaclass' % pack)
-    core_wsdl_classes = []
-    core_wsdl_classes.append(func_metaclass.Func_MetaClass)
-
+    core_wsdl_classes = importlib.import_module('%s.func_metaclass' % pack).Func_MetaClass
     from .baseClass import Basic
     # make server metaclass
     if args.method or args.list_methods:
         from .local_call import local_method, LocalCall
 
         ClService = CoreInnerWsdl("ClService",
-                                   tuple([LocalCall] + outer_wsdl_classes + [Basic] + core_wsdl_classes), 
+                                   tuple([LocalCall] + outer_wsdl_classes + [Basic] + [core_wsdl_classes]), 
                                    {
                                         "__metaclass__" : CoreInnerWsdl
                                    })
-        tc = ClService()
-        tc.set_comb_class_ref(tc)
-        return local_method(tc, args, unknown_args)
+        # tc = ClService()
+        ClService.set_comb_class_ref(ClService)
+        return local_method(ClService, args, unknown_args)
 
     ClService = make_service(Basic, core_wsdl_classes, outer_wsdl_classes, "ClService")
     from .server_class import ClApplication, OpenSSLAdapter
-    #do we even need this anymore?
-    tc = ClService() 
     App = Application([ClService], 'tns',
         name="ClApplication",
         in_protocol=Soap11(),
@@ -267,28 +262,22 @@ def main(*args, **keywords):
     wsgi_application = ClApplication(App, log=file_logger)
     cert_cmd.create_path(data_path, certbase, rights, group_rights,
                          local_data_path)
-
+    
     # set all path
-    tc.set_paths(data_path, certbase, serv_certbase,
+    ClService.set_paths(data_path, certbase, serv_certbase,
                  rights, group_rights, sids, pids, sids_pids, 
                  sids_file, pids_file, max_sid,
                  max_pid, cert_path, log_filename, 
                  cert, key)
 
-    tc.set_comb_class_ref(tc)
-    tc.run_tasks()
+    # tc.set_comb_class_ref(tc)
+    ClService.run_tasks()
 
     
 
     max_num = 99999999
     import calculate.contrib
-    # from cherrypy.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
     from cheroot import wsgi
-
-    # dispatcher = WSGIPathInfoDispatcher({'': wsgi_application})
-    # server = CherryPyWSGIServer(('0.0.0.0', port), dispatcher,
-    #                             numthreads=10, max=max_num,
-    #                             request_queue_size=max_num)
     server = wsgi.Server(('0.0.0.0', port), wsgi_application,
                                 numthreads=10, max=max_num,
                                 request_queue_size=max_num)

pym/core/server/func.py

@@ -26,12 +26,10 @@ from os import path
 import glob
 import traceback
 from traceback import print_exc
-from .core_interfaces import (CoreServiceInterface,
-                                                   MethodsInterface)
+from .core_interfaces import (CoreServiceInterface, MethodsInterface)
 from calculate.install.distr import Distributive
 from calculate.lib.cl_log import log
 from calculate.lib.utils.colortext import convert_console_to_xml
-from .api_types import ReturnProgress
 from calculate.lib.cl_lang import setLocalTranslate, getLazyLocalTranslate
 
 _ = lambda x: x
@@ -48,7 +46,7 @@ from itertools import *
 import calculate.contrib
 from spyne import String, Integer, Boolean, Array
 
-from .api_types import ReturnedMessage, CommonInfo
+from .api_types import ReturnedMessage, CommonInfo, ReturnProgress
 from .api_types import (Field, GroupField, ViewInfo, ViewParams)
 from calculate.lib.cl_template import Template
 from calculate.lib.datavars import DataVars
@@ -98,14 +96,14 @@ class CommonMethods(MethodsInterface):
                     pass
             if (self.clVars.Get('cl_autoupdate_set') == 'on' or
                         origdata == newdata):
-                answ = "zap new" #was use new
+                answ = "use new"
             elif dispatch_var in answ_map:
                 answ = answ_map.get(dispatch_var)
             else:
                 orig_content = normalize_config(readFile(orig))
                 new_content = normalize_config(readFile(data[i_cfgname]))
                 if orig_content == new_content:
-                    answ = "zap new" #was use new
+                    answ = "use new"
                 else:
                     for i, s in enumerate(list(process("diff", "-Nu",
                                                        orig, data[i_cfgname]))):
@@ -810,15 +808,15 @@ class Action(MethodsInterface):
         return True
 
 # Never used. Why do we need it?
-# def commonView(self, sid, params, arg):
-#     dv = self.get_cache(sid, arg, "vars")
-#     if not dv:
-#         dv = getattr(self, "%s_vars" % arg)()
-#     else:
-#         dv.processRefresh()
-#     view = ViewInfo(dv, viewparams=params)
-#     self.set_cache(sid, arg, "vars", dv, smart=False)
-#     return view
+def commonView(self, sid, params, arg):
+    dv = self.get_cache(sid, arg, "vars")
+    if not dv:
+        dv = getattr(self, "%s_vars" % arg)()
+    else:
+        dv.processRefresh()
+    view = ViewInfo(dv, viewparams=params)
+    self.set_cache(sid, arg, "vars", dv, smart=False)
+    return view
 
 
 def catchExcept(*skipException):
@@ -941,7 +939,7 @@ class CoreWsdl(CoreServiceInterface):
 
         cert_id = find_cert_id(certificate, cls.data_path, cls.certbase)
 
-        rights = cls.serv_view_cert_right(cert_id, cls.data_path, client_type)
+        rights = cls.serv_view_cert_right(cls, cert_id, cls.data_path, client_type)
         return_list = []
         if client_type == "console":
             for meth in cls.return_conMethod():
@@ -1157,14 +1155,15 @@ class CoreWsdl(CoreServiceInterface):
         def addMessage(self, message_type='normal', message=None, id=None,
                        onlyShow='', default=None):
             from .api_types import Message
-
+            if isinstance(message, bytes):
+                message = message.decode("UTF-8")
             re_clean = re.compile('\[(?:\d+;)?\d+m')
             messageObj = Message(
                 message_type=message_type,
                 message=(
                     None if message in (None, True, False)
                     # else re_clean.sub('', [x for x in message if x >= ' '])),
-                     else re_clean.sub('', message)),
+                     else re_clean.sub('', [x for x in message if x.strip()])),
                 result=message if message in (True, False) else None,
                 id=id, onlyShow=onlyShow, default=default)
             try:
@@ -1376,6 +1375,8 @@ class CoreWsdl(CoreServiceInterface):
             fd.close()
             com.endFrame()
 
+
+    @staticmethod
     def serv_view_cert_right(cls, cert_id, data_path, client_type=None):
         """ rights for the selected certificate """
         try:

pym/core/server/local_call.py

@@ -36,9 +36,9 @@ from calculate.lib.cl_lang import setLocalTranslate
 from .api_types import FieldAdapter
 from calculate.lib.utils.tools import ignore
 from calculate.lib.utils.files import makeDirectory
-from .result_viewer import ResultViewer
+from ..result_viewer import ResultViewer
 from .loaded_methods import LoadedMethods
-from .result_viewer_gui import ProgressGui, ErrorGui, WarningGui
+from ..result_viewer_gui import ProgressGui, ErrorGui, WarningGui
 from .gen_pid import ProcessStatus
 
 from .methods_func import (get_method_argparser, collect_object,

pym/core/server/spyne_adapter.py

@@ -97,9 +97,9 @@ def make_service(basic_class, wsdl_core_class_list, outer_wsdl_class_list, servi
                     functions_to_add[meth] = make_rpc_func_caller(getattr(klass, meth))
     
     functions_to_add.update({"__metaclass__" : ServiceMetaAdapter})
-    ClService = ServiceMetaAdapter(service_name, tuple([basic_class] + wsdl_core_class_list), functions_to_add)
+    ClService = ServiceMetaAdapter(service_name, tuple([basic_class] + [wsdl_core_class_list]), functions_to_add)
     ClService.public_methods.update(saved_pub_methods)
     #TODO replace with a single ref
     ServiceMetaAdapter.global_class_ref = ClService
-    basic_class.set_comb_class_ref(ClService)
+    ClService.set_comb_class_ref(ClService)
     return ClService