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))
