def logoff_user(self, user): Logger.info("SessionManagement::logoff_user %s" % (user.name)) if user.infos.has_key("tsid"): sessid = user.infos["tsid"] try: status = RolePlatform.TS.getState(sessid) except Exception, err: Logger.error("RDP server dialog failed ... ") Logger.debug("SessionManagement::logoff_user: %s" % (str(err))) return if status in [ RolePlatform.TS.STATUS_LOGGED, RolePlatform.TS.STATUS_DISCONNECTED ]: Logger.info("must log off ts session %s user %s" % (sessid, user.name)) try: RolePlatform.TS.logoff(sessid) except Exception, err: Logger.error("RDP server dialog failed ... ") Logger.debug("SessionManagement::logoff_user: %s" % (str(err))) return del (user.infos["tsid"])
def init(self): Logger.info("FileServer init") if not Config.init_role(): return False if not self.FSBackend.start(): Logger.error("FileServer: failed to initialize FSBackend") self.FSBackend.stop() return False if not self.cleanup_samba(): Logger.error("FileServer: unable to cleanup samba") return False if not self.purgeGroup(): Logger.error("FileServer: unable to cleanup users") return False if not self.cleanup_repository(): Logger.error("FileServer: unable to cleanup users") return False self.shares = self.get_existing_shares() return True
def destroy_user(self, user): Logger.info("SessionManagement::destroy_user %s"%(user.name)) if user.infos.has_key("tsid"): self.logoff_user(user) user.destroy()
def SvcDoRun(self): self.ReportServiceStatus(win32service.SERVICE_START_PENDING) #win32evtlogutil.ReportEvent(self.log_type, 2, eventType=win32evtlog.EVENTLOG_INFORMATION_TYPE, strings=["Message d'arret"]) if not SlaveServer.init(self): Logger.error("Unable to initialize SlaveServer") SlaveServer.stop(self) return self.ReportServiceStatus(win32service.SERVICE_RUNNING) inited = False rc = win32event.WAIT_TIMEOUT while rc == win32event.WAIT_TIMEOUT: if not inited: ret = SlaveServer.push_production(self) if ret: inited = True Logger.info("SlaveServer started") else: Logger.warn("Session Manager not connected. Sleeping for a while ...") if inited: SlaveServer.loop_procedure(self) rc = win32event.WaitForSingleObject(self.hWaitStop, 30 * 1000) if not self.stopped: SlaveServer.stop(self) Logger.info("SlaveServer stopped")
def destroy_user(self, user): Logger.info("SessionManagement::destroy_user %s" % (user.name)) if user.infos.has_key("tsid"): self.logoff_user(user) user.destroy()
def init(self): Logger.info("FileServer init") if not Config.init_role(): Logger.info( "FileServer never initialized, creating repository on '%s'" % (Config.spool)) os.makedirs(Config.spool) if not self.cleanup_samba(): Logger.error("FileServer: unable to cleanup samba") return False if not self.purgeGroup(): Logger.error("FileServer: unable to cleanup users") return False if not self.cleanup_repository(): Logger.error("FileServer: unable to cleanup users") return False self.wm = DirectoryWatcher() self.shares = self.get_existing_shares() return True
def _create(self, data): sess_id = data.pop('id') Logger.info('[WebApps] creating session id={0} for user {1}'.format(sess_id, data.get('login'))) data.setdefault('cookies', {}) session = Session(sess_id, data, self.debug) self.sessions[sess_id] = session return session
def disconnect_session(self, session): Logger.info("SessionManagement::disconnect %s"%(session.id)) if session.user.created or not session.domain.manage_user(): # Doesn't have to disconnect the session if the user was never created try: sessid = TS.getSessionID(session.user.name) except Exception: Logger.exception("RDP server dialog failed ... ") return False try: status = TS.getState(sessid) except Exception: Logger.exception("RDP server dialog failed ... ") return if status in [TS.STATUS_LOGGED]: Logger.info("must disconnect ts session %s user %s"%(sessid, session.user.name)) try: TS.disconnect(sessid) except Exception: Logger.exception("RDP server dialog failed ... ") return session.switch_status(Session.SESSION_STATUS_INACTIVE)
def process(self, request): path = request["path"] if request["method"] == "GET": Logger.debug("[WebApps] do_GET " + path) if path == "/sync": Logger.info("[WebApps] Starting config synchronization") setup_apps(reset=True) return self.req_answerText('OK') elif path.startswith("/session/status/"): buf = path[len("/session/status/"):] return self.req_session_status(buf) elif path.startswith("/session/destroy/"): buf = path[len("/session/destroy/"):] return self.req_session_destroy(buf) elif request["method"] == "POST": Logger.debug("[WebApps] do_POST " + path) if path == "/session/create": return self.req_session_create(request) Logger.info("WebApps role Dialog::process(%s)" % (str(request))) return None
def init(self): Logger.info("Gateway init") if version[0] != 2 or version[1] < 6 or (version[1] == 7 and version[2] in [1, 2]): Logger.error("Gateway:: incompatibility with current Python machine '%d.%d.%d'" % version[:3]) return False fpem = os.path.join(Config.general.conf_dir, "gateway.pem") if os.path.exists(fpem): self.ssl_ctx = SSL.Context(SSL.SSLv23_METHOD) self.ssl_ctx.use_privatekey_file(fpem) self.ssl_ctx.use_certificate_file(fpem) self.ssl_ctx.load_verify_locations(fpem) else: Logger.error("Gateway role need a certificate (%s)" % fpem) return False addr = (Config.address, Config.port) try: GatewayTCPHandler.role = self self.server = TCPServer(addr, GatewayTCPHandler, bind_and_activate=False) self.server.allow_reuse_address = Config.general.server_allow_reuse_address self.server.server_bind() self.server.server_activate() except socket.error, e: Logger.error("Gateway:: socket init: %s" % e) return False
def create_session(self, session): Logger.info("SessionManagement::create %s for user %s"%(session.id, session.user.name)) if System.userExist(session.user.name): Logger.error("unable to create session: user %s already exists"%(session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR self.aps_instance.session_switch_status(session, Session.SESSION_STATUS_ERROR) return self.destroy_session(session) rr = session.user.create() if rr is False: Logger.error("unable to create session for user %s"%(session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR self.aps_instance.session_switch_status(session, Session.SESSION_STATUS_ERROR) return self.destroy_session(session) session.user.created = True try: rr = session.install_client() except Exception,err: Logger.debug("Unable to initialize session %s: %s"%(session.id, str(err))) rr = False
def disconnect_session(self, session): Logger.info("SessionManagement::disconnect %s" % (session.id)) if session.user.created or not session.domain.manage_user(): # Doesn't have to disconnect the session if the user was never created try: sessid = TS.getSessionID(session.user.name) except Exception: Logger.exception("RDP server dialog failed ... ") return False try: status = TS.getState(sessid) except Exception: Logger.exception("RDP server dialog failed ... ") return if status in [TS.STATUS_LOGGED]: Logger.info("must disconnect ts session %s user %s" % (sessid, session.user.name)) try: TS.disconnect(sessid) except Exception: Logger.exception("RDP server dialog failed ... ") return session.switch_status(Session.SESSION_STATUS_INACTIVE)
def session_switch_status(self, session, status): if status == Session.SESSION_STATUS_DESTROYED: self.send_session_dump(session) session.switch_status(status) Logger.info("Session %s switch status %s"%(session.id, session.status)) self.send_session_status(session)
def init_role(cls): try: infos = pwd.getpwnam(cls.user) except KeyError, err: Logger.info("FileServer Config failed: no such user '%s'" % (cls.user)) return False
def process(self, request): path = request["path"] if request["method"] == "GET": Logger.debug("[WebApps] do_GET " + path) if path == "/sync": Logger.info("[WebApps] Starting config synchronization") setup_apps(reset=True) return self.req_answerText("OK") elif path.startswith("/session/status/"): buf = path[len("/session/status/") :] return self.req_session_status(buf) elif path.startswith("/session/destroy/"): buf = path[len("/session/destroy/") :] return self.req_session_destroy(buf) elif request["method"] == "POST": Logger.debug("[WebApps] do_POST " + path) if path == "/session/create": return self.req_session_create(request) Logger.info("WebApps role Dialog::process(%s)" % (str(request))) return None
def init(self): Logger.info("Gateway init") if version[0] != 2 or version[1] < 6 or (version[1] == 7 and version[2] in [1, 2]): Logger.error("Gateway:: incompatibility with current Python machine '%d.%d.%d'" % version[:3]) return False fpem = os.path.join(Config.general.conf_dir, "gateway.pem") if os.path.exists(fpem): self.ssl_ctx = SSL.Context(SSL.SSLv23_METHOD) self.ssl_ctx.use_privatekey_file(fpem) self.ssl_ctx.use_certificate_file(fpem) self.ssl_ctx.load_verify_locations(fpem) if Config.disable_sslv2: self.ssl_ctx.set_options(SSL.OP_NO_SSLv2) else: Logger.error("Gateway role need a certificate (%s)" % fpem) return False addr = (Config.address, Config.port) try: GatewayTCPHandler.role = self self.server = GatewayTCPServer(addr, GatewayTCPHandler, bind_and_activate=False) self.server.allow_reuse_address = Config.general.server_allow_reuse_address self.server.server_bind() self.server.server_activate() except socket.error: Logger.exception("Gateway:: socket init") return False Logger.info('Gateway:: running on (%s, %d)' % addr) return True
def order_stop(self): Logger.info("%s role::stop"%(self.getName())) if self.status == Role.STATUS_INIT: self.status = Role.STATUS_STOP return self.status = Role.STATUS_STOPPING
def req_session_status(self, session_id): session = SessionsRepository.get(session_id, check_active=False) if session is None: Logger.info("[WebApps] session id={0} not found".format(session_id)) session = Session(session_id, {}) session.status = Session.SESSION_STATUS_UNKNOWN return self.req_answer(self.session2xmlstatus(session))
def disconnect(self): Logger.info("%s is disconnecting..." % self.uuid) if self.libvirt_connection: self.libvirt_connection.close() self.libvirt_connection = None
def session_switch_status(self, session, status): if status == Session.SESSION_STATUS_DESTROYED: self.send_session_dump(session) session.switch_status(status) Logger.info("Session %s switch status %s" % (session.id, session.status)) self.send_session_status(session)
def init(cls, infos): Logger.info("Guest role Config::init") if not infos.has_key("hypervisor"): return False cls.hypervisor = infos["hypervisor"] return True
def pre_process(self, context): Logger.debug("StaticRequestFilter pre_process") session = context.session if not session.get('ulteo_autologin', self.options.get('autologin', False)): Logger.debug("StaticRequestFilter pre_process autologin = false") return target = self.config['target'] login_url = '{0}://{1}/{2}'.format(target.scheme, target.netloc, self.options['path']) needed_fields = set(self.options['form']) Logger.debug( "StaticRequestFilter pre_process target:%s url:%s fields:%r" % (target, login_url, needed_fields)) br = mechanize.Browser() #br.set_debug_http(True) #br.set_debug_responses(True) #br.set_debug_redirects(True) br.set_handle_robots(False) br.addheaders = parse_request_headers_list(context.communicator) for header in br.addheaders: if header[0].lower() in ('accept-encoding', ): br.addheaders.remove(header) br.open(login_url) to_select = None for i, form in enumerate(br.forms()): available_fields = set([control.name for control in form.controls]) if needed_fields.issubset(available_fields): to_select = i if to_select is None: Logger.info('Necessary fields not found in any form!') session['ulteo_autologin'] = False return br.select_form(nr=to_select) for name, value in self.options['form'].items(): br.form[name] = self.get_value(value, session) response = br.submit() if response.code != 200: Logger.error("Couldn't log in:") Logger.error(response.get_data()) session['ulteo_autologin'] = False return False session['auth_cookies'] = {} for value in response.info().getheaders('set-cookie'): m = COOKIE_RE.search(value) if m: session['auth_cookies'][m.group(1)] = value session['ulteo_autologin'] = response.get_data() Logger.debug("StaticRequestFilter pre_process set autologin")
def connect_domain(self): if self.domain: Logger.info("Already connected to domain. Ignoring") return try: self.domain = self.virt_co.lookupByName(self.name) except: Logger.error("Can't connect to domain with name %s " % self.name)
def req_session_status(self, session_id): session = SessionsRepository.get(session_id, check_active=False) if session is None: Logger.info( "[WebApps] session id={0} not found".format(session_id)) session = Session(session_id, {}) session.status = Session.SESSION_STATUS_UNKNOWN return self.req_answer(self.session2xmlstatus(session))
def connect_domain(self): if self.domain: Logger.info("Already connected to domain. Ignoring") return try: self.domain = self.virt_co.lookupByName(self.name) except: Logger.error("Can't connect to domain with name %s " %self.name)
def create_session(self, session): Logger.info("SessionManagement::create %s for user %s" % (session.id, session.user.name)) if session.domain.manage_user(): if System.userExist(session.user.name): Logger.error( "unable to create session: user %s already exists" % (session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) session.user.infos["groups"] = [ self.aps_instance.ts_group_name, self.aps_instance.ovd_group_name ] if session.mode == "desktop": session.user.infos["shell"] = "OvdDesktop" else: session.user.infos["shell"] = "OvdRemoteApps" rr = session.user.create() if rr is False: Logger.error("unable to create session for user %s" % (session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) session.user.created = True try: rr = session.install_client() except Exception: Logger.exception("Unable to initialize session %s" % session.id) rr = False if rr is False: Logger.error("unable to initialize session %s" % (session.id)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) else: # will be customize by a lock system when the users will connect in RDP if not session.domain.onSessionCreate(): session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return False session.post_install() session.switch_status(Session.SESSION_STATUS_INITED)
def main(): parser = OptionParser() parser.add_option("-V", "--verbose", action="store_true", dest="verbose", default=False, help="Print more informations") parser.add_option("-a", "--address", action="store_true", dest="address", default="127.0.0.1", help="TCP Bind ip address") parser.add_option("-p", "--port", action="store_true", dest="port", default=3000, help="TCP port to bind") parser.add_option("-c", "--config", action="store", type="string", dest="config", default=None, help="Json configuration file") parser.add_option("-v", "--value", action="append", nargs=2, type="string", dest="values", default=[], help="Configuration value") options, args = parser.parse_args() if not options.config: parser.error("You must supply a configuration file") loglevel = Logger.ERROR|Logger.WARN if options.verbose: loglevel |= Logger.INFO|Logger.DEBUG|Logger.DEBUG_2|Logger.DEBUG_3 Logger.initialize("WEBAPPS", loglevel, stdout=True) Logger.info("Start webapps") repo = ApplicationsRepository.initialize() SessionsRepository.debug = True sess = SessionsRepository.initialize() sess.start() repo.start() my_sess = {'id': 1, 'published_applications': (1, ), 'login':'******'} for k, v in options.values: my_sess[k] = v SessionsRepository.create(my_sess) SessionsRepository._instance.sessions[1].switch_status(Session.SESSION_STATUS_ACTIVE) server = WebAppsServer(options.address, int(options.port)) try: config = json.load(open(options.config, "r")) for k, v in options.values: config['Configuration'][k]['value'] = v app_id = 1 app_name = "app" appl = setup_app({"app":config}, app_id, app_name, "domain") if not appl: parser.error("Invalid parameters") appl.rule = re.compile('') ApplicationsRepository.register(appl) try: print "Connect to http://%s:%s/" % (options.address, options.port) asyncore.loop() except (InterruptedException, KeyboardInterrupt): Logger.info("interruption") finally: server.close() repo.stop() sess.stop()
def dump(self): if self.gpos == {}: Logger.info("There is no GPO") return for action in self.gpos: print "%s rules" % (action) for (program, parameters) in self.gpos[action]: Logger.info("\t - %s %s" % (program, parameters))
def dump(self): if self.gpos == {}: Logger.info("There is no GPO") return for action in self.gpos: print "%s rules"%(action) for (program, parameters) in self.gpos[action]: Logger.info("\t - %s %s"%(program, parameters))
def run(self): if self.domain and (self.domain.info()[0] == 1 or self.domain.info()[0] == 2 or self.domain.info()[0] == 3): return "ERROR" self.domain.create() Logger.info("Virtual Machine created") return "OK"
def destroy(self): if self.domain and (self.domain.info()[0] == 5 or self.domain.info()[0] == 6): return "ERROR" self.domain.destroy() Logger.info("Domain destroyed") return "OK"
def shutdown(self): if self.domain and (self.domain.info()[0] == 4 or self.domain.info()[0] == 5 or self.domain.info()[0] == 6): return "ERROR" self.domain.shutdown() Logger.info("Domain shutdown") return "OK"
def suspend(self): if self.domain and (self.domain.info()[0] == 3 or self.domain.info()[0] == 5 or self.domain.info()[0] == 6): return "ERROR" self.domain.suspend() Logger.info("Virtual machine paused") return "OK"
def resume(self): if self.domain and (self.domain.info()[0] == 4 or self.domain.info()[0] == 5 or self.domain.info()[0] == 6): return "ERROR" self.domain.resume() Logger.info("Virtual machine unpaused") return "OK"
def __init__(self): Logger.info('[WebApps] SessionsRepository init') self.sessions = {} self.looping = False self.queue_in = multiprocessing.Queue() self.queue_out = multiprocessing.Queue() self.lock = threading.Lock() self.thread = threading.Thread(name="webapps_session", target=self.run)
def pre_process(self, context): Logger.debug("StaticRequestFilter pre_process") session = context.session if not session.get('ulteo_autologin', self.options.get('autologin', False)): Logger.debug("StaticRequestFilter pre_process autologin = false") return target = self.config['target'] login_url = '{0}://{1}/{2}'.format(target.scheme, target.netloc, self.options['path']) needed_fields = set(self.options['form']) Logger.debug("StaticRequestFilter pre_process target:%s url:%s fields:%r"%(target,login_url,needed_fields)) br = mechanize.Browser() #br.set_debug_http(True) #br.set_debug_responses(True) #br.set_debug_redirects(True) br.set_handle_robots(False) br.addheaders = parse_request_headers_list(context.communicator) for header in br.addheaders: if header[0].lower() in ('accept-encoding', ): br.addheaders.remove(header) br.open(login_url) to_select = None for i, form in enumerate(br.forms()): available_fields = set([control.name for control in form.controls]) if needed_fields.issubset(available_fields): to_select = i if to_select is None: Logger.info('Necessary fields not found in any form!') session['ulteo_autologin'] = False return br.select_form(nr=to_select) for name, value in self.options['form'].items(): br.form[name] = self.get_value(value, session) response = br.submit() if response.code != 200: Logger.error("Couldn't log in:") Logger.error(response.get_data()) session['ulteo_autologin'] = False return False session['auth_cookies'] = {} for value in response.info().getheaders('set-cookie'): m = COOKIE_RE.search(value) if m: session['auth_cookies'][m.group(1)] = value session['ulteo_autologin'] = response.get_data() Logger.debug("StaticRequestFilter pre_process set autologin")
def init(self): Logger.debug("ApplicationServer init") try: TS.getList() except Exception: Logger.exception("RDP server dialog failed ... exiting") return if not System.groupExist(self.manager.ts_group_name): Logger.error("The group '%s' doesn't exist" % (self.manager.ts_group_name)) return False if not System.groupExist(self.manager.ovd_group_name): if not System.groupCreate(self.manager.ovd_group_name): return False if not self.manager.purgeGroup(): Logger.error("Unable to purge group") return False if Config.clean_dump_archive: self.purgeArchives() if Config.thread_count is None: cpuInfos = System.getCPUInfos() vcpu = cpuInfos[0] ram_total = System.getRAMTotal() ram = int(round(ram_total / 1024.0 / 1024.0)) nb_thread = int(round(1 + (ram + vcpu * 2) / 3)) else: nb_thread = Config.thread_count Logger._instance.setQueue(self.logging_queue, True) for _ in xrange(nb_thread): self.threads.append( SessionManagement(self.manager, self.sessions_spooler, self.sessions_spooler2, self.sessions_sync, self.logging_queue)) if self.canManageApplications(): self.apt = Apt() self.apt.init() self.threads.append(self.apt) Logger.info( "ApplicationServer:: retrieve all applications installed (can take some time)" ) self.updateApplications() return True
class Config: general = None user = "******" group = None uid = None gid = None spool = None backendSpool = None dav_user = "******" dav_uid = None dav_passwd_file = "/var/spool/ulteo/ovd/fs.dav.passwd" dav_group_file = "/var/spool/ulteo/ovd/fs.dav.group" FSBackendConf = "/etc/ulteo/rufs/FSBackend.conf" @classmethod def init(cls, infos): if infos.has_key("user"): cls.user = infos["user"] if infos.has_key("FSBackendConf"): cls.FSBackendConf = infos["FSBackendConf"] return True @classmethod def init_role(cls): try: infos = pwd.getpwnam(cls.user) except KeyError, err: Logger.info("FileServer Config failed: no such user '%s'" % (cls.user)) return False cls.uid = infos[2] cls.gid = infos[3] cls.spool = infos.pw_dir cls.backendSpool = cls.spool + ".real" if not os.path.isdir(cls.spool): Logger.info("FileServer Config failed: no such directory '%s'" % (cls.spool)) return False try: infos = grp.getgrgid(cls.gid) except KeyError, err: Logger.info("FileServer Config failed: no such group '%d'" % (cls.gid)) return False
def SvcDoRun(self): config_file = os.path.join(System.get_default_config_dir(), "slaveserver.conf") if not Config.read(ConfigReader.process(None)): return if not Config.is_valid(): return Win32Logger.initialize("OVD", Config.log_level, Config.log_file) try: ServerCheckup.check() except: Logger.exception("Server checkup") return slave = SlaveServer(Communication) if not slave.load_roles(): return if not slave.init(): Logger.error("Unable to initialize SlaveServer") slave.stop() return inited = False rc = win32event.WAIT_TIMEOUT while rc == win32event.WAIT_TIMEOUT: if not inited: ret = slave.push_production() if ret: inited = True Logger.info("SlaveServer started") else: Logger.warn( "Session Manager not connected. Sleeping for a while ..." ) if inited: slave.loop_procedure() rc = win32event.WaitForSingleObject(self.hWaitStop, 30 * 1000) if not slave.stopped: slave.stop() Logger.info("SlaveServer stopped")
def __init__(self, main_instance): AbstractRole.__init__(self, main_instance) Logger.info("Guest role::__init__") self.loop = True self.url = None self.host = Conf.hypervisor self.port = "1112" self.session = None self.session_spooler = multiprocessing.Queue() self.session_sync = multiprocessing.Queue() self.manager = Manager(self.main_instance.smRequestManager) self.session_manager = SessionManagement(self.manager, self.session_spooler, self.session_sync) self.current_session_status = None
def init(self): Logger.debug("SlaveServer init") if not self.communication.initialize(): return False self.communication.thread.start() for (role, dialog) in self.role_dialogs: try: if not role.init(): raise Exception() except InterruptedException: return False except Exception: Logger.exception("SlaveServer: unable to initialize role '%s'" % role.getName()) return False role.thread.start() # Check each thread has started correctly (communication + roles) t0 = time.time() while self.communication.getStatus() is not self.communication.STATUS_RUNNING: t1 = time.time() if ( (t1 - t0 > 20) or (not self.communication.thread.isAlive()) or self.communication.getStatus() is self.communication.STATUS_ERROR ): Logger.warn("SlaveServer::init communication thread error") return False Logger.info("Waiting for communication status running") time.sleep(1) for (role, dialog) in self.role_dialogs: while role.getStatus() is not role.STATUS_RUNNING: t1 = time.time() if (t1 - t0 > 20) or (not role.thread.isAlive()) or role.getStatus() is role.STATUS_ERROR: Logger.warn("SlaveServer::init role %s error" % (role.getName())) return False Logger.info("Waiting for role %s status running" % (role.getName())) time.sleep(1) self.updateMonitoring() return True
def create_session(self, session): Logger.info("SessionManagement::create %s for user %s"%(session.id, session.user.name)) if session.domain.manage_user(): if System.userExist(session.user.name): Logger.error("unable to create session: user %s already exists"%(session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) session.user.infos["groups"] = [self.aps_instance.ts_group_name, self.aps_instance.ovd_group_name] if session.mode == "desktop": session.user.infos["shell"] = "OvdDesktop" else: session.user.infos["shell"] = "OvdRemoteApps" rr = session.user.create() if rr is False: Logger.error("unable to create session for user %s"%(session.user.name)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) session.user.created = True try: rr = session.install_client() except Exception: Logger.exception("Unable to initialize session %s"%session.id) rr = False if rr is False: Logger.error("unable to initialize session %s"%(session.id)) session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return self.destroy_session(session) else: # will be customize by a lock system when the users will connect in RDP if not session.domain.onSessionCreate(): session.end_status = Session.SESSION_END_STATUS_ERROR session.switch_status(Session.SESSION_STATUS_ERROR) return False session.post_install() session.switch_status(Session.SESSION_STATUS_INITED)
def init(self): Logger.debug("ApplicationServer init") try: TS.getList() except Exception: Logger.exception("RDP server dialog failed ... exiting") return if not System.groupExist(self.manager.ts_group_name): Logger.error("The group '%s' doesn't exist"%(self.manager.ts_group_name)) return False if not System.groupExist(self.manager.ovd_group_name): if not System.groupCreate(self.manager.ovd_group_name): return False if not self.manager.purgeGroup(): Logger.error("Unable to purge group") return False if Config.clean_dump_archive: self.purgeArchives() if Config.thread_count is None: cpuInfos = System.getCPUInfos() vcpu = cpuInfos[0] ram_total = System.getRAMTotal() ram = int(round(ram_total / 1024.0 / 1024.0)) nb_thread = int(round(1 + (ram + vcpu * 2)/3)) else: nb_thread = Config.thread_count Logger._instance.setQueue(self.logging_queue, True) for _ in xrange(nb_thread): self.threads.append(SessionManagement(self.manager, self.sessions_spooler, self.sessions_spooler2, self.sessions_sync, self.logging_queue)) if self.canManageApplications(): self.apt = Apt() self.apt.init() self.threads.append(self.apt) Logger.info("ApplicationServer:: retrieve all applications installed (can take some time)") self.updateApplications() return True
def destroy_session(self, session): Logger.info("SessionManagement::destroy %s"%(session.id)) if session.user.created or not session.domain.manage_user(): # Doesn't have to destroy the session if the user was never created try: sessid = RolePlatform.TS.getSessionID(session.user.name) except Exception,err: Logger.error("RDP server dialog failed ... ") Logger.debug("SessionManagement::destroy_session: %s"%(str(err))) return if sessid is not None: session.user.infos["tsid"] = sessid self.logoff_user(session.user)
def SvcDoRun(self): config_file = os.path.join(System.get_default_config_dir(), "slaveserver.conf") if not Config.read(ConfigReader.process(None)): return if not Config.is_valid(): return Win32Logger.initialize("OVD", Config.log_level, Config.log_file) try: ServerCheckup.check() except: Logger.exception("Server checkup") return slave = SlaveServer(Communication) if not slave.load_roles(): return if not slave.init(): Logger.error("Unable to initialize SlaveServer") slave.stop() return inited = False rc = win32event.WAIT_TIMEOUT while rc == win32event.WAIT_TIMEOUT: if not inited: ret = slave.push_production() if ret: inited = True Logger.info("SlaveServer started") else: Logger.warn("Session Manager not connected. Sleeping for a while ...") if inited: slave.loop_procedure() rc = win32event.WaitForSingleObject(self.hWaitStop, 30 * 1000) if not slave.stopped: slave.stop() Logger.info("SlaveServer stopped")
def stop(self, Signum=None, Frame=None): Logger.info("SlaveServer stop") self.stopped = True t0 = time.time() stop_timeout = Config.stop_timeout for (role, dialog) in self.role_dialogs: role.order_stop() self.smRequestManager.switch_status(self.smRequestManager.STATUS_PENDING) for (role, dialog) in self.role_dialogs: while not role.stopped(): t1 = time.time() if (stop_timeout > 0) and (t1 - t0 > stop_timeout): Logger.warn("SlaveServer::stop role %s error" % (role.getName())) role.force_stop() break Logger.debug("Waiting for role %s status stop" % (role.getName())) time.sleep(2) for (role, dialog) in self.role_dialogs: if role.thread.isAlive(): Logger.debug("Waiting %s will stop" % role.getName()) role.thread.join(10) if role.thread.isAlive(): Logger.error("Role %s was stopped by using low force" % role.getName()) role.thread._Thread__stop() role.thread.join(5) if role.thread.isAlive(): Logger.error("Role %s was stopped by using force" % role.getName()) role.thread._Thread__delete() role.finalize() Logger.info("Role %s stopped" % role.getName()) self.communication.stop() if self.communication.thread.isAlive(): self.communication.thread.join() self.smRequestManager.switch_status(self.smRequestManager.STATUS_DOWN)