def run(self):
base_extract_messages.run(self)
srcdir = get_path([DOCDIR, 'rst'])
outdir = get_path([DOCDIR, 'rst', 'i18n', 'pot'])
doctreedir = get_path([DOCDIR, 'doctrees'])
buildername = 'gettext'
app = Sphinx(srcdir=srcdir,
confdir=srcdir,
outdir=outdir,
doctreedir=doctreedir,
buildername=buildername,
confoverrides=None,
status=sys.stdout,
warning=sys.stderr,
freshenv=True,
warningiserror=False,
tags=None)
try:
app.build(force_all=True)
except Exception as e:
print e
try:
shutil.rmtree(doctreedir)
except Exception as e:
print e
def get_package_data(path=None, packages=None, data_files=None,
exclude_packages=None, exclude_files=None):
"""
For a list of packages, find the package_data
This function scans the subdirectories of a package and considers all
non-submodule subdirectories as resources, including them in
the package_data
Returns a dictionary suitable for setup(package_data=<result>)
"""
assert path is not None
assert packages is not None
assert data_files is not None
path = os.path.normpath(path)
package_data = {}
for package in packages:
package_data[package] = []
for f in find_files(path=get_path([path, package_to_path(package)]), pattern='*.*'):
package_data[package].append(f)
for e in exclude_packages + ['ez_setup', 'distribute_setup']:
if fnmatch.fnmatch(f, get_path([path, package_to_path(e), '*'])) \
and f in package_data[package]:
package_data[package].remove(f)
for x in exclude_files + ['*.py']:
if fnmatch.fnmatch(f, get_path([path, x])) \
and f in package_data[package]:
package_data[package].remove(f)
package_data[package] = list(
set(package_data[package]) - set(flatten_list(list(zip(*data_files)[1]))))
for i, j in enumerate(package_data[package]):
package_data[package][i] = package_data[package][i].replace(path + os.sep + package_to_path(package) + os.sep, '')
return package_data
def run(self):
log.debug("[%s.%s] Compressing JS." %
(__name__, self.__class__.__name__))
JSFULL_DIR = get_path(
[BASEDIR, 'tribus', 'data', 'static', 'js', 'full'])
JSMIN_DIR = get_path(
[BASEDIR, 'tribus', 'data', 'static', 'js', 'min'])
try:
os.makedirs(JSMIN_DIR)
except Exception as e:
print e
for JS_FILE in find_files(path=JSFULL_DIR, pattern='*.js'):
JSMIN_FILE = get_path([JSMIN_DIR, os.path.basename(JS_FILE)])
try:
with open(JSMIN_FILE, 'w') as _file:
_file.write(slimit.minify(open(JS_FILE).read()))
_file.close()
except Exception as e:
print e
log.debug("[%s.%s] %s > %s." %
(__name__, self.__class__.__name__, JS_FILE, JSMIN_FILE))
def run(self):
log.debug("[%s.%s] Compressing CSS." %
(__name__, self.__class__.__name__))
CSSFULL_DIR = get_path(
[BASEDIR, 'tribus', 'data', 'static', 'css', 'full'])
CSSMIN_DIR = get_path(
[BASEDIR, 'tribus', 'data', 'static', 'css', 'min'])
try:
os.makedirs(CSSMIN_DIR)
except Exception as e:
print e
for CSS_FILE in find_files(path=CSSFULL_DIR, pattern='*.css'):
CSSMIN_FILE = get_path([CSSMIN_DIR, os.path.basename(CSS_FILE)])
try:
with open(CSSMIN_FILE, 'w') as _file:
_file.write(cssmin.cssmin(open(CSS_FILE).read()))
_file.close()
except Exception as e:
print e
log.debug(
"[%s.%s] %s > %s." %
(__name__, self.__class__.__name__, CSS_FILE, CSSMIN_FILE))
def setUp(self):
from tribus.common.utils import get_path
from tribus.common.iosync import makedirs, touch, ln, rmtree
self.tmpdir = get_path(['/', 'tmp', 'test_io'])
self.tmpdir_1 = get_path([self.tmpdir, '1'])
self.tmpdir_2 = get_path([self.tmpdir, '2'])
self.tmpfile_1 = get_path([self.tmpdir_1, '1.txt'])
self.tmpfile_2 = get_path([self.tmpdir_2, '2.txt'])
self.tmpfile_3 = get_path([self.tmpdir_2, '3.log'])
self.tmpfile_4 = get_path([self.tmpdir_2, '4.txt'])
self.tmpfile_5 = get_path([self.tmpdir, '5.log'])
self.tmpfile_6 = get_path([self.tmpdir, '6.py'])
if os.path.isdir(self.tmpdir):
rmtree(self.tmpdir)
makedirs(self.tmpdir_1)
makedirs(self.tmpdir_2)
touch(self.tmpfile_1)
touch(self.tmpfile_2)
touch(self.tmpfile_3)
touch(self.tmpfile_5)
touch(self.tmpfile_6)
ln(self.tmpfile_3, self.tmpfile_4)
def run(self):
log.debug("[%s.%s] Compiling manual from RST sources." %
(__name__, self.__class__.__name__))
pub = Publisher(writer=manpage.Writer())
pub.set_components(reader_name='standalone',
parser_name='restructuredtext',
writer_name='pseudoxml')
pub.publish(argv=[
u'%s' % get_path([DOCDIR, 'man', 'tribus.rst']),
u'%s' % get_path([DOCDIR, 'man', 'tribus.1'])
])
def run(self):
for sphnxdir in [
get_path([DOCDIR, 'html']),
get_path([DOCDIR, 'doctrees'])
]:
if os.path.isdir(sphnxdir):
try:
shutil.rmtree(sphnxdir)
log.debug("[%s.%s] Removing \"%s\"." %
(__name__, self.__class__.__name__, sphnxdir))
except Exception as e:
print e
def test_update_paragraph(self):
from tribus.common.recorder import update_paragraph
from tribus.config.pkgrecorder import PACKAGE_FIELDS, DETAIL_FIELDS
old_paragraph = deb822.Packages(open(get_path([SMPLDIR, 'Blender'])))
new_paragraph = deb822.Packages(open(get_path([SMPLDIR,
'BlenderNew'])))
Package.objects.create_auto(old_paragraph, test_dist, 'main')
update_paragraph(new_paragraph, test_dist, 'main')
p = Package.objects.get(Name='blender')
d = Details.objects.get(package=p)
name, mail = email.Utils.parseaddr(new_paragraph.get('Maintainer'))
total_relations = 0
total_labels = 0
self.assertEqual(p.Maintainer.Name, name)
self.assertEqual(p.Maintainer.Email, mail)
self.assertEqual(d.Distribution, test_dist)
tag_list = new_paragraph['Tag'].replace('\n', '').split(', ')
clean_list = [tuple(tag.split('::')) for tag in tag_list]
for label in p.Labels.all():
total_labels += 1
self.assertIn((label.Name, label.Tags.Value), clean_list)
self.assertEqual(total_labels, len(clean_list))
for field, field_db in PACKAGE_FIELDS.items():
if new_paragraph.get(field):
self.assertEqual(str(getattr(p, field_db)),
new_paragraph[field])
for field, field_db in DETAIL_FIELDS.items():
if new_paragraph.get(field):
self.assertEqual(str(getattr(d, field_db)),
new_paragraph[field])
for _, relations in new_paragraph.relations.items():
if relations:
for relation in relations:
if len(relation) > 1:
for _ in relation:
total_relations += 1
else:
total_relations += 1
self.assertEqual(d.Relations.all().count(), total_relations)
def get_sphinx_locale_list(self):
return set(
filter(
None,
list_items(path=get_path([DOCDIR, 'rst', 'i18n']),
dirs=True,
files=False))) - set(['pot'])
def docker_create_service_cluster():
"""
Crea un cluster de consul para un servicio.
.. versionadded:: 0.2
"""
env.port = 22
env.target_img = "consul:test"
env.build_dockerfile = get_path([BASEDIR, 'tribus', 'data', 'consul'])
with hide('warnings', 'stderr', 'running'):
# Deben agregarse algunas verificaciones previas
# por ejemplo, debe existir la imagen base para los
# nodos, de lo contrario debe crearse
# - Necesito asignar un nombre a la imagen
# - Necesito especificar de donde se construye la imagen
# Para no ralentizar mas el desarrollo, generare la imagen a partir
# de un Dockerfile a pesar de que pueden existir otras tecnicas
# mas eficientes para generar las imagenes.
bimage = sudo(
'%(docker)s build -t %(target_img)s %(build_dockerfile)s' % env)
def run(self):
man_file = get_path([DOCDIR, 'man', 'tribus.1'])
if os.path.isfile(man_file):
try:
os.unlink(man_file)
log.debug("[%s.%s] Removing \"%s\"." %
(__name__, self.__class__.__name__, man_file))
except Exception as e:
print e
def run(self):
base_update_catalog.run(self)
for potfile in self.get_sphinx_pot_list():
self.domain = os.path.splitext(os.path.basename(potfile))[0]
self.input_file = potfile
self.output_dir = get_path([DOCDIR, 'rst', 'i18n'])
base_update_catalog.finalize_options(self)
base_update_catalog.run(self)
def run(self):
for dist_dir in ['dist', 'build', 'Tribus.egg-info']:
dist_subdir = get_path([BASEDIR, dist_dir])
if os.path.isdir(dist_subdir):
try:
shutil.rmtree(dist_subdir)
log.debug("[%s.%s] Removing \"%s\"." %
(__name__, self.__class__.__name__, dist_subdir))
except Exception as e:
print e
def run(self):
base_compile_catalog.run(self)
for potfile in self.get_sphinx_pot_list():
base_compile_catalog.initialize_options(self)
self.domain = os.path.splitext(os.path.basename(potfile))[0]
self.directory = get_path([DOCDIR, 'rst',
'i18n']).replace(BASEDIR + os.sep, '')
self.use_fuzzy = True
base_compile_catalog.run(self)
def get_object_list(self, bundle):
if hasattr(bundle.request, 'GET'):
charm_name = bundle.request.GET.get('name', None)
CHARM = CharmDirectory(get_path([CHARMSDIR, charm_name]))
return [CharmObject({
'config': CHARM.config._data,
})]
def run(self):
html_dir = get_path([DOCDIR, 'html'])
if os.path.isdir(html_dir):
try:
shutil.rmtree(html_dir)
log.debug(
"[%s.%s] Removing \"%s\"." %
(__name__, self.__class__.__name__, html_dir))
except Exception as e:
print e
def flake8_report(self):
"""
Outputs flake8 report.
"""
log.info("\n\nFlake8 Report:")
base = get_path([BASEDIR, 'tribus'])
pys = find_files(path=base, pattern='*.py')
flake8_style = get_style_guide()
report = flake8_style.check_files(pys)
exit_code = print_report(report, flake8_style)
def run(self):
for locale in self.get_locale_list():
self.locale = locale
self.domain = 'django'
self.output_dir = get_path([BASEDIR, 'tribus', 'data', 'i18n'])
self.input_file = get_path(
[BASEDIR, 'tribus', 'data', 'i18n', 'pot', 'django.pot'])
self.output_file = None
base_init_catalog.finalize_options(self)
base_init_catalog.run(self)
for potfile in self.get_sphinx_pot_list():
self.locale = locale
self.domain = os.path.splitext(os.path.basename(potfile))[0]
self.output_dir = get_path([DOCDIR, 'rst', 'i18n'])
self.input_file = potfile
self.output_file = None
base_init_catalog.finalize_options(self)
base_init_catalog.run(self)
def run(self):
CSSMIN_DIR = get_path(
[BASEDIR, 'tribus', 'data', 'static', 'css', 'min'])
if os.path.isdir(CSSMIN_DIR):
try:
shutil.rmtree(CSSMIN_DIR)
log.debug("[%s.%s] Removing \"%s\"." %
(__name__, self.__class__.__name__, CSSMIN_DIR))
except Exception as e:
print e
def get_data_files(path=None, patterns=None, exclude_files=None):
"""
Procesess a list of patterns to get a list of files that should be put in
a directory. This function helps the Tribus Maintainer to define a list of
files to be installed in a certain system directory.
For example, generated documentation (everything under
``tribus/data/docs/html`` after executing ``make build_sphinx``) should be
put in ``/usr/share/doc/tribus/``. The maintainer should add a pattern like
the following so that everything from ``tribus/data/docs/html`` gets copied
to ``/usr/share/doc/tribus/`` when the package is installed
(``python setup.py install``) or a binary distribution is created
(``python setup.py bdist``).
:param path: the path where the files reside. Generally the top level
directory of the project. Patterns will be expanded in
this directory.
:param patterns: this is a list of strings in the form of::
['relative/path/inside/project *.some.*regex* /dest',
'another/path/inside/project *.foo.*regex* /dest2',
'path/ *.* dest/']
which means, *Put every file from this folder matching the
regex inside this other folder*.
:param exclude_files: this is a list of file patterns to exclude from the
results.
:return: a list of pairs ``('directory', [file-list])`` ready for use
in ``setup(data_files=...)`` from Setuptools/Distutils.
:rtype: ``list``
.. versionadded:: 0.1
"""
assert path is not None
assert patterns is not None
path = os.path.normpath(path)
d = []
for l in patterns:
src, rgx, dest = l.split()
for subdir in find_dirs(path=get_path([path, src])):
f = []
for files in list_files(path=subdir):
f.append(files)
for exclude in exclude_files:
if fnmatch.fnmatch(files, exclude) and files in f:
f.remove(files)
d.append((dest + subdir.replace(os.path.join(path, src), ''), f))
return d
def pep257_report(self):
"""
Outputs flake8 report.
"""
log.info("\n\nPEP257 Report:")
base = get_path([BASEDIR, 'tribus'])
pys = find_files(path=base, pattern='*.py')
report = pep257.check_files(pys)
if len(report) > 0:
for r in report:
log.info(r)
else:
log.info("\nNo errors found!")
def get_object_list(self, bundle):
if hasattr(bundle.request, 'GET'):
charm_name = bundle.request.GET.get('name', None)
SERVICE = RecipeDir(get_path([SERVICEDIR, charm_name]))
return [ServiceObject({
'name': SERVICE.metadata.name,
'summary': SERVICE.metadata.summary,
'maintainer': SERVICE.metadata.maintainer,
'description': SERVICE.metadata.description,
'components' : SERVICE.metadata.components.items()
})]
def get_object_list(self, bundle):
if hasattr(bundle.request, 'GET'):
charm_name = bundle.request.GET.get('name', None)
CHARM = CharmDirectory(get_path([CHARMSDIR, charm_name]))
config = {}
for k, v in CHARM.config._data.iteritems():
default = v.get('default', None)
if default:
config[k] = default
return [CharmObject({'config': config})]
def get_object_list(self, bundle):
if hasattr(bundle.request, 'GET'):
charm_name = bundle.request.GET.get('name', None)
CHARM = CharmDirectory(get_path([CHARMSDIR, charm_name]))
return [
CharmObject({
'name': CHARM.metadata.name,
'summary': CHARM.metadata.summary,
'maintainer': CHARM.metadata.maintainer,
'description': CHARM.metadata.description,
})
]
env.port = 22222
env.password = '******'
env.warn_only = True
env.output_prefix = False
# Docker config
env.docker = 'docker.io'
env.arch = get_local_arch()
env.docker_maintainer = '%s <%s>' % (AUTHOR, AUTHOR_EMAIL)
env.debian_base_image = 'luisalejandro/debian-%(arch)s:wheezy' % env
env.tribus_base_image = 'luisalejandro/tribus-%(arch)s:wheezy' % env
env.tribus_runtime_image = 'luisalejandro/tribus-run-%(arch)s:wheezy' % env
env.tribus_runtime_container = 'tribus-run-container'
env.debian_base_image_script = get_path(
[BASEDIR, 'tribus', 'data', 'scripts', 'debian-base-image.sh'])
env.tribus_base_image_script = get_path(
[BASEDIR, 'tribus', 'data', 'scripts', 'tribus-base-image.sh'])
env.tribus_django_syncdb_script = get_path(
[BASEDIR, 'tribus', 'data', 'scripts', 'django-syncdb.sh'])
env.tribus_django_runserver_script = get_path(
[BASEDIR, 'tribus', 'data', 'scripts', 'django-runserver.sh'])
env.tribus_start_container_script = get_path(
[BASEDIR, 'tribus', 'data', 'scripts', 'start-container.sh'])
waffle_switches = SWITCHES_CONFIGURATION.keys()
mounts = ['%(basedir)s:%(basedir)s:rw' % env, '/tmp:/tmp:rw']
start_services = ['ssh', 'postgresql', 'slapd']
change_passwd = ['root:tribus', 'postgres:tribus', 'openldap:tribus']
env.mounts = ' '.join('--volume %s' % i for i in mounts)
These are the tests for the tribus.common.repository module.
'''
import os
import gzip
import email.Utils
from fabric.api import env, lcd, local, settings
from debian import deb822
from django.test import TestCase
from doctest import DocTestSuite
from tribus.__init__ import BASEDIR
from tribus.common.utils import get_path
from tribus.web.cloud.models import Package
SAMPLESDIR = get_path([BASEDIR, "tribus", "testing", "samples"])
FIXTURES = get_path([BASEDIR, "tribus", "testing", "fixtures"])
dist = 'kerepakupai'
class RepositoryFunctions(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_init_sample_packages(self):
pass
def test_select_sample_packages(self):
SITE_ID = 1
DEBUG = True
TEMPLATE_DEBUG = DEBUG
ADMINS = ()
MANAGERS = ADMINS
USE_I18N = True
USE_L10N = True
USE_TZ = True
TIME_ZONE = 'America/Caracas'
LANGUAGE_CODE = 'es'
DATABASE_OPTIONS = {'charset': 'utf8'}
DEFAULT_CHARSET = 'utf-8'
LOCALE_PATHS = [get_path([BASEDIR, 'tribus', 'data', 'i18n'])]
SITE_ROOT = get_path([BASEDIR, 'tribus', 'web'])
MEDIA_ROOT = ''
MEDIA_URL = '/media/'
STATIC_ROOT = ''
STATIC_URL = '/static/'
STATICFILES_DIRS = [get_path([BASEDIR, 'tribus', 'data', 'static'])]
TEMPLATE_DIRS = [get_path([BASEDIR, 'tribus', 'data', 'templates'])]
DJANGO_STATIC = not DEBUG
DJANGO_STATIC_MEDIA_ROOTS = [get_path([BASEDIR, 'tribus', 'data'])]
DJANGO_STATIC_FILENAME_GENERATOR = 'tribus.common.utils.filename_generator'
DJANGO_STATIC_NAME_MAX_LENGTH = 200
LOGIN_URL = '/login'
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from tribus import BASEDIR
from tribus.common.utils import get_path
from tribus.config.ldap import AUTH_LDAP_BASE
DEBUG = True
SITE_ROOT = get_path([BASEDIR, 'tribus', 'web'])
MEDIA_ROOT = ''
MEDIA_URL = '/media/'
STATIC_ROOT = ''
STATIC_URL = '/static/'
STATICFILES_DIRS = [get_path([BASEDIR, 'tribus', 'data', 'static'])]
TEMPLATE_DIRS = [get_path([BASEDIR, 'tribus', 'data', 'templates'])]
DATABASES = {'default': {'ENGINE': 'django.db.backends.sqlite3'}}
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django_auth_ldap',
'django_static',
'tribus.web.cloud',
'south',
'haystack',
#'waffle',
)
ROOT_URLCONF = 'tribus.web.urls'
#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2013 Desarrolladores de Tribus # # This file is part of Tribus. # # Tribus is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Tribus is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. ''' tribus ====== ''' from tribus.common.utils import get_path BASEDIR = get_path([__file__, '..', '..'])
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
from debian import deb822
from email.Utils import parseaddr
from django.test.testcases import TestCase
from tribus.web.cloud.models import (Maintainer, Package, Details, Relation)
from tribus.__init__ import BASEDIR
from tribus.common.utils import get_path
SAMPLESDIR = get_path([BASEDIR, "tribus", "testing", "samples"])
test_dist = "kukenan"
'''
tribus.tests.tribus_web_cloud_models
====================================
These are the tests for the tribus.web.cloud models.
'''
class RegistrationModelTests(TestCase):
def setUp(self):
pass
def tearDown(self):
