def do_chpasswd(cur_opts, log_com): srv_com = server_command.srv_command(command="modify_password") srv_com["server_key:user_name"] = cur_opts.username print("changing password for user '{}'".format(cur_opts.username)) srv_com["server_key:old_password"] = base64.b64encode( bz2.compress( get_pass("please enter current password:"******"server_key:new_password_1"] = base64.b64encode( bz2.compress( get_pass("please enter the new password:"******"server_key:new_password_2"] = base64.b64encode( bz2.compress( get_pass("please reenter the new password:"******"pwd_change_request", timeout=cur_opts.timeout, ) _conn.add_connection("tcp://localhost:8004", srv_com, immediate=True) _result = _conn.loop()[0] _res_str, _res_state = _result.get_log_tuple() # _res_str, _res_state = ("ok", logging_tools.LOG_LEVEL_OK) print( "change gave [{}]: {}".format( logging_tools.get_log_level_str(_res_state) , _res_str ) ) if _res_state == logging_tools.LOG_LEVEL_OK: _conn = net_tools.ZMQConnection( "ldap_update_request", timeout=cur_opts.timeout, ) upd_com = server_command.srv_command(command="sync_ldap_config") _conn.add_connection("tcp://localhost:8004", upd_com, immediate=True) _res_str, _res_state = _conn.loop()[0].get_log_tuple() print( "syncing the LDAP tree returned ({}) {}".format( logging_tools.get_log_level_str(_res_state), _res_str, ) ) # print(_result.pretty_print()) return 0
def dummy_print(what, log_level=logging_tools.LOG_LEVEL_OK): print( "{} {}".format( logging_tools.get_log_level_str(log_level), what ) )
def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): if self.log_com: self.log_com("[RRD] {}".format(what), log_level) else: if log_level > logging_tools.LOG_LEVEL_WARN: print "**** [RRD, {}] {}".format( logging_tools.get_log_level_str(log_level), what)
def set_variable(opts): if not opts.name or not opts.value: print("Need variable name and value") sys.exit(1) _def_args = net_tools.SendCommandDefaults() _def_args.port = opts.server_port _def_args.host = opts.server_address my_com = net_tools.SendCommand(_def_args) my_com.init_connection() srv_com = server_command.srv_command( command="set_job_variable", jobid=opts.full_job_id, varname=opts.name, varvalue=opts.value, varunit=opts.unit, ) # print srv_com.pretty_print() if my_com.connect(): _reply = my_com.send_and_receive(srv_com) if _reply is None: print("Nothing returned from server") else: _ret_str, _ret_state = _reply.get_log_tuple() if _ret_state == logging_tools.LOG_LEVEL_OK: print(_ret_str) else: print("a problem occured: [{}]: {}".format( logging_tools.get_log_level_str(_ret_state), _ret_str, )) else: print("unable to connect") my_com.close()
def logger(what, log_level=logging_tools.LOG_LEVEL_OK): if log_all or log_level > logging_tools.LOG_LEVEL_OK: print( u"{} [{}] {}".format( str(datetime.datetime.now()), logging_tools.get_log_level_str(log_level), what ) )
def log(self, what, lev=logging_tools.LOG_LEVEL_OK): if self.__log_template: while self.__log_cache: self.__log_template.log(*self.__log_cache.pop(0)) self.__log_template.log(lev, what) else: self.__log_cache.append((lev, what)) if self.__verbose: print("[{:4s}.{:<10s}] {}".format(logging_tools.get_log_level_str(lev), self.name, what))
def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): if not self.__quiet: if self.__log_com: self.__log_com( "[CS {}] {}".format( self.name if self.tree_valid else "N/V", what, ), log_level) else: print("{} {}".format( logging_tools.get_log_level_str(log_level), what))
def show(self, logger=None): def _log(what, log_level=logging_tools.LOG_LEVEL_OK): if logger is None: print("[{}] {}".format( logging_tools.get_log_level_str(log_level), what)) # log status to logger or stdout _log("overal state is {}, {} defined:".format( logging_tools.get_log_level_str(self.max_log_level), logging_tools.get_plural("log message", len(self.log_buffer)), )) for _log_level, _log_str in self.log_buffer: _log(_log_str, _log_level)
def query_local_server(inst, cmd): _port = inst.get_port_dict(icswServiceEnum.cluster_server, ptype="command") _result = net_tools.ZMQConnection("icsw_image_{:d}".format( os.getpid())).add_connection( "tcp://localhost:{:d}".format(_port), server_command.srv_command(command=cmd), ) if _result is None: print("Unable to send '{}' to local cluster-server".format(cmd)) sys.exit(1) _ret, _state = _result.get_log_tuple() if _state != logging_tools.LOG_LEVEL_OK: print("a problem occured ({}): {}".format( logging_tools.get_log_level_str(_state), _ret)) sys.exit(_state) return _result
def build_response(self): """ builds the xml response """ num_errors, num_warnings = ( len([ True for log_lev, _log_str in self.log_buffer if log_lev == logging_tools.LOG_LEVEL_ERROR ]), len([ True for log_lev, _log_str in self.log_buffer if log_lev == logging_tools.LOG_LEVEL_WARN ])) return E.response( E.header( E.messages(*[ E.message( log_str, **{ "log_level": "{:d}".format(log_lev), "log_level_str": logging_tools.get_log_level_str(log_lev) }) for log_lev, log_str in self.log_buffer ]), **{ "code": "{:d}".format( max([log_lev for log_lev, log_str in self.log_buffer] + [logging_tools.LOG_LEVEL_OK])), "errors": "{:d}".format(num_errors), "warnings": "{:d}".format(num_warnings), "messages": "{:d}".format(len(self.log_buffer)) }), E.values(*[ self._get_value_xml(key, value) for key, value in self.val_dict.iteritems() ]))
def log(self, what, level=logging_tools.LOG_LEVEL_OK, dst=icswLogHandleTypes.log, **kwargs): if not self["exit_requested"]: if dst.value in self.__handles: cur_dst = self.__handles[dst.value] # check for open handles if dst != icswLogHandleTypes.log: for cur_handle in cur_dst.handlers: if not os.path.exists(cur_handle.baseFilename): self.log("reopening file {} for {}".format( cur_handle.baseFilename, dst.value)) cur_handle.stream = cur_handle._open() # print dir(cur_dst) if "src_thread" in kwargs or "src_process" in kwargs: # build record to log src_thread cur_record = logging.makeLogRecord({ "threadName": kwargs.get("src_thread", kwargs.get("src_process", "???")), "process": kwargs.get("src_pid", 0), "msg": what, "levelno": level, "levelname": logging_tools.get_log_level_str(level) }) cur_dst.handle(cur_record) else: cur_dst.log(level, what) else: self.__log_cache.append((dst, what, level)) else: logging_tools.my_syslog(what, level)
def _log(what, log_level=logging_tools.LOG_LEVEL_OK): if logger is None: print("[{}] {}".format( logging_tools.get_log_level_str(log_level), what))
def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): if self.log_com: self.log_com("[dh] {}".format(what), log_level) else: print("[dh {:2d} {}] {}".format( log_level, logging_tools.get_log_level_str(log_level), what))
def stdout_log(self, what, log_level=logging_tools.LOG_LEVEL_OK): print("[{:<5s}] {}".format(logging_tools.get_log_level_str(log_level), what))
def log_com(what, level): print("{} [{}] {}".format(time.ctime(), logging_tools.get_log_level_str(level), what))
def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): self.__log_template.log(log_level, what) if self.__verbose: print("[{:4s}.{:<10s}] {}".format(logging_tools.get_log_level_str(log_level), self.name, what))
def log_com(a, b): print("[{:>6s}] {}".format(logging_tools.get_log_level_str(b), a))