def main():
# Initialize configuration
configurationManager = ConfigurationManager()
configurations = configurationManager.initialize()
driver = Driver()
testManager = TestManager(driver, configurations)
testManager.run_test()
def reloadSchemes(self) -> None:
self.clear()
self.setColumnCount(3)
self.setHorizontalHeaderLabels(["Name", "Standalone book", "Series volume"])
self._schemes = ConfigurationManager().namingSchemes
scheme: NamingScheme
for scheme in self._schemes:
item: QStandardItem
row: List[QStandardItem] = []
item = QStandardItem(scheme.name)
item.setEditable(False)
row.append(item)
item = QStandardItem(scheme.standalone.getResolved())
item.setEditable(False)
row.append(item)
item = QStandardItem(scheme.volume.getResolved())
item.setEditable(False)
row.append(item)
self.appendRow(row)
def __init__(self, client):
self.manually_overriden = False
self.configuration_manager = ConfigurationManager(self.CONFIGURATION_FILENAME)
self.repost_manager = RepostManager(self.HASHES_FILENAME)
self.command_processor = CommandProcessor(self)
self.configuration_manager.load_configuration()
self.TOKEN = self.configuration_manager.configuration['token']
self.MASTER_ADMIN_ID = self.configuration_manager.configuration['admin']
self.ABOUT_MESSAGE = self.configuration_manager.configuration['about']
self.client = client
def __init__(self):
try:
self.protocols = []
self.configuration_manager = ConfigurationManager()
self.configuration_manager.load_config(path / 'config' /
'config.json',
default=True)
self.plugin_manager = PluginManager(self.configuration_manager)
self.plugin_manager.load_from_path(
path / self.configuration_manager.config.plugin_path)
self.plugin_manager.resolve_dependencies()
self.plugin_manager.activate_all()
asyncio.Task(self.plugin_manager.get_overrides())
except Exception as e:
print("Exception encountered during server startup.")
print(e)
loop.stop()
sys.exit()
def __init__(self):
try:
self.connections = []
self.configuration_manager = ConfigurationManager()
self.configuration_manager.load_config(path / 'config' /
'config.json',
default=True)
self.plugin_manager = PluginManager(self.configuration_manager,
factory=self)
self.plugin_manager.load_from_path(
path / self.configuration_manager.config.plugin_path)
self.plugin_manager.resolve_dependencies()
self.plugin_manager.activate_all()
asyncio.ensure_future(self.plugin_manager.get_overrides())
except Exception as err:
logger.exception("Error during server startup.", exc_info=True)
loop.stop()
sys.exit()
def start_app(self):
if not os.getenv('PWRCON_CONFIG'):
self._logger.error('PWRCON_CONFIG environment variable missing!')
sys.exit(1)
config_file = os.getenv('PWRCON_CONFIG')
self._config_mgr = ConfigurationManager()
config = self._config_mgr.parse_config_file(config_file)
if not config:
print(f"ERROR: {self._config_mgr.last_error_msg}")
return
wx_app = wx.App()
main_window = MainWindow(config)
main_window.Show()
wx_app.MainLoop()
def start_app(self):
self._config_mgr = ConfigurationManager()
config = self._config_mgr.parse_config_file('configuration.json')
if not config:
self._logger.Log(LogType.Error, self._config_mgr.last_error_msg)
return
wx_app = wx.App()
reactor.registerWxApp(wx_app)
self._state_object = KeypadStateObject(config, self._logger)
keypad_api_ctrl = KeypadApiController(config, self._state_object,
self._log_store, self._logger)
api_server = server.Site(keypad_api_ctrl)
reactor.listenTCP(config.keypadController.networkPort, api_server)
check_panel_loop = LoopingCall(self._state_object.check_panel)
check_panel_loop.start(0.01, now=False)
reactor.run()
def accept(self) -> None:
if not self.testConnection():
return
self.library.setBackend(self.backend_tab.getBackend())
self.library.setName(self.name_input.text())
# resolving naming scheme selection
indices: List[int] = [
m.row() for m in self.naming_schemes_list.selectionModel().selectedRows()
]
assert len(indices) == 1
scheme: NamingScheme = cast(
List[NamingScheme], ConfigurationManager().namingSchemes
)[indices[0]]
self.library.setNamingScheme(scheme)
return super().accept()
def main():
config_file_path = sys.argv[1]
endpoints_description = sys.argv[2]
junit_output = sys.argv[3]
custom_payloads_path = sys.argv[4] if len(sys.argv) == 5 else None
with open(config_file_path, 'r') as config_file_pointer:
ConfigurationManager(config_file_pointer)
target = ConfigurationManager.config["target"]
# Load and generate default payloads
load_default_payloads(target["hostname"])
# If user specified file with custom payloads, we add them to our mutations
payloads_loader = PayloadsLoader(target["hostname"])
payloads_loader.load_payloads(custom_payloads_path,
FuzzPayloads.CUSTOM_PAYLOADS_KEY)
with open(junit_output, 'w', encoding='utf8') as junit_output_file_pointer:
with open(FUZZING_LOG_FILE, "w",
encoding='utf8') as full_log_file_pointer:
text_logger = TextLogger(full_log_file_pointer)
junit_logger = JUnitLogger(junit_output_file_pointer,
test_suite_name_delimiter=":",
hostname=target["hostname"])
protocol = 'ssl' if target["ssl"] is True else 'tcp'
with open(endpoints_description,
'r') as endpoints_description_file_pointer:
endpoints = json.loads(
endpoints_description_file_pointer.read())
fuzzer = Fuzzer(endpoints, text_logger, junit_logger, protocol)
fuzzer.fuzz()
return fuzzer.was_there_any_failure()
def deserialize(self, serialized: Dict[str, Any]) -> None:
b: Type[Backend]
name: str = serialized.get("backendName", "")
backend: Optional[Backend] = None
for b in Backends:
if b.getName() == name:
backend = b()
break
if not backend:
raise IOError(
"backend with name {name} not found".format(name=name))
ser: Dict[str, Any] = serialized.get("backend", {})
if not ser:
raise IOError("no backend data supplied")
backend.deserialize(ser)
self._backend = backend
self._tree.setBackend(self._backend)
self._uuid = uuid.UUID(serialized.get("uuid", ""))
self._name = serialized.get("name", "")
tree: Dict[str, Any] = serialized.get("tree", {})
if tree:
self._tree.deserialize(tree)
books: List[Dict[str, Any]] = serialized.get("books", [])
book: Dict[str, Any]
for book in books:
book_obj: Book = Book()
book_obj.deserialize(book)
self._books[book_obj.path.as_posix()] = book_obj
scheme_s: str = serialized.get("naming_scheme", "")
if not scheme_s:
warnings.warn(
f"library '{self._name}' has no naming scheme. Will use the default naming scheme instead."
)
self._naming_scheme = cast(List[NamingScheme],
ConfigurationManager().namingSchemes)[0]
else:
scheme_idx: int = cast(List[NamingScheme],
ConfigurationManager().namingSchemes).index(
scheme_s) # type: ignore
self._naming_scheme = cast(
List[NamingScheme],
ConfigurationManager().namingSchemes)[scheme_idx]
import logging
import time
from configuration_manager import ConfigurationManager
conf_manager = ConfigurationManager()
module_params = {}
@conf_manager.observe
def update_configuration(new_configuration):
print('updating new configuration')
global module_params
module_params = new_configuration
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
module_params = conf_manager.configuration()
print(module_params)
conf_manager.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
conf_manager.stop()
conf_manager.join()
# Broadening the base path in order to import remind-me's libraries
Install_Directory = os.path.dirname(os.path.abspath(__file__))
os.chdir(Install_Directory)
sys.path.append(Install_Directory + '/src/python')
# remind-me's libraries imports
from configuration_manager import ConfigurationManager
from data_manager_plyvel import DataManagerPlyvel
from data_manager_pickle import DataManagerPickle
from mordelles_library_api import MordellesLibraryAPI
from xtemplate import Xtemplate
from loans_mailer import LoansMailer
if __name__ == "__main__":
with ConfigurationManager(Install_Directory + '/preferences.yaml') as cm, \
DataManagerPickle(cm) as dm, \
MordellesLibraryAPI(cm) as lib_api, \
Xtemplate() as formatter, \
LoansMailer(cm, dm, lib_api, formatter) as mailer:
# Configure logging facility
app_logger = logging.getLogger()
app_logger.setLevel(0)
# Defines logger file and max size
handler = logging.handlers.RotatingFileHandler(
cm.get('configuration.log-directory') + '/' +
cm.get("configuration.log-file"),
maxBytes=1000000)
# Define logger format
formatter = logging.Formatter(
def setup(self):
self.config = ConfigurationManager()
def __init__(self, config=None, create=None):
config = config or self.DEFAULT_CONFIG_PATH
create = create or False
self.config_manager = ConfigurationManager(os.path.abspath(config),
create)
self.executor = CommandExecutor(self.config_manager)
def __init__(
self, backend_tab: Type[BackendTab], library: Library, *args: Any, **kwargs: Any
):
super().__init__(*args, **kwargs)
self.library = library
self.name_input_was_edited = False
self.updated.connect(self.handleUpdated)
layout = QHBoxLayout(self)
self.tabs = QTabWidget(self)
self.general_tab = QWidget(self)
general_layout: QHBoxLayout = QHBoxLayout(self.general_tab)
name_label: QLabel = QLabel("Name:", self.general_tab)
general_layout.addWidget(name_label)
self.name_input = QLineEdit(self.library.getName(), self.general_tab)
self.name_input.textChanged.connect(self.handleUpdated)
self.name_input.textEdited.connect(self.setNameInputWasEdited)
name_label.setBuddy(self.name_input)
general_layout.addWidget(self.name_input)
naming_schemes_label: QLabel = QLabel("Naming scheme:", self.general_tab)
general_layout.addWidget(naming_schemes_label)
self.naming_schemes_list = QTableView(self.general_tab)
self.naming_schemes_list.setTabKeyNavigation(False)
self.naming_schemes_model = NamingSchemesModel()
self.naming_schemes_list.setModel(self.naming_schemes_model)
self.naming_schemes_list.setSelectionMode(QTableView.SingleSelection)
self.naming_schemes_list.setSelectionBehavior(QTableView.SelectRows)
self.naming_schemes_list.selectRow(
0
if not self.library.getNamingScheme()
else cast(List[NamingScheme], ConfigurationManager().namingSchemes).index(
cast(NamingScheme, self.library.getNamingScheme())
)
)
naming_schemes_label.setBuddy(self.naming_schemes_list)
general_layout.addWidget(self.naming_schemes_list)
self.general_tab.setLayout(general_layout)
self.tabs.addTab(self.general_tab, "General")
self.backend_tab = backend_tab(self, self.library.getBackend())
self.tabs.addTab(self.backend_tab, "Location")
self.button_box = QDialogButtonBox(
cast(
QDialogButtonBox.StandardButton,
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
),
self,
)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
layout.addWidget(self.button_box)
self.setLayout(layout)
self.updated.emit()