def run_ansible_playbook_module(install_file_path):
"""
Run the install.yml file through an Ansible playbook using the dedicated neuron !
:param install_file_path: the path of the Ansible playbook to run.
:return:
"""
logger.debug("[ResourcesManager] Run ansible playbook")
Utils.print_info("Starting neuron installation")
# ask the sudo password
pswd = getpass.getpass('Sudo password:')
if not pswd or pswd == "":
Utils.print_warning("You must enter a sudo password")
return False
else:
ansible_neuron_parameters = {
"task_file": install_file_path,
"sudo": True,
"sudo_user": "******",
"sudo_password": pswd
}
neuron = Neuron(name="ansible_playbook",
parameters=ansible_neuron_parameters)
NeuronLauncher.start_neuron(neuron)
return True
def wait_before_stop(self):
logger.debug(
"[Ambient_sounds] Wait %s minutes before checking if the thread is alive"
% self.auto_stop_minutes)
Utils.print_info(
"[Ambient_sounds] Wait %s minutes before stopping the ambient sound"
% self.auto_stop_minutes)
sleep(self.auto_stop_minutes *
60) # *60 to convert received minutes into seconds
logger.debug("[Ambient_sounds] Time is over, Stop player")
Utils.print_info(
"[Ambient_sounds] Time is over, stopping the ambient sound")
self.stop_last_process()
def _clone_repo(path, git_url):
"""
Use git to clone locally the neuron in a temp folder
:return:
"""
# clone the repo
logger.debug("[ResourcesManager] GIT clone into folder: %s" % path)
Utils.print_info("Cloning repository...")
# if the folder already exist we remove it
if os.path.exists(path):
shutil.rmtree(path)
else:
os.makedirs(path)
Repo.clone_from(git_url, path)
def is_repo_ok(dna_file_path, install_file_path):
"""
Check if the git cloned repo is fine to be installed
:return: True if repo is ok to be installed, False otherwise
"""
Utils.print_info("Checking repository...")
repo_ok = True
# check that a install.yml file is present
if not os.path.exists(install_file_path):
Utils.print_danger("Missing %s file" % INSTALL_FILE_NAME)
repo_ok = False
if not os.path.exists(dna_file_path):
Utils.print_danger("Missing %s file" % DNA_FILE_NAME)
repo_ok = False
return repo_ok
def _check_supported_version(current_version, supported_versions):
"""
The dna file contains supported Intelora version for the module to install.
Check if supported versions are match the current installed version. If not, ask the user to confirm the
installation anyway
:param current_version: current version installed of Intelora. E.g 0.4.0
:param supported_versions: list of supported version
:return: True if the version is supported or user has confirmed the installation
"""
logger.debug(
"[ResourcesManager] Current installed version of Intelora: %s" %
str(current_version))
logger.debug("[ResourcesManager] Module supported version: %s" %
str(supported_versions))
supported_version_found = False
# Extract major version
match_current_version = re.search('^[\d]*[.][\d]*', current_version)
if match_current_version:
current_version = match_current_version.group(0)
for supported_version in supported_versions:
if version.parse(str(current_version)) == version.parse(
str(supported_version)):
# we found the exact version
supported_version_found = True
break
if not supported_version_found:
# we ask the user if we want to install the module even if the version doesn't match
Utils.print_info("Current installed version of Intelora: %s" %
current_version)
Utils.print_info("Module supported versions: %s" %
str(supported_versions))
Utils.print_warning(
"The neuron seems to be not supported by your current version of Intelora"
)
supported_version_found = Utils.query_yes_no("install it anyway?")
logger.debug(
"[ResourcesManager] install it anyway user answer: %s" %
supported_version_found)
logger.debug("[ResourcesManager] check_supported_version: %s" %
str(supported_version_found))
return supported_version_found