def daemon_directory(self):
"""Determine the daemon_directory.
Args:
None
Returns:
value: configured daemon_directory
"""
# Initialize key variables
key = 'pattoo'
sub_key = 'daemon_directory'
# Get result
_value = search(key, sub_key, self._base_yaml_configuration)
# Expand linux ~ notation for home directories if provided.
value = os.path.expanduser(_value)
# Create directory if it doesn't exist
files.mkdir(value)
# Return
return value
def system_daemon_directory(self):
"""Determine the system_daemon_directory.
Args:
None
Returns:
value: configured system_daemon_directory
"""
# Initialize key variables
key = 'pattoo'
sub_key = 'system_daemon_directory'
# Get result
result = search(key, sub_key, self._base_yaml_configuration, die=False)
_value = result if bool(result) else self.daemon_directory()
# Expand linux ~ notation for home directories if provided.
value = os.path.expanduser(_value)
# Create directory if it doesn't exist
files.mkdir(value)
# Return
return value
def install():
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_directory = os.environ.get('PATTOO_CONFIGDIR')
opcua_agent_dict = {
'polling_interval': 300,
}
# Attempt to create configuration directory
files.mkdir(config_directory)
# Create the pattoo user and group
configure.create_user('pattoo', '/nonexistent', ' /bin/false', True)
# Attempt to change the ownership of the configuration directory
shared.chown(config_directory)
config_file = configure.pattoo_config(
'pattoo_agent_opcuad',
config_directory,
opcua_agent_dict)
configure.check_config(config_file, opcua_agent_dict)
def install(pattoo_home):
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_dir = os.environ.get('PATTOO_CONFIGDIR')
bacnet_agent_dict = {
'polling_interval': 300,
}
# Attempt to create configuration directory
files.mkdir(config_dir)
# Create the pattoo user and group
if _shared.root_check() is True:
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, '/bin/false', True)
# Attempt to change the ownership of the config and home directories
shared.chown(config_dir)
shared.chown(pattoo_home)
config_file = configure.pattoo_config('pattoo_agent_bacnetipd', config_dir,
bacnet_agent_dict)
configure.check_config(config_file, bacnet_agent_dict)
def install(daemon_list):
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_dir = os.environ.get('PATTOO_CONFIGDIR')
autonomousd_agent_dict = {
'polling_interval': 300,
}
hubd_agent_dict = {
'polling_interval': 300,
'ip_targets': {
'ip_address': '127:0.0.1',
'ip_bind_port': 5000
}
}
spoked_agent_dict = {
'polling_interval': 300,
'ip_listen_address': '127.0.0.1',
'ip_bind_port': 5000
}
# Attempt to create configuration directory
files.mkdir(config_dir)
# Create the pattoo user and group
configure.create_user('pattoo', '/nonexistent', ' /bin/false', True)
# Attempt to change the ownership of the configuration directory
shared.chown(config_dir)
# Configure daemons in list regardless of order
for daemon in daemon_list:
# Configure autonomous agent
if 'autonomousd' in daemon:
configure.configure_component(daemon, config_dir,
autonomousd_agent_dict)
# Configure spoked agent
elif 'spoked' in daemon:
configure.configure_component(daemon, config_dir,
spoked_agent_dict)
# Convert hubd agents
elif 'hubd' in daemon:
configure.configure_component(daemon, config_dir, hubd_agent_dict)
else:
continue
def pattoo_config(file_name, config_directory, config_dict):
"""Create configuration file.
Args:
file_name: Name of the configuration file without its file extension
config_directory: Full path to the configuration directory
config_dict: A dictionary containing the configuration values.
Returns:
The path to the configuration file
"""
# Initialize key variables
config_file = os.path.join(config_directory, '{}.yaml'.format(file_name))
# Say what we are doing
print('\nConfiguring {} file.\n'.format(config_file))
# Get configuration
config = read_config(config_file, config_dict)
# Check validity of directories, if any
if bool(config) is False:
# Set default
config = config_dict
# Iterate over config dict
for _, value in sorted(config.items()):
if isinstance(value, dict) is True:
for secondary_key in value.keys():
if 'directory' in secondary_key:
if os.sep not in value.get(secondary_key):
log.log2die_safe(
1019, '{} is an invalid directory'.format(value))
# Attempt to create directory
full_directory = os.path.expanduser(
value.get(secondary_key))
if os.path.isdir(full_directory) is False:
print('Creating: {}'.format(full_directory))
files.mkdir(full_directory)
# Recursively set file ownership to pattoo user and group
if getpass.getuser() == 'root':
shared.chown(full_directory)
# Write file
try:
f_handle = open(config_file, 'w')
except PermissionError:
log.log2die(
1076, '''\
Insufficient permissions for creating the file:{}'''.format(config_file))
else:
with f_handle:
yaml.dump(config, f_handle, default_flow_style=False)
return config_file
def __init__(self, agent_name, directory=None):
"""Instantiate the class.
Args:
agent_name: Name of agent generating the private key
directory: Alternative key storage directory
Returns:
None
"""
# Initialize key variables
config = configuration.Config()
self._agent_name = agent_name
# Use the agent_id as the email address because it is a unique
# identifier across all agents. This allows multiple agents with the
# same name to have indepenent sessions.
self.email = files.get_agent_id(agent_name, config)
# Associate directories
if directory is None:
# Store keys and keyrings in directories named after the agent.
# If the same directory were universally used there could be
# conflicts in cases where the API daemon and agents run on the
# same server This eliminates this risk.
keyring_directory = config.keyring_directory(agent_name)
self._keys_directory = config.keys_directory(agent_name)
else:
keyring_directory = '{}{}.keyring'.format(directory, os.sep)
self._keys_directory = directory
files.mkdir(directory)
files.mkdir(keyring_directory)
# Initialize GPG object. Note: options=['--pinentry-mode=loopback']
# ensures the passphrase can be entered via python and won't prompt
# the user.
self._gpg = gnupg.GPG(gnupghome=keyring_directory,
options=['--pinentry-mode=loopback'])
# Import metadata for managing keys
metadata = self._import()
# Create and store metadata if nonexistent
if metadata is None:
metadata = self._generate(self.email)
self._export(metadata)
# Share passphrase
self._passphrase = metadata.passphrase
self._fingerprint = metadata.fingerprint
# Get the public key ID
self._public_keyid = self._get_public_keyid(metadata.fingerprint)
def install(pattoo_home):
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_dir = os.environ.get('PATTOO_CONFIGDIR')
pattoo_webd_dict = {
'pattoo_webd': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20200,
},
'pattoo_web_api': {
'ip_address': '::1',
'ip_bind_port': 20202
},
}
shared_config = {
'pattoo': {
'language': 'en',
'log_directory': ('/var/log/pattoo'),
'log_level': 'debug',
'cache_directory': ('/opt/pattoo/cache'),
'daemon_directory': ('/opt/pattoo/daemon'),
'system_daemon_directory': '/var/run/pattoo',
}
}
# Attempt to create configuration directory
files.mkdir(config_dir)
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, '/bin/false', True)
# Attempt to change the ownership of the config and pattoo-home directories
shared.chown(config_dir)
shared.chown(pattoo_home)
# Create pattoo configuration if pattoo had not been installed
configure.configure_component('pattoo', config_dir, shared_config)
# Configure pattoo web
configure.configure_component('pattoo_webd', config_dir, pattoo_webd_dict)
def test_mkdir(self):
"""Testing function mkdir."""
# Test with file, not directory
tmpfile = tempfile.NamedTemporaryFile(delete=False).name
open(tmpfile, 'a').close()
with self.assertRaises(SystemExit):
files.mkdir(tmpfile)
os.remove(tmpfile)
# Create a sub directory of a temp directory.
directory = '{0}tmp{0}test_pattoo-unittest{0}{1}.fake'.format(
os.sep,
randint(1, 10000) * pi)
files.mkdir(directory)
self.assertTrue(os.path.isdir(directory))
shutil.rmtree(directory)
def agent_cache_directory(self, agent_program):
"""Get agent_cache_directory.
Args:
agent_program: Name of agent
Returns:
result: result
"""
# Get result
result = '{}/{}'.format(self.cache_directory(), agent_program)
# Create directory if it doesn't exist
files.mkdir(result)
# Return
return result
def session_directory(self):
"""Get directory for storing session infomation.
Args:
None
Returns:
result: result
"""
# Get result
result = '{}{}session'.format(self.cache_directory(), os.sep)
# Create directory if it doesn't exist
files.mkdir(result)
# Change filemode to 700
# Only allow the user to access the flash session folder
os.chmod(result, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
return result
def install(daemon_list, pattoo_home):
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_dir = os.environ.get('PATTOO_CONFIGDIR')
snmp_agent_dict = {
'polling_interval': 300,
}
# Attempt to create configuration directory
files.mkdir(config_dir)
# Create the pattoo user and group
if getpass.getuser() != 'travis':
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, '/bin/false', True)
# Attempt to change the ownership of the config and home directories
shared.chown(config_dir)
shared.chown(pattoo_home)
# Attempt to change the ownership of the configuration directory
shared.chown(config_dir)
for daemon in daemon_list:
config_file = configure.pattoo_config(daemon, config_dir,
snmp_agent_dict)
configure.check_config(config_file, snmp_agent_dict)
def keys_directory(self, agent_name):
"""Get keys_directory.
Args:
agent_name: Name of agent
Returns:
result: result
"""
# Get result
result = '{0}{1}keys{1}{2}'.format(self.daemon_directory(), os.sep,
agent_name)
# Create directory if it doesn't exist
files.mkdir(result)
# Make only accessible to the user
os.chmod(result, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
# Return
return result
def install(pattoo_home):
"""Start configuration process.
Args:
None
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_dir = os.environ.get('PATTOO_CONFIGDIR')
pattoo_webd_dict = {
'pattoo_webd': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20200,
},
'pattoo_web_api': {
'ip_address': '::1',
'ip_bind_port': 20202
},
}
# Attempt to create configuration directory
files.mkdir(config_dir)
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, ' /bin/false', True)
# Attempt to change the ownership of the config and pattoo-home directories
shared.chown(config_dir)
shared.chown(pattoo_home)
# Configure pattoo web
configure.configure_component('pattoo_webd', config_dir, pattoo_webd_dict)
def install(pattoo_home):
"""Start configuration process.
Args:
pattoo_home: The home directory of the pattoo user
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_directory = os.environ.get('PATTOO_CONFIGDIR')
shared_config = {
'encryption': {
'api_email': '*****@*****.**',
},
'pattoo': {
'language': 'en',
'log_directory': ('/var/log/pattoo'),
'log_level': 'debug',
'cache_directory': ('/opt/pattoo-cache'),
'daemon_directory': ('/opt/pattoo-daemon'),
'system_daemon_directory': '/var/run/pattoo',
}
}
agent_config = {
'encryption': {
'agent_email': '*****@*****.**'
},
'pattoo_agent_api': {
'ip_address': '127.0.0.1',
'ip_bind_port': 20201
},
'pattoo_web_api': {
'ip_address': '127.0.0.1',
'ip_bind_port': 20202,
}
}
server_config = {
'pattoo_db': {
'db_pool_size': 10,
'db_max_overflow': 20,
'db_hostname': 'localhost',
'db_username': '******',
'db_password': '******',
'db_name': 'pattoo'
},
'pattoo_api_agentd': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20201,
},
'pattoo_apid': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20202,
},
'pattoo_ingesterd': {
'ingester_interval': 3600,
'batch_size': 500,
'graceful_timeout': 10
}
}
# Attempt to create configuration directory
files.mkdir(config_directory)
if getpass.getuser() != 'travis':
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, '/bin/false', True)
# Attempt to change the ownership of the config and home directories
shared.chown(config_directory)
shared.chown(pattoo_home)
# Create configuration
configure.configure_component('pattoo', config_directory, shared_config)
configure.configure_component('pattoo_agent', config_directory,
agent_config)
configure.configure_component('pattoo_server', config_directory,
server_config)
def install(pattoo_home):
"""Start configuration process.
Args:
pattoo_home: The home directory of the pattoo user
Returns:
None
"""
# Initialize key variables
if os.environ.get('PATTOO_CONFIGDIR') is None:
os.environ['PATTOO_CONFIGDIR'] = '{0}etc{0}pattoo'.format(os.sep)
config_directory = os.environ.get('PATTOO_CONFIGDIR')
shared_config = {
'pattoo': {
'language': 'en',
'log_directory': (
'/var/log/pattoo'),
'log_level': 'debug',
'cache_directory': (
'/opt/pattoo/cache'),
'daemon_directory': (
'/opt/pattoo/daemon'),
'system_daemon_directory': '/var/run/pattoo',
}
}
# Defines how agents will communicate with the API daemons
# Only required for travis-ci unittesting
agent_config = {
'pattoo_agent_api': {
'ip_address': '127.0.0.1',
'ip_bind_port': 20201
},
}
server_config = {
'pattoo_db': {
'db_pool_size': 10,
'db_max_overflow': 20,
'db_hostname': 'localhost',
'db_username': '******',
'db_password': '******',
'db_name': 'pattoo'
},
'pattoo_api_agentd': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20201,
'api_encryption_email': '*****@*****.**',
},
'pattoo_apid': {
'ip_listen_address': '0.0.0.0',
'ip_bind_port': 20202,
'jwt_secret_key': secrets.token_urlsafe(64),
'acesss_token_exp': '15_m',
'refresh_token_exp': '1_D'
},
'pattoo_ingesterd': {
'ingester_interval': 3600,
'batch_size': 500,
'graceful_timeout': 10
}
}
# Attempt to create configuration directory
files.mkdir(config_directory)
if _shared.root_check() is True:
# Create the pattoo user and group
configure.create_user('pattoo', pattoo_home, '/bin/false', True)
# Attempt to change the ownership of the config and home directories
shared.chown(config_directory)
shared.chown(pattoo_home)
# Create configuration
configure.configure_component('pattoo', config_directory, shared_config)
configure.configure_component(
'pattoo_server', config_directory, server_config)
configure.configure_component(
'pattoo_agent', config_directory, agent_config)
def install(requirements_dir, installation_directory=None, verbose=True):
"""Ensure PIP3 packages are installed correctly.
Args:
requirements_dir: The directory with the pip_requirements file.
installation_directory: Directory where packages must be installed.
verbose: Print status messages if True
Returns:
True if pip3 packages are installed successfully
"""
# Initialize key variables
lines = []
if bool(installation_directory) is False:
installation_directory = '/opt/pattoo-daemon/.python'
# Create directory if it doesn't exist
if os.path.isdir(installation_directory) is False:
files.mkdir(installation_directory)
# Appends pip3 dir to python path
sys.path.append(installation_directory)
# Read pip_requirements file
filepath = '{}{}pip_requirements.txt'.format(requirements_dir, os.sep)
# Say what we are doing
print('Checking pip3 packages')
if os.path.isfile(filepath) is False:
shared.log('Cannot find PIP3 requirements file {}'.format(filepath))
# Opens pip_requirements file for reading
with open(filepath, 'r') as _fp:
line = _fp.readline()
while line:
# Strip line
_line = line.strip()
# Read line
if True in [_line.startswith('#'), bool(_line) is False]:
pass
else:
lines.append(_line)
line = _fp.readline()
# Process each line of the file
for line in lines:
# Determine the package
package = line.split('=', 1)[0]
package = package.split('>', 1)[0]
# If verbose is true, the package being checked is shown
if verbose:
print('Installing package {}'.format(package))
command = 'python3 -m pip show {}'.format(package)
(returncode, _, _) = shared.run_script(
command, verbose=verbose, die=False)
# Install any missing pip3 package
if bool(returncode) is True:
install_missing_pip3(
package, installation_directory, verbose=verbose)
# Set ownership of any newly installed python packages to pattoo user
if getpass.getuser() == 'root':
if os.path.isdir(installation_directory) is True:
shared.run_script('chown -R pattoo:pattoo {}'.format(
installation_directory), verbose=verbose)
print('pip3 packages successfully installed')
