%PDF-
%PDF-
Mini Shell
Mini Shell
"""
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Copyright © 2019 Cloud Linux Software Inc.
This software is also available under ImunifyAV commercial license,
see <https://www.imunify360.com/legal/eula>
"""
import inspect
import logging
import os
import time
from datetime import datetime, timedelta
from peewee import (
BlobField,
CharField,
DateField,
ForeignKeyField,
IntegerField,
PeeweeException,
)
from defence360agent.model import instance, Model
#: seconds in a POSIX day
POSIX_DAY = 24 * 60 * 60
logger = logging.getLogger(__name__)
class FilenameField(BlobField):
"""
Class to store file names in database
"""
def db_value(self, value):
return os.fsencode(value)
def python_value(self, value):
return os.fsdecode(value)
class ScanPathField(CharField):
REALTIME_SCAN_PATH_STUB = 'list_of_files'
def db_value(self, value):
if isinstance(value, list):
return self.REALTIME_SCAN_PATH_STUB
return value
class ModelError(PeeweeException):
"""
Model exception. Please use this one from other modules instead
PeeweeException directly
"""
pass
async def run_in_executor(loop, cb, *args):
"""
Fake run_in_executor() test (DEF-4541)
"""
return cb(*args)
def remove_old_and_truncate(table: Model,
num_days: int,
max_count: int) -> int:
"""
Removes records that is older that *num_days* days and
all others that are out of range *max_count* from *table*.
Returns count of rows deleted.
"""
has_timestamp = getattr(table, 'timestamp', False)
if not has_timestamp:
raise ValueError("No 'timestamp' column in table {!r}".format(table))
# keep no more than *max_count* rows that are newer than *num_days*
end_save_time = time.time() - num_days * POSIX_DAY
to_keep = table.select(table.timestamp).order_by(
table.timestamp.desc()).limit(max_count).where(
table.timestamp > end_save_time)
deleted_count = table.delete().where(
table.timestamp.not_in(to_keep)).execute()
return deleted_count
class Eula(Model):
"""Keeps track of updates and acceptions of end user license agreement.
Admins will be asked to accept EULA if the latest version is not accepted
yet.
"""
class Meta:
database = instance.db
db_table = 'eula'
#: Date when EULA was updated.
updated = DateField(primary_key=True)
#: Timestamp when EULA was accepted.
accepted = IntegerField(null=True, default=None)
@classmethod
def is_accepted(cls) -> bool:
unaccepted = next(iter(
cls.select().where(
cls.accepted.is_null()
).order_by(
cls.updated
).limit(1)), None)
return unaccepted is None
@classmethod
def accept(cls) -> None:
cls.update(accepted=time.time()) \
.where(cls.accepted.is_null()).execute()
def get_models(module):
return [
obj for _, obj in inspect.getmembers(
module, lambda obj:
inspect.isclass(obj) and issubclass(obj, Model) and obj != Model
)]
def create_tables(module):
instance.db.connect()
instance.db.create_tables(get_models(module), safe=True)
class ApplyOrderBy:
@staticmethod
def resolve_nodes(_model, column_name: str) -> tuple:
"""
:param _model: peewee.Model or peewee.ForeignKeyField
:param column_name: str
:return: tuple<peewee.Node>
"""
model = _model.rel_model\
if isinstance(_model, ForeignKeyField) else _model
nodes = ()
custom_order_by = getattr(model, 'OrderBy', None)
if custom_order_by is not None:
nodes = getattr(custom_order_by,
column_name, lambda: nodes)()
if not nodes:
node = getattr(model, column_name, None)
if node is not None:
nodes = node, # type: ignore
return nodes
@staticmethod
def get_nodes(model, column_names: list) -> list:
"""
:param model: peewee.Model or peewee.ForeignKeyField
:param column_names: list<str>
:return: list<peewee.Node>
"""
column_name, rest = column_names[0], column_names[1:]
nodes = ApplyOrderBy.resolve_nodes(model, column_name)
result = []
for node_or_model in nodes:
if rest: # model
for node in ApplyOrderBy.get_nodes(node_or_model, rest):
result.append(node)
else: # node
result.append(node_or_model)
return result
def __call__(self, order_by, model, query_builder):
"""
:param order_by: list<OrderBy>
:param model: peewee.Model or peewee.ForeignKeyField
:param query_builder: peewee.Query
:return: peewee.Query with applied order_by
"""
orders = []
for order in order_by:
nodes = ApplyOrderBy.get_nodes(model, order.column_name.split('.'))
for node in nodes:
orders.append(node.desc() if order.desc else node)
return query_builder.order_by(*orders)
apply_order_by = ApplyOrderBy()
Zerion Mini Shell 1.0