def lambda_handler(event, context):
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'])
try:
print("File to process %s" % key)
response = s3.get_object(Bucket=bucket, Key=key)
body = response['Body']
data = body.read()
# If the name has a .gz extension, then decompress the data
if key[-3:] == '.gz':
data = zlib.decompress(data, 16 + zlib.MAX_WBITS)
config = Configuration("config.json")
con = Sender(config=config.get("sender"))
# Send json events to Devo
print("Starting to send lines to Devo")
counter = 0
for line in data.splitlines():
events_json = json.loads(line)
for single_event in events_json["Records"]:
dumped_event = json.dumps(single_event)
aws_account_id = "a"
if single_event.get("getuserIdentity", None) is not None:
if single_event.get("getuserIdentity")\
.get("accountId", None) is not None:
aws_account_id = single_event["getuserIdentity"][
"accountId"]
elif single_event.get("account", None) is not None:
aws_account_id = single_event["account"]
elif single_event.get("recipientAccountId", None) is not None:
aws_account_id = single_event["recipientAccountId"]
aws_region = "b"
if single_event.get("awsRegion", None) is not None:
aws_region = single_event["awsRegion"]
elif single_event.get("region", None) is not None:
aws_region = single_event["region"]
tag = "{!s}.{!s}.{!s}".format(config.get("tag"),
aws_account_id, aws_region)
counter += con.send(tag=encode(tag),
msg=encode(dumped_event),
zip=False)
con.close()
print("Finished sending lines to Devo (%d)" % counter)
except Exception as e:
print(e)
print("Error getting file '%s' from bucket '%s'. Make sure they \
exist and your bucket is in the same region as this function." %
(key, bucket))
def test_ssl_lookup_simplify(self):
engine_config = SenderConfigSSL(
address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain,
check_hostname=False,
verify_mode=CERT_NONE,
)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, historic_tag=None, con=con)
lookup.send_headers(headers=["KEY", "HEX", "COLOR"],
key="KEY",
action="START")
if len(con.socket.recv(1000)) == 0:
raise Exception("Not msg sent!")
lookup.send_data_line(key="11", fields=["11", "HEX12", "COLOR12"])
if len(con.socket.recv(1000)) == 0:
raise Exception("Not msg sent!")
lookup.send_headers(headers=["KEY", "HEX", "COLOR"],
key="KEY",
action="END")
if len(con.socket.recv(1000)) == 0:
raise Exception("Not msg sent!")
con.socket.shutdown(0)
def configure(args):
"""For load configuration file/object"""
if args.get('config'):
config = Configuration(args.get('config'))
config.mix(dict(args))
else:
config = dict(args)
if 'freq' in config.keys():
parts = config['freq'].split('-')
config['freq'] = (float(parts[0]), float(parts[1]))
config['template'] = config['template'].read()
# Initialize LtSender with the config credentials but only
# if we aren't in batch mode or simulation mode
engine = None
if not (config['batch_mode'] or config['simulation']):
try:
if "sender" not in config.keys():
config['sender'] = {
'key': config.get('key', None),
'chain': config.get('chain', None),
'cert': config.get('cert', None),
'address': config.get('address', None),
'port': config.get('port', 443)
}
engine = Sender(config=config.get('sender'))
except Exception as error:
print_error(error, show_help=False)
print_error("Error when loading devo sender configuration",
show_help=True)
return engine, config
def test_sender_as_handler_static(self):
"""
Test that tries to check that Sender class can be used as a Handler
through the static functions
and related logs are send to remote server
"""
try:
engine_config = {"address": self.server, "port": self.port,
"key": self.key, "cert": self.cert,
"chain": self.chain, "check_hostname": False,
"verify_mode": CERT_NONE}
con = Sender.for_logging(config=engine_config, tag=self.my_app,
level=TEST_FACILITY)
logger = get_log(name="DevoLogger2", handler=con,
level=TEST_FACILITY)
print("Testing logger info")
logger.info("Testing Sender static handler functionality... "
"INFO - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger error")
logger.error("Testing Sender static logging handler "
"functionality... ERROR - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger warning")
logger.warning("Testing Sender static logging handler "
"functionality... WARNING - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger debug")
logger.debug("Testing Sender static logging handler "
"functionality... DEBUG - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger critical")
logger.critical("Testing Sender static logging handler "
"functionality... CRITICAL - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
def test_sender_with_default_logger(self):
"""
Test that tries to check that Sender class can still use an internal
logger and shows both local and remote
traces
"""
try:
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain,
check_hostname=False,
verify_mode=CERT_NONE)
con = Sender.for_logging(config=engine_config,
tag=self.my_app,
level=TEST_FACILITY)
# NOTE: this logger logging traces will be visible in console
con.logger.info("Testing Sender default handler functionality in "
"local console... INFO - log")
# NOTE: this logger logging traces will be visible in the remote
# table
con.info("Testing Sender default handler functionality in remote "
"table... INFO - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
def test_create_lookup_key_index_preserves_structure(self):
engine_config = SenderConfigSSL(
address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain,
check_hostname=False,
verify_mode=CERT_NONE,
)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, con=con)
headers = ["col1", "col2", "col3"]
fields = ["a", "b", "c"]
expected_headers = '[{"col1":{"type":"str","key":true}},{"col2":{"type":"str"}},{"col3":{"type":"str"}}]'
with mock.patch.object(lookup,
"send_control",
wraps=lookup.send_control) as lookup_spy:
lookup.send_headers(headers=headers,
key_index=0,
event="START",
action="FULL")
lookup_spy.assert_called_with(action="FULL",
event="START",
headers=expected_headers)
lookup.send_data_line(key_index=0, fields=fields)
lookup.send_headers(headers=headers,
key_index=0,
event="END",
action="FULL")
lookup_spy.assert_called_with(action="FULL",
event="END",
headers=expected_headers)
con.socket.shutdown(0)
def test_sender_as_handler(self):
"""
Test that tries to check that Sender class can be used as a Handler
and related logs are send to remote server
"""
try:
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key, cert=self.cert,
chain=self.chain,
check_hostname=False,
verify_mode=CERT_NONE)
con = Sender.for_logging(config=engine_config, tag=self.my_app,
level=TEST_FACILITY)
logger = get_log(name="DevoLogger", handler=con,
level=TEST_FACILITY)
print("Testing logger info")
logger.info("Testing Sender inherit logging handler functio"
"nality... INFO - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger error")
logger.error("Testing Sender inherit logging handler function"
"ality... ERROR - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger warning")
logger.warning("Testing Sender inherit logging handler functio"
"nality... WARNING - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger debug")
logger.debug("Testing Sender inherit logging handler functiona"
"lity... DEBUG - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
print("Testing logger critical")
logger.critical("Testing Sender inherit logging handler functio"
"nality... CRITICAL - log")
data_received = con.socket.recv(5000)
print(b"\n" + data_received)
if len(data_received) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
def write_to_lookup_table_command():
lookup_table_name = demisto.args()['lookupTableName']
headers = check_type(demisto.args()['headers'], list)
records = check_type(demisto.args()['records'], list)
creds = get_writer_creds()
engine_config = SenderConfigSSL(address=(WRITER_RELAY, 443),
key=creds['key'].name,
cert=creds['crt'].name,
chain=creds['chain'].name)
try:
con = Sender(config=engine_config, timeout=60)
lookup = Lookup(name=lookup_table_name, historic_tag=None, con=con)
# Order sensitive list
pHeaders = json.dumps(headers)
lookup.send_control('START', pHeaders, 'INC')
for r in records:
lookup.send_data_line(key=r['key'], fields=r['values'])
lookup.send_control('END', pHeaders, 'INC')
finally:
con.flush_buffer()
con.socket.shutdown(0)
entry = {
'Type': entryTypes['note'],
'Contents': {
'recordsWritten': records
},
'ContentsFormat': formats['json'],
'ReadableContentsFormat': formats['markdown'],
'EntryContext': {
'Devo.RecordsWritten': records
}
}
md = tableToMarkdown('Entries to load into Devo', records)
entry['HumanReadable'] = md
return [entry]
def test_sender_as_handler_static(self):
"""
Test that tries to check that Sender class can be used as a Handler
through the static functions
and related logs are send to remote server
"""
try:
engine_config = {
"address": self.server,
"port": self.port,
"key": self.key,
"cert": self.cert,
"chain": self.chain,
"type": "SSL",
"cert_regs": True
}
con = Sender.for_logging(engine_config, "SSL", self.my_app)
logger = logging.getLogger('DEVO_logger_static')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s|%(levelname)s|'
'%(message)s')
con.setFormatter(formatter)
con.setLevel(logging.DEBUG)
logger.addHandler(con)
logger.info("Testing Sender static handler functionality... "
"INFO - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.error("Testing Sender static logging handler "
"functionality... ERROR - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.warning("Testing Sender static logging handler "
"functionality... WARNING - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.debug("Testing Sender static logging handler "
"functionality... DEBUG - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.critical("Testing Sender static logging handler "
"functionality... CRITICAL - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_sender_with_default_logger(self):
"""
Test that tries to check that Sender class can still use an internal
logger and shows both local and remote
traces
"""
try:
engine_config = SenderConfigSSL(address=self.server,
port=self.port,
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config, tag=self.my_app)
# NOTE: this logger logging traces will be visible in console
con.logger.info("Testing Sender default handler functionality in "
"local console... INFO - log")
# NOTE: this logger logging traces will be visible in the remote
# table
con.info("Testing Sender default handler functionality in remote "
"table... INFO - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_Sender_with_default_logger(self):
"""
Test that tries to check that Sender class can still use an internal logger and shows both local and remote
traces
"""
try:
engine_config = SenderConfigSSL(address=self.server,
port=self.port,
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config, tag=self.my_app)
for i in range(0, self.default_numbers_sendings):
# NOTE: this logger logging traces will be visible in console
con.logger.info(
"Testing Sender default handler functionality in local console... INFO - log"
)
# NOTE: this logger logging traces will be visible in the remote table
con.info(
"Testing Sender default handler functionality in remote table... INFO - log"
)
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_compose_mem(self):
self.assertEqual(Sender.compose_mem("test.tag"),
'<14>Jan 1 00:00:00 %s test.tag: ' % self.localhost)
self.assertEqual(Sender.compose_mem("test.tag", hostname="my-pc"),
'<14>Jan 1 00:00:00 my-pc test.tag: ')
self.assertEqual(
Sender.compose_mem("test.tag", date="1991-02-20 12:00:00"),
'<14>1991-02-20 12:00:00 %s test.tag: ' % self.localhost)
self.assertEqual(
Sender.compose_mem(b"test.tag", bytes=True),
b'<14>Jan 1 00:00:00 %s test.tag: ' %
self.localhost.encode("utf-8"))
self.assertEqual(
Sender.compose_mem(b"test.tag", hostname=b"my-pc", bytes=True),
b'<14>Jan 1 00:00:00 my-pc test.tag: ')
self.assertEqual(
Sender.compose_mem(b"test.tag",
date=b"1991-02-20 12:00:00",
bytes=True),
b'<14>1991-02-20 12:00:00 %s test.tag: ' %
self.localhost.encode("utf-8"))
def __init__(self,
profile='default',
key=None,
crt=None,
chain=None,
relay=None,
port=443,
credential_path=None,
**kwargs):
self.profile = profile
self.key = key
self.crt = crt
self.chain = chain
self.relay = relay
self.port = port
if credential_path is None:
self.credential_path = Path.home() / '.devo_credentials'
else:
self.credential_path = Path(credential_path).resolve().expanduser()
if not all([key, crt, chain, relay]):
self._read_profile()
if not all([self.key, self.crt, self.chain, self.relay]):
raise Exception(
'Credentials and relay must be specified or in ~/.devo_credentials'
)
config_dict = kwargs
config_dict.update(
dict(address=self.relay,
port=self.port,
key=self.key,
cert=self.crt,
chain=self.chain))
self.sender = Sender(config_dict)
def test_sender_as_handler(self):
"""
Test that tries to check that Sender class can be used as a Handler
and related logs are send to remote server
"""
try:
engine_config = SenderConfigSSL(address=self.server,
port=self.port,
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config, tag=self.my_app)
logger = logging.getLogger('DEVO_logger')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s|%(levelname)s'
'|%(message)s')
con.setFormatter(formatter)
con.setLevel(logging.DEBUG)
logger.addHandler(con)
logger.info("Testing Sender inherit logging handler functio"
"nality... INFO - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.error("Testing Sender inherit logging handler function"
"ality... ERROR - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.warning("Testing Sender inherit logging handler functio"
"nality... WARNING - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.debug("Testing Sender inherit logging handler functiona"
"lity... DEBUG - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.critical("Testing Sender inherit logging handler functio"
"nality... CRITICAL - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def lambda_handler(event, context):
# Get the object from the event and show its content type
bucket = event['Records'][0]['s3']['bucket']['name']
key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'])
try:
print("File to process %s" % key)
response = s3.get_object(Bucket=bucket, Key=key)
body = response['Body']
data = body.read()
###### START: From this point until END, you need to
###### carefully review the code to make sure all
###### variables match your environment.
# If the name has a .gz extension, then decompress the data
if key[-3:] == '.gz':
data = zlib.decompress(data, 16 + zlib.MAX_WBITS)
config = Configuration("config.json")
con = Sender(config=config.get("sender"))
# Send json events to Devo
print("Starting to send lines to Devo")
counter = 0
for line in data.splitlines():
events_json = json.loads(line)
for single_event in events_json["Records"]:
counter += con.send(tag=encode(config.get("tag")),
msg=encode(json.dumps(single_event)),
zip=False)
con.close()
print("Finished sending lines to Devo (%d)" % counter)
###### END of code containing key variables.
except Exception as e:
print(e)
print("Error getting file '%s' from bucket '%s'. Make sure they \
exist and your bucket is in the same region as this function." %
(key, bucket))
def write_to_table_command():
table_name = demisto.args()['tableName']
records = check_type(demisto.args()['records'], list)
linq_base = demisto.args().get('linqLinkBase', None)
creds = get_writer_creds()
linq = f"from {table_name}"
sender = Sender(
SenderConfigSSL(address=(WRITER_RELAY, PORT),
key=creds['key'].name,
cert=creds['crt'].name,
chain=creds['chain'].name))
for r in records:
try:
sender.send(tag=table_name, msg=json.dumps(r))
except TypeError:
sender.send(tag=table_name, msg=f"{r}")
querylink = {
'DevoTableLink':
build_link(linq,
int(1000 * time.time()) - 3600000,
int(1000 * time.time()),
linq_base=linq_base)
}
entry = {
'Type': entryTypes['note'],
'Contents': {
'recordsWritten': records
},
'ContentsFormat': formats['json'],
'ReadableContentsFormat': formats['markdown'],
'EntryContext': {
'Devo.RecordsWritten': records,
'Devo.LinqQuery': linq
}
}
entry_linq = {
'Type': entryTypes['note'],
'Contents': querylink,
'ContentsFormat': formats['json'],
'ReadableContentsFormat': formats['markdown'],
'EntryContext': {
'Devo.QueryLink': createContext(querylink)
}
}
md = tableToMarkdown('Entries to load into Devo', records)
entry['HumanReadable'] = md
md_linq = tableToMarkdown(
'Link to Devo Query',
{'DevoTableLink': f'[Devo Direct Link]({querylink["DevoTableLink"]})'})
entry_linq['HumanReadable'] = md_linq
return [entry, entry_linq]
def test_ssl_lookup_override(self):
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, historic_tag=None, con=con)
p_headers = Lookup.list_to_headers(['KEY', 'HEX', 'COLOR'], 'KEY')
lookup.send_control('START', p_headers, 'FULL')
lookup.send_data_line(key="11", fields=["11", "HEX12", "COLOR12"])
lookup.send_control('END', p_headers, 'FULL')
con.socket.shutdown(0)
def test_ssl_lookup_csv_send(self):
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key, cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, historic_tag=None, con=con)
with open(self.lookup_file) as f:
line = f.readline()
lookup.send_csv(self.lookup_file,
headers=line.rstrip().split(","),
key=self.lookup_key)
con.socket.shutdown(0)
def test_ssl_lookup_simplify(self):
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, historic_tag=None, con=con)
lookup.send_headers(headers=['KEY', 'HEX', 'COLOR'],
key='KEY',
action='START')
lookup.send_data_line(key="11", fields=["11", "HEX12", "COLOR12"])
lookup.send_headers(headers=['KEY', 'HEX', 'COLOR'],
key='KEY',
action='END')
con.socket.shutdown(0)
def test_sender_as_handler_static(self):
"""
Test that tries to check that Sender class can be used as a Handler
through the static functions
and related logs are send to remote server
"""
try:
engine_config = {
"address": self.server,
"port": self.port,
"key": self.key,
"cert": self.cert,
"chain": self.chain
}
con = Sender.for_logging(config=engine_config, tag=self.my_app)
logger = get_log(name="DevoLogger2", handler=con)
logger.info("Testing Sender static handler functionality... "
"INFO - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.error("Testing Sender static logging handler "
"functionality... ERROR - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.warning("Testing Sender static logging handler "
"functionality... WARNING - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.debug("Testing Sender static logging handler "
"functionality... DEBUG - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.critical("Testing Sender static logging handler "
"functionality... CRITICAL - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
def test_escape_quotes_in_send_data_line(self):
engine_config = SenderConfigSSL(
address=(self.server, self.port),
key=self.key,
cert=self.cert,
)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name,
historic_tag=None,
con=con,
escape_quotes=True)
with mock.patch.object(Lookup, 'clean_field',
wraps=Lookup.clean_field) as clean_field:
lookup.send_data_line(fields=["11", 'Double quotes"'])
clean_field.assert_called_with('Double quotes"', True)
def test_ssl_zip_send(self):
"""
Test that tries to send a message through a ssl connection
"""
try:
engine_config = SenderConfigSSL(address=self.server,
port=self.port,
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
for i in range(0, self.default_numbers_sendings):
con.send(tag=self.my_bapp,
msg=b'Test SSL msg_ python_sdk_ fork',
zip=True)
con.flush_buffer()
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_Sender_as_handler(self):
"""
Test that tries to check that Sender class can be used as a Handler and related logs are send to remote server
"""
try:
engine_config = SenderConfigSSL(address=self.server,
port=self.port,
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config, tag=self.my_app)
logger = logging.getLogger('DEVO_logger')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s|%(levelname)s|%(message)s')
con.setFormatter(formatter)
con.setLevel(logging.DEBUG)
logger.addHandler(con)
for i in range(0, self.default_numbers_sendings):
# con.debug("DEVO LOGGING HANDLER TEST at: test_Sender_as_handler" )
# logger.addHandler(con.logger.handlers[0])
logger.info(
"Testing Sender inherit logging handler functionality... INFO - log"
)
logger.error(
"Testing Sender inherit logging handler functionality... ERROR - log"
)
logger.warning(
"Testing Sender inherit logging handler functionality... WARNING - log"
)
logger.debug(
"Testing Sender inherit logging handler functionality... DEBUG - log"
)
logger.critical(
"Testing Sender inherit logging handler functionality... CRITICAL - log"
)
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_ssl_zip_send(self):
"""
Test that tries to send a message through a ssl connection
"""
try:
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config, timeout=15)
for i in range(self.default_numbers_sendings):
con.send(tag=self.my_bapp,
msg=self.test_msg.encode("utf-8"),
zip=True)
con.flush_buffer()
if len(con.socket.recv(1000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
def check_configuration():
# Check all settings related if set
# Basic functionality of integration
list(
ds.Reader(oauth_token=READER_OAUTH_TOKEN,
end_point=READER_ENDPOINT,
verify=not ALLOW_INSECURE).query(HEALTHCHECK_QUERY,
start=int(time.time() - 1),
stop=int(time.time()),
output='dict'))
if WRITER_RELAY and WRITER_CREDENTIALS:
creds = get_writer_creds()
Sender(SenderConfigSSL(address=(WRITER_RELAY, PORT),
key=creds['key'].name, cert=creds['crt'].name, chain=creds['chain'].name))\
.send(tag=HEALTHCHECK_WRITER_TABLE, msg=f'{HEALTHCHECK_WRITER_RECORD}')
if FETCH_INCIDENTS_FILTER:
alert_filters = check_type(FETCH_INCIDENTS_FILTER, dict)
assert alert_filters['type'] in [
'AND', 'OR'
], 'Missing key:"type" or unsupported value in fetch_incidents_filters'
filters = check_type(alert_filters['filters'], list)
for filt in filters:
assert filt[
'key'], 'Missing key: "key" in fetch_incidents_filters.filters configuration'
assert filt['operator'] in ['=', '/=', '>', '<', '>=', '<=', 'and', 'or', '->'], 'Missing key: "operator"'\
' or unsupported operator in fetch_incidents_filters.filters configuration'
assert filt[
'value'], 'Missing key:"value" in fetch_incidents_filters.filters configuration'
if FETCH_INCIDENTS_DEDUPE:
dedupe_conf = check_type(FETCH_INCIDENTS_DEDUPE, dict)
assert isinstance(
dedupe_conf['cooldown'],
(int,
float)), 'Invalid fetch_incidents_deduplication configuration'
return True
def test_multiline_send(self):
"""
Test that tries to send a multiple line message through a ssl connection
"""
try:
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
with open(self.test_file, 'r') as file:
content = file.read()
con.send(tag=self.my_app, msg=content, multiline=True)
con.flush_buffer()
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_ssl_lookup_new_line(self):
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key, cert=self.cert,
chain=self.chain)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name, historic_tag=None, con=con)
p_headers = Lookup.list_to_headers(['KEY', 'HEX', 'COLOR'], 'KEY')
lookup.send_control('START', p_headers, 'INC')
if len(con.socket.recv(1000)) == 0:
raise Exception('Not msg sent!')
lookup.send_data_line(key="11", fields=["11", "HEX12", "COLOR12"])
if len(con.socket.recv(1000)) == 0:
raise Exception('Not msg sent!')
lookup.send_control('END', p_headers, 'INC')
if len(con.socket.recv(1000)) == 0:
raise Exception('Not msg sent!')
con.socket.shutdown(0)
def test_escape_quotes_in_send_csv(self):
engine_config = SenderConfigSSL(
address=(self.server, self.port),
key=self.key,
cert=self.cert,
)
con = Sender(engine_config)
lookup = Lookup(name=self.lookup_name,
historic_tag=None,
con=con,
escape_quotes=True)
with mock.patch.object(Lookup, 'clean_field',
wraps=Lookup.clean_field) as clean_field:
lookup.send_csv(path=self.lookup_file,
has_header=True,
key=self.lookup_key)
clean_field.assert_called_with('ffffff', True)
def test_tcp_rt_send(self):
"""
Tests that a TCP connection and data send it is possible
"""
try:
engine_config = SenderConfigTCP(address=(self.tcp_server,
self.tcp_port))
con = Sender(engine_config)
for i in range(self.default_numbers_sendings):
con.send(tag=self.my_app, msg=self.test_msg)
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % error)
def test_sender_as_handler(self):
"""
Test that tries to check that Sender class can be used as a Handler
and related logs are send to remote server
"""
try:
engine_config = SenderConfigSSL(address=(self.server, self.port),
key=self.key,
cert=self.cert,
chain=self.chain)
con = Sender.for_logging(config=engine_config, tag=self.my_app)
logger = get_log(name="DevoLogger", handler=con)
logger.info("Testing Sender inherit logging handler functio"
"nality... INFO - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.error("Testing Sender inherit logging handler function"
"ality... ERROR - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.warning("Testing Sender inherit logging handler functio"
"nality... WARNING - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.debug("Testing Sender inherit logging handler functiona"
"lity... DEBUG - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
logger.critical("Testing Sender inherit logging handler functio"
"nality... CRITICAL - log")
if len(con.socket.recv(5000)) == 0:
raise Exception('Not msg sent!')
con.close()
except Exception as error:
self.fail("Problems with test: %s" % str(error))
