def do_set_host(self, host):
"""Устанавливает хост брокера и подгружает данные.
:param host: Хост брокера
:type host: str
"""
self.host = host
print("Preloading leaves... ", end="")
try:
r = requests.get("http://{}/api/druid/leaf".format(self.host),
headers={"Token": self.token})
self.leaves = loads(r.text)
print("done, {} elements".format(len(self.leaves)))
except Exception as e:
print("Failed: {}".format(e))
print("Preloading branches... ", end="")
try:
r = requests.get("http://{}/api/druid/branch".format(self.host),
headers={"Token": self.token})
self.branches = loads(r.text)
print("done, {} elements".format(len(self.branches)))
except Exception as e:
print("Failed: {}".format(e))
print("Preloading species... ", end="")
try:
r = requests.get("http://{}/api/druid/species".format(self.host),
headers={"Token": self.token})
self.species = loads(r.text)
print("done, {} elements".format(len(self.species)))
except Exception as e:
print("Failed: {}".format(e))
def patch(self, _id):
"""Модифицирует указанный вид приложения."""
data = loads(self.request.body)
self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def patch(self, _id):
"""Модифицирует указанный вид приложения."""
data = loads(self.request.body)
self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def post(self):
"""Инициализирует новый вид приложения."""
data = loads(self.request.body)
yield self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def post(self):
"""Инициализирует новый вид приложения."""
data = loads(self.request.body)
yield self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def do_status(self, *args, **kwargs):
"""Выводит статус листа."""
r = requests.get(
"http://{}/api/druid/leaf/{}/status".format(self.host, self.__leaf__),
headers={"Token": self.token}
)
print_dict(loads(r.text))
def do_info(self, *args, **kwargs):
"""Выводит информацию о листе."""
r = requests.get(
"http://{}/api/druid/leaf/{}".format(self.host, self.__leaf__),
headers={"Token": self.token}
)
print_dict(loads(r.text))
def post(self, _id):
"""Обрабатывает rpc-запрос."""
data = loads(self.request.body)
assert type(data) == list
response = yield self.application.emperor.call_vassal_rpc(_id, *data)
self.finish(dumps(response))
def post(self, _id):
"""Обрабатывает rpc-запрос."""
data = loads(self.request.body)
assert type(data) == list
response = yield self.application.emperor.call_vassal_rpc(_id, *data)
self.finish(dumps(response))
def patch(self, leaf_name):
"""Модифицирует информацию о листе.
:param leaf_name: Имя листа
:type leaf_name: str
"""
# Обрабатываем только ключи active, address
apply_changes = self.get_argument("apply",
default="TRUE").upper() == "TRUE"
keys = ["active", "address"]
data = loads(self.request.body)
for key in data.keys():
if key not in keys:
del data[key]
leaf_data = yield self.application.async_db.leaves.find_one(
{"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish(dumps({
"result": "failure",
"message": "Unknown leaf"
}))
raise gen.Return()
yield self.application.async_db.leaves.update({"name": leaf_name},
{"$set": data})
leaf = yield self.application.async_db.leaves.find_one(
{"name": leaf_name})
if apply_changes:
if leaf["active"]:
branch = next(x for x in self.application.druid.branch
if x["name"] == leaf["branch"])
species = yield self.application.async_db.species.find_one(
{"_id": leaf["type"]})
leaf = full_leaf_info(leaf, self.application.druid.air,
species)
yield branch_prepare_species(branch, species)
yield branch_start_leaf(branch, leaf)
yield [
air_enable_host(air, address) for air, address in product(
self.application.druid.air, leaf["address"])
]
else:
branch = next(x for x in self.application.druid.branch
if x["name"] == leaf["branch"])
yield branch_stop_leaf(branch, leaf)
self.finish(dumps({"result": "success", "message": "OK"}))
def post(self):
"""Создает новый логгер."""
data = loads(self.request.body)
try:
self.application.branch.add_logger(data)
self.finish(dumps({"result": "success"}))
except Logger.LoggerCreationError as e:
self.set_status(400)
self.finish(dumps({"result": "failure", "message": e.message}))
def post(self):
"""Создает новый логгер."""
data = loads(self.request.body)
try:
self.application.branch.add_logger(data)
self.finish(dumps({"result": "success"}))
except Logger.LoggerCreationError as e:
self.set_status(400)
self.finish(dumps({"result": "failure", "message": e.message}))
def wrapper(self, *args, **kwargs):
try:
data = loads(self.request.body)
validate(data, schema_descriptor)
except (ValidationError, JSONDecodeError) as e:
self.set_status(400)
self.finish({"result": "failure", "message": str(e)})
else:
data.update(kwargs)
return function(self, *args, **data)
def do_find_traceback(self, tb_id):
"""Ищет трейсбек ошибки по его id.
:param tb_id: id трейсбека
:type tb_id: str
"""
r = requests.get(
"http://{}/api/druid/traceback/{}".format(self.host, tb_id),
headers={"Token": self.token}
)
print(highlight(loads(r.text)["traceback"], PythonTracebackLexer(), TerminalFormatter()))
def do_check_branch(self, branch):
"""Обработчик команды check_branch."""
if not branch:
print("Specify branch")
return
r = requests.put("http://{}/api/druid/branch/{}".format(
self.host, branch),
headers={"Token": self.token},
data="")
print(loads(r.text))
def post(self):
"""Создает новый лист."""
data = loads(self.request.body)
try:
leaf = self.application.branch.create_leaf(**data)
started = self.application.branch.add_leaf(leaf)
self.finish(dumps({"result": "started" if started else "queued"}))
except Species.NotDefined:
self.set_status(400)
self.finish(dumps({"result": "error", "message": "Unknown species"}))
def watch_logs():
conn = yield websocket_connect(HTTPRequest(
"ws://{}/api/druid/logs/{}".format(self.host, self.__id__),
headers={"Token": self.token}
))
while True:
msg = yield conn.read_message()
if not msg:
break
print_log(loads(msg))
def do_check_branch(self, branch):
"""Обработчик команды check_branch."""
if not branch:
print("Specify branch")
return
r = requests.put(
"http://{}/api/druid/branch/{}".format(self.host, branch),
headers={"Token": self.token},
data=""
)
print(loads(r.text))
def watch_logs():
conn = yield websocket_connect(
HTTPRequest("ws://{}/api/druid/logs/{}".format(
self.host, self.__id__),
headers={"Token": self.token}))
while True:
msg = yield conn.read_message()
if not msg:
break
print_log(loads(msg))
def do_update_species(self, species):
"""Обработчик команды update_species.
:param species: Имя обновляемого вида
:type species: str
"""
species = next(x for x in self.species if x["name"] == species)
r = requests.patch("http://{}/api/druid/species/{}".format(
self.host, species["_id"]),
headers={"Token": self.token},
data="")
print(loads(r.text))
def do_set_host(self, host):
"""Устанавливает хост брокера и подгружает данные.
:param host: Хост брокера
:type host: str
"""
self.host = host
print("Preloading leaves... ", end="")
try:
r = requests.get(
"http://{}/api/druid/leaf".format(self.host),
headers={"Token": self.token}
)
self.leaves = loads(r.text)
print("done, {} elements".format(len(self.leaves)))
except Exception as e:
print("Failed: {}".format(e))
print("Preloading branches... ", end="")
try:
r = requests.get(
"http://{}/api/druid/branch".format(self.host),
headers={"Token": self.token}
)
self.branches = loads(r.text)
print("done, {} elements".format(len(self.branches)))
except Exception as e:
print("Failed: {}".format(e))
print("Preloading species... ", end="")
try:
r = requests.get(
"http://{}/api/druid/species".format(self.host),
headers={"Token": self.token}
)
self.species = loads(r.text)
print("done, {} elements".format(len(self.species)))
except Exception as e:
print("Failed: {}".format(e))
def do_update_species(self, species):
"""Обработчик команды update_species.
:param species: Имя обновляемого вида
:type species: str
"""
species = next(x for x in self.species if x["name"] == species)
r = requests.patch(
"http://{}/api/druid/species/{}".format(self.host, species["_id"]),
headers={"Token": self.token},
data=""
)
print(loads(r.text))
def do_find_traceback(self, tb_id):
"""Ищет трейсбек ошибки по его id.
:param tb_id: id трейсбека
:type tb_id: str
"""
r = requests.get("http://{}/api/druid/traceback/{}".format(
self.host, tb_id),
headers={"Token": self.token})
print(
highlight(
loads(r.text)["traceback"], PythonTracebackLexer(),
TerminalFormatter()))
def patch(self, leaf_name):
"""Модифицирует информацию о листе.
:param leaf_name: Имя листа
:type leaf_name: str
"""
# Обрабатываем только ключи active, address
apply_changes = self.get_argument("apply", default="TRUE").upper() == "TRUE"
keys = ["active", "address"]
data = loads(self.request.body)
for key in data.keys():
if key not in keys:
del data[key]
leaf_data = yield self.application.async_db.leaves.find_one({"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish(dumps({"result": "failure", "message": "Unknown leaf"}))
raise gen.Return()
yield self.application.async_db.leaves.update(
{"name": leaf_name},
{"$set": data}
)
leaf = yield self.application.async_db.leaves.find_one({"name": leaf_name})
if apply_changes:
if leaf["active"]:
branch = next(x for x in self.application.druid.branch if x["name"] == leaf["branch"])
species = yield self.application.async_db.species.find_one({"_id": leaf["type"]})
leaf = full_leaf_info(leaf, self.application.druid.air, species)
yield branch_prepare_species(branch, species)
yield branch_start_leaf(branch, leaf)
yield [
air_enable_host(air, address) for air, address in product(
self.application.druid.air,
leaf["address"]
)
]
else:
branch = next(x for x in self.application.druid.branch if x["name"] == leaf["branch"])
yield branch_stop_leaf(branch, leaf)
self.finish(dumps({"result": "success", "message": "OK"}))
def do_create_leaf(self, args):
"""Обработчик команды create_leaf."""
leaf_name, leaf_type, leaf_address = args.split()
if not all([leaf_name, leaf_type, leaf_address]):
print("Specify all args")
return
r = requests.post("http://{}/api/druid/leaf".format(self.host),
headers={"Token": self.token},
data=dumps({
"name": leaf_name,
"type": leaf_type,
"address": leaf_address
}))
print(loads(r.text))
def post(self):
"""Создает новый лист."""
data = loads(self.request.body)
try:
leaf = self.application.branch.create_leaf(**data)
started = self.application.branch.add_leaf(leaf)
self.finish(dumps({"result": "started" if started else "queued"}))
except Species.NotDefined:
self.set_status(400)
self.finish(
dumps({
"result": "error",
"message": "Unknown species"
}))
def do_create_leaf(self, args):
"""Обработчик команды create_leaf."""
leaf_name, leaf_type, leaf_address = args.split()
if not all([leaf_name, leaf_type, leaf_address]):
print("Specify all args")
return
r = requests.post(
"http://{}/api/druid/leaf".format(self.host),
headers={"Token": self.token},
data=dumps({
"name": leaf_name,
"type": leaf_type,
"address": leaf_address
})
)
print(loads(r.text))
def __restore_leaves__(self):
"""Выполняет восстановление листьев после перезагрузки."""
for leaf_config in os.listdir(self.trunk.emperor.vassal_dir):
config = ConfigParser.ConfigParser()
config.read(os.path.join(self.trunk.emperor.vassal_dir, leaf_config))
try:
data = loads(config.get("forest", "data"))
if data.get("cls") != "Leaf":
continue
try:
leaf = self.create_leaf(**data)
except (TypeError, ValueError):
pass
if leaf:
log_message("Restoring leaf {}".format(leaf.id), component="Branch")
self.add_leaf(leaf, start=False)
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError, Species.NotDefined):
continue
def __restore_leaves__(self):
"""Выполняет восстановление листьев после перезагрузки."""
for leaf_config in os.listdir(self.trunk.emperor.vassal_dir):
config = ConfigParser.ConfigParser()
config.read(os.path.join(self.trunk.emperor.vassal_dir, leaf_config))
try:
data = loads(config.get("forest", "data"))
if data.get("cls") != "Leaf":
continue
try:
leaf = self.create_leaf(**data)
except (TypeError, ValueError):
pass
if leaf:
log_message("Restoring leaf {}".format(leaf.id), component="Branch")
self.add_leaf(leaf, start=False)
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError, Species.NotDefined):
continue
def log_message(self, message):
"""Логгирует входящее сообщение в базе, дополняя информацией о времени, компоненте и т.п.
:param message: Логгируемое сообщение
:type message: list
"""
for data in (_.strip() for _ in message if _.strip()):
try:
data_parsed = loads(data)
try:
data_parsed["time"] = datetime.datetime.utcfromtimestamp(int(data_parsed["time"]))
except KeyError:
data_parsed["time"] = datetime.datetime.utcnow()
except ValueError:
pass
for key in ["msecs", "status", "request_size", "response_size"]:
if key in data_parsed:
data_parsed[key] = int(data_parsed[key])
data_parsed["log_type"] = "leaf.event"
except json.JSONDecodeError:
data_parsed = logparse(data)
data_parsed["time"] = datetime.datetime.utcnow()
data_parsed.update({
"component_name": self.trunk.name,
"component_type": "branch"
})
try:
yield [logger.log(data_parsed) for logger in self.__loggers__ if logger.suitable(data_parsed)]
except:
traceback.print_exc()
failed_loggers = [logger for logger in self.__loggers__ if logger.failed]
for logger in failed_loggers:
self.__loggers__.remove(logger)
def log_message(self, message):
"""Логгирует входящее сообщение в базе, дополняя информацией о времени, компоненте и т.п.
:param message: Логгируемое сообщение
:type message: list
"""
for data in (_.strip() for _ in message if _.strip()):
try:
data_parsed = loads(data)
try:
data_parsed["time"] = datetime.datetime.utcfromtimestamp(int(data_parsed["time"]))
except KeyError:
data_parsed["time"] = datetime.datetime.utcnow()
except ValueError:
pass
for key in ["msecs", "status", "request_size", "response_size"]:
if key in data_parsed:
data_parsed[key] = int(data_parsed[key])
data_parsed["log_type"] = "leaf.event"
except json.JSONDecodeError:
data_parsed = logparse(data)
data_parsed["time"] = datetime.datetime.utcnow()
data_parsed.update({"component_name": self.trunk.name, "component_type": "branch"})
try:
yield [logger.log(data_parsed) for logger in self.__loggers__ if logger.suitable(data_parsed)]
except:
traceback.print_exc()
failed_loggers = [logger for logger in self.__loggers__ if logger.failed]
for logger in failed_loggers:
self.__loggers__.remove(logger)
def do_info(self, *args, **kwargs):
"""Выводит информацию о листе."""
r = requests.get("http://{}/api/druid/leaf/{}".format(
self.host, self.__leaf__),
headers={"Token": self.token})
print_dict(loads(r.text))
def do_status(self, *args, **kwargs):
"""Выводит статус листа."""
r = requests.get("http://{}/api/druid/leaf/{}/status".format(
self.host, self.__leaf__),
headers={"Token": self.token})
print_dict(loads(r.text))
