def __init__(self, name, force_enable=False, **kwargs): ConfigReader.__init__(self, **kwargs) self.__name = name self.__filter = None self.__force_enable = force_enable self.__actions = list() self.__opts = None
def __init__(self, force_enable=False, **kwargs): """ Parameters ---------- force_enable : bool, optional Passed to JailReader to force enable the jails. It is for internal use """ ConfigReader.__init__(self, **kwargs) self.__jails = list() self.__force_enable = force_enable
def __readConfig(self):
''' Read the base config
'''
config_reader = ConfigReader(self.__log_config_url)
config = config_reader.readConfig()
self.__format = config.get("Output", "format", 1)
self.__level = config.get("Level", "level")
#self.__url = config.get("Url", "log_save_url")
output_place_string = config.get("Output", "output_place")
output_place_string.upper()
self.__out_place = output_place_string.split(",")
self.readConfigByFileType(config)
def proceed_message(message_object):
message_text = message_object['text']
message_command = re.sub('^(.*?)[\\s@].*', '\\1', message_text, flags=re.S)
if message_command[0] != '/' or message_command == '':
raise ValueError
message_command = message_command[1:]
logger.info('Command: ' + message_command)
config = ConfigReader(CONFIG_FILE_NAME)
module_name = config.get_command_dict()[message_command]
logger.info('Command found in config')
module = getattr(__import__('modules.' + module_name), module_name) # Black python magic
logger.info('Module successfully imported')
result = module.run(message_object)
return result
def getOptions(self, section=None):
"""Reads configuration for jail(s) and adds enabled jails to __jails
"""
opts = []
self.__opts = ConfigReader.getOptions(self, "Definition", opts)
if section is None:
sections = self.sections()
else:
sections = [ section ]
# Get the options of all jails.
parse_status = True
for sec in sections:
jail = JailReader(sec, basedir=self.getBaseDir(),
force_enable=self.__force_enable)
jail.read()
ret = jail.getOptions()
if ret:
if jail.isEnabled():
# We only add enabled jails
self.__jails.append(jail)
else:
logSys.error("Errors in jail %r. Skipping..." % sec)
parse_status = False
return parse_status
def getOptions(self, section = None):
opts = []
self.__opts = ConfigReader.getOptions(self, "Definition", opts)
if section:
# Get the options of a specific jail.
jail = JailReader(section)
jail.read()
ret = jail.getOptions()
if ret:
if jail.isEnabled():
# We only add enabled jails
self.__jails.append(jail)
else:
logSys.error("Errors in jail '%s'. Skipping..." % section)
return False
else:
# Get the options of all jails.
for sec in self.sections():
jail = JailReader(sec)
jail.read()
ret = jail.getOptions()
if ret:
if jail.isEnabled():
# We only add enabled jails
self.__jails.append(jail)
else:
logSys.error("Errors in jail '" + sec + "'. Skipping...")
return False
return True
def __init__(self, file, clientName, fileType):
configreader = ConfigReader()
config = configreader.readConfig()
fileDelimiter = config.get(clientName, fileType + '.delimiter')
self.fileTopOffset = int(config.get(clientName, fileType + '.topOffset'))
self.fileLeftOffset = int(config.get(clientName, fileType + '.leftOffset'))
try:
with open(file, 'rb') as csvfile:
file = csv.reader(csvfile.read().decode('utf-8-sig').encode('utf-8').splitlines(),
delimiter=fileDelimiter, quotechar='"')
self.data = []
for line in file:
self.data.append(line)
except Exception as error:
exit(error)
def getOptions(self, pOpts):
opts = [
["string", "timeregex", None],
["string", "timepattern", None],
["string", "ignoreregex", ""],
["string", "failregex", ""],
]
self.__opts = ConfigReader.getOptions(self, "Definition", opts, pOpts)
def __readConfig(self):
''' Read the base config
'''
config_reader = ConfigReader(self.__log_config_url)
config = config_reader.readConfig()
self.__format = config.get("Output", "format", raw=True)
self.__level = config.get("Level", "level")
self.__url = config.get("Url", "log_save_url")
output_place_string = config.get("Output", "output_place")
output_place_string.upper()
self.__out_place = output_place_string.split(",")
# if output_place=CONSOLE, FILE, ROTATINGFILE
# then self.__out_place would be ['CONSOLE', ' FILE', ' ROTATINGFILE']
# in this case, items in self.__out_place should be stripped of blank spaces
self.__out_place = [output.strip() for output in self.__out_place]
self.readConfigByFileType(config)
def getOptions(self, pOpts):
opts = [["string", "actionstart", ""],
["string", "actionstop", ""],
["string", "actioncheck", ""],
["string", "actionban", ""],
["string", "actionunban", ""]]
self.__opts = ConfigReader.getOptions(self, "Definition", opts, pOpts)
if self.has_section("Init"):
for opt in self.options("Init"):
if not self.__cInfo.has_key(opt):
self.__cInfo[opt] = self.get("Init", opt)
def getOptions(self):
opts = [["bool", "enabled", "false"],
["string", "logpath", "/var/log/messages"],
["string", "backend", "auto"],
["int", "maxretry", 3],
["int", "findtime", 600],
["int", "bantime", 600],
["string", "usedns", "warn"],
["string", "failregex", None],
["string", "ignoreregex", None],
["string", "ignorecommand", None],
["string", "ignoreip", None],
["string", "filter", ""],
["string", "action", ""]]
self.__opts = ConfigReader.getOptions(self, self.__name, opts)
if not self.__opts:
return False
if self.isEnabled():
# Read filter
if self.__opts["filter"]:
self.__filter = FilterReader(self.__opts["filter"], self.__name,
basedir=self.getBaseDir())
ret = self.__filter.read()
if ret:
self.__filter.getOptions(self.__opts)
else:
logSys.error("Unable to read the filter")
return False
else:
self.__filter = None
logSys.warn("No filter set for jail %s" % self.__name)
# Read action
for act in self.__opts["action"].split('\n'):
try:
if not act: # skip empty actions
continue
splitAct = JailReader.splitAction(act)
action = ActionReader(splitAct, self.__name, basedir=self.getBaseDir())
ret = action.read()
if ret:
action.getOptions(self.__opts)
self.__actions.append(action)
else:
raise AttributeError("Unable to read action")
except Exception, e:
logSys.error("Error in action definition " + act)
logSys.debug("Caught exception: %s" % (e,))
return False
if not len(self.__actions):
logSys.warn("No actions were defined for %s" % self.__name)
def getOptions(self):
opts = []
self.__opts = ConfigReader.getOptions(self, "Definition", opts)
for sec in self.sections():
jail = JailReader(sec)
jail.read()
ret = jail.getOptions()
if ret:
if jail.isEnabled():
self.__jails.append(jail)
else:
logSys.error("Errors in jail '" + sec + "'. Skipping...")
return False
return True
def getOptions(self):
opts = [["bool", "enabled", "false"],
["string", "logpath", "/var/log/messages"],
["string", "backend", "auto"], ["int", "maxretry", 3],
["int", "findtime", 600], ["int", "bantime", 600],
["string", "usedns", "warn"], ["string", "failregex", None],
["string", "ignoreregex", None], ["string", "ignoreip", None],
["string", "filter", ""], ["string", "action", ""]]
self.__opts = ConfigReader.getOptions(self, self.__name, opts)
if self.isEnabled():
# Read filter
self.__filter = FilterReader(self.__opts["filter"],
self.__name,
basedir=self.getBaseDir())
ret = self.__filter.read()
if ret:
self.__filter.getOptions(self.__opts)
else:
logSys.error("Unable to read the filter")
return False
# Read action
for act in self.__opts["action"].split('\n'):
try:
if not act: # skip empty actions
continue
splitAct = JailReader.splitAction(act)
action = ActionReader(splitAct,
self.__name,
basedir=self.getBaseDir())
ret = action.read()
if ret:
action.getOptions(self.__opts)
self.__actions.append(action)
else:
raise AttributeError("Unable to read action")
except Exception, e:
logSys.error("Error in action definition " + act)
logSys.debug("Caught exception: %s" % (e, ))
return False
if not len(self.__actions):
logSys.warn("No actions were defined for %s" % self.__name)
def _load_configuration(self):
""" Try and load configuration based on the predefined precendence """
self.config_reader = ConfigReader(self._config_path)
self.credentials_reader = CredentialsReader(
self._get_credentials_path())
self.metadata_reader = MetadataReader(self._metadata_server)
self._load_credentials()
self._load_region()
self._load_hostname()
self._load_proxy_server_name()
self._load_proxy_server_port()
self._set_endpoint()
self._set_ec2_endpoint()
self._load_autoscaling_group()
self.debug = self.config_reader.debug
self.pass_through = self.config_reader.pass_through
self.push_asg = self.config_reader.push_asg
self.push_constant = self.config_reader.push_constant
self.constant_dimension_value = self.config_reader.constant_dimension_value
self._check_configuration_integrity()
def getOptions(self):
opts = [["bool", "enabled", "false"],
["string", "logpath", "/var/log/messages"],
["string", "backend", "auto"],
["int", "maxretry", 3],
["int", "findtime", 600],
["int", "bantime", 600],
["string", "usedns", "warn"],
["string", "failregex", None],
["string", "ignoreregex", None],
["string", "ignoreip", None],
["string", "filter", ""],
["string", "action", ""]]
self.__opts = ConfigReader.getOptions(self, self.__name, opts)
if self.isEnabled():
# Read filter
self.__filter = FilterReader(self.__opts["filter"], self.__name,
basedir=self.getBaseDir())
ret = self.__filter.read()
if ret:
self.__filter.getOptions(self.__opts)
else:
logSys.error("Unable to read the filter")
return False
# Read action
for act in self.__opts["action"].split('\n'):
try:
splitAct = JailReader.splitAction(act)
action = ActionReader(splitAct, self.__name, basedir=self.getBaseDir())
ret = action.read()
if ret:
action.getOptions(self.__opts)
self.__actions.append(action)
else:
raise AttributeError("Unable to read action")
except Exception, e:
logSys.error("Error in action definition " + act)
logSys.debug(e)
return False
def __init__(self, config_file):
if path.exists(config_file) and path.isfile(config_file):
conf = ConfigReader(config_file)
self.output = conf.get("output")
self.output_file = conf.get("output_file")
self.level = conf.get("level")
self.__log_levels = {
"debug": 10,
"info": 20,
"warning": 30,
"error": 40,
"critical": 50,
}
self.message_format = conf.get("message_format")
self.date_format = conf.get("date_format")
self.formatter = Formatter(self.level, self.message_format,
self.date_format)
else:
raise IOError("Can't find configuration file.")
def getOptions(self):
opts = [["bool", "enabled", "false"],
["string", "logpath", "/var/log/messages"],
["string", "backend", "auto"],
["int", "maxretry", 3],
["int", "findtime", 600],
["int", "bantime", 600],
["string", "failregex", None],
["string", "ignoreregex", None],
["string", "ignoreip", None],
["string", "filter", ""],
["string", "action", ""]]
self.__opts = ConfigReader.getOptions(self, self.__name, opts)
if self.isEnabled():
# Read filter
self.__filter = FilterReader(self.__opts["filter"], self.__name)
ret = self.__filter.read()
if ret:
self.__filter.getOptions(self.__opts)
else:
logSys.error("Unable to read the filter")
return False
# Read action
for act in self.__opts["action"].split('\n'):
try:
splitAct = JailReader.splitAction(act)
action = ActionReader(splitAct, self.__name)
ret = action.read()
if ret:
action.getOptions(self.__opts)
self.__actions.append(action)
else:
raise AttributeError("Unable to read action")
except Exception, e:
logSys.error("Error in action definition " + act)
logSys.debug(e)
return False
def __init__(self, config_file):
if path.exists(config_file) and path.isfile(config_file):
conf = ConfigReader(config_file)
self.output = conf.get("output")
self.output_file = conf.get("output_file")
self.level = conf.get("level")
self.__log_levels = {
"debug": 10,
"info": 20,
"warning": 30,
"error": 40,
"critical": 50,
}
self.message_format = conf.get("message_format")
self.date_format = conf.get("date_format")
self.formatter = Formatter(
self.level, self.message_format, self.date_format)
else:
raise IOError("Can't find configuration file.")
def setBaseDir(folderName): ConfigReader.setBaseDir(folderName)
def read(self): return ConfigReader.read(self, "filter.d/" + self.__file)
def read(self): ConfigReader.read(self, "jail")
def getOptions(self, pOpts): opts = [["string", "ignoreregex", ""], ["string", "failregex", "failmodel", ""]] self.__opts = ConfigReader.getOptions(self, "Definition", opts, pOpts)
def read(self):
return ConfigReader.read(self, "jail")
def read(self): ConfigReader.read(self, "fail2ban")
from daterelate.daterelate import relate
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.firefox.options import Options as FirefoxOptions
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as conditions
from selenium.webdriver.support import ui
from configreader import ConfigReader
os.environ['DISPLAY'] = ':0' # Set the display if set to run as cronjob
HOMEPAGE = 'http://myaccount.telkom.co.ke'
TODAY = datetime.now()
config = ConfigReader('defaults.ini')
TITLE = config.get('notificationtitle', default='Telkom Balance')
NUMBER = config.get('number', section='credentials', default='')
PASSWD = config.get('pass', section='credentials', default='')
s = os.path.join(os.path.expanduser('~'), 'bin')
driver_path = config.get('driverspath', default=s)
chrome_driver_name = config.get('chromedrivername',
section='Chrome',
default='chromedriver')
firefox_driver_name = config.get('firefoxdrivername',
section='Firefox',
default='geckodriver')
headless = config.get('headless', default=True)
chrome_options = ChromeOptions()
firefox_options = FirefoxOptions()
def read(self): return ConfigReader.read(self, "action.d/" + self.__file)
from configreader import ConfigReader
config = ConfigReader("../../res/test.cfg")
print config.get("name")
print config.get_string("name")
print config.get_int("some_int")
print config.get_float("some_float")
print config.get_long("some_long")
print config.get_boolean("some_bool")
print config.get_boolean("some_int")
print config.get_boolean("some_nonexistent_property")
class InputReceiver():
def __init__(self):
self.oP = OutPipe("InputReceiver", 0)
self.cR = ConfigReader(GAME_PATH + "controls")
self.sE = ScriptExecuter()
self.eI = EngineInterface(objectMode=False)
self.keyboard = self.eI.getKeyboard()
self.mouse = self.eI.getMouse()
self.tH = TypingHandler(self.keyboard)
self.pairs = {}
self.responses = {}
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
self.sE.addContext("Input", self)
self.sE.execute(INPUT_PATH + "csp")
self.sE.execute(INPUT_PATH + "input")
self.keyEvents = []
self.readControls()
self.locked = False
self.xsens = 50
self.ysens = 50
self.inverted = 0
self.predict = False
self.recent = {}
self.oP("Initialized.")
def addEvent(self, event):
if not event in self.recent.keys():
self.keyEvents.append(["INPUT", "COMMAND", event])
if not type(event) == type(tuple()):
self.recent[event] = time.time()
if self.predict:
self.callClientSidePrediction(event)
def callClientSidePrediction(self, event):
if not type(event) == type(tuple()):
if hasattr(self, "csp_" + event):
getattr(self, "csp_" + event)()
else:
if hasattr(self, "csp_look"):
getattr(self, "csp_look")(event)
def readControls(self):
keys = self.cR.getAllOptions("CONTROLS")
for key in keys:
keyString = self.cR.get("CONTROLS", key)
keyCode = self.eI.getKeyCode(keyString)
try:
self.pairs[keyCode] = getattr(self, key)
self.oP("Read in key response %s successfully." % key)
except:
self.oP("Failed to read in key response %s successfully." %
key)
def checkControls(self):
for keyCode in self.pairs.keys():
if keyCode in self.keyboard.events and not self.locked:
if self.keyboard.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("KEYBOARD", keyCode)
elif keyCode in self.mouse.events:
if self.mouse.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("MOUSE", keyCode)
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
#Handle the "recent" spam blocker
keys = self.recent.keys()
for key in keys:
if abs(self.recent[key] - time.time()) > 0.1:
del self.recent[key]
break
if self.locked:
self.tH.process()
def callCommand(self, mode, keyCode):
if mode == "KEYBOARD":
state = self.getState(self.keyboard.events[keyCode],
self.oldKeyboard[keyCode])
elif mode == "MOUSE":
state = self.getState(self.mouse.events[keyCode],
self.oldMouse[keyCode])
consumed = False
if state == "DEACTIVATE" and keyCode in [
self.eI.e.LEFTMOUSE, self.eI.e.RIGHTMOUSE
]:
consumed = self.checkInterfaceClick(keyCode, self.mouse.position)
if not consumed and not keyCode in [
self.eI.e.MOUSEX, self.eI.e.MOUSEY
]:
self.pairs[keyCode](state)
elif keyCode in [self.eI.e.MOUSEX, self.eI.e.MOUSEY]:
pos = self.mouse.position
self.pairs[keyCode](pos)
def checkInterfaceClick(self, keyCode, pos):
return self.eI.getGlobal("client").inputClick(keyCode, pos)
def getState(self, newstate, oldstate):
if newstate == self.eI.l.KX_INPUT_ACTIVE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_NONE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "INACTIVE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_RELEASED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
def __init__(self, action, name): ConfigReader.__init__(self) self.__file = action[0] self.__cInfo = action[1] self.__name = name
def __init__(self, fileName, name):
ConfigReader.__init__(self)
self.__file = fileName
self.__name = name
def __init__(self, name): ConfigReader.__init__(self) self.__name = name self.__filter = None self.__actions = list()
from configreader import ConfigReader
import getpass
import psycopg2
from prettytable import PrettyTable
from prettytable import from_db_cursor
def get_script_path():
return os.path.dirname(os.path.realpath(sys.argv[0]))
configfile = '/etc/pgsnapman/pgsnapman.config'
if not os.path.exists(configfile):
configfile = home = expanduser("~") + '/.pgsnapman.config'
print configfile
if not os.path.exists(configfile):
configfile = get_script_path() + '/../bin/pgsnapman.config'
config = ConfigReader(configfile)
PGSCHOST=config.getval('PGSCHOST')
PGSCPORT=config.getval('PGSCPORT')
PGSCUSER=config.getval('PGSCUSER')
PGSCDB=config.getval('PGSCDB')
PGSCPASSWORD=config.getval('PGSCPASSWORD')
print('')
print('+-----------------------------+')
print('| pgsnapman script uploader |')
print('+-----------------------------+')
print('')
print('Verifying database connection...')
if PGSCPASSWORD == '':
PGSCPASSWORD=getpass.getpass('password: ')
try:
def __init__(self, fileName, name, **kwargs):
ConfigReader.__init__(self, **kwargs)
self.__file = fileName
self.__name = name
from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StructField, DateType, \
StringType, TimestampType, DecimalType, IntegerType
from configreader import ConfigReader
from parsers import parse_line
spark = SparkSession.builder.getOrCreate()
spark.sparkContext.addPyFile("parsers.py")
from azure.storage.blob import BlobServiceClient
reader = ConfigReader("config.cfg", "azure-storage")
config = reader.get_config()
# Get Azure storage info from config
storage_acct_name = config["account_name"]
storage_acct_access_key = config["access_key"]
storage_container = config["container_name"]
mount_root = config["mount_root"]
# Set Spark Azure storage account and key
storage_acct_key_str = f"fs.azure.account.key.{storage_acct_name}.blob.core.windows.net"
spark.conf.set(storage_acct_key_str, storage_acct_access_key)
# Set base Spark filepath for container
container_base_path = f"wasbs://{storage_container}@{storage_acct_name}.blob.core.windows.net"
mount_base_path = f"{mount_root}/{storage_container}"
# Set up container client
blob_service_client = BlobServiceClient(account_url=f"https://{storage_acct_name}.blob.core.windows.net", \
credential=storage_acct_access_key)
def getOptions(self, pOpts):
opts = [["string", "ignoreregex", ""], ["string", "failregex", ""]]
self.__opts = ConfigReader.getOptions(self, "Definition", opts, pOpts)
def read(self):
return ConfigReader.read(self, os.path.join("filter.d", self.__file))
def getOptions(self): opts = [["int", "loglevel", 1], ["string", "logtarget", "STDERR"]] self.__opts = ConfigReader.getOptions(self, "Definition", opts)
def read(self):
ConfigReader.read(self, "jail")
def read(self):
ConfigReader.read(self, "fail2ban")
def __init__(self, fileName, name, **kwargs):
ConfigReader.__init__(self, **kwargs)
# Defer initialization to the set Methods
self.__file = self.__name = self.__opts = None
self.setFile(fileName)
self.setName(name)
def __init__(self, name, force_enable=False, **kwargs):
ConfigReader.__init__(self, **kwargs)
self.__name = name
self.__filter = None
self.__force_enable = force_enable
self.__actions = list()
def getOptions(self):
opts = [["int", "loglevel", 1], ["string", "logtarget", "STDERR"]]
self.__opts = ConfigReader.getOptions(self, "Definition", opts)
def __init__(self, fileName, name): ConfigReader.__init__(self) self.__file = fileName self.__name = name
def __init__(self, name): ConfigReader.__init__(self) self.__name = name self.__filter = None self.__actions = list()
def __init__(self): ConfigReader.__init__(self) self.__jails = list()
from cellgrid import CellGrid
from cell import Cell
from coord import Coord
from configreader import ConfigReader
import route
import json
import datetime
config = ConfigReader("settings.conf")
api_key = config.apikey
grid = CellGrid(Coord(39.0095, -77.16796),
Coord(38.8044, -76.89331),
grid_width=5,
grid_height=5)
with open('gridfeaturecounts.json', 'r') as featurecounts_per_cell:
javascript_analysis_results_json = featurecounts_per_cell.read().replace(
'\n', '')
grid.load_javascript_analysis_json(javascript_analysis_results_json)
grid.generate_scaled_scores_zero_to_one()
print(grid.to_geojson())
def __init__(self, **kwargs):
ConfigReader.__init__(self, **kwargs)
def __init__(self, action, name): ConfigReader.__init__(self) self.__file = action[0] self.__cInfo = action[1] self.__name = name
def getBaseDir(): return ConfigReader.getBaseDir()
def read(self): return ConfigReader.read(self, "action.d/" + self.__file)
def read(self):
return ConfigReader.read(self, "filter.d/" + self.__file)
def getEarlyOptions(self):
opts = [["string", "socket", "/var/run/fail2ban/fail2ban.sock"],
["string", "pidfile", "/var/run/fail2ban/fail2ban.pid"]]
return ConfigReader.getOptions(self, "Definition", opts)
def __init__(self): ConfigReader.__init__(self)
def setBaseDir(folderName): ConfigReader.setBaseDir(folderName)
def getEarlyOptions(self): opts = [["string", "socket", "/tmp/fail2ban.sock"], ["string", "pidfile", "/var/run/fail2ban/fail2ban.pid"]] return ConfigReader.getOptions(self, "Definition", opts)
def getBaseDir(): return ConfigReader.getBaseDir()
def __init__(self):
ConfigReader.__init__(self)
self.__jails = list()
for pattern in sortDict.keys():
if re.search(pattern, filename):
logging.info(" Regex matched: " + pattern + " with Filename: " + filename)
src = folder_to_track + "/" + filename
to = sortDict.get(pattern) + "/" + filename
try:
os.rename(src, to)
logging.info(" Moved " + src + " to " + to)
except FileNotFoundError as Identifier:
logging.warning(Identifier)
logging.warning(" Please look at your destination path and whether the path exists. ")
# Config
StartLogging()
config = ConfigReader()
sortDict = config.getParams()
folder_to_track = config.getTrackFolder()
# Handling
eventHandler = DownloadFileHandler()
observer = Observer()
observer.schedule(eventHandler, folder_to_track, recursive =True)
observer.start()
try:
while True:
time.sleep(10)
logging.info(" Running, timestamp: [" + str(time.asctime()) + "]")
except KeyboardInterrupt:
observer.stop()
def __init__(self):
configreader = ConfigReader()
self.config = configreader.readConfig()
def read(self): return ConfigReader.read(self, "jail")
