def delete(self, identifier):
"""Удаляет логгер."""
result, code, message = self.application.branch.delete_logger(identifier)
if not result:
self.set_status(code)
self.finish(dumps({"result": "failure", "message": message}))
else:
self.finish(dumps({"result": "success"}))
def delete(self, identifier):
"""Удаляет логгер."""
result, code, message = self.application.branch.delete_logger(
identifier)
if not result:
self.set_status(code)
self.finish(dumps({"result": "failure", "message": message}))
else:
self.finish(dumps({"result": "success"}))
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 get(self, _id):
"""Возвращает информацию об указанном виде приложения."""
_id = ObjectId(_id)
species = self.application.branch.species.get(_id)
if species:
self.finish(dumps(species.description))
else:
self.set_status(404)
self.finish(dumps({}))
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 get(self, _id):
"""Возвращает информацию об указанном виде приложения."""
_id = ObjectId(_id)
species = self.application.branch.species.get(_id)
if species:
self.finish(dumps(species.description))
else:
self.set_status(404)
self.finish(dumps({}))
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:
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 put(self, data):
"""Отправляет лог клиенту.
:param data: Передаваемый лог
:type data: dict
"""
self.write_message(dumps(data))
def put(self, branch_name):
"""Выполняет принудительную проверку всех листьев на указанной ветви.
:param branch_name: Имя ветви
:type branch_name: str
"""
try:
branch = next(x for x in self.application.druid.branch
if x["name"] == branch_name)
except StopIteration:
self.set_status(404)
self.finish()
raise gen.Return()
cursor = self.application.async_db.leaves.find({
"branch": branch_name,
"active": True
})
verified_species = set()
while (yield cursor.fetch_next):
leaf = cursor.next_object()
species = yield self.application.async_db.species.find_one(
{"_id": leaf["type"]})
leaf = full_leaf_info(leaf, self.application.druid.air, species)
if leaf["type"] not in verified_species:
yield branch_prepare_species(branch, species)
verified_species.add(leaf["type"])
yield branch_start_leaf(branch, leaf)
self.finish(dumps({"result": "success"}))
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 patch(self, _id):
"""Модифицирует указанный вид приложения."""
data = loads(self.request.body)
self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def put(self, data):
"""Отправляет лог клиенту.
:param data: Передаваемый лог
:type data: dict
"""
self.write_message(dumps(data))
def get(self):
"""Получает информацию о всех логгерах."""
self.finish(
dumps([{
"identifier": logger.identifier,
"type": logger.__class__.__name__
} for logger in self.application.branch.__loggers__]))
def get(self, address=None):
"""Возвращает все листья, соответствующие фильтру.
:param address: Адрес для фильтрации
:type address: str
"""
if address:
query = {"address": address}
else:
query = {}
cursor = self.application.async_db.leaves.find(
query,
{
"name": True
}
)
self.write("[")
leaf = None
while (yield cursor.fetch_next):
if leaf:
self.write(",")
leaf = cursor.next_object()
self.write(dumps(leaf))
self.finish("]")
def patch(self, _id):
"""Модифицирует указанный вид приложения."""
data = loads(self.request.body)
self.application.branch.create_species(data)
self.finish(dumps({"result": "success", "message": "OK"}))
def put(self, branch_name):
"""Выполняет принудительную проверку всех листьев на указанной ветви.
:param branch_name: Имя ветви
:type branch_name: str
"""
try:
branch = next(x for x in self.application.druid.branch if x["name"] == branch_name)
except StopIteration:
self.set_status(404)
self.finish()
raise gen.Return()
cursor = self.application.async_db.leaves.find({"branch": branch_name, "active": True})
verified_species = set()
while (yield cursor.fetch_next):
leaf = cursor.next_object()
species = yield self.application.async_db.species.find_one({"_id": leaf["type"]})
leaf = full_leaf_info(leaf, self.application.druid.air, species)
if leaf["type"] not in verified_species:
yield branch_prepare_species(branch, species)
verified_species.add(leaf["type"])
yield branch_start_leaf(branch, leaf)
self.finish(dumps({"result": "success"}))
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 post(self, host):
"""Добавляет передаваемый в параметре host в список разрешенных.
:param host: Хостнейм, разрешаемый в системе
:type host: str
"""
self.application.air.allow_host(host)
self.finish(dumps({"result": "success"}))
def get(self):
"""Получает информацию о всех логгерах."""
self.finish(dumps([
{
"identifier": logger.identifier,
"type": logger.__class__.__name__
} for logger in self.application.branch.__loggers__
]))
def post(self, host):
"""Добавляет передаваемый в параметре host в список разрешенных.
:param host: Хостнейм, разрешаемый в системе
:type host: str
"""
self.application.air.allow_host(host)
self.finish(dumps({"result": "success"}))
def get(self, species_id):
"""Возвращает информацию о виде листа.
:param species_id: Идентификатор вида
:type species_id: str
"""
_id = ObjectId(species_id)
species = yield self.application.async_db.species.find_one({"_id": _id})
self.set_status(200 if species else 404)
self.finish(dumps(species))
def get(self, species_id):
"""Возвращает информацию о виде листа.
:param species_id: Идентификатор вида
:type species_id: str
"""
_id = ObjectId(species_id)
species = yield self.application.async_db.species.find_one(
{"_id": _id})
self.set_status(200 if species else 404)
self.finish(dumps(species))
def get(self):
"""Возвращает все известные виды листьев."""
cursor = self.application.async_db.species.find()
self.write("[")
species = None
while (yield cursor.fetch_next):
if species:
self.write(",")
species = cursor.next_object()
self.write(dumps({"_id": species["_id"], "name": species["name"]}))
self.finish("]")
def get(self, traceback_id):
"""Возвращает трейсбек по его id.
:param traceback_id: Идентификатор трейсбека
:type traceback_id: str
"""
traceback = yield self.application.async_db.logs.find_one({
"log_type": "leaf.traceback",
"traceback_id": traceback_id
})
self.set_status(200 if traceback else 404)
self.finish(dumps(traceback))
def get(self, leaf_name):
"""Возвращает настройки листа.
:param leaf_name: Имя листа
:type leaf_name: str
"""
leaf_data = yield self.application.async_db.leaves.find_one({"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish("")
else:
self.finish(dumps(leaf_data))
def get(self, leaf_name):
"""Возвращает настройки листа.
:param leaf_name: Имя листа
:type leaf_name: str
"""
leaf_data = yield self.application.async_db.leaves.find_one(
{"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish("")
else:
self.finish(dumps(leaf_data))
def get(self):
"""Возвращает список всех известных листьев."""
self.write("[")
first = True
for leaf in self.application.branch.leaves.keys():
if not first:
self.write(",")
else:
first = False
self.write(dumps(leaf))
self.finish("]")
def get(self):
"""Возвращает список всех известных листьев."""
self.write("[")
first = True
for leaf in self.application.branch.leaves.keys():
if not first:
self.write(",")
else:
first = False
self.write(dumps(leaf))
self.finish("]")
def get(self, traceback_id):
"""Возвращает трейсбек по его id.
:param traceback_id: Идентификатор трейсбека
:type traceback_id: str
"""
traceback = yield self.application.async_db.logs.find_one({
"log_type":
"leaf.traceback",
"traceback_id":
traceback_id
})
self.set_status(200 if traceback else 404)
self.finish(dumps(traceback))
def get(self):
"""Возвращает все известные виды листьев."""
cursor = self.application.async_db.species.find()
self.write("[")
species = None
while (yield cursor.fetch_next):
if species:
self.write(",")
species = cursor.next_object()
self.write(dumps({
"_id": species["_id"],
"name": species["name"]
}))
self.finish("]")
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 get(self, leaf_name):
"""Возвращает статус листа, полученный с активной ветви.
:param leaf_name: Имя листа
:type leaf_name: str
"""
leaf_data = yield self.application.async_db.leaves.find_one({"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish("")
branch = next(x for x in self.application.druid.branch if x["name"] == leaf_data["branch"])
leaf_status, code = yield send_request(branch, "branch/leaf/{}".format(str(leaf_data["_id"])), "GET")
self.finish(dumps(leaf_status))
def open(self, leaf):
"""Открывает подключение и регистрирует логгер.
:param leaf: Лист, логи которого передаются клиенту
:type leaf: str
"""
if self.application.secret != self.request.headers.get("Token"):
self.write_message(dumps({
"result": "error",
"message": "Not authenticated"
}))
self.close()
return
self.leaf = leaf
self.application.druid.add_listener(self.leaf, self)
def open(self, leaf):
"""Открывает подключение и регистрирует логгер.
:param leaf: Лист, логи которого передаются клиенту
:type leaf: str
"""
if self.application.secret != self.request.headers.get("Token"):
self.write_message(
dumps({
"result": "error",
"message": "Not authenticated"
}))
self.close()
return
self.leaf = leaf
self.application.druid.add_listener(self.leaf, self)
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 get(self, leaf_name):
"""Возвращает статус листа, полученный с активной ветви.
:param leaf_name: Имя листа
:type leaf_name: str
"""
leaf_data = yield self.application.async_db.leaves.find_one(
{"name": leaf_name})
if not leaf_data:
self.set_status(404)
self.finish("")
branch = next(x for x in self.application.druid.branch
if x["name"] == leaf_data["branch"])
leaf_status, code = yield send_request(
branch, "branch/leaf/{}".format(str(leaf_data["_id"])), "GET")
self.finish(dumps(leaf_status))
def get(self, address=None):
"""Возвращает все листья, соответствующие фильтру.
:param address: Адрес для фильтрации
:type address: str
"""
if address:
query = {"address": address}
else:
query = {}
cursor = self.application.async_db.leaves.find(query, {"name": True})
self.write("[")
leaf = None
while (yield cursor.fetch_next):
if leaf:
self.write(",")
leaf = cursor.next_object()
self.write(dumps(leaf))
self.finish("]")
def __get_config__(self):
"""Конфигурация листа в нормальном состоянии.
:returns: Конфигурация uwsgi-вассала
:rtype: str
"""
logs_format = {
"uri": "%(uri)",
"addr": "%(addr)",
"host": "%(host)",
"time": "%(epoch)",
"proto": "%(proto)",
"msecs": "%(msecs)",
"method": "%(method)",
"status": "%(status)",
"warning": "%(warning)",
"request_size": "%(cl)",
"response_size": "%(size)",
"traceback": "%(traceback)",
"log_source": {
"$oid": str(self.id)
}
}
config = """[forest]
data={leaf_data_dict}
[uwsgi]
master=1
need-app=
buffer-size=65535
heartbeat=10
socket={leaf_host}:0
logger=zeromq:tcp://127.0.0.1:{log_port}
req-logger=zeromq:tcp://127.0.0.1:{log_port}
logformat={logformat}
log-encoder=prefix [Leaf {id}]
{media}
{static}
plugin={python}
module=wsgi:application
processes={workers}
offload-threads=4
{threads}
chdir={chdir}
env=BATTERIES={batteries}
env=APPLICATION_SETTINGS={app_settings}
env=VIRTUAL_ENV={virtualenv}
virtualenv={virtualenv}
if-env=PATH
env=PATH={virtualenv}/bin:%(_)
endif=
{mules}
{cron}
{triggers}
""".format(
app_settings=dumps(self.settings),
batteries=dumps(self.__batteries__),
chdir=self.__species__.src_path,
cron=self.get_cron_config(),
id=self.id,
leaf_data_dict=dumps(self.dict),
leaf_host=self.leaf_host,
log_port=self.log_port,
logformat=dumps(logs_format),
media=self.get_media_config(),
mules=self.get_mules_config(),
python=self.__species__.python,
static=self.get_static_config(),
threads="enable-threads=" if self.threads else "",
triggers=self.get_triggers_config(),
virtualenv=self.species.environment,
workers=self.workers
)
for router, address in product(self.__fastrouters__, self.address):
config += "subscribe-to={0}:{1},5,SHA1:{2}\n".format(
router,
address, self.keyfile
)
return config
def get(self, _id):
"""Получает информацию о листе с указанным id."""
self.finish(dumps(self.application.emperor.stats(_id)))
def get(self):
"""Возвращает имена всех ветвей, известных серверу."""
self.finish(dumps([x["name"] for x in self.application.druid.branch]))
def post(self, **data):
"""Создает новый лист."""
with (yield self.application.druid.creation_lock.acquire()):
leaf_address_check = yield self.application.async_db.leaves.find_one(
{
"$or": [{
"address": data["address"]
}, {
"name": data["name"]
}]
})
if leaf_address_check:
self.set_status(400)
self.finish(
dumps({
"result": "error",
"message": "Duplicate address"
}))
raise gen.Return()
try:
query = {"_id": ObjectId(data["type"])}
except (TypeError, InvalidId):
query = {"name": data["type"]}
species = yield self.application.async_db.species.find_one(query)
if not species:
self.set_status(400)
self.finish(
dumps({
"result": "error",
"message": "Unknown species"
}))
raise gen.Return()
branch = random.choice(self.application.druid.branch)
leaf_id = yield self.application.async_db.leaves.insert({
"name":
data["name"],
"desc":
data.get("description", ""),
"type":
species["_id"],
"active":
data.get("start", True),
"address": [data["address"]],
"branch":
branch["name"],
"settings":
data.get("settings", {})
})
yield [
air_enable_host(air, data["address"])
for air in self.application.druid.air
]
if species.get("requires", []):
roots = self.application.druid.roots[0]
db_settings, code = yield send_request(
roots, "roots/db", "POST", {
"name": leaf_id,
"db_type": species["requires"]
})
yield self.application.async_db.leaves.update(
{"_id": leaf_id}, {"$set": {
"batteries": db_settings
}})
else:
pass
leaf = yield self.application.async_db.leaves.find_one(
{"_id": leaf_id})
if leaf.get("active", True):
leaf = full_leaf_info(leaf, self.application.druid.air,
species)
yield branch_prepare_species(branch, species)
yield branch_start_leaf(branch, leaf)
self.finish(
dumps({
"result": "success",
"message": "OK",
"branch": branch["name"]
}))
def get(self):
"""Возвращает имена всех ветвей, известных серверу."""
self.finish(dumps([x["name"] for x in self.application.druid.branch]))
def post(self, **data):
"""Создает новый лист."""
with (yield self.application.druid.creation_lock.acquire()):
leaf_address_check = yield self.application.async_db.leaves.find_one({
"$or": [
{"address": data["address"]},
{"name": data["name"]}
]
})
if leaf_address_check:
self.set_status(400)
self.finish(dumps({
"result": "error",
"message": "Duplicate address"
}))
raise gen.Return()
try:
query = {"_id": ObjectId(data["type"])}
except (TypeError, InvalidId):
query = {"name": data["type"]}
species = yield self.application.async_db.species.find_one(query)
if not species:
self.set_status(400)
self.finish(dumps({
"result": "error",
"message": "Unknown species"
}))
raise gen.Return()
branch = random.choice(self.application.druid.branch)
leaf_id = yield self.application.async_db.leaves.insert(
{
"name": data["name"],
"desc": data.get("description", ""),
"type": species["_id"],
"active": data.get("start", True),
"address": [data["address"]],
"branch": branch["name"],
"settings": data.get("settings", {})
}
)
yield [air_enable_host(air, data["address"]) for air in self.application.druid.air]
if species.get("requires", []):
roots = self.application.druid.roots[0]
db_settings, code = yield send_request(
roots,
"roots/db",
"POST",
{
"name": leaf_id,
"db_type": species["requires"]
}
)
yield self.application.async_db.leaves.update(
{"_id": leaf_id},
{"$set": {"batteries": db_settings}}
)
else:
pass
leaf = yield self.application.async_db.leaves.find_one({"_id": leaf_id})
if leaf.get("active", True):
leaf = full_leaf_info(leaf, self.application.druid.air, species)
yield branch_prepare_species(branch, species)
yield branch_start_leaf(branch, leaf)
self.finish(dumps({"result": "success", "message": "OK", "branch": branch["name"]}))
def get(self, _id):
"""Получает информацию о листе с указанным id."""
self.finish(dumps(self.application.emperor.stats(_id)))
