def config(cfgname, inisect):
cfg = { }
cfgpr = ConfigParser()
try:
cfgpr.readfp(open(cfgname))
except IOError, e:
raise ConfigError(str(e))
def __init__(self, name='redhat.repo'):
ConfigParser.__init__(self)
self.path = Path.join(self.PATH, name)
self.manage_repos = 1
if CFG.has_option('rhsm', 'manage_repos'):
self.manage_repos = int(CFG.get('rhsm', 'manage_repos'))
self.create()
def post(self, command, output_dir, vars):
common.Template.post(self, command, output_dir, vars)
#etc = os.path.join(vars['path'], 'etc', 'plone')
#if not os.path.isdir(etc):
# os.makedirs(etc)
cfg = os.path.join(vars['path'], 'etc', 'base.cfg')
dst = os.path.join(vars['path'],
'etc', 'plone', 'plone%s.buildout.cfg' % vars['major'])
vdst = os.path.join(vars['path'],
'etc', 'plone', 'plone%s.versions.cfg' % vars['major'])
sdst = os.path.join(vars['path'],
'etc', 'plone', 'plone%s.sources.cfg' % vars['major'])
ztkdst = os.path.join(vars['path'], 'etc', 'plone', 'ztk.versions.cfg')
zaztkdst = os.path.join(vars['path'], 'etc', 'plone', 'zopeapp.versions.cfg')
zdst = os.path.join(vars['path'],
'etc', 'plone', 'zope2.versions.cfg')
os.rename(os.path.join(vars['path'], 'gitignore'),
os.path.join(vars['path'], '.gitignore'))
bc = ConfigParser()
bc.read(cfg)
for f in (glob(os.path.join(output_dir, 'scripts/*'))
+ glob(os.path.join(output_dir, 'etc/hudson/%s/build/*' % vars['project']))
):
os.chmod(f, 0700)
# release KGS
#try:
# open(vdst, 'w').write(
# urllib2.urlopen(vars['versions_url']).read()
# )
#except Exception, e:
suffix = vars['major']
if vars['major'] > 3:
suffix = self.name.replace('minitage.plone', '')
def __init__(self, name='redhat.repo'):
ConfigParser.__init__(self)
self.path = Path.join(self.PATH, name)
self.manage_repos = 1
if CFG.has_option('rhsm', 'manage_repos'):
self.manage_repos = int(CFG.get('rhsm', 'manage_repos'))
self.create()
def checkSSLvdsm(self):
"""check if vdsm is running as SSL or without it"""
cfg = ConfigParser()
cfg.read('/etc/vdsm/vdsm.conf')
cfg.get('vars', 'ssl')
return cfg.data.vars.ssl
def write(self):
if not self.manage_repos:
log.debug("Skipping write due to manage_repos setting: %s" %
self.path)
return
f = open(self.path, 'w')
tidy_writer = TidyWriter(f)
ConfigParser.write(self, tidy_writer)
tidy_writer.close()
f.close()
def update(self, repo):
# Need to clear out the old section to allow unsetting options:
# don't use remove section though, as that will reorder sections,
# and move whitespace around (resulting in more and more whitespace
# as time progresses).
for (k, v) in self.items(repo.id):
self.remove_option(repo.id, k)
for k, v in repo.items():
ConfigParser.set(self, repo.id, k, v)
def write(self):
if not self.manage_repos:
log.debug("Skipping write due to manage_repos setting: %s" %
self.path)
return
f = open(self.path, 'w')
tidy_writer = TidyWriter(f)
ConfigParser.write(self, tidy_writer)
tidy_writer.close()
f.close()
def update(self, repo):
# Need to clear out the old section to allow unsetting options:
# don't use remove section though, as that will reorder sections,
# and move whitespace around (resulting in more and more whitespace
# as time progresses).
for (k, v) in self.items(repo.id):
self.remove_option(repo.id, k)
for k, v in repo.items():
ConfigParser.set(self, repo.id, k, v)
def parseDesktopFile(self):
"""
Getting all necessary data from *.dektop file of the app
"""
cmd = "rpm -qlf $(which %s)" % self.appCommand
cmd += '| grep "^/usr/share/applications/.*%s.desktop$"' % self.desktopFileName
proc = Popen(cmd, shell=True, stdout=PIPE)
# !HAVE TO check if the command and its desktop file exist
if proc.wait() != 0:
raise Exception("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def parseDesktopFile(self):
"""
Getting all necessary data from *.dektop file of the app
"""
cmd = 'ls -d /usr/share/applications/* | grep ".*%s.desktop"' % self.desktopFileName
proc = Popen(cmd, shell=True, stdout=PIPE)
# !HAVE TO check if the command and its desktop file exist
if proc.wait() != 0:
raise Exception("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
desktopConfig = ConfigParser()
desktopConfig.read(output)
return desktopConfig
def test_enabling_yum_plugin_with_wrong_conf(self):
"""
Test automatic enabling of configuration files of already plugins with wrong values in conf file.
"""
self.init_yum_plugin_conf_files(conf_string=PKG_PLUGIN_CONF_FILE_WRONG_VALUE)
plugin_list = YumPluginManager.enable_pkg_plugins()
self.assertEqual(len(plugin_list), 2)
for plugin_conf_file_name in YumPluginManager.PLUGINS:
yum_plugin_config = ConfigParser()
result = yum_plugin_config.read(YumPluginManager.YUM_PLUGIN_DIR + '/' + plugin_conf_file_name + '.conf')
self.assertGreater(len(result), 0)
is_plugin_enabled = yum_plugin_config.getint('main', 'enabled')
self.assertEqual(is_plugin_enabled, 1)
self.restore_yum_plugin_conf_files()
def __generate(self):
if not os.path.exists(self.repofile):
return []
# Unfortuantely, we can not use the SafeConfigParser for zypper repo
# files because the repository urls contains strings which the
# SafeConfigParser don't like. It would crash with
# ConfigParser.InterpolationSyntaxError: '%' must be followed by '%' or '('
if use_zypper:
config = ConfigParser()
else:
config = SafeConfigParser()
config.read(self.repofile)
enabled_sections = [
section for section in config.sections()
if config.getboolean(section, "enabled")
]
enabled_repos = []
for section in enabled_sections:
try:
enabled_repos.append({
"repositoryid":
section,
"baseurl":
[self._format_baseurl(config.get(section, "baseurl"))]
})
except ImportError:
break
return enabled_repos
def test_enabling_yum_plugin_with_invalid_values(self):
"""
Test automatic enabling of configuration files of already enabled plugins
"""
self.init_plugin_conf_files(conf_string=YUM_PLUGIN_CONF_FILE_INVALID_VALUE)
plugin_list = YumPluginManager.enable_yum_plugins()
self.assertEqual(len(plugin_list), 2)
for plugin_conf_file_name in YumPluginManager.YUM_PLUGINS:
yum_plugin_config = ConfigParser()
result = yum_plugin_config.read(YumPluginManager.DNF_PLUGIN_DIR + '/' + plugin_conf_file_name + '.conf')
self.assertGreater(len(result), 0)
is_plugin_enabled = yum_plugin_config.getint('main', 'enabled')
self.assertEqual(is_plugin_enabled, 1)
self.restore_plugin_conf_files()
def test_enabling_enabled_yum_plugin_int(self):
"""
Test automatic enabling of configuration files of already enabled plugins
"""
self.init_yum_plugin_conf_files(conf_string=PKG_PLUGIN_CONF_FILE_ENABLED_INT)
plugin_list = YumPluginManager.enable_pkg_plugins()
self.assertEqual(len(plugin_list), 0)
for plugin_conf_file_name in YumPluginManager.PLUGINS:
yum_plugin_config = ConfigParser()
result = yum_plugin_config.read(YumPluginManager.YUM_PLUGIN_DIR + '/' + plugin_conf_file_name + '.conf')
self.assertGreater(len(result), 0)
is_plugin_enabled = yum_plugin_config.getint('main', 'enabled')
self.assertEqual(is_plugin_enabled, 1)
self.restore_yum_plugin_conf_files()
def test_not_enabling_disabled_yum_plugin(self):
"""
Test not enabling (disabled in rhsm.conf) of configuration files of disabled plugins
"""
self.init_yum_plugin_conf_files(conf_string=PKG_PLUGIN_CONF_FILE_DISABLED_BOOL)
plugin_list = YumPluginManager.enable_pkg_plugins()
self.assertEqual(len(plugin_list), 0)
for plugin_conf_file_name in YumPluginManager.PLUGINS:
yum_plugin_config = ConfigParser()
result = yum_plugin_config.read(YumPluginManager.YUM_PLUGIN_DIR + '/' + plugin_conf_file_name + '.conf')
self.assertGreater(len(result), 0)
is_plugin_enabled = yum_plugin_config.getboolean('main', 'enabled')
self.assertEqual(is_plugin_enabled, False)
self.restore_yum_plugin_conf_files()
def __init__(self, filename):
'''
@param filename: absolute path to the repo file; the repo file does not need to
exist at the time of instantiation, the save method will write it
out if it doesn't
@type filename: string; may not be None
@raise ValueError: if filename is missing
'''
if filename is None:
raise ValueError(
'Filename must be specified when creating a RepoFile')
self.filename = filename
self.parser = ConfigParser()
def test_enabling_enabled_yum_plugin_bool(self):
"""
Test automatic enabling of configuration files of already enabled plugins
"""
self.init_yum_plugin_conf_files(conf_string=PKG_PLUGIN_CONF_FILE_ENABLED_BOOL)
plugin_list = YumPluginManager.enable_pkg_plugins()
self.assertEqual(len(plugin_list), 0)
for plugin_conf_file_name in YumPluginManager.PLUGINS:
yum_plugin_config = ConfigParser()
result = yum_plugin_config.read(YumPluginManager.YUM_PLUGIN_DIR + '/' + plugin_conf_file_name + '.conf')
self.assertGreater(len(result), 0)
# The file was not modified. We have to read value with with getboolean()
is_plugin_enabled = yum_plugin_config.getboolean('main', 'enabled')
self.assertEqual(is_plugin_enabled, True)
self.restore_yum_plugin_conf_files()
def _has_changed(self):
'''
Check if the version on disk is different from what we have loaded
'''
on_disk = ConfigParser()
on_disk.read(self.path)
return not self._configparsers_equal(on_disk)
def __init__(self, name='redhat.repo'):
ConfigParser.__init__(self)
# note PATH get's expanded with chroot info, etc
self.path = Path.join(self.PATH, name)
self.repos_dir = Path.abs(self.PATH)
self.manage_repos = 1
if CFG.has_option('rhsm', 'manage_repos'):
self.manage_repos = int(CFG.get('rhsm', 'manage_repos'))
# Simulate manage repos turned off if no yum.repos.d directory exists.
# This indicates yum is not installed so clearly no need for us to
# manage repos.
if not os.path.exists(self.repos_dir):
log.warn("%s does not exist, turning manage_repos off." %
self.repos_dir)
self.manage_repos = 0
self.create()
def __init__(self, name='redhat.repo'):
ConfigParser.__init__(self)
# note PATH get's expanded with chroot info, etc
self.path = Path.join(self.PATH, name)
self.repos_dir = Path.abs(self.PATH)
self.manage_repos = 1
if CFG.has_option('rhsm', 'manage_repos'):
self.manage_repos = int(CFG.get('rhsm', 'manage_repos'))
# Simulate manage repos turned off if no yum.repos.d directory exists.
# This indicates yum is not installed so clearly no need for us to
# manage repos.
if not os.path.exists(self.repos_dir):
log.warn("%s does not exist, turning manage_repos off." %
self.repos_dir)
self.manage_repos = 0
self.create()
def read_ini_file(self, filename):
cp = ConfigParser()
cp.read(filename)
if not self.backup_base_dir:
self.backup_base_dir = cp.get('global', 'backup_base_dir')
if not os.path.isdir(self.backup_base_dir):
self.logger.info('Creating backup directory %s' %
self.backup_base_dir)
os.makedirs(self.backup_base_dir)
self.logger.debug("backup directory : " + self.backup_base_dir)
self.dbstat = BackupStat(
os.path.join(self.backup_base_dir, 'log', 'tisbackup.sqlite'))
for section in cp.sections():
if (section != 'global'):
self.logger.debug("reading backup config " + section)
backup_item = None
type = cp.get(section, 'type')
backup_item = backup_drivers[type](backup_name=section,
backup_dir=os.path.join(
self.backup_base_dir,
section),
dbstat=self.dbstat,
dry_run=self.dry_run)
backup_item.read_config(cp)
backup_item.verbose = self.verbose
self.backup_list.append(backup_item)
def write(self,
path=None,
dependencies = None,
src_uri = None,
description = None,
install_method = None,
src_type = None,
url = None,
revision = None,
category = None,
src_opts = None,
src_md5 = None,
python = None,
scm_branch = None,
):
"""Store/Update the minibuild config
"""
to_write = OrderedDict(
[('dependencies', dependencies),
('src_uri', src_uri),
('install_method', install_method),
('src_type', src_type),
('revision', revision),
('category', category),
('description', description),
('src_md5', src_md5),
('url', url),
('src_opts', src_opts),
('python', python),
('scm_branch', scm_branch),]
)
# open config
if not path:
path = self.path
shutil.copy2(path, path+'.sav')
wconfig = WritableConfigParser()
wconfig.read(path)
for metadata in to_write:
value = to_write[metadata]
if isinstance(value, list):
if len(value) < 1:
value = None
else:
value = ' '.join(value)
if value is not None:
wconfig.set('minibuild' , metadata, value)
# write back cofig
fic = open(path, 'w')
wconfig.write(fic)
fic.flush()
fic.close()
newline(path)
# reload minibuild
self.load()
def config(cfgname, inisect):
cfg = { }
cfgpr = ConfigParser()
try:
cfgpr.read(cfgname)
cfg["sleep"] = cfgpr.get(inisect, "sleep")
cfg["cmd"] = cfgpr.get(inisect, "cmd")
cfg["file"] = cfgpr.get(inisect, "file")
cfg["s3mode"] = cfgpr.get(inisect, "s3mode")
cfg["s3host"] = cfgpr.get(inisect, "s3host")
cfg["s3user"] = cfgpr.get(inisect, "s3user")
cfg["s3pass"] = cfgpr.get(inisect, "s3pass")
cfg["bucket"] = cfgpr.get(inisect, "s3bucket")
cfg["prefix"] = cfgpr.get(inisect, "prefix")
except NoSectionError:
# Unfortunately if the file does not exist, we end here.
raise ConfigError("Unable to open or find section " + inisect)
except NoOptionError, e:
raise ConfigError(str(e))
def _apply():
debug('Write ini settings to %s' % filename)
debug(config)
cfg = ConfigParser()
cfg.read(filename)
for section, values in config.items():
if not cfg.has_section(section):
if strict_sections:
raise Exception('No section %s in ini file %s' % (section, filename))
else:
cfg.add_section(section)
for key, val in values.items():
cfg.set(section, key, val)
with open(filename, 'w') as configfile:
cfg.write(configfile)
event(on_apply)
def archive_inv(gameDir, dummyPath, game='FO3', mode=True):
'''Apply ArchiveInvalidationInvalidated.'''
if mode:
if game == 'NV':
try:
ini = ConfigParser()
ini.read(os.environ['USERPROFILE'] + '\\My Games\\FalloutNV\\Fallout.ini')
ini.set('Archive', 'bInvalidateOlderFiles', '1')
ini.set('Archive', 'SArchiveList', 'Dummy.bsa,' + ini.get('Archive', 'SArchiveList'))
iniFile = open(os.environ['USERPROFILE'] + '\\My Games\\FalloutNV\\Fallout.ini', 'w')
ini.write(iniFile)
bsa = open(dummyPath, 'rb').read()
dummy = open(gameDir + '\\Data\\Dummy.bsa', 'wb')
dummy.write(bsa)
dummy.close()
return True
except IOError:
return False
def read_ini_file(self,filename):
cp = ConfigParser()
cp.read(filename)
if not self.backup_base_dir:
self.backup_base_dir = cp.get('global','backup_base_dir')
if not os.path.isdir(self.backup_base_dir):
self.logger.info('Creating backup directory %s' % self.backup_base_dir)
os.makedirs(self.backup_base_dir)
self.logger.debug("backup directory : " + self.backup_base_dir)
self.dbstat = BackupStat(os.path.join(self.backup_base_dir,'log','tisbackup.sqlite'))
for section in cp.sections():
if (section != 'global'):
self.logger.debug("reading backup config " + section)
backup_item = None
type = cp.get(section,'type')
backup_item = backup_drivers[type](backup_name=section,
backup_dir=os.path.join(self.backup_base_dir,section),dbstat=self.dbstat,dry_run=self.dry_run)
backup_item.read_config(cp)
backup_item.verbose = self.verbose
self.backup_list.append(backup_item)
def __init__(self, filename):
"""
@param filename: absolute path to the repo file; the repo file does not need to
exist at the time of instantiation, the save method will write it
out if it doesn't
@type filename: string; may not be None
@raise ValueError: if filename is missing
"""
if filename is None:
raise ValueError("Filename must be specified when creating a RepoFile")
self.filename = filename
self.parser = ConfigParser()
def _LoadActorDefs(filename):
"""Load actor definitions from Config/ActorDef/<filename>.ini.
Instantiate an Actor from a definition with Actor.Create(<name>)
If called a second time, it will reload the file, so the definitions
will be updated, but any existing Actors that were created from them
remain the same.
"""
path_try = os.path.join("Config", "ActorDef", filename + ".ini")
if not (os.path.exists(path_try)):
raise IOError, "Couldn't find " + path_try
if not hasattr(Actor, "_defs"):
Actor._defs = {}
config = ConfigParser()
config.read(path_try)
for section in config.sections():
definition = {}
for item in config.items(section):
definition[item[0]] = item[1]
if 'class' not in definition:
definition["class"] = "Actor"
Actor._defs[section] = definition
def _LoadLevelDef(filename):
"""Load level definitions from Config/Level/<filename>.ini.
Call LoadLevel(<name>) to actually load all the Actors described in
the file.
If called a second time, it will reload the file, so the definitions
will be updated, but the existing world won't be affected.
"""
path_try = os.path.join("Config", "Level", filename + ".ini")
if not (os.path.exists(path_try)):
raise IOError, "Couldn't find " + path_try
if not hasattr(angel, "_levels"):
angel._levels = {}
angel._levels[filename] = {}
config = ConfigParser()
config.read(path_try)
for section in config.sections():
actor = {}
for item in config.items(section):
actor[item[0]] = item[1]
angel._levels[filename][section] = actor
def __init__(self, appName, critical=None, shortcut='<Control><Q>',
quitButton=None, timeout=10, forceKill=True,
parameters='', clean_dirs=None, polkit=False):
"""
Initialize object App
appName command to run the app
critical what's the function we check? {start,quit}
shortcut default quit shortcut
timeout timeout for starting and shuting down the app
forceKill is the app supposed to be kill before/after test?
parameters has the app any params needed to start?
(only for startViaCommand)
"""
self.appCommand = appName.lower()
self.shortcut = shortcut
self.timeout = timeout
self.forceKill = forceKill
self.critical = critical
self.quitButton = quitButton
# the result remains false until the correct result is verified
self.result = False
self.updateCorePattern()
self.parameters = parameters
self.internCommand = self.appCommand.lower()
self.polkit = polkit
self.polkitPass = '******'
self.clean_dirs = clean_dirs or []
"""
Getting all necessary data from *.desktop file of the app
"""
cmd = "rpm -qlf $(which %s)" % appName
#cmd2 = "grep %s.desktop" % self.appCommand
#is it enough to search for .desktop?; vhumpa: no
cmd += '|grep "^/usr/share/applications/.*\%s.desktop$"' % appName
logging.debug("cmd = %s", cmd)
proc = Popen(cmd, shell=True, stdout=PIPE)
#have to check if the command and its desktop file exist
#raise Exception, "*.desktop file of the app not found"
#print("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
logging.debug("output = %s", output)
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def startService(self):
cfgpr = ConfigParser()
# TODO: config location from argparse or something
cfgpr.read('config/config.ini')
ip = cfgpr.get('main', 'ip')
port = cfgpr.getint('main', 'port')
tag = cfgpr.get('main', 'tag')
password = cfgpr.get('main', 'password')
server_data = {
'ip': ip,
'port': port,
'tag': tag, # TODO: what is this:
'secret': password, # TODO: refactor how this kind of data is passed and stored in factory
}
factory = getClientRconFactory(server_data)
client = TCPClient(server_data["ip"], server_data["port"], factory)
client.setServiceParent(self)
self.server["factory"] = factory
MultiService.startService(self)
from libtisbackup.common import *
import time
from flask import request, Flask, session, g, appcontext_pushed, redirect, url_for, abort, render_template, flash, jsonify, Response
from urlparse import urlparse
import json
import glob
import time
from config import huey
from tasks import run_export_backup, get_task, set_task
from tisbackup import tis_backup
import logging
import re
cp = ConfigParser()
cp.read("/etc/tis/tisbackup_gui.ini")
CONFIG = cp.get('general', 'config_tisbackup').split(",")
SECTIONS = cp.get('general', 'sections')
ADMIN_EMAIL = cp.get('general', 'ADMIN_EMAIL')
tisbackup_config_file = CONFIG[0]
config_number = 0
cp = ConfigParser()
cp.read(tisbackup_config_file)
backup_base_dir = cp.get('global', 'backup_base_dir')
dbstat = BackupStat(os.path.join(backup_base_dir, 'log', 'tisbackup.sqlite'))
mindate = None
error = None
class RepoFile(object):
"""
Represents a .repo file, including operations to manipulate its repositories and
CRUD operations on the file itself.
"""
# Be careful when changing the spacing below, the parser takes issue when the comment
# indicator isn't in the first column. The blank line at the end is fine though.
FILE_HEADER = """#
# Pulp Repositories
# Managed by Pulp client
#
"""
def __init__(self, filename):
"""
@param filename: absolute path to the repo file; the repo file does not need to
exist at the time of instantiation, the save method will write it
out if it doesn't
@type filename: string; may not be None
@raise ValueError: if filename is missing
"""
if filename is None:
raise ValueError("Filename must be specified when creating a RepoFile")
self.filename = filename
self.parser = ConfigParser()
# -- file manipulation ------------------------------------------------------------
def delete(self):
"""
If the repo file exists, it will be deleted. If not, this method does nothing.
@raise Exception: if there is an error during the delete
"""
if os.path.exists(self.filename):
os.unlink(self.filename)
def load(self, allow_missing=True):
"""
Loads the repo file.
@param allow_missing: if True, this call will not throw an error if the file cannot
be found; defaults to True
@type allow_missing: bool
@raise Exception: if there is an error during the read
"""
if allow_missing and not os.path.exists(self.filename):
return
r = Reader(self.filename)
self.parser.readfp(r)
def save(self):
"""
Saves the current repositories to the repo file.
@raise Exception: if there is an error during the write
"""
# If the file doesn't exist, initialize with Pulp header
first_write = not os.path.exists(self.filename)
f = open(self.filename, "w")
if first_write:
f.write(RepoFile.FILE_HEADER)
# Write the contents of the parser
self.parser.write(f)
f.close()
# -- contents manipulation ------------------------------------------------------------
def add_repo(self, repo):
"""
Adds a new repo to this object, however the file is not saved.
This is not saved as an object reference, so future changes to the passed in
repo will not be captured in this RepoFile instance. If changes are made to
the original Repo object, it must be passed into the RepoFile instance through
update_repo in order for the changes to be captured.
@param repo: repo to add; may not be None
@type repo: L{Repo}
"""
self.parser.add_section(repo.id)
self._repo_to_parser(repo)
def remove_repo_by_name(self, repo_name):
"""
Removes the repo with the given name. If the repo does not exist, this
method does nothing.
@param repo: identifies the repo to remove
@type repo: string
"""
return self.parser.remove_section(repo_name)
def update_repo(self, repo):
"""
Updates the underlying store with the latest contents of a repo. The repo
passed to this method must have been created prior to this call.
The repo is not saved as an object reference. Instead, the values are captured
to the underlying store at the point in time this is called.
@param repo: repo instance containing updated values to store; cannot be None
@type repo: L{Repo}
"""
self._repo_to_parser(repo)
def get_repo(self, repo_id):
"""
Loads a repo by repo ID. If the repo does not exist, returns None.
@param repo_id: id of the repo to retrieve
@type repo_id: string
@return: repo instance if one exists; None otherwise
@rtype: L{Repo}
"""
if self.parser.has_section(repo_id):
repo = self._parser_to_repo(repo_id)
return repo
else:
return None
def all_repos(self):
"""
Returns a list of all repos in the store.
@return: list of repo instances; empty list if there are none
@rtype: list of L{Repo}
"""
repos = []
for repo_name in self.parser.sections():
repo = self._parser_to_repo(repo_name)
repos.append(repo)
return repos
def _repo_to_parser(self, repo):
"""
Adds the contents of the repo to the underlying store. This call assumes
the parser section has already been created.
@param repo: repo instance to update in the parser; cannot be None
@type repo: L{Repo}
"""
for k, v in repo.items():
if v:
self.parser.set(repo.id, k, v)
else:
self.parser.remove_option(repo.id, k)
def _parser_to_repo(self, repo_name):
"""
Utility for converting the config parser section into a repo object.
@param repo_name: name of the repo being retrieved from the store
@type repo_name: string
@return: repo instance populated from the section data
@rtype: L{Repo}
"""
repo = Repo(repo_name)
for key, value in self.parser.items(repo_name):
repo[key] = value
return repo
def enable_yum_plugins(cls):
"""
This function tries to enable yum plugins: subscription-manager and product-id.
It takes no action, when automatic enabling of yum plugins is disabled in rhsm.conf.
:return: It returns list of enabled plugins
"""
# When user doesn't want to automatically enable yum plugins, then return empty list
if cls.is_auto_enable_enabled() is False:
log.info(
'The rhsm.auto_enable_yum_plugins is disabled. Skipping the enablement of yum plugins.'
)
return []
log.debug('The rhsm.auto_enable_yum_plugins is enabled')
# List of successfully enabled plugins
enabled_yum_plugins = []
plugin_dir = ""
if version.use_dnf:
plugin_dir = cls.DNF_PLUGIN_DIR
else:
plugin_dir = cls.YUM_PLUGIN_DIR
# Go through the list of yum plugins and try to find configuration
# file of these plugins.
for yum_plugin_name in cls.YUM_PLUGINS:
yum_plugin_file_name = plugin_dir + '/' + yum_plugin_name + '.conf'
yum_plugin_config = ConfigParser()
try:
result = yum_plugin_config.read(yum_plugin_file_name)
except Exception as err:
# Capture all errors during reading yum plugin conf file
# report them and skip this conf file
log.error(
"Error during reading yum plugin config file '%s': %s. Skipping this file."
% (yum_plugin_file_name, err))
continue
if len(result) == 0:
log.info(
'Configuration file of yum plugin: "%s" cannot be read' %
yum_plugin_file_name)
continue
is_plugin_enabled = False
if not yum_plugin_config.has_section('main'):
log.warn(
'Configuration file of yum plugin: "%s" does not include main section. Adding main section.'
% yum_plugin_file_name)
yum_plugin_config.add_section('main')
elif yum_plugin_config.has_option('main', 'enabled'):
try:
# Options 'enabled' can be 0 or 1
is_plugin_enabled = yum_plugin_config.getint(
'main', 'enabled')
except ValueError:
try:
# Options 'enabled' can be also: true or false
is_plugin_enabled = yum_plugin_config.getboolean(
'main', 'enabled')
except ValueError:
log.warn(
"File %s has wrong value of options: 'enabled' in section: 'main' (not a int nor boolean)"
% yum_plugin_file_name)
if is_plugin_enabled == cls.YUM_PLUGIN_ENABLED:
log.debug('Yum plugin: "%s" already enabled. Nothing to do.' %
yum_plugin_file_name)
else:
log.warn('Enabling yum plugin: "%s".' % yum_plugin_file_name)
# Change content of plugin configuration file and enable this plugin.
with open(yum_plugin_file_name, 'w') as cfg_file:
yum_plugin_config.set('main', 'enabled',
cls.YUM_PLUGIN_ENABLED)
yum_plugin_config.write(cfg_file)
enabled_yum_plugins.append(yum_plugin_file_name)
return enabled_yum_plugins
def _enable_plugins(cls, pkg_mgr_name, plugin_dir):
"""
This class method tries to enable plugins for DNF or YUM
:param pkg_mgr_name: It can be "dnf" or "yum"
:type pkg_mgr_name: str
:param plugin_dir: Directory with configuration files for (dnf/yum) plugins
:type plugin_dir: str
:return:
"""
# List of successfully enabled plugins
enabled_lugins = []
# Go through the list of yum plugins and try to find configuration
# file of these plugins.
for plugin_name in cls.PLUGINS:
plugin_file_name = plugin_dir + '/' + plugin_name + '.conf'
plugin_config = ConfigParser()
try:
result = plugin_config.read(plugin_file_name)
except Exception as err:
# Capture all errors during reading yum plugin conf file
# report them and skip this conf file
log.error(
"Error during reading %s plugin config file '%s': %s. Skipping this file."
% (pkg_mgr_name, plugin_file_name, err))
continue
if len(result) == 0:
log.info(
'Configuration file of %s plugin: "%s" cannot be read' %
(pkg_mgr_name, plugin_file_name))
continue
is_plugin_enabled = False
if not plugin_config.has_section('main'):
log.warning(
'Configuration file of %s plugin: "%s" does not include main section. Adding main section.'
% (pkg_mgr_name, plugin_file_name))
plugin_config.add_section('main')
elif plugin_config.has_option('main', 'enabled'):
try:
# Options 'enabled' can be 0 or 1
is_plugin_enabled = plugin_config.getint('main', 'enabled')
except ValueError:
try:
# Options 'enabled' can be also: true or false
is_plugin_enabled = plugin_config.getboolean(
'main', 'enabled')
except ValueError:
log.warning(
"File %s has wrong value of options: 'enabled' in section: 'main' (not a int nor boolean)"
% plugin_file_name)
if is_plugin_enabled == cls.PLUGIN_ENABLED:
log.debug('%s plugin: "%s" already enabled. Nothing to do.' %
(pkg_mgr_name, plugin_file_name))
else:
log.warning('Enabling %s plugin: "%s".' %
(pkg_mgr_name, plugin_file_name))
# Change content of plugin configuration file and enable this plugin.
with open(plugin_file_name, 'w') as cfg_file:
plugin_config.set('main', 'enabled', cls.PLUGIN_ENABLED)
plugin_config.write(cfg_file)
enabled_lugins.append(plugin_file_name)
return enabled_lugins
def main():
(options, args) = parser.parse_args()
if len(args) != 1:
print "ERROR : You must provide one action to perform"
parser.print_usage()
sys.exit(2)
backup_start_date = datetime.datetime.now().strftime('%Y%m%d-%Hh%Mm%S')
# options
action = args[0]
if action == "listdrivers":
for t in backup_drivers:
print backup_drivers[t].get_help()
sys.exit(0)
config_file = options.config
dry_run = options.dry_run
verbose = options.verbose
loglevel = options.loglevel
# setup Logger
logger = logging.getLogger('tisbackup')
hdlr = logging.StreamHandler()
hdlr.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
logger.addHandler(hdlr)
# set loglevel
if loglevel in ('debug', 'warning', 'info', 'error', 'critical'):
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % loglevel)
logger.setLevel(numeric_level)
# Config file
if not os.path.isfile(config_file):
logger.error("Error : could not find file : " + config_file +
", please check the path")
logger.info("Using " + config_file + " config file")
cp = ConfigParser()
cp.read(config_file)
backup_base_dir = options.backup_base_dir or cp.get(
'global', 'backup_base_dir')
log_dir = os.path.join(backup_base_dir, 'log')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
# if we run the nagios check, we don't create log file, everything is piped to stdout
if action != 'checknagios':
hdlr = logging.FileHandler(
os.path.join(log_dir, 'tisbackup_%s.log' % (backup_start_date)))
hdlr.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
logger.addHandler(hdlr)
# Main
backup = tis_backup(dry_run=dry_run,
verbose=verbose,
backup_base_dir=backup_base_dir)
backup.read_ini_file(config_file)
backup_sections = options.sections.split(',') if options.sections else []
all_sections = [
backup_item.backup_name for backup_item in backup.backup_list
]
if not backup_sections:
backup_sections = all_sections
else:
for b in backup_sections:
if not b in all_sections:
raise Exception('Section %s is not defined in config file' % b)
if dry_run:
logger.warning(
"WARNING : DRY RUN, nothing will be done, just printing on screen..."
)
if action == "backup":
backup.process_backup(backup_sections)
elif action == "exportbackup":
if not options.exportdir:
raise Exception(
'No export directory supplied dor exportbackup action')
backup.export_backups(backup_sections, options.exportdir)
elif action == "cleanup":
backup.cleanup_backup_section(backup_sections)
elif action == "checknagios":
backup.checknagios(backup_sections)
elif action == "dumpstat":
for s in backup_sections:
backup.dbstat.last_backups(s, count=options.statscount)
elif action == "retryfailed":
backup.retry_failed_backups()
elif action == "register_existing":
backup.register_existingbackups(backup_sections)
else:
logger.error('Unhandled action "%s", quitting...', action)
sys.exit(1)
class RepoFile(object):
'''
Represents a .repo file, including operations to manipulate its repositories and
CRUD operations on the file itself.
'''
# Be careful when changing the spacing below, the parser takes issue when the comment
# indicator isn't in the first column. The blank line at the end is fine though.
FILE_HEADER = '''#
# Pulp Repositories
# Managed by Pulp client
#
'''
def __init__(self, filename):
'''
@param filename: absolute path to the repo file; the repo file does not need to
exist at the time of instantiation, the save method will write it
out if it doesn't
@type filename: string; may not be None
@raise ValueError: if filename is missing
'''
if filename is None:
raise ValueError(
'Filename must be specified when creating a RepoFile')
self.filename = filename
self.parser = ConfigParser()
# -- file manipulation ------------------------------------------------------------
def delete(self):
'''
If the repo file exists, it will be deleted. If not, this method does nothing.
@raise Exception: if there is an error during the delete
'''
if os.path.exists(self.filename):
os.unlink(self.filename)
def load(self, allow_missing=True):
'''
Loads the repo file.
@param allow_missing: if True, this call will not throw an error if the file cannot
be found; defaults to True
@type allow_missing: bool
@raise Exception: if there is an error during the read
'''
if allow_missing and not os.path.exists(self.filename):
return
r = Reader(self.filename)
self.parser.readfp(r)
def save(self):
'''
Saves the current repositories to the repo file.
@raise Exception: if there is an error during the write
'''
# If the file doesn't exist, initialize with Pulp header
first_write = not os.path.exists(self.filename)
f = open(self.filename, 'w')
if first_write:
f.write(RepoFile.FILE_HEADER)
# Write the contents of the parser
self.parser.write(f)
f.close()
# -- contents manipulation ------------------------------------------------------------
def add_repo(self, repo):
'''
Adds a new repo to this object, however the file is not saved.
This is not saved as an object reference, so future changes to the passed in
repo will not be captured in this RepoFile instance. If changes are made to
the original Repo object, it must be passed into the RepoFile instance through
update_repo in order for the changes to be captured.
@param repo: repo to add; may not be None
@type repo: L{Repo}
'''
self.parser.add_section(repo.id)
self._repo_to_parser(repo)
def remove_repo_by_name(self, repo_name):
'''
Removes the repo with the given name. If the repo does not exist, this
method does nothing.
@param repo: identifies the repo to remove
@type repo: string
'''
return self.parser.remove_section(repo_name)
def update_repo(self, repo):
'''
Updates the underlying store with the latest contents of a repo. The repo
passed to this method must have been created prior to this call.
The repo is not saved as an object reference. Instead, the values are captured
to the underlying store at the point in time this is called.
@param repo: repo instance containing updated values to store; cannot be None
@type repo: L{Repo}
'''
self._repo_to_parser(repo)
def get_repo(self, repo_id):
'''
Loads a repo by repo ID. If the repo does not exist, returns None.
@param repo_id: id of the repo to retrieve
@type repo_id: string
@return: repo instance if one exists; None otherwise
@rtype: L{Repo}
'''
if self.parser.has_section(repo_id):
repo = self._parser_to_repo(repo_id)
return repo
else:
return None
def all_repos(self):
'''
Returns a list of all repos in the store.
@return: list of repo instances; empty list if there are none
@rtype: list of L{Repo}
'''
repos = []
for repo_name in self.parser.sections():
repo = self._parser_to_repo(repo_name)
repos.append(repo)
return repos
def _repo_to_parser(self, repo):
'''
Adds the contents of the repo to the underlying store. This call assumes
the parser section has already been created.
@param repo: repo instance to update in the parser; cannot be None
@type repo: L{Repo}
'''
for k, v in repo.items():
if v:
self.parser.set(repo.id, k, v)
else:
self.parser.remove_option(repo.id, k)
def _parser_to_repo(self, repo_name):
'''
Utility for converting the config parser section into a repo object.
@param repo_name: name of the repo being retrieved from the store
@type repo_name: string
@return: repo instance populated from the section data
@rtype: L{Repo}
'''
repo = Repo(repo_name)
for key, value in self.parser.items(repo_name):
repo[key] = value
return repo
def main():
(options,args)=parser.parse_args()
if len(args) != 1:
print "ERROR : You must provide one action to perform"
parser.print_usage()
sys.exit(2)
backup_start_date = datetime.datetime.now().strftime('%Y%m%d-%Hh%Mm%S')
# options
action = args[0]
if action == "listdrivers":
for t in backup_drivers:
print backup_drivers[t].get_help()
sys.exit(0)
config_file =options.config
dry_run = options.dry_run
verbose = options.verbose
loglevel = options.loglevel
# setup Logger
logger = logging.getLogger('tisbackup')
hdlr = logging.StreamHandler()
hdlr.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
logger.addHandler(hdlr)
# set loglevel
if loglevel in ('debug','warning','info','error','critical'):
numeric_level = getattr(logging, loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % loglevel)
logger.setLevel(numeric_level)
# Config file
if not os.path.isfile(config_file):
logger.error("Error : could not find file : " + config_file + ", please check the path")
logger.info("Using " + config_file + " config file")
cp = ConfigParser()
cp.read(config_file)
backup_base_dir = options.backup_base_dir or cp.get('global','backup_base_dir')
log_dir = os.path.join(backup_base_dir,'log')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
# if we run the nagios check, we don't create log file, everything is piped to stdout
if action!='checknagios':
hdlr = logging.FileHandler(os.path.join(log_dir,'tisbackup_%s.log' % (backup_start_date)))
hdlr.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
logger.addHandler(hdlr)
# Main
backup = tis_backup(dry_run=dry_run,verbose=verbose,backup_base_dir=backup_base_dir)
backup.read_ini_file(config_file)
backup_sections = options.sections.split(',') if options.sections else []
all_sections = [backup_item.backup_name for backup_item in backup.backup_list]
if not backup_sections:
backup_sections = all_sections
else:
for b in backup_sections:
if not b in all_sections:
raise Exception('Section %s is not defined in config file' % b)
if dry_run:
logger.warning("WARNING : DRY RUN, nothing will be done, just printing on screen...")
if action == "backup":
backup.process_backup(backup_sections)
elif action == "exportbackup":
if not options.exportdir:
raise Exception('No export directory supplied dor exportbackup action')
backup.export_backups(backup_sections,options.exportdir)
elif action == "cleanup":
backup.cleanup_backup_section(backup_sections)
elif action == "checknagios":
backup.checknagios(backup_sections)
elif action == "dumpstat":
for s in backup_sections:
backup.dbstat.last_backups(s,count=options.statscount)
elif action == "retryfailed":
backup.retry_failed_backups()
elif action == "register_existing":
backup.register_existingbackups(backup_sections)
else:
logger.error('Unhandled action "%s", quitting...',action)
sys.exit(1)
def read(self):
ConfigParser.read(self, self.path)
class App():
"""
Does all basic events with app
"""
def __init__(self, appName, critical=None, shortcut='<Control><Q>',
quitButton=None, timeout=10, forceKill=True,
parameters='', clean_dirs=None, polkit=False):
"""
Initialize object App
appName command to run the app
critical what's the function we check? {start,quit}
shortcut default quit shortcut
timeout timeout for starting and shuting down the app
forceKill is the app supposed to be kill before/after test?
parameters has the app any params needed to start?
(only for startViaCommand)
"""
self.appCommand = appName.lower()
self.shortcut = shortcut
self.timeout = timeout
self.forceKill = forceKill
self.critical = critical
self.quitButton = quitButton
# the result remains false until the correct result is verified
self.result = False
self.updateCorePattern()
self.parameters = parameters
self.internCommand = self.appCommand.lower()
self.polkit = polkit
self.polkitPass = '******'
self.clean_dirs = clean_dirs or []
"""
Getting all necessary data from *.desktop file of the app
"""
cmd = "rpm -qlf $(which %s)" % appName
#cmd2 = "grep %s.desktop" % self.appCommand
#is it enough to search for .desktop?; vhumpa: no
cmd += '|grep "^/usr/share/applications/.*\%s.desktop$"' % appName
logging.debug("cmd = %s", cmd)
proc = Popen(cmd, shell=True, stdout=PIPE)
#have to check if the command and its desktop file exist
#raise Exception, "*.desktop file of the app not found"
#print("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
logging.debug("output = %s", output)
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def end(self):
"""
Ends the test with correct return value
"""
if self.result:
#print "PASS"
sys.exit(0)
else:
sys.exit("FAIL")
def updateResult(self, result):
self.result = result
def getName(self):
return self.desktopConfig.get('Desktop Entry', 'name')
def getCategories(self):
return self.desktopConfig.get('Desktop Entry', 'categories')
def getMenuGroups(self):
"""
Convert group list to the one correct menu group
"""
groupsList = self.getCategories().split(';')
groupsList.reverse()
groupConversionDict = {
'Accessibility': 'Universal Access',
'System': 'System Tools',
'Development': 'Programming',
'Network': 'Internet',
'Office': 'Office',
'Graphics': 'Graphics',
'Game': 'Games',
'Education': 'Education',
'Utility': 'Accessories',
'AudioVideo': 'Sound & Video'
}
for i in groupsList:
if i in groupConversionDict:
return groupConversionDict[i]
def isRunning(self):
"""
Is the app running?
"""
#print "*** Checking if '%s' is running" % self.internCommand
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.internCommand:
app = i
break
if app.isChild(roleName='frame', recursive=False):
#print "*** The app '%s' is running" % self.internCommand
return True
else:
#print "*** The app '%s' is not running" % self.internCommand
return False
def kill(self):
"""
Kill the app via 'killall'
"""
#print "*** Killing all '%s' instances" % self.appCommand
#return Popen("killall " + self.appCommand, shell = True).wait()
return Popen("pkill -u `whoami` -9 " + self.appCommand,
shell=True).wait()
def updateCorePattern(self):
"""
Update string in /proc/sys/kernel/core_pattern to catch
possible return code
"""
#Popen("sudo rm -rf /tmp/cores", shell = True).wait()
#Popen("mkdir /tmp/cores", shell = True).wait()
#Popen("chmod a+rwx /tmp/cores", shell = True).wait()
#Popen("echo \"/tmp/cores/core.%e.%s.%p\" \
# | sudo tee /proc/sys/kernel/core_pattern", shell = True).wait()
pass
def existsCoreDump(self):
"""
Check if there is core dump created
"""
#dirPath = "/tmp/cores/"
#files = os.listdir(dirPath)
#regexp = "core\.%s\.[0-9]{1,3}\.[0-9]*" % self.appCommand
#for f in files:
# if re.match(regexp, f):
# return int(f.split(".")[2])
return 0
def startViaMenu(self):
"""
Start the app via Gnome Shell menu
"""
internCritical = (self.critical == 'start')
#check if the app is running
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
if self.isRunning():
if internCritical:
self.updateResult(False)
#print "!!! The app is running but it shouldn't be"
return False
else:
#print "*** The app has been killed succesfully"
pass
try:
#panel button Activities
gnomeShell = root.application('gnome-shell')
activities = gnomeShell.child(name='Activities', roleName='label')
activities.click()
sleep(6) # time for overview to appear
#menu Applications
x, y = getDashIconPosition('Show Applications')
absoluteMotion(x, y)
sleep(1)
click(x, y)
sleep(4) # time for all the oversized app icons to appear
#submenu that contains the app
submenu = gnomeShell.child(name=self.getMenuGroups(),
roleName='list item')
submenu.click()
sleep(4)
#the app itself
app = gnomeShell.child(name=self.getName(), roleName='label')
app.click()
#if there is a polkit
if self.polkit:
sleep(3)
typeText(self.polkitPass)
keyCombo('<Enter>')
sleep(self.timeout)
if self.isRunning():
#print "*** The app started successfully"
if internCritical:
self.updateResult(True)
return True
else:
#print "!!! The app is not running but it should be"
if internCritical:
self.updateResult(False)
return False
except SearchError:
#print "!!! Lookup error while passing the path"
if internCritical:
self.updateResult(False)
return False
def startViaCommand(self):
"""
Start the app via command
"""
internCritical = (self.critical == 'start')
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
if self.isRunning():
if internCritical:
self.updateResult(False)
#print "!!! The app is running but it shouldn't be"
return False
else:
pass
#print "*** The app has been killed succesfully"
returnValue = 0
command = "%s %s &" % (self.appCommand, self.parameters)
import os
os.system(command)
returnValue = 1
#returnValue = utilsRun(command, timeout = 1, dumb = True)
#if there is a polkit
if self.polkit:
sleep(3)
typeText(self.polkitPass)
keyCombo('<Enter>')
start_time = 0
while start_time < self.timeout:
if self.isRunning():
break
sleep(0.5)
start_time += 0.5
#check the returned values
if returnValue is None:
if internCritical:
self.updateResult(False)
#print "!!! The app command could not be found"
return False
else:
if self.isRunning():
if internCritical:
self.updateResult(True)
#print "*** The app started successfully"
return True
else:
if internCritical:
self.updateResult(False)
#print "!!! The app did not started despite " \
# + "the fact that the command was found"
return False
def closeViaShortcut(self):
"""
Close the app via shortcut
"""
internCritical = (self.critical == 'quit')
if not self.isRunning():
if internCritical:
self.updateResult(False)
#print "!!! The app does not seem to be running"
return False
keyCombo(self.shortcut)
sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
#print "!!! The app is running but it shouldn't be"
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
# print "!!! The app closed with core dump created. Signal %d"\
# % self.existsCoreDump()
return False
if internCritical:
self.updateResult(True)
#print "*** The app was successfully closed"
return True
def closeViaMenu(self):
"""
Close app via menu button
"""
internCritical = (self.critical == 'quit')
if not self.isRunning():
if internCritical:
self.updateResult(False)
#print "!!! The app does not seem to be running"
return False
#bind to the right app
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.internCommand:
app = i
break
app = app # variable app is not used FIXME
#try to bind the menu and the button
try:
firstSubmenu = self.getMenuNth(0)
firstSubmenu.click()
length = len(firstSubmenu.children)
closeButton = firstSubmenu.children[length - 1]
if self.quitButton is None:
while re.search('(Close|Quit|Exit)', closeButton.name) is None:
length = length - 1
closeButton = firstSubmenu.children[length]
if length < 0:
if internCritical:
self.update(False)
#print "!!! The app quit button coldn't be found"
return False
else:
closeButton = firstSubmenu.child(self.quitButton)
except SearchError:
if internCritical:
self.updateResult(False)
#print "!!! The app menu bar or the quit button could'n be found"
if self.forceKill:
self.kill()
return False
sleep(2) # timeout until menu appear
#print "*** Trying to click to '%s'" % closeButton
closeButton.click()
sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
#print "!!! The app is running but it shouldn't be"
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
# print "!! The app closed with core dump created. Signal %d" \
# % self.existsCoreDump()
return False
if internCritical:
self.updateResult(True)
#print "*** The app was successfully closed"
return True
def getMenuNamed(self, menuName):
"""
Return submenu with name specified with 'menuName'
"""
#bind to the right app
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.internCommand:
app = i
break
#try to bind the menu and the button
try:
appMenu = app.child(roleName='menu bar')
return appMenu.child(name=menuName)
except:
return None
def getMenuNth(self, nth):
"""
Return nth submenu
"""
#bind to the right app
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.internCommand:
app = i
break
#try to bind the menu and the button
try:
appMenu = app.child(roleName='menu bar')
return appMenu.children[nth]
except:
return None
def getGnomePanelMenu(self):
"""
Return object of gnome-panel menu of the app
"""
try:
app = root.application('gnome-shell')
menu = app.child(roleName='menu')
return menu.child(self.getName(), roleName='label')
except:
raise Exception("Gnome-panel menu of the app could not be found!")
def openGnomePanelMenu(self):
"""
Click to the gnome-panel menu
"""
menu = self.getGnomePanelMenu()
if menu is not None:
menu.click()
else:
raise Exception("Gnome-panel menu of the app could not be found!")
def getGnomePanelMenuItems(self):
"""
Return a list of objects in gnome-panel app menu
"""
quitButton = self.getGnomePanelQuit()
if quitButton is None:
return []
else:
return quitButton.get_parent().children
def getGnomePanelQuit(self):
"""
Return object of Quit button in gnome-panel menu
It's the only way how to find out the gnome-panel menu...
"""
try:
return root.application('gnome-shell').child('Quit')
except:
raise Exception("Quit menu item at gnome-panel menu" +
" could not be found!")
def closeViaGnomePanel(self):
"""
Close the app via menu at gnome-panel
"""
internCritical = (self.critical == 'quit')
if not self.isRunning():
if internCritical:
self.updateResult(False)
#print "!!! The app does not seem to be running"
return False
self.openGnomePanelMenu()
closeButton = self.getGnomePanelQuit()
sleep(2) # timeout until menu appear
#print "*** Trying to click to '%s'" % closeButton
closeButton.click()
sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
#print "!!! The app is running but it shouldn't be"
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
# print "!!! The app closed with core dumps. Signal %d" % \
# self.existsCoreDump()
return False
if internCritical:
self.updateResult(True)
#print "*** The app was successfully closed"
return True
def read_config():
config_file = CONFIG[config_number]
cp = ConfigParser()
cp.read(config_file)
backup_base_dir = cp.get('global', 'backup_base_dir')
backup = tis_backup(backup_base_dir=backup_base_dir)
backup.read_ini_file(config_file)
backup_sections = SECTIONS or []
all_sections = [
backup_item.backup_name for backup_item in backup.backup_list
]
if not backup_sections:
backup_sections = all_sections
else:
for b in backup_sections:
if not b in all_sections:
raise Exception('Section %s is not defined in config file' % b)
result = []
if not backup_sections:
sections = [
backup_item.backup_name for backup_item in backup.backup_list
]
for backup_item in backup.backup_list:
if backup_item.backup_name in backup_sections:
b = {}
for attrib_name in backup_item.required_params + backup_item.optional_params:
if hasattr(backup_item, attrib_name):
b[attrib_name] = getattr(backup_item, attrib_name)
result.append(b)
backup_dict = {}
backup_dict['rsync_ssh_list'] = []
backup_dict['rsync_btrfs_list'] = []
backup_dict['rsync_list'] = []
backup_dict['null_list'] = []
backup_dict['pgsql_list'] = []
backup_dict['mysql_list'] = []
backup_dict['sqlserver_list'] = []
backup_dict['xva_list'] = []
backup_dict['metadata_list'] = []
backup_dict['switch_list'] = []
backup_dict['oracle_list'] = []
backup_dict['samba_list'] = []
for row in result:
backup_name = row['backup_name']
server_name = row['server_name']
backup_type = row['type']
if backup_type == "xcp-dump-metadata":
backup_dict['metadata_list'].append(
[server_name, backup_name, backup_type, ""])
if backup_type == "rsync+ssh":
remote_dir = row['remote_dir']
backup_dict['rsync_ssh_list'].append(
[server_name, backup_name, backup_type, remote_dir])
if backup_type == "rsync+btrfs+ssh":
remote_dir = row['remote_dir']
backup_dict['rsync_btrfs_list'].append(
[server_name, backup_name, backup_type, remote_dir])
if backup_type == "rsync":
remote_dir = row['remote_dir']
backup_dict['rsync_list'].append(
[server_name, backup_name, backup_type, remote_dir])
if backup_type == "null":
backup_dict['null_list'].append(
[server_name, backup_name, backup_type, ""])
if backup_type == "pgsql+ssh":
db_name = row['db_name'] if len(row['db_name']) > 0 else '*'
backup_dict['pgsql_list'].append(
[server_name, backup_name, backup_type, db_name])
if backup_type == "mysql+ssh":
db_name = row['db_name'] if len(row['db_name']) > 0 else '*'
backup_dict['mysql_list'].append(
[server_name, backup_name, backup_type, db_name])
if backup_type == "sqlserver+ssh":
db_name = row['db_name']
backup_dict['sqlserver_list'].append(
[server_name, backup_name, backup_type, db_name])
if backup_type == "oracle+ssh":
db_name = row['db_name']
backup_dict['oracle_list'].append(
[server_name, backup_name, backup_type, db_name])
if backup_type == "xen-xva":
backup_dict['xva_list'].append(
[server_name, backup_name, backup_type, ""])
if backup_type == "switch":
backup_dict['switch_list'].append(
[server_name, backup_name, backup_type, ""])
if backup_type == "samba4":
backup_dict['samba_list'].append(
[server_name, backup_name, backup_type, ""])
return backup_dict
def __build_yum_config(self, repoid):
"""
Builds the YUM config that will be used for YUM initialization.
@param repoid The ID of repository to be analyzed.
@return The path to generated YUM config file.
"""
config_path = temporaries.create_temporary_file("yum.conf")
config = ConfigParser()
# FIXME: This config was get from my Ubuntu default yum config, maybe
# we should somehow modify it.
config.add_section("main")
cache_path = temporaries.create_temporary_directory("yum.cache")
config.set("main", "cachedir", cache_path)
config.set("main", "keepcache", "1")
config.set("main", "debuglevel", "2")
log_path = temporaries.create_temporary_file("yum.log")
config.set("main", "logfile", log_path)
# FIXME: Is this a reason why ARM RPMs are ignored?
config.set("main", "exactarch", "1")
config.set("main", "obsoletes", "1")
config.add_section(repoid)
config.set(repoid, "name", "Analyzed repository")
config.set(repoid, "baseurl",
"file://{0}".format(self.repository_path))
with open(config_path, "w") as config_file:
config.write(config_file)
config_file.close()
return config_path
import time
from flask import request, Flask, session, g, appcontext_pushed, redirect, url_for, abort, render_template, flash, jsonify, Response
from urlparse import urlparse
import json
import glob
import time
from config import huey
from tasks import run_export_backup, get_task, set_task
from tisbackup import tis_backup
import logging
import re
cp = ConfigParser()
cp.read("/etc/tis/tisbackup_gui.ini")
CONFIG = cp.get('general','config_tisbackup').split(",")
SECTIONS = cp.get('general','sections')
ADMIN_EMAIL = cp.get('general','ADMIN_EMAIL')
tisbackup_config_file= CONFIG[0]
config_number=0
cp = ConfigParser()
cp.read(tisbackup_config_file)
backup_base_dir = cp.get('global','backup_base_dir')
dbstat = BackupStat(os.path.join(backup_base_dir,'log','tisbackup.sqlite'))
mindate = None
def read_config():
config_file = CONFIG[config_number]
cp = ConfigParser()
cp.read(config_file)
backup_base_dir = cp.get('global','backup_base_dir')
backup = tis_backup(backup_base_dir=backup_base_dir)
backup.read_ini_file(config_file)
backup_sections = SECTIONS or []
all_sections = [backup_item.backup_name for backup_item in backup.backup_list]
if not backup_sections:
backup_sections = all_sections
else:
for b in backup_sections:
if not b in all_sections:
raise Exception('Section %s is not defined in config file' % b)
result = []
if not backup_sections:
sections = [backup_item.backup_name for backup_item in backup.backup_list]
for backup_item in backup.backup_list:
if backup_item.backup_name in backup_sections:
b = {}
for attrib_name in backup_item.required_params+backup_item.optional_params:
if hasattr(backup_item,attrib_name):
b[attrib_name] = getattr(backup_item,attrib_name)
result.append(b)
backup_dict = {}
backup_dict['rsync_ssh_list'] = []
backup_dict['rsync_btrfs_list'] = []
backup_dict['rsync_list'] = []
backup_dict['null_list'] = []
backup_dict['pgsql_list'] = []
backup_dict['mysql_list'] = []
backup_dict['sqlserver_list'] = []
backup_dict['xva_list'] = []
backup_dict['metadata_list'] = []
backup_dict['switch_list'] = []
backup_dict['oracle_list'] = []
for row in result:
backup_name = row['backup_name']
server_name = row['server_name']
backup_type = row['type']
if backup_type == "xcp-dump-metadata":
backup_dict['metadata_list'].append([server_name, backup_name, backup_type, ""])
if backup_type == "rsync+ssh":
remote_dir = row['remote_dir']
backup_dict['rsync_ssh_list'].append([server_name, backup_name, backup_type,remote_dir])
if backup_type == "rsync+btrfs+ssh":
remote_dir = row['remote_dir']
backup_dict['rsync_btrfs_list'].append([server_name, backup_name, backup_type,remote_dir])
if backup_type == "rsync":
remote_dir = row['remote_dir']
backup_dict['rsync_list'].append([server_name, backup_name, backup_type,remote_dir])
if backup_type == "null":
backup_dict['null_list'].append([server_name, backup_name, backup_type, ""])
if backup_type == "pgsql+ssh":
db_name = row['db_name'] if len(row['db_name']) > 0 else '*'
backup_dict['pgsql_list'].append([server_name, backup_name, backup_type, db_name])
if backup_type == "mysql+ssh":
db_name = row['db_name'] if len(row['db_name']) > 0 else '*'
backup_dict['mysql_list'].append([server_name, backup_name, backup_type, db_name])
if backup_type == "sqlserver+ssh":
db_name = row['db_name']
backup_dict['sqlserver_list'].append([server_name, backup_name, backup_type, db_name])
if backup_type == "oracle+ssh":
db_name = row['db_name']
backup_dict['oracle_list'].append([server_name, backup_name, backup_type, db_name])
if backup_type == "xen-xva":
backup_dict['xva_list'].append([server_name, backup_name, backup_type, ""])
if backup_type == "switch":
backup_dict['switch_list'].append([server_name, backup_name, backup_type, ""])
return backup_dict
import datetime
import xlrd
from xls import *
from vt import *
from iniparse import ConfigParser
import sys
#ayarlar
ayar = ConfigParser()
ayardos = '.\exnet\DATA\default.ini'
ayardosyol = '.\\exnet\\DATA\\'
if len(sys.argv) > 1:
ayardos = sys.argv[1]
ayar.read(ayardos)
dosya = ayar.get("excel", "dosya")
sayfa = ayar.get("excel", "sayfa")
fisler = ayar.get("excel", "fisler")
fisler = fisler.split("@")
form = xls()
#komut satirindan yukleme yapmak icin
#form nesnesine ilgili sayfa yukleniyor.
form.sayfa(ayardosyol + dosya, sayfa)
for fis in fisler:
print fis
merkezhc = ayar.get(fis, "merkez")
merkez = form.deger(merkezhc)
tarihhc = ayar.get(fis, "tarih")
tarih = form.degertarih(tarihhc)
islemhc = ayar.get(fis, "islem")
islem = form.deger(islemhc)
urtkodhc = ayar.get(fis, "urtkod")
class App(object):
"""
This class does all basic events with the app
"""
def __init__(self,
appName,
desktopFileName=None,
shortcut='<Control><Q>',
a11yAppName=None,
forceKill=True,
parameters='',
recordVideo=False):
"""
Initialize object App
appName command to run the app
shortcut default quit shortcut
a11yAppName app's a11y name is different than binary
forceKill is the app supposed to be kill before/after test?
parameters has the app any params needed to start? (only for startViaCommand)
recordVideo start gnome-shell recording while running the app
"""
self.appCommand = appName
self.shortcut = shortcut
self.forceKill = forceKill
self.parameters = parameters
self.internCommand = self.appCommand.lower()
self.a11yAppName = a11yAppName
self.recordVideo = recordVideo
self.pid = None
if desktopFileName is None:
desktopFileName = self.appCommand
self.desktopFileName = desktopFileName
# a way of overcoming overview autospawn when mouse in 1,1 from start
pressKey('Esc')
absoluteMotion(100, 100, 2)
# attempt to make a recording of the test
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
def isRunning(self):
"""
Is the app running?
"""
if self.a11yAppName is None:
self.a11yAppName = self.internCommand
# Trap weird bus errors
for attempt in xrange(0, 30):
sleep(1)
try:
return self.a11yAppName in [
x.name for x in root.applications()
]
except GLib.GError:
continue
raise Exception("10 at-spi errors, seems that bus is blocked")
def getDashIconPosition(name):
"""Get a position of miniature on Overview"""
over = root.application('gnome-shell').child(name='Overview')
button = over[2].child(name=name)
(x, y) = button.position
(a, b) = button.size
return (x + a / 2, y + b / 2)
def parseDesktopFile(self):
"""
Getting all necessary data from *.dektop file of the app
"""
cmd = "rpm -qlf $(which %s)" % self.appCommand
cmd += '| grep "^/usr/share/applications/.*%s.desktop$"' % self.desktopFileName
proc = Popen(cmd, shell=True, stdout=PIPE)
# !HAVE TO check if the command and its desktop file exist
if proc.wait() != 0:
raise Exception("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def kill(self):
"""
Kill the app via 'killall'
"""
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
try:
self.process.kill()
except:
# Fall back to killall
Popen("killall " + self.appCommand, shell=True).wait()
def getName(self):
return self.desktopConfig.get('Desktop Entry', 'name')
def startViaCommand(self):
"""
Start the app via command
"""
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
assert not self.isRunning(), "Application cannot be stopped"
self.process = Popen(self.appCommand.split() + self.parameters.split(),
stdout=PIPE,
stderr=PIPE,
bufsize=0)
self.pid = self.process.pid
assert self.isRunning(), "Application failed to start"
return root.application(self.a11yAppName)
def startViaMenu(self, throughCategories=False):
self.parseDesktopFile()
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
assert not self.isRunning(), "Application cannot be stopped"
try:
gnomeShell = root.application('gnome-shell')
pressKey('Super_L')
sleep(6)
if throughCategories:
# menu Applications
x, y = getDashIconPosition('Show Applications')
absoluteMotion(x, y)
time.sleep(1)
click(x, y)
time.sleep(4) # time for all the oversized app icons to appear
# submenu that contains the app
submenu = gnomeShell.child(name=self.getMenuGroups(),
roleName='list item')
submenu.click()
time.sleep(4)
# the app itself
app = gnomeShell.child(name=self.getName(), roleName='label')
app.click()
else:
typeText(self.getName())
sleep(2)
pressKey('Enter')
assert self.isRunning(), "Application failed to start"
except SearchError:
print("!!! Lookup error while passing the path")
return root.application(self.a11yAppName)
def closeViaShortcut(self):
"""
Close the app via shortcut
"""
if not self.isRunning():
raise Exception("App is not running")
keyCombo(self.shortcut)
assert not self.isRunning(), "Application cannot be stopped"
class App(object):
"""
Does all basic events with app
"""
def __init__(
self, appName, critical=None, shortcut='<Control><Q>', desktopFileName=None, a11yAppName=None, quitButton=None, timeout=5,
forceKill=True, parameters='', polkit=False, recordVideo=True):
"""
Initialize object App
appName command to run the app
critical what's the function we check? {start,quit}
shortcut default quit shortcut
timeout timeout for starting and shuting down the app
forceKill is the app supposed to be kill before/after test?
parameters has the app any params needed to start? (only for startViaCommand)
desktopFileName = name of the desktop file if other than appName (without .desktop extension)
"""
self.appCommand = appName
self.shortcut = shortcut
self.timeout = timeout
self.forceKill = forceKill
self.critical = critical
self.quitButton = quitButton
# the result remains false until the correct result is verified
self.result = False
self.updateCorePattern()
self.parameters = parameters
self.internCommand = self.appCommand.lower()
self.polkit = polkit
self.polkitPass = '******'
self.a11yAppName = a11yAppName
self.recordVideo = recordVideo
if desktopFileName is None:
desktopFileName = self.appCommand
self.desktopFileName = desktopFileName
# a way of overcoming overview autospawn when mouse in 1,1 from start
pressKey('Esc')
absoluteMotion(100, 100, 2)
# attempt to make a recording of the test
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
def parseDesktopFile(self):
"""
Getting all necessary data from *.dektop file of the app
"""
cmd = "rpm -qlf $(which %s)" % self.appCommand
cmd += '| grep "^/usr/share/applications/.*%s.desktop$"' % self.desktopFileName
proc = Popen(cmd, shell=True, stdout=PIPE)
# !HAVE TO check if the command and its desktop file exist
if proc.wait() != 0:
raise Exception("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def end(self):
"""
Ends the test with correct return value
"""
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
time.sleep(2)
if not isProcessRunning('gnome-shell') or isProcessRunning('gnome-shell --mode=gdm'):
print ("Error: gnome-shell/Xorg crashed during or after the test!")
self.result = False
if self.result:
print("PASS")
sys.exit(0)
else:
print("FAIL")
sys.exit(1)
def updateResult(self, result):
self.result = result
def getName(self):
return self.desktopConfig.get('Desktop Entry', 'name')
def getExec(self):
try:
return (
self.desktopConfig.get(
'Desktop Entry',
'exec').split()[0].split('/')[-1]
)
except ConfigParser.NoOptionError:
return self.getName()
def getCategories(self):
return self.desktopConfig.get('Desktop Entry', 'categories')
def getMenuGroups(self):
"""
Convert group list to the one correct menu group
"""
groupsList = self.getCategories().split(';')
groupsList.reverse()
groupConversionDict = {
'Accessibility': 'Universal Access',
'System': 'System Tools',
'Development': 'Programming',
'Network': 'Internet',
'Office': 'Office',
'Graphics': 'Graphics',
'Game': 'Games',
'Education': 'Education',
'Utility': 'Accessories',
'AudioVideo': 'Sound & Video'
}
for i in groupsList:
if i in groupConversionDict:
return groupConversionDict[i]
def isRunning(self):
"""
Is the app running?
"""
if self.a11yAppName is None:
self.a11yAppName = self.internCommand
def getApp():
try:
#from dogtail.tree import root
apps = root.applications()
except:
traceback.print_exc(file=sys.stdout)
time.sleep(4)
#from dogtail.tree import root
try:
app = root.application(self.a11yAppName)
return app
except SearchError:
return None
for i in apps:
if i.name.lower() == self.a11yAppName:
return i
return None
print("*** Checking if '%s' is running" % self.a11yAppName)
try: # should the a11y app reload due to start screen (i.e. gimp)
app = getApp()
except:
time.sleep(5)
app = getApp()
if app is None or len(app) == 0:
print("*** The app '%s' is not running" % self.a11yAppName)
return False
else:
print("*** The app '%s' is running" % self.a11yAppName)
return True
def kill(self):
"""
Kill the app via 'killall'
"""
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
print("*** Killing all '%s' instances" % self.appCommand)
return Popen("pkill " + self.appCommand, shell=True).wait()
def updateCorePattern(self):
"""
Update string in /proc/sys/kernel/core_pattern to catch
possible return code
"""
Popen("sudo rm -rf /tmp/cores", shell=True).wait()
Popen("mkdir /tmp/cores", shell=True).wait()
Popen("chmod a+rwx /tmp/cores", shell=True).wait()
Popen(
"echo \"/tmp/cores/core.%e.%s.%p\" | sudo tee /proc/sys/kernel/core_pattern",
shell=True).wait()
def existsCoreDump(self):
"""
Check if there is core dump created
"""
dirPath = "/tmp/cores/"
files = os.listdir(dirPath)
regexp = "core\.%s\.[0-9]{1,3}\.[0-9]*" % self.appCommand
for f in files:
if re.match(regexp, f):
return int(f.split(".")[2])
return 0
def startViaMenu(self, throughCategories=False):
"""
Start the app via Gnome Shell menu
"""
internCritical = (self.critical == 'start')
self.parseDesktopFile()
# check if the app is running
if self.forceKill and self.isRunning():
self.kill()
time.sleep(2)
if self.isRunning():
if internCritical:
self.updateResult(False)
print("!!! The app is running but it shouldn't be")
return False
else:
print("*** The app has been killed succesfully")
try:
# panel button Activities
gnomeShell = root.application('gnome-shell')
pressKey('Super_L')
time.sleep(6) # time for overview to appear
if throughCategories:
# menu Applications
x, y = getDashIconPosition('Show Applications')
absoluteMotion(x, y)
time.sleep(1)
click(x, y)
time.sleep(4) # time for all the oversized app icons to appear
# submenu that contains the app
submenu = gnomeShell.child(
name=self.getMenuGroups(), roleName='list item')
submenu.click()
time.sleep(4)
# the app itself
app = gnomeShell.child(
name=self.getName(), roleName='label')
app.click()
else:
typeText(self.getName())
time.sleep(2)
pressKey('Enter')
# if there is a polkit
if self.polkit:
time.sleep(3)
typeText(self.polkitPass)
keyCombo('<Enter>')
time.sleep(self.timeout)
if self.isRunning():
print("*** The app started successfully")
if internCritical:
self.updateResult(True)
return True
else:
print("!!! The app is not running but it should be")
if internCritical:
self.updateResult(False)
return False
except SearchError:
print("!!! Lookup error while passing the path")
if internCritical:
self.updateResult(False)
return False
def startViaCommand(self):
"""
Start the app via command
"""
internCritical = (self.critical == 'start')
if self.forceKill and self.isRunning():
self.kill()
time.sleep(2)
if self.isRunning():
if internCritical:
self.updateResult(False)
print("!!! The app is running but it shouldn't be")
return False
else:
print("*** The app has been killed succesfully")
returnValue = 0
command = "%s %s" % (self.appCommand, self.parameters)
returnValue = utilsRun(command, timeout=10, dumb=True)
# if there is a polkit
if self.polkit:
time.sleep(3)
typeText(self.polkitPass)
keyCombo('<Enter>')
time.sleep(self.timeout)
# check the returned values
if returnValue is None:
if internCritical:
self.updateResult(False)
print("!!! The app command could not be found")
return False
else:
if self.isRunning():
if internCritical:
self.updateResult(True)
print("*** The app started successfully")
return True
else:
if internCritical:
self.updateResult(False)
print("!!! The app did not started despite the fact that the command was found")
return False
def closeViaShortcut(self):
"""
Close the app via shortcut
"""
internCritical = (self.critical == 'quit')
if not self.isRunning():
if internCritical:
self.updateResult(False)
print("!!! The app does not seem to be running")
return False
keyCombo(self.shortcut)
time.sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
print("!!! The app is running but it shouldn't be")
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
print("!!! The app closed with core dump created. Signal %d" % self.existsCoreDump())
return False
if internCritical:
self.updateResult(True)
print("*** The app was successfully closed")
return True
def closeViaMenu(self):
"""
Close app via menu button
"""
internCritical = (self.critical == 'quit')
if not self.isRunning():
if internCritical:
self.updateResult(False)
print("!!! The app does not seem to be running")
return False
# try to bind the menu and the button
try:
firstSubmenu = self.getMenuNth(0)
firstSubmenu.click()
length = len(firstSubmenu.children)
closeButton = firstSubmenu.children[length - 1]
if self.quitButton is None:
while re.search('(Close|Quit|Exit)', closeButton.name) is None:
length = length - 1
closeButton = firstSubmenu.children[length]
if length < 0:
if internCritical:
self.updateResult(False)
print("!!! The app quit button coldn't be found")
return False
else:
closeButton = firstSubmenu.child(self.quitButton)
except SearchError:
if internCritical:
self.updateResult(False)
print("!!! The app menu bar or the quit button could'n be found")
if self.forceKill:
self.kill()
return False
time.sleep(2) # timeout until menu appear
print("*** Trying to click to '%s'" % closeButton)
closeButton.click()
time.sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
print("!!! The app is running but it shouldn't be")
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
print("!!! The app closed with core dump created. Signal %d" % self.existsCoreDump())
return False
if internCritical:
self.updateResult(True)
print("*** The app was successfully closed")
return True
def getMenuNamed(self, menuName):
"""
Return submenu with name specified with 'menuName'
"""
# bind to the right app
if self.a11yAppName is None:
self.a11yAppName = self.internCommand
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.a11yAppName:
app = i
break
# try to bind the menu and the button
try:
appMenu = app.child(roleName='menu bar')
return appMenu.child(name=menuName)
except:
return None
def getMenuNth(self, nth):
"""
Return nth submenu
"""
# bind to the right app
if self.a11yAppName is None:
self.a11yAppName = self.internCommand
app = root
apps = root.applications()
for i in apps:
if i.name.lower() == self.a11yAppName:
app = i
break
# try to bind the menu and the button
try:
appMenu = app.child(roleName='menu bar')
return appMenu.children[nth]
except:
return None
def closeViaGnomePanel(self):
"""
Close the app via menu at gnome-panel
"""
internCritical = (self.critical == 'quit')
self.parseDesktopFile()
if not self.isRunning():
if internCritical:
self.updateResult(False)
print("!!! The app does not seem to be running")
return False
print("*** Trying to click to '%s -> Quit'" % self.getName())
shell = GnomeShell()
shell.clickApplicationMenuItem(self.getName(), 'Quit')
time.sleep(self.timeout)
if self.isRunning():
if self.forceKill:
self.kill()
if internCritical:
self.updateResult(False)
print("!!! The app is running but it shouldn't be")
return False
else:
if self.existsCoreDump() != 0:
if internCritical:
self.updateResult(False)
print("!!! The app closed with core dump created. Signal %d" % self.existsCoreDump())
return False
if internCritical:
self.updateResult(True)
print("*** The app was successfully closed")
return True
class App(object):
"""
This class does all basic events with the app
"""
def __init__(
self, appName, desktopFileName = None, shortcut='<Control><Q>', a11yAppName=None,
forceKill=True, parameters='', recordVideo=False):
"""
Initialize object App
appName command to run the app
shortcut default quit shortcut
a11yAppName app's a11y name is different than binary
forceKill is the app supposed to be kill before/after test?
parameters has the app any params needed to start? (only for startViaCommand)
recordVideo start gnome-shell recording while running the app
"""
self.appCommand = appName
self.shortcut = shortcut
self.forceKill = forceKill
self.parameters = parameters
self.internCommand = self.appCommand.lower()
self.a11yAppName = a11yAppName
self.recordVideo = recordVideo
self.pid = None
if desktopFileName is None:
desktopFileName = self.appCommand
self.desktopFileName = desktopFileName
# a way of overcoming overview autospawn when mouse in 1,1 from start
pressKey('Esc')
absoluteMotion(100, 100, 2)
# attempt to make a recording of the test
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
def isRunning(self):
"""
Is the app running?
"""
if self.a11yAppName is None:
self.a11yAppName = self.internCommand
# Trap weird bus errors
for attempt in xrange(0, 30):
sleep(1)
try:
return self.a11yAppName in [x.name for x in root.applications()]
except GLib.GError:
continue
raise Exception("10 at-spi errors, seems that bus is blocked")
def getDashIconPosition(name):
"""Get a position of miniature on Overview"""
over = root.application('gnome-shell').child(name='Overview')
button = over[2].child(name=name)
(x, y) = button.position
(a, b) = button.size
return (x + a / 2, y + b / 2)
def parseDesktopFile(self):
"""
Getting all necessary data from *.dektop file of the app
"""
cmd = "rpm -qlf $(which %s)" % self.appCommand
cmd += '| grep "^/usr/share/applications/.*%s.desktop$"' % self.desktopFileName
proc = Popen(cmd, shell=True, stdout=PIPE)
# !HAVE TO check if the command and its desktop file exist
if proc.wait() != 0:
raise Exception("*.desktop file of the app not found")
output = proc.communicate()[0].rstrip()
self.desktopConfig = ConfigParser()
self.desktopConfig.read(output)
def kill(self):
"""
Kill the app via 'killall'
"""
if self.recordVideo:
keyCombo('<Control><Alt><Shift>R')
try:
self.process.kill()
except:
# Fall back to killall
Popen("killall " + self.appCommand, shell=True).wait()
def getName(self):
return self.desktopConfig.get('Desktop Entry', 'name')
def startViaCommand(self):
"""
Start the app via command
"""
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
assert not self.isRunning(), "Application cannot be stopped"
self.process = Popen(self.appCommand.split() + self.parameters.split(),
stdout=PIPE, stderr=PIPE, bufsize=0)
self.pid = self.process.pid
assert self.isRunning(), "Application failed to start"
return root.application(self.a11yAppName)
def startViaMenu(self, throughCategories = False):
self.parseDesktopFile()
if self.forceKill and self.isRunning():
self.kill()
sleep(2)
assert not self.isRunning(), "Application cannot be stopped"
try:
gnomeShell = root.application('gnome-shell')
pressKey('Super_L')
sleep(6)
if throughCategories:
# menu Applications
x, y = getDashIconPosition('Show Applications')
absoluteMotion(x, y)
time.sleep(1)
click(x, y)
time.sleep(4) # time for all the oversized app icons to appear
# submenu that contains the app
submenu = gnomeShell.child(
name=self.getMenuGroups(), roleName='list item')
submenu.click()
time.sleep(4)
# the app itself
app = gnomeShell.child(
name=self.getName(), roleName='label')
app.click()
else:
typeText(self.getName())
sleep(2)
pressKey('Enter')
assert self.isRunning(), "Application failed to start"
except SearchError:
print("!!! Lookup error while passing the path")
return root.application(self.a11yAppName)
def closeViaShortcut(self):
"""
Close the app via shortcut
"""
if not self.isRunning():
raise Exception("App is not running")
keyCombo(self.shortcut)
assert not self.isRunning(), "Application cannot be stopped"
import datetime
import xlrd
from xls import *
from vt import *
from iniparse import ConfigParser
import sys
import platform
#ayarlarin yuklenmesi
ayar=ConfigParser()
yol='.\etoku\DATA\\'
if platform.system()=='Linux':
yol="etoku/DATA/"
ayardos='bal.ini'
if len(sys.argv) > 1:
ayardos=sys.argv[1]
ayar.read(yol+ayardos)
print "-->",yol+ayardos
dosya=yol+ayar.get("excel","dosya")
sayfa=ayar.get("excel","sayfa")
yon=ayar.get("excel","yon")
if len(sys.argv) > 2:
sayfa=sys.argv[2]
if len(sys.argv) > 3:
konsdos=sys.argv[3]
dosya=yol+konsdos
form=xls()
#sayfanin yuklenmesi
form.sayfa(dosya,sayfa)
def read(self):
ConfigParser.read(self, self.path)
