def run_build(self, docker=False, record=True):
"""
Build the docs in an environment.
If `docker` is True, or Docker is enabled by the settings.DOCKER_ENABLE
setting, then build in a Docker environment. Otherwise build locally.
"""
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerBuildEnvironment
else:
env_cls = LocalBuildEnvironment
self.build_env = env_cls(project=self.project,
version=self.version,
config=self.config,
build=self.build,
record=record,
environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_python_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Finalize build and update web servers
if build_id:
self.update_app_instances(
html=bool(outcomes['html']),
search=bool(outcomes['search']),
localmedia=bool(outcomes['localmedia']),
pdf=bool(outcomes['pdf']),
epub=bool(outcomes['epub']),
)
else:
log.warning('No build ID, not syncing files')
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def run_build(self, docker=False, record=True):
"""Build the docs in an environment.
If `docker` is True, or Docker is enabled by the settings.DOCKER_ENABLE
setting, then build in a Docker environment. Otherwise build locally.
"""
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerEnvironment
else:
env_cls = LocalEnvironment
self.build_env = env_cls(project=self.project, version=self.version,
build=self.build, record=record, environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Web Server Tasks
if build_id:
finish_build.delay(
version_pk=self.version.pk,
build_pk=build_id,
hostname=socket.gethostname(),
html=outcomes['html'],
search=outcomes['search'],
localmedia=outcomes['localmedia'],
pdf=outcomes['pdf'],
epub=outcomes['epub'],
)
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
self.build_env.update_build(state=BUILD_STATE_FINISHED)
def run_build(self, docker=False, record=True):
"""Build the docs in an environment.
If `docker` is True, or Docker is enabled by the settings.DOCKER_ENABLE
setting, then build in a Docker environment. Otherwise build locally.
"""
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerEnvironment
else:
env_cls = LocalEnvironment
self.build_env = env_cls(project=self.project, version=self.version,
build=self.build, record=record, environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Web Server Tasks
if build_id:
finish_build.delay(
version_pk=self.version.pk,
build_pk=build_id,
hostname=socket.gethostname(),
html=outcomes['html'],
search=outcomes['search'],
localmedia=outcomes['localmedia'],
pdf=outcomes['pdf'],
epub=outcomes['epub'],
)
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
self.build_env.update_build(state=BUILD_STATE_FINISHED)
def run_build(self, docker=False, record=True):
"""
Build the docs in an environment.
If `docker` is True, or Docker is enabled by the settings.DOCKER_ENABLE
setting, then build in a Docker environment. Otherwise build locally.
"""
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerEnvironment
else:
env_cls = LocalEnvironment
self.build_env = env_cls(project=self.project, version=self.version,
build=self.build, record=record, environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Finalize build and update web servers
if build_id:
self.update_app_instances(
html=bool(outcomes['html']),
search=bool(outcomes['search']),
localmedia=bool(outcomes['localmedia']),
pdf=bool(outcomes['pdf']),
epub=bool(outcomes['epub']),
)
else:
log.warning('No build ID, not syncing files')
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def after_return(self, status, retval, task_id, args, kwargs, einfo):
# Update build object
self.data.build['length'] = (timezone.now() -
self.data.start_time).seconds
self.update_build(BUILD_STATE_FINISHED)
build_complete.send(sender=Build, build=self.data.build)
clean_build(self.data.version)
log.info('Build finished.',
length=self.data.build['length'],
success=self.data.build['success'])
def run_build(self, docker, record):
"""
Build the docs in an environment.
:param docker: if ``True``, the build uses a ``DockerBuildEnvironment``,
otherwise it uses a ``LocalBuildEnvironment`` to run all the
commands to build the docs
:param record: whether or not record all the commands in the ``Build``
instance
"""
env_vars = self.get_env_vars()
if docker:
env_cls = DockerBuildEnvironment
else:
env_cls = LocalBuildEnvironment
self.build_env = env_cls(
project=self.project,
version=self.version,
config=self.config,
build=self.build,
record=record,
environment=env_vars,
)
# Environment used for building code, usually with Docker
with self.build_env:
python_env_cls = Virtualenv
if self.config.conda is not None:
log.info(
LOG_TEMPLATE.format(
project=self.project.slug,
version=self.version.slug,
msg='Using conda',
))
python_env_cls = Conda
self.python_env = python_env_cls(
version=self.version,
build_env=self.build_env,
config=self.config,
)
try:
self.setup_python_environment()
# TODO the build object should have an idea of these states,
# extend the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except vcs_support_utils.LockTimeout as e:
self.task.retry(exc=e, throw=False)
raise VersionLockedError
except SoftTimeLimitExceeded:
raise BuildTimeoutError
# Finalize build and update web servers
if build_id:
self.update_app_instances(
html=bool(outcomes['html']),
search=bool(outcomes['search']),
localmedia=bool(outcomes['localmedia']),
pdf=bool(outcomes['pdf']),
epub=bool(outcomes['epub']),
)
else:
log.warning('No build ID, not syncing files')
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def run(self,
pk,
version_pk=None,
build_pk=None,
record=True,
docker=False,
search=True,
force=False,
localmedia=True,
**kwargs):
self.project = self.get_project(pk)
self.version = self.get_version(self.project, version_pk)
self.build = self.get_build(build_pk)
self.build_search = search
self.build_localmedia = localmedia
self.build_force = force
self.config = None
env_cls = LocalEnvironment
self.setup_env = env_cls(project=self.project,
version=self.version,
build=self.build,
record=record,
report_build_success=False)
# Environment used for code checkout & initial configuration reading
with self.setup_env:
if self.project.skip:
raise BuildEnvironmentError(
_('Builds for this project are temporarily disabled'))
try:
self.setup_vcs()
except vcs_support_utils.LockTimeout as e:
self.retry(exc=e, throw=False)
raise BuildEnvironmentError(
'Version locked, retrying in 5 minutes.', status_code=423)
self.config = load_yaml_config(version=self.version)
if self.setup_env.failed or self.config is None:
self.send_notifications()
self.setup_env.update_build(state=BUILD_STATE_FINISHED)
return None
if self.setup_env.successful and not self.project.has_valid_clone:
self.set_valid_clone()
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerEnvironment
self.build_env = env_cls(project=self.project,
version=self.version,
build=self.build,
record=record,
environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
self.setup_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
# Web Server Tasks
if build_id:
finish_build.delay(
version_pk=self.version.pk,
build_pk=build_id,
hostname=socket.gethostname(),
html=outcomes['html'],
search=outcomes['search'],
localmedia=outcomes['localmedia'],
pdf=outcomes['pdf'],
epub=outcomes['epub'],
)
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def run_build(self, docker, record):
"""
Build the docs in an environment.
:param docker: if ``True``, the build uses a ``DockerBuildEnvironment``,
otherwise it uses a ``LocalBuildEnvironment`` to run all the
commands to build the docs
:param record: whether or not record all the commands in the ``Build``
instance
"""
env_vars = self.get_env_vars()
if docker:
env_cls = DockerBuildEnvironment
else:
env_cls = LocalBuildEnvironment
self.build_env = env_cls(project=self.project, version=self.version, config=self.config,
build=self.build, record=record, environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_python_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except vcs_support_utils.LockTimeout as e:
self.task.retry(exc=e, throw=False)
raise BuildEnvironmentError(
'Version locked, retrying in 5 minutes.',
status_code=423
)
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Finalize build and update web servers
if build_id:
self.update_app_instances(
html=bool(outcomes['html']),
search=bool(outcomes['search']),
localmedia=bool(outcomes['localmedia']),
pdf=bool(outcomes['pdf']),
epub=bool(outcomes['epub']),
)
else:
log.warning('No build ID, not syncing files')
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def run_build(self, docker, record):
"""
Build the docs in an environment.
:param docker: if ``True``, the build uses a ``DockerBuildEnvironment``,
otherwise it uses a ``LocalBuildEnvironment`` to run all the
commands to build the docs
:param record: whether or not record all the commands in the ``Build``
instance
"""
env_vars = self.get_env_vars()
if docker:
env_cls = DockerBuildEnvironment
else:
env_cls = LocalBuildEnvironment
self.build_env = env_cls(project=self.project,
version=self.version,
config=self.config,
build=self.build,
record=record,
environment=env_vars)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == 'auto':
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log('Using conda')
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version,
build_env=self.build_env,
config=self.config)
try:
self.setup_python_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get('id')
except vcs_support_utils.LockTimeout as e:
self.task.retry(exc=e, throw=False)
raise BuildEnvironmentError(
'Version locked, retrying in 5 minutes.', status_code=423)
except SoftTimeLimitExceeded:
raise BuildEnvironmentError(_('Build exited due to time out'))
# Finalize build and update web servers
if build_id:
self.update_app_instances(
html=bool(outcomes['html']),
search=bool(outcomes['search']),
localmedia=bool(outcomes['localmedia']),
pdf=bool(outcomes['pdf']),
epub=bool(outcomes['epub']),
)
else:
log.warning('No build ID, not syncing files')
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
def run(
self,
pk,
version_pk=None,
build_pk=None,
record=True,
docker=False,
search=True,
force=False,
localmedia=True,
**kwargs
):
self.project = self.get_project(pk)
self.version = self.get_version(self.project, version_pk)
self.build = self.get_build(build_pk)
self.build_search = search
self.build_localmedia = localmedia
self.build_force = force
self.config = None
env_cls = LocalEnvironment
self.setup_env = env_cls(project=self.project, version=self.version, build=self.build, record=record)
# Environment used for code checkout & initial configuration reading
with self.setup_env:
if self.project.skip:
raise BuildEnvironmentError(_("Builds for this project are temporarily disabled"))
try:
self.setup_vcs()
except vcs_support_utils.LockTimeout as e:
self.retry(exc=e, throw=False)
raise BuildEnvironmentError("Version locked, retrying in 5 minutes.", status_code=423)
self.config = load_yaml_config(version=self.version)
if self.setup_env.failure or self.config is None:
self._log("Failing build because of setup failure: %s" % self.setup_env.failure)
self.send_notifications()
self.setup_env.update_build(state=BUILD_STATE_FINISHED)
return None
if self.setup_env.successful and not self.project.has_valid_clone:
self.set_valid_clone()
env_vars = self.get_env_vars()
if docker or settings.DOCKER_ENABLE:
env_cls = DockerEnvironment
self.build_env = env_cls(
project=self.project, version=self.version, build=self.build, record=record, environment=env_vars
)
# Environment used for building code, usually with Docker
with self.build_env:
if self.project.documentation_type == "auto":
self.update_documentation_type()
python_env_cls = Virtualenv
if self.config.use_conda:
self._log("Using conda")
python_env_cls = Conda
self.python_env = python_env_cls(version=self.version, build_env=self.build_env, config=self.config)
self.setup_environment()
# TODO the build object should have an idea of these states, extend
# the model to include an idea of these outcomes
outcomes = self.build_docs()
build_id = self.build.get("id")
# Web Server Tasks
if build_id:
finish_build.delay(
version_pk=self.version.pk,
build_pk=build_id,
hostname=socket.gethostname(),
html=outcomes["html"],
search=outcomes["search"],
localmedia=outcomes["localmedia"],
pdf=outcomes["pdf"],
epub=outcomes["epub"],
)
if self.build_env.failed:
self.send_notifications()
build_complete.send(sender=Build, build=self.build_env.build)
self.build_env.update_build(state=BUILD_STATE_FINISHED)
