From 59f0166420363761668752975a3a48b95ac9db86 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 12:38:01 +0100 Subject: [PATCH 01/22] move sphinx extensions to ext/ * for consistency with sphinx convention --- src/conf.py | 2 +- src/{custom => ext}/cylc_lang.py | 0 src/{custom => ext}/index.css | 0 src/{custom => ext}/whitespace_include | 0 4 files changed, 1 insertion(+), 1 deletion(-) rename src/{custom => ext}/cylc_lang.py (100%) rename src/{custom => ext}/index.css (100%) rename src/{custom => ext}/whitespace_include (100%) diff --git a/src/conf.py b/src/conf.py index d5546021a4..a3287da4d2 100644 --- a/src/conf.py +++ b/src/conf.py @@ -25,7 +25,7 @@ needs_sphinx = '1.5.3' # Sphinx extension module names. -sys.path.append(os.path.abspath('custom')) # path to custom extensions. +sys.path.append(os.path.abspath('ext')) # path to custom extensions. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.doctest', diff --git a/src/custom/cylc_lang.py b/src/ext/cylc_lang.py similarity index 100% rename from src/custom/cylc_lang.py rename to src/ext/cylc_lang.py diff --git a/src/custom/index.css b/src/ext/index.css similarity index 100% rename from src/custom/index.css rename to src/ext/index.css diff --git a/src/custom/whitespace_include b/src/ext/whitespace_include similarity index 100% rename from src/custom/whitespace_include rename to src/ext/whitespace_include From 1d277db8f6e90983f5d1da1a114b0e2db79f1aa6 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 12:40:47 +0100 Subject: [PATCH 02/22] install rose sphinx extensions * sphinx extensions coppied from rose documentation --- src/conf.py | 9 ++ src/ext/hieroglyph_patch.py | 41 ++++++ src/ext/minicylc.py | 254 ++++++++++++++++++++++++++++++++++++ src/ext/practical.py | 79 +++++++++++ src/ext/sub_lang.py | 43 ++++++ 5 files changed, 426 insertions(+) create mode 100644 src/ext/hieroglyph_patch.py create mode 100644 src/ext/minicylc.py create mode 100644 src/ext/practical.py create mode 100644 src/ext/sub_lang.py diff --git a/src/conf.py b/src/conf.py index a3287da4d2..1f622f3bc1 100644 --- a/src/conf.py +++ b/src/conf.py @@ -27,11 +27,20 @@ # Sphinx extension module names. sys.path.append(os.path.abspath('ext')) # path to custom extensions. extensions = [ + # sphinx built-in extensions 'sphinx.ext.autodoc', 'sphinx.ext.doctest', + 'sphinx.ext.graphviz', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', + # sphinx user community extensions + 'hieroglyph', + # custom project extensions (located in ext/) 'cylc_lang', + 'minicylc', + 'practical', + 'sub_lang', + 'hieroglyph_patch' # https://github.com/nyergler/hieroglyph/issues/148 ] # Add any paths that contain templates. diff --git a/src/ext/hieroglyph_patch.py b/src/ext/hieroglyph_patch.py new file mode 100644 index 0000000000..0c870bad1f --- /dev/null +++ b/src/ext/hieroglyph_patch.py @@ -0,0 +1,41 @@ +"""Monkey patch hieroglyph to work with Sphinx 1.8.0+. + +This extension serves as a temporary workaround, for more information see +`https://github.com/nyergler/hieroglyph/issues/148`_. + +If an extension provides its own visit or depart methods, patch them into the +``HTMLTranslator`` class below. + +It would be possible to patch the ``add_node`` method of the Sphinx application +to patch extensions automatically but in the interests of keeping the hack to a +minimum this hard-coded extension should suffice. + +""" + +import sphinx + +from sphinx.writers.html import HTMLTranslator + +from sphinx.ext.graphviz import html_visit_graphviz +from sphinx.ext.autosummary import (autosummary_toc_visit_html, + autosummary_table_visit_html) +from minicylc import MiniCylc + + +def none(*args, **kwargs): + pass + + +def setup(app): + if tuple(int(x) for x in sphinx.__version__.split('.')) > (1, 7, 9): + # sphinx.ext.graphviz + HTMLTranslator.visit_graphviz = html_visit_graphviz + + # sphinx.ext.autosummary + HTMLTranslator.visit_autosummary_toc = autosummary_toc_visit_html + HTMLTranslator.depart_autosummary_toc = none + HTMLTranslator.visit_autosummary_table = autosummary_table_visit_html + HTMLTranslator.depart_autosummary_table = none + + # ext.minicylc + HTMLTranslator.visit_MiniCylc = MiniCylc.visit_html diff --git a/src/ext/minicylc.py b/src/ext/minicylc.py new file mode 100644 index 0000000000..f1154b95b9 --- /dev/null +++ b/src/ext/minicylc.py @@ -0,0 +1,254 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# Copyright (C) 2012-2019 British Crown (Met Office) & Contributors. +# +# This file is part of Rose, a framework for meteorological suites. +# +# Rose 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. +# +# Rose 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 Rose. If not, see . +# ----------------------------------------------------------------------------- +"""Provides the minicylc directive and its associated node as sphinx +extensions.""" + +import re +import types + +import sphinx +from sphinx.directives.code import CodeBlock +from docutils import nodes +from docutils.parsers.rst import directives + +from sphinx.ext.graphviz import ( + graphviz, GraphvizSimple, html_visit_graphviz, latex_visit_graphviz, + texinfo_visit_graphviz, text_visit_graphviz, man_visit_graphviz) + + +class MiniCylc(graphviz): + """Node to represent an animated Cylc graph. + + Works by extending the built-in ``sphinx.ext.graphviz`` code. + + """ + + @staticmethod + def promote_graphviz(graphviz_node): + """Promote a sphinx.ext.graphviz node to a MiniCylc node. + + Returns a new MiniCylc node with attributes set to the values of the + provided graphviz node. + + """ + # Duplicate provided node + new_node = MiniCylc() + for item in dir(graphviz_node): + if item.startswith('__'): + # Skip builtins. + continue + attr = getattr(graphviz_node, item) + if isinstance(attr, types.MethodType): + # Skip methods. + continue + setattr(new_node, item, attr) + + # Use the digraph graphviz layout. + new_node['code'] = new_node['code'].replace('minicylc', 'digraph') + return new_node + + @staticmethod + def visit_html(builder, node): + """Wrap the standard graphviz output to provide alignment for svg. + + At present the ``align`` option for ``sphinx.ext.graphviz`` directives + does nothing for html output when ``graphviz_output_format`` is set to + ``svg``. This method wraps the html output to provide alignment + capability. + + """ + # Alignment. + try: + align = node['align'] + except KeyError: + align = 'center' + style = 'text-align: %s;' % align + + # Theme. + theme = node.get('theme', 'default') + + # Graphing. + data = '//'.join(node['graph_lines']) + + # Construct
element. + builder.body.append( + ('
').format(style, data, theme)) + + # Call graphviz html builder. + try: + # This method raises nodes.SkipNode in the success and fail case! + html_visit_graphviz(builder, node) + except nodes.SkipNode: + # Close
element (we are not using an exit_html function. + builder.body.append('
') + raise + + +class MiniCylcDirective(GraphvizSimple): + """Implement the ``mini-cylc`` directive for animating Cylc graphs. + + Works by extending the built-in ``sphinx.ext.graphviz`` code. + + """ + option_spec = dict(GraphvizSimple.option_spec) + option_spec['snippet'] = directives.flag + option_spec['theme'] = directives.unchanged + option_spec['size'] = directives.unchanged + required_arguments = 0 # Arg will be provided in run(). + + CONDITIONAL_CHARS = ['&', '|', '(', ')'] + CONDITIONAL_REGEX = re.compile(r'([\(\)\|\&])') + + @staticmethod + def extract_or_deps(dep): + """Return a list of tasks which have an OR dependency in a string.""" + ors = set([]) + ind = 0 + while ind < len(dep): + if dep[ind] == '|': + # Scan backwards. + lvl = 0 + tmp_ind = ind + while lvl >= 0 and tmp_ind > 0: + if dep[tmp_ind] == '(': + lvl -= 1 + elif dep[tmp_ind] == ')': + lvl += 1 + else: + if dep[tmp_ind] not in ['&', '|']: + ors.add(dep[tmp_ind]) + tmp_ind -= 1 + # Scan forwards. + lvl = 0 + tmp_ind = ind + while lvl >= 0 and tmp_ind < len(dep): + if dep[tmp_ind] == '(': + lvl += 1 + elif dep[tmp_ind] == ')': + lvl -= 1 + else: + if dep[tmp_ind] not in ['&', '|']: + ors.add(dep[tmp_ind]) + tmp_ind += 1 + ind += 1 + return ors + + @classmethod + def get_triggers(cls, graph_lines): + """Return a set of triggers for the provided graph code. + + Returned set of the form (left, right, conditional?). + + """ + trigs = set() + + for line in graph_lines: + deps = [[y.strip() for y in cls.CONDITIONAL_REGEX.split(x)] + for x in line.split('=>')] + for itt, dep in enumerate(deps): + if itt < len(deps) - 1: + ors = cls.extract_or_deps(dep) + # There is a RHS to this dep. + for left in (i for i in dep if i not in + cls.CONDITIONAL_CHARS): + for right in (i for i in deps[itt + 1] if i not in + cls.CONDITIONAL_CHARS): + trigs.add((left, right, left in ors)) + elif len(dep) == 1: + # No depedent task. + for left in (i for i in dep if i not in + cls.CONDITIONAL_CHARS): + trigs.add((None, left, False)) + return trigs + + def rationalise_graphing(self): + """Reduces a graph string to a list of individual dependency + strings.""" + lines = [] + buff = [] + for line in self.content: + if not line: + continue + temp = line.strip() + if temp[-1] in ['|', '&'] or temp[-2:] == '=>': + buff.append(line) + elif buff: + lines.append(' '.join(buff)) + buff = [] + else: + lines.append(line) + self.content = lines + + def run(self): + ret = [] + + # Provide a dummy argument to match the spec of GraphvizSimple. + self.arguments = ['Mini_Cylc'] + + # Generate Cylc code snippet if requested. + if 'snippet' in self.options: + ret.extend(CodeBlock(self.name, + ['cylc-graph'], + {}, # Opts. + self.content, + self.lineno, + self.content_offset, + self.block_text, + self.state, + self.state_machine).run()) + + # Clean up graphing. + self.rationalise_graphing() + clean_graphing = self.content + + # Generate dotcode for graphviz. + # dotcode = ['bgcolor=none'] now set in conf.py:graphviz_dot_args + dotcode = [] + if 'size' in self.options: + dotcode.append('size="%s"' % self.options['size']) + for left, right, conditional in self.get_triggers(self.content): + if left: + dotcode.append('%s -> %s%s' % ( + left, right, ' [arrowhead=o]' if conditional else '')) + else: + dotcode.append(right) + self.content = dotcode + + # Get MiniCylc node. + node = MiniCylc.promote_graphviz(GraphvizSimple.run(self)[0]) + node['graph_lines'] = clean_graphing + if 'theme' in self.options: + node['theme'] = self.options['theme'] + ret.append(node) + + return ret + + +def setup(app): + app.add_node(MiniCylc, + html=(MiniCylc.visit_html, None), + latex=(latex_visit_graphviz, None), + texinfo=(texinfo_visit_graphviz, None), + text=(text_visit_graphviz, None), + man=(man_visit_graphviz, None)) + app.add_directive('minicylc', MiniCylcDirective) + app.add_javascript('js/minicylc.js') + return {'version': sphinx.__display_version__, 'parallel_read_safe': True} diff --git a/src/ext/practical.py b/src/ext/practical.py new file mode 100644 index 0000000000..15378621e0 --- /dev/null +++ b/src/ext/practical.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# Copyright (C) 2012-2019 British Crown (Met Office) & Contributors. +# +# This file is part of Rose, a framework for meteorological suites. +# +# Rose 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. +# +# Rose 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 Rose. If not, see . +# ----------------------------------------------------------------------------- +"""An extension providing a directive for writing pratical sections.""" + +from docutils import nodes +from docutils.parsers.rst.directives.admonitions import BaseAdmonition + + +class Practical(BaseAdmonition): + """Directive for practical sections in documentation. + + This class serves as a standin for maintainability purposes. It is + equivalient to: + + .. admonition:: Practical + :class: note + + """ + node_class = nodes.admonition + NAME = 'Practical' + CLASSES = ['note'] + + def run(self): + self.options.update({'class': self.CLASSES}) # Affects the display. + self.arguments = [self.NAME] # Sets the title of the admonition. + return super(Practical, self).run() + + +class PracticalExtension(Practical): + """Directive for practical extension exercises.""" + NAME = 'Practical Extension' + CLASSES = ['note', 'spoiler'] + + +class Spoiler(BaseAdmonition): + """Directive for auto-hiden "spoiler" sections. + + When rendered in HTML the section will be collapsed and a "Show" button put + in its place. + + Otherwise the content will be displayed normally. + + """ + node_class = nodes.admonition + required_arguments = 1 + + def run(self): + classes = ['spoiler'] + args = self.arguments[0].split(' ') + if len(args) > 1: + classes.append(args[1]) + self.arguments = args[:1] + self.options.update({'class': classes}) + return super(Spoiler, self).run() + + +def setup(app): + """Sphinx setup function.""" + app.add_directive('practical', Practical) + app.add_directive('practical-extension', PracticalExtension) + app.add_directive('spoiler', Spoiler) + app.add_javascript('js/spoiler.js') # self-hiding node. diff --git a/src/ext/sub_lang.py b/src/ext/sub_lang.py new file mode 100644 index 0000000000..2e22fbd927 --- /dev/null +++ b/src/ext/sub_lang.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# ----------------------------------------------------------------------------- +# Copyright (C) 2012-2019 British Crown (Met Office) & Contributors. +# +# This file is part of Rose, a framework for meteorological suites. +# +# Rose 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. +# +# Rose 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 Rose. If not, see . +# ----------------------------------------------------------------------------- +"""An extension providing a lexer which highlights text .""" + +from pygments.lexer import RegexLexer +from pygments.token import Text, String, Comment + + +class SubstitutionLexer(RegexLexer): + """Pygments lexer for highlighting in code e.g. paths.""" + name = 'Substitution' + aliases = [] + filenames = [] + + tokens = { + 'root': [ + (r'\<[^\>]+\>', String), + ('#.*', Comment), + ('.', Text) + ] + } + + +def setup(app): + """Sphinx plugin setup function.""" + app.add_lexer('sub', SubstitutionLexer()) From f4878d7fd073a3d1b2bdb5838cdd9b94e049a4c1 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 12:46:50 +0100 Subject: [PATCH 03/22] copy cylc tutorial from rose docs --- src/conf.py | 4 + src/index.rst | 1 + src/tutorial/furthertopics/broadcast.rst | 135 ++++ .../furthertopics/clock-triggered-tasks.rst | 175 +++++ .../furthertopics/family-triggers.rst | 208 ++++++ src/tutorial/furthertopics/index.rst | 16 + src/tutorial/furthertopics/inheritance.rst | 610 ++++++++++++++++ src/tutorial/furthertopics/queues.rst | 105 +++ src/tutorial/furthertopics/retries.rst | 156 ++++ .../furthertopics/suicide-triggers.rst | 676 ++++++++++++++++++ src/tutorial/img/cylc-graph-cluster.png | Bin 0 -> 6668 bytes src/tutorial/img/cylc-graph-refresh.png | Bin 0 -> 6946 bytes src/tutorial/img/cylc-graph-reversible.svg | 77 ++ src/tutorial/img/cylc-graph.png | Bin 0 -> 49286 bytes src/tutorial/img/cylc-gui-dot.png | Bin 0 -> 35155 bytes src/tutorial/img/cylc-gui-graph.png | Bin 0 -> 111441 bytes src/tutorial/img/cylc-gui-suite-start.png | Bin 0 -> 18138 bytes src/tutorial/img/cylc-gui-tree.png | Bin 0 -> 59606 bytes src/tutorial/img/cylc-gui-view-log.png | Bin 0 -> 19206 bytes src/tutorial/img/cylc-gui-view-selector.png | Bin 0 -> 7023 bytes src/tutorial/img/cylc-gui.png | Bin 0 -> 153532 bytes src/tutorial/img/gcylc-play.png | Bin 0 -> 1939 bytes src/tutorial/img/iso8601-dates.svg | 265 +++++++ src/tutorial/index.rst | 21 + src/tutorial/introduction.rst | 94 +++ .../configuration-consolidation/families.rst | 333 +++++++++ .../configuration-consolidation/index.rst | 191 +++++ .../configuration-consolidation/jinja2.rst | 235 ++++++ .../parameters.rst | 349 +++++++++ src/tutorial/runtime/index.rst | 18 + src/tutorial/runtime/introduction.rst | 518 ++++++++++++++ .../runtime/runtime-configuration.rst | 501 +++++++++++++ src/tutorial/scheduling/datetime-cycling.rst | 632 ++++++++++++++++ .../scheduling/further-scheduling.rst | 107 +++ src/tutorial/scheduling/graphing.rst | 408 +++++++++++ src/tutorial/scheduling/index.rst | 15 + src/tutorial/scheduling/integer-cycling.rst | 612 ++++++++++++++++ 37 files changed, 6462 insertions(+) create mode 100644 src/tutorial/furthertopics/broadcast.rst create mode 100644 src/tutorial/furthertopics/clock-triggered-tasks.rst create mode 100644 src/tutorial/furthertopics/family-triggers.rst create mode 100644 src/tutorial/furthertopics/index.rst create mode 100644 src/tutorial/furthertopics/inheritance.rst create mode 100644 src/tutorial/furthertopics/queues.rst create mode 100644 src/tutorial/furthertopics/retries.rst create mode 100644 src/tutorial/furthertopics/suicide-triggers.rst create mode 100644 src/tutorial/img/cylc-graph-cluster.png create mode 100644 src/tutorial/img/cylc-graph-refresh.png create mode 100644 src/tutorial/img/cylc-graph-reversible.svg create mode 100644 src/tutorial/img/cylc-graph.png create mode 100644 src/tutorial/img/cylc-gui-dot.png create mode 100644 src/tutorial/img/cylc-gui-graph.png create mode 100644 src/tutorial/img/cylc-gui-suite-start.png create mode 100644 src/tutorial/img/cylc-gui-tree.png create mode 100644 src/tutorial/img/cylc-gui-view-log.png create mode 100644 src/tutorial/img/cylc-gui-view-selector.png create mode 100644 src/tutorial/img/cylc-gui.png create mode 100644 src/tutorial/img/gcylc-play.png create mode 100644 src/tutorial/img/iso8601-dates.svg create mode 100644 src/tutorial/index.rst create mode 100644 src/tutorial/introduction.rst create mode 100644 src/tutorial/runtime/configuration-consolidation/families.rst create mode 100644 src/tutorial/runtime/configuration-consolidation/index.rst create mode 100644 src/tutorial/runtime/configuration-consolidation/jinja2.rst create mode 100644 src/tutorial/runtime/configuration-consolidation/parameters.rst create mode 100644 src/tutorial/runtime/index.rst create mode 100644 src/tutorial/runtime/introduction.rst create mode 100644 src/tutorial/runtime/runtime-configuration.rst create mode 100644 src/tutorial/scheduling/datetime-cycling.rst create mode 100644 src/tutorial/scheduling/further-scheduling.rst create mode 100644 src/tutorial/scheduling/graphing.rst create mode 100644 src/tutorial/scheduling/index.rst create mode 100644 src/tutorial/scheduling/integer-cycling.rst diff --git a/src/conf.py b/src/conf.py index 1f622f3bc1..ce2e48f2d0 100644 --- a/src/conf.py +++ b/src/conf.py @@ -71,6 +71,10 @@ numfig = True numfig_secnum_depth = 0 +# Global configuration for graphviz diagrams. +graphviz_dot_args = ['-Gfontname=sans', '-Gbgcolor=none', + '-Nfontname=sans'] + # -- Options for HTML output ---------------------------------------------- diff --git a/src/index.rst b/src/index.rst index 1cb39bd49a..8c8248f014 100644 --- a/src/index.rst +++ b/src/index.rst @@ -27,6 +27,7 @@ indefinitely. introduction installation + tutorial/index terminology workflows global-flow-conf diff --git a/src/tutorial/furthertopics/broadcast.rst b/src/tutorial/furthertopics/broadcast.rst new file mode 100644 index 0000000000..447b49c15b --- /dev/null +++ b/src/tutorial/furthertopics/broadcast.rst @@ -0,0 +1,135 @@ +Broadcast +========= + +This tutorial walks you through using ``cylc broadcast`` which can be used +to change :ref:`task runtime configuration ` in a +running suite, on-the-fly. + + +Purpose +------- + +``cylc broadcast`` can be used to change any ``[runtime]`` setting whilst the +suite is running. + +The standard use of ``cylc broadcast`` is to update the suite to an +unexpected change in configuration, for example modifying the host a task +runs on. + + +Standalone Example +------------------ + +Create a new suite in the ``cylc-run`` directory called +``tutorial-broadcast``:: + + mkdir ~/cylc-run/tutorial-broadcast + cd ~/cylc-run/tutorial-broadcast + +Copy the following configuration into a ``suite.rc`` file: + +.. code-block:: cylc + + [scheduling] + initial cycle point = 1012 + [[dependencies]] + [[[R1]]] + graph = wipe_log => announce + [[[PT1H]]] + graph = announce[-PT1H] => announce + + [runtime] + [[wipe_log]] + # Delete any files in the suite's "share" directory. + script = rm "${CYLC_SUITE_SHARE_DIR}/knights" || true + + [[announce]] + script = echo "${CYLC_TASK_CYCLE_POINT} - ${MESSAGE}" >> "${FILE}" + [[[environment]]] + WORD = ni + MESSAGE = We are the knights who say \"${WORD}\"! + FILE = "${CYLC_SUITE_SHARE_DIR}/knights" + +We now have a suite with an ``announce`` task which runs every hour, writing a +message to a log file (``share/knights``) when it does so. For the first cycle +the log entry will look like this:: + + 10120101T0000Z - We are the knights who say "ni"! + +The ``cylc broadcast`` command enables us to change runtime configuration +whilst the suite is running. For instance we could change the value of the +``WORD`` environment variable using the command:: + + cylc broadcast tutorial-broadcast -n announce -s "[environment]WORD=it" + +* ``tutorial-broadcast`` is the name of the suite. +* ``-n announce`` tells Cylc we want to change the runtime configuration of the + ``announce`` task. +* ``-s "[environment]WORD=it"`` changes the value of the ``WORD`` environment + variable to ``it``. + +Run the suite then try using the ``cylc broadcast`` command to change the +message:: + + cylc run tutorial-broadcast + cylc broadcast tutorial-broadcast -n announce -s "[environment]WORD=it" + +Inspect the ``share/knights`` file, you should see the message change at +certain points. + +Stop the suite:: + + cylc stop tutorial-broadcast + + +In-Situ Example +--------------- + +We can call ``cylc broadcast`` from within a task's script. This effectively +provides the ability for tasks to communicate between themselves. + +It is almost always better for tasks to communicate using files but there are +some niche situations where communicating via ``cylc broadcast`` is justified. +This tutorial walks you through using ``cylc broadcast`` to communicate between +tasks. + +.. TODO - examples of this? + +Add the following recurrence to the ``dependencies`` section: + +.. code-block:: cylc + + [[[PT3H]]] + graph = announce[-PT1H] => change_word => announce + +The ``change_word`` task runs the ``cylc broadcast`` command to randomly +change the ``WORD`` environment variable used by the ``announce`` task. + +Add the following runtime configuration to the ``runtime`` section: + +.. code-block:: cylc + + [[change_word]] + script = """ + # Select random word. + IFS=',' read -r -a WORDS <<< $WORDS + WORD=${WORDS[$(date +%s) % ${#WORDS[@]}]} + + # Broadcast random word to the announce task. + cylc broadcast $CYLC_SUITE_NAME -n announce -s "[environment]WORD=${WORD}" + """ + [[[environment]]] + WORDS = ni, it, ekke ekke ptang zoo boing + +Run the suite and inspect the log. You should see the message change randomly +after every third entry (because the ``change_word`` task runs every 3 hours) +e.g:: + + 10120101T0000Z - We are the knights who say "ni"! + 10120101T0100Z - We are the knights who say "ni"! + 10120101T0200Z - We are the knights who say "ni"! + 10120101T0300Z - We are the knights who say "ekke ekke ptang zoo boing!" + +Stop the suite:: + + cylc stop tutorial-broadcast diff --git a/src/tutorial/furthertopics/clock-triggered-tasks.rst b/src/tutorial/furthertopics/clock-triggered-tasks.rst new file mode 100644 index 0000000000..43181eebf1 --- /dev/null +++ b/src/tutorial/furthertopics/clock-triggered-tasks.rst @@ -0,0 +1,175 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +.. _tutorial-cylc-clock-trigger: + +Clock Triggered Tasks +===================== + +.. TODO + + After #2423 has been finalised and merged this tutorial should be + re-factored / re-written to incorporate the usage of ``cylc-graph``. + +In a :term:`datetime cycling` suite the time represented by the +:term:`cycle points ` bear no relation to the real-world time. +Using clock-triggers we can make tasks wait until their cycle point time before +running. + +Clock-triggering effectively enables us to tether the "cycle time" to the +"real world time" which we refer to as the :term:`wall-clock time`. + + +Clock Triggering +---------------- + +When clock-triggering tasks we can use different +:ref:`offsets ` to the cycle time as follows: + +.. code-block:: cylc + + clock-trigger = taskname(CYCLE_OFFSET) + +.. note:: + + Regardless of the offset used, the task still belongs to the cycle from + which the offset has been applied. + + +Example +------- + +Our example suite will simulate a clock chiming on the hour. + +Within your ``~/cylc-run`` directory create a new directory called +``clock-trigger``:: + + mkdir ~/cylc-run/clock-trigger + cd ~/cylc-run/clock-trigger + +Paste the following code into a ``suite.rc`` file: + +.. code-block:: cylc + + [cylc] + UTC mode = True # Ignore DST + + [scheduling] + initial cycle point = TODO + final cycle point = +P1D # Run for one day + [[dependencies]] + [[[PT1H]]] + graph = bell + + [runtime] + [[root]] + [[[events]]] + mail events = failed + [[bell]] + env-script = eval $(rose task-env) + script = printf 'bong%.0s\n' $(seq 1 $(cylc cyclepoint --print-hour)) + +Change the initial cycle point to 00:00 this morning (e.g. if it was +the first of January 2000 we would write ``2000-01-01T00Z``). + +We now have a simple suite with a single task that prints "bong" a number +of times equal to the (cycle point) hour. + +Run your suite using:: + + cylc run clock-trigger + +Stop the suite after a few cycles using the :guilabel:`stop` button in the +``cylc gui``. Notice how the tasks run as soon as possible rather than +waiting for the actual time to be equal to the cycle point. + + +Clock-Triggering Tasks +---------------------- + +We want our clock to only ring in real-time rather than the simulated +cycle time. + +To do this, add the following lines to the ``[scheduling]`` section of +your ``suite.rc``: + +.. code-block:: cylc + + [[special tasks]] + clock-trigger = bell(PT0M) + +This tells the suite to clock trigger the ``bell`` task with a cycle +offset of ``0`` hours. + +Save your changes and run your suite. + +Your suite should now be running the ``bell`` task in real-time. Any cycle times +that have already passed (such as the one defined by ``initial cycle time``) +will be run as soon as possible, while those in the future will wait for that +time to pass. + +At this point you may want to leave your suite running until the next hour +has passed in order to confirm the clock triggering is working correctly. +Once you are satisfied, stop your suite. + +By making the ``bell`` task a clock triggered task we have made it run in +real-time. Thus, when the wall-clock time caught up with the cycle time, the +``bell`` task triggered. + + +Adding More Clock-Triggered Tasks +--------------------------------- + +We will now modify our suite to run tasks at quarter-past, half-past and +quarter-to the hour. + +Open your ``suite.rc`` and modify the ``[runtime]`` section by adding the +following: + +.. code-block:: cylc + + [[quarter_past, half_past, quarter_to]] + script = echo 'chimes' + +Edit the ``[[scheduling]]`` section to read: + +.. code-block:: cylc + + [[special tasks]] + clock-trigger = bell(PT0M), quarter_past(PT15M), half_past(PT30M), quarter_to(PT45M) + [[dependencies]] + [[[PT1H]]] + graph = """ + bell + quarter_past + half_past + quarter_to + """ + +Note the different values used for the cycle offsets of the clock-trigger tasks. + +Save your changes and run your suite using:: + + cylc run clock-trigger now + +.. note:: + + The ``now`` argument will run your suite using the current time for the + initial cycle point. + +Again, notice how the tasks trigger until the current time is reached. + +Leave your suite running for a while to confirm it is working as expected +and then shut it down using the :guilabel:`stop` button in the ``cylc gui``. + + +Summary +------- + +* Clock triggers are a type of :term:`dependency` which cause + :term:`tasks ` to wait for the :term:`wall-clock time` to reach the + :term:`cycle point` time. +* A clock trigger applies only to a single task. +* Clock triggers can only be used in datetime cycling suites. + +For more information see the `Cylc User Guide`_. diff --git a/src/tutorial/furthertopics/family-triggers.rst b/src/tutorial/furthertopics/family-triggers.rst new file mode 100644 index 0000000000..29cd03bc6d --- /dev/null +++ b/src/tutorial/furthertopics/family-triggers.rst @@ -0,0 +1,208 @@ +.. _tutorial-cylc-family-triggers: + +Family Triggers +=============== + +To reduce duplication in the :term:`graph` is is possible to write +:term:`dependencies ` using collections of tasks called +:term:`families `). + +This tutorial walks you through writing such dependencies using family +:term:`triggers `. + + +Explanation +----------- + +Dependencies between tasks can be written using a :term:`qualifier` to describe +the :term:`task state` that the dependency refers to (e.g. ``succeed`` +``fail``, etc). If a dependency does not use a qualifier then it is assumed +that the dependency refers to the ``succeed`` state e.g: + +.. code-block:: cylc-graph + + bake_bread => sell_bread # sell_bread is dependent on bake_bread succeeding. + bake_bread:succeed => sell_bread # sell_bread is dependent on bake_bread succeeding. + sell_bread:fail => through_away # through_away is dependent on sell_bread failing. + +The left-hand side of a :term:`dependency` (e.g. ``sell_bread:fail``) is +referred to as the :term:`trigger `. + +When we write a trigger involving a family, special qualifiers are required +to specify whether the dependency is concerned with *all* or *any* of the tasks +in that family reaching the desired :term:`state ` e.g: + +* ``succeed-all`` +* ``succeed-any`` +* ``fail-all`` + +Such :term:`triggers ` are referred to as +:term:`family triggers ` + +Foo ``cylc gui`` bar + + +Example +------- + +Create a new suite called ``tutorial-family-triggers``:: + + mkdir ~/cylc-run/tutorial-family-triggers + cd ~/cylc-run/tutorial-family-triggers + +Paste the following configuration into the ``suite.rc`` file: + +.. code-block:: cylc + + [cylc] + UTC mode = True # Ignore DST + [scheduling] + [[dependencies]] + graph = visit_mine => MINERS + [runtime] + [[visit_mine]] + script = sleep 5; echo 'off to work we go' + + [[MINERS]] + script = """ + sleep 5; + if (($RANDOM % 2)); then + echo 'Diamonds!'; true; + else + echo 'Nothing...'; false; + fi + """ + [[doc, grumpy, sleepy, happy, bashful, sneezy, dopey]] + inherit = MINERS + +You have now created a suite that: + +* Has a ``visit_mine`` task that sleeps for 5 seconds then outputs a + message. +* Contains a ``MINERS`` family with a command in it that randomly succeeds + or fails. +* Has 7 tasks that inherit from the ``MINERS`` family. + +Open the ``cylc gui`` then run the suite by pressing the "play" button +(top left hand corner) then clicking :guilabel:`Start`:: + + cylc gui tutorial-family-triggers & + +You should see the ``visit_mine`` task run, then trigger the members of the +``MINERS`` family. Note that some of the ``MINERS`` tasks may fail so you +will need to stop your suite using the "stop" button in the ``cylc gui`` in +order to allow it to shutdown. + + +Family Triggering: Success +-------------------------- + +As you will have noticed by watching the suite run, some of the tasks in the +``MINERS`` family succeed and some fail. + +We would like to add a task to sell any diamonds we find, but wait for all +the miners to report back first so we only make the one trip. + +We can address this by using *family triggers*. In particular, we are going +to use the ``finish-all`` trigger to check for all members of the ``MINERS`` +family finishing, and the ``succeed-any`` trigger to check for any of the +tasks in the ``MINERS`` family succeeding. + +Open your ``suite.rc`` file and change the ``[[dependencies]]`` to look like +this: + +.. code-block:: cylc + + [[dependencies]] + graph = """visit_mine => MINERS + MINERS:finish-all & MINERS:succeed-any => sell_diamonds""" + +Then, add the following task to the ``[runtime]`` section: + +.. code-block:: cylc + + [[sell_diamonds]] + script = sleep 5 + +These changes add a ``sell_diamonds`` task to the suite which is run once +all the ``MINERS`` tasks have finished and if any of them have succeeded. + +Save your changes and run your suite. You should see the new +``sell_diamonds`` task being run once all the miners have finished and at +least one of them has succeeded. As before, stop your suite using the "stop" +button in the ``cylc gui``. + + +Family Triggering: Failure +-------------------------- + +Cylc also allows us to trigger off failure of tasks in a particular family. + +We would like to add another task to close down unproductive mineshafts once +all the miners have reported back and had time to discuss their findings. + +To do this we will make use of family triggers in a similar manner to before. + +Open your ``suite.rc`` file and change the ``[[dependencies]]`` to look like +this: + +.. code-block:: cylc + + [[dependencies]] + graph = """visit_mine => MINERS + MINERS:finish-all & MINERS:succeed-any => sell_diamonds + MINERS:finish-all & MINERS:fail-any => close_shafts + close_shafts => !MINERS + """ + +Alter the ``[[sell_diamonds]]`` section to look like this: + +.. code-block:: cylc + + [[close_shafts, sell_diamonds]] + script = sleep 5 + +These changes add a ``close_shafts`` task which is run once all the +``MINERS`` tasks have finished and any of them have failed. On completion +it applies a *suicide trigger* to the ``MINERS`` family in order to allow +the suite to shutdown. + +Save your changes and run your suite. You should see the new +``close_shafts`` run should any of the ``MINERS`` tasks be in the failed +state once they have all finished. + +.. tip:: + + See the :ref:`tut-cylc-suicide-triggers` tutorial for handling task + failures. + + +Different Triggers +------------------ + +Other family :term:`qualifiers ` beyond those covered in the +example are also available. + +The following types of "all" qualifier are available: + +* ``:start-all`` - all the tasks in the family have started +* ``:succeed-all`` - all the tasks in the family have succeeded +* ``:fail-all`` - all the tasks in the family have failed +* ``:finish-all`` - all the tasks in the family have finished + +The following types of "any" qualifier are available: + +* ``:start-any`` - at least one task in the family has started +* ``:succeed-any`` - at least one task in the family has succeeded +* ``:fail-any`` - at least one task in the family has failed +* ``:finish-any`` - at least one task in the family has finished + + +Summary +------- + +* Family triggers allow you to write dependencies for collections of tasks. +* Like :term:`task triggers `, family triggers can be based on + success, failure, starting and finishing of tasks in a family. +* Family triggers can trigger off either *all* or *any* of the tasks in a + family. diff --git a/src/tutorial/furthertopics/index.rst b/src/tutorial/furthertopics/index.rst new file mode 100644 index 0000000000..17e4126286 --- /dev/null +++ b/src/tutorial/furthertopics/index.rst @@ -0,0 +1,16 @@ +Further Topics +============== + +This section looks at further topics in cylc. + +.. toctree:: + :name: cylc-futher-topics + :maxdepth: 1 + + clock-triggered-tasks + broadcast + family-triggers + inheritance + queues + retries + suicide-triggers diff --git a/src/tutorial/furthertopics/inheritance.rst b/src/tutorial/furthertopics/inheritance.rst new file mode 100644 index 0000000000..c1bf03af3c --- /dev/null +++ b/src/tutorial/furthertopics/inheritance.rst @@ -0,0 +1,610 @@ +Inheritance +=========== + +We have seen in the :ref:`runtime tutorial ` how +tasks can be grouped into families. + +In this tutorial we will look at nested families, inheritance order and +multiple inheritance. + + +Inheritance Hierarchy +--------------------- + +Create a new suite by running the command:: + + rose tutorial inheritance-tutorial + cd ~/cylc-run/inheritance-tutorial + +You will now have a ``suite.rc`` file that defines two tasks each representing +a different aircraft, the Airbus A380 jumbo jet and the Robson R44 helicopter: + +.. image:: https://upload.wikimedia.org/wikipedia/commons/0/09/A6-EDY_A380_Emirates_31_jan_2013_jfk_%288442269364%29_%28cropped%29.jpg + :width: 49% + :alt: A380 + +.. image:: https://upload.wikimedia.org/wikipedia/commons/2/2f/Robinson-R44_1.jpg + :width: 49% + :alt: R44 + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = a380 & r44 + + [runtime] + [[VEHICLE]] + init-script = echo 'Boarding' + pre-script = echo 'Departing' + post-script = echo 'Arriving' + + [[AIR_VEHICLE]] + inherit = VEHICLE + [[[meta]]] + description = A vehicle which can fly. + [[AIRPLANE]] + inherit = AIR_VEHICLE + [[[meta]]] + description = An air vehicle with fixed wings. + [[[environment]]] + CAN_TAKE_OFF_VERTICALLY = false + [[HELICOPTER]] + inherit = AIR_VEHICLE + [[[meta]]] + description = An air vehicle with rotors. + [[[environment]]] + CAN_TAKE_OFF_VERTICALLY = true + + [[a380]] + inherit = AIRPLANE + [[[meta]]] + title = Airbus A380 Jumbo-Jet. + [[r44]] + inherit = HELICOPTER + [[[meta]]] + title = Robson R44 Helicopter. + +.. note:: + + The ``[meta]`` section is a freeform section where we can define metadata + to be associated with a task, family or the suite itself. + + This metadata should not be mistaken with Rose :ref:`conf-meta`. + +.. admonition:: Reminder + :class: hint + + By convention we write family names in upper case (with the exception of the + special ``root`` family) and task names in lower case. + +These two tasks sit at the bottom of an inheritance tree. The ``cylc graph`` +command has an option (``-n``) for drawing such inheritance hierarchies:: + + cylc graph -n . & + +Running this command will generate the following output: + +.. digraph:: Example + :align: center + + AIRPLANE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + a380 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + AIRPLANE -> a380 [color=royalblue]; + HELICOPTER [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + r44 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + HELICOPTER -> r44 [color=royalblue]; + root [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + root -> VEHICLE [color=royalblue]; + AIR_VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE -> AIR_VEHICLE [color=royalblue]; + AIR_VEHICLE -> AIRPLANE [color=royalblue]; + AIR_VEHICLE -> HELICOPTER [color=royalblue]; + +.. note:: + + The ``root`` family sits at the top of the inheritance tree as all + tasks/families automatically inherit it: + +Cylc handles inheritance by starting with the root family and working down the +inheritance tree applying each section in turn. + +To see the resulting configuration for the ``a380`` task use the +``cylc get-config`` command:: + + cylc get-config . --sparse -i "[runtime][a380]" + +You should see some settings which have been inherited from the ``VEHICLE`` and +``AIRPLANE`` families as well as a couple defined in the ``a380`` task. + +.. code-block:: cylc + + init-script = echo 'Boarding' # Inherited from VEHICLE + pre-script = echo 'Departing' # Inherited from VEHICLE + post-script = echo 'Arriving' # Inherited from VEHICLE + inherit = AIRPLANE # Defined in a380 + [[[meta]]] + description = An air vehicle with fixed wings. # Inherited from AIR_VEHICLE - overwritten by AIRPLANE + title = Airbus A380 Jumbo-Jet. # Defined in a380 + [[[environment]]] + CAN_TAKE_OFF_VERTICALLY = false # Inherited from AIRPLANE + +Note that the ``description`` setting is defined in the ``AIR_VEHICLE`` +family but is overwritten by the value specified in the ``AIRPLANE`` family. + + +Multiple Inheritance +-------------------- + +Next we want to add a vehicle called the V-22 Osprey to the suite. The V-22 +is a cross between a plane and a helicopter - it has wings but can take-off and +land vertically. + +.. image:: https://upload.wikimedia.org/wikipedia/commons/e/e3/MV-22_mcas_Miramar_2014.JPG + :width: 300px + :align: center + +As the V-22 can be thought of as both a plane and a helicopter we want it to +inherit from both the ``AIRPLANE`` and ``HELICOPTER`` families. In Cylc we can +inherit from multiple families by separating their names with commas: + +Add the following task to your ``suite.rc`` file. + +.. code-block:: cylc + + [[v22]] + inherit = AIRPLANE, HELICOPTER + [[[meta]]] + title = V-22 Osprey Military Aircraft. + +Refresh your ``cylc graph`` window or re-run the ``cylc graph`` command. + +The inheritance hierarchy should now look like this: + +.. digraph:: Example + :align: center + + AIRPLANE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + v22 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + AIRPLANE -> v22 [color=royalblue]; + a380 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + AIRPLANE -> a380 [color=royalblue]; + HELICOPTER [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + HELICOPTER -> v22 [color=royalblue]; + r44 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + HELICOPTER -> r44 [color=royalblue]; + root [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + root -> VEHICLE [color=royalblue]; + AIR_VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE -> AIR_VEHICLE [color=royalblue]; + AIR_VEHICLE -> AIRPLANE [color=royalblue]; + AIR_VEHICLE -> HELICOPTER [color=royalblue]; + +Inspect the configuration of the ``v22`` task using the ``cylc get-config`` +command. + +.. spoiler:: Hint warning + + .. code-block:: bash + + cylc get-config . --sparse -i "[runtime][v22]" + +You should see that the ``CAN_TASK_OFF_VERTICALLY`` environment variable has +been set to ``false`` which isn't right. This is because of the order in which +inheritance is applied. + +Cylc handles multiple-inheritance by applying each family from right to left. +For the ``v22`` task we specified ``inherit = AIRPLANE, HELICOPTER`` so the +``HELICOPTER`` family will be applied first and the ``AIRPLANE`` family after. + +The inheritance order would be as follows: + +.. code-block:: bash + + root + VEHICLE + AIR_VEHICLE + HELICOPTER # sets "CAN_TAKE_OFF_VERTICALLY to "true" + AIRPLANE # sets "CAN_TAKE_OFF_VERTICALLY to "false" + v22 + +We could fix this problem by changing the order of inheritance: + +.. code-block:: cylc + + inherit = HELICOPTER, AIRPLANE + +Now the ``HELICOPTER`` family is applied second so its values will override any +in the ``AIRPLANE`` family. + +.. code-block:: bash + + root + VEHICLE + AIR_VEHICLE + AIRPLANE # sets "CAN_TAKE_OFF_VERTICALLY to "false" + HELICOPTER # sets "CAN_TAKE_OFF_VERTICALLY to "true" + v22 + +Inspect the configuration of the ``v22`` task using ``cylc get-config`` to +confirm this. + + +More Inheritance +---------------- + +We will now add some more families and tasks to the suite. + +Engine Type +^^^^^^^^^^^ + +Next we will define four families to represent three different types of engine. + +.. digraph:: Example + :align: center + + size = "5,5" + + ENGINE [color=royalblue, fillcolor=powderblue, shape=box, style=filled, + margin="0.3,0.055"] + TURBINE_ENGINE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled, margin="0.3,0.055"] + INTERNAL_COMBUSTION_ENGINE [color=royalblue, fillcolor=powderblue, + shape=box, style=filled, margin="0.3,0.055"] + HUMAN_ENGINE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled, margin="0.3,0.055"] + + "ENGINE" -> "TURBINE_ENGINE" + "ENGINE" -> "INTERNAL_COMBUSTION_ENGINE" + "ENGINE" -> "HUMAN_ENGINE" + +Each engine type should set an environment variable called ``FUEL`` which we +will assign to the following values: + +* Turbine - kerosene +* Internal Combustion - petrol +* Human - pizza + +Add lines to the ``runtime`` section to represent these four families. + +.. spoiler:: Solution warning + + .. code-block:: cylc + + [[ENGINE]] + [[TURBINE_ENGINE]] + inherit = ENGINE + [[[environment]]] + FUEL = kerosene + [[INTERNAL_COMBUSTION_ENGINE]] + inherit = ENGINE + [[[environment]]] + FUEL = petrol + [[HUMAN_ENGINE]] + inherit = ENGINE + [[[environment]]] + FUEL = pizza + +We now need to make the three aircraft inherit from one of the three engines. +The aircraft use the following types of engine: + +* A380 - turbine +* R44 - internal combustion +* V22 - turbine + +Modify the three tasks so that they inherit from the relevant engine families. + +.. spoiler:: Solution warning + + .. code-block:: cylc + + [[a380]] + inherit = AIRPLANE, TURBINE_ENGINE + [[[meta]]] + title = Airbus A380 Jumbo-Jet. + [[r44]] + inherit = HELICOPTER, INTERNAL_COMBUSTION_ENGINE + [[[meta]]] + title = Robson R44 Helicopter. + [[v22]] + inherit = AIRPLANE, HELICOPTER, TURBINE_ENGINE + [[[meta]]] + title = V-22 Ofsprey Military Aircraft. + +Penny Farthing +^^^^^^^^^^^^^^ + +Next we want to add a new type of vehicle, an old-fashioned bicycle called a +penny farthing. + +.. image:: https://upload.wikimedia.org/wikipedia/commons/a/a7/Ordinary_bicycle01.jpg + :width: 300px + :alt: Penny Farthing Bicycle + :align: center + +To do this we will need to add two new families, ``LAND_VEICHLE`` and +``BICYCLE`` as well as a new task, ``penny_farthing`` related in the +following manner: + +.. digraph:: Example + :align: center + + VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + LAND_VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled] + BICYCLE [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + HUMAN_ENGINE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled, margin="0.3,0.055"] + penny_farthing [color=royalblue, fillcolor=powderblue, shape=box, + style=filled, margin="0.3,0.055"] + VEHICLE -> LAND_VEHICLE -> BICYCLE -> penny_farthing + HUMAN_ENGINE -> penny_farthing + +Add lines to the ``runtime`` section to represent the two new families and one +task outlined above. + +Add a description (``[meta]description``) to the ``LAND_VEHICLE`` and +``BICYCLE`` families and a title (``[meta]title``) to the ``penny_farthing`` +task. + +.. spoiler:: Solution warning + + .. code-block:: cylc + + [[LAND_VEHICLE]] + inherit = VEHICLE + [[[meta]]] + description = A vehicle which can travel over the ground. + + [[BICYCLE]] + inherit = LAND_VEHICLE + [[[meta]]] + description = A small two-wheeled vehicle. + + [[penny_farthing]] + inherit = BICYCLE, HUMAN_ENGINE + [[[meta]]] + title = An old-fashioned bicycle. + + +Using ``cylc get-config`` to inspect the configuration of the ``penny_farthing`` +task we can see that it inherits settings from the ``VEHICLE``, +``BICYCLE`` and ``HUMAN_ENGINE`` families. + +.. code-block:: cylc + + inherit = BICYCLE, HUMAN_ENGINE + init-script = echo 'Boarding' # Inherited from VEHICLE + pre-script = echo 'Departing' # Inherited from VEHICLE + post-script = echo 'Arriving' # Inherited from VEHICLE + [[[environment]]] + FUEL = pizza # Inherited from HUMAN_ENGINE + [[[meta]]] + description = A small two-wheeled vehicle. # Inherited from LAND_VEHICLE - overwritten by BICYCLE + title = An old-fashioned bicycle. # Defined in penny_farthing + +.. spoiler:: Hint hint + + .. code-block:: bash + + cylc get-config . --sparse -i "[runtime]penny_farthing" + +Hovercraft +^^^^^^^^^^ + +We will now add a hovercraft called the Hoverwork BHT130, better known to some +as the Isle Of Wight Ferry. + +.. image:: https://upload.wikimedia.org/wikipedia/commons/e/e7/Hovercraft_leaving_Ryde.JPG + :width: 300px + :align: center + :alt: Hoverwork BHT130 Hovercraft + +Hovercraft can move over both land and water and in some respects can be thought +of as flying vehicles. + +.. digraph:: Example + :align: center + + size = "7,5" + + VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + AIR_VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + LAND_VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled] + WATER_VEHICLE [color=royalblue, fillcolor=powderblue, shape=box, + style=filled] + HOVERCRAFT [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + bht130 [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + ENGINE [color=royalblue, fillcolor=powderblue, shape=box, style=filled] + INTERNAL_COMBUSTION_ENGINE [color=royalblue, fillcolor=powderblue, + shape=box, style=filled, margin="0.3,0.055"] + VEHICLE -> AIR_VEHICLE -> HOVERCRAFT + VEHICLE -> LAND_VEHICLE -> HOVERCRAFT + VEHICLE -> WATER_VEHICLE -> HOVERCRAFT + HOVERCRAFT -> bht130 + ENGINE -> INTERNAL_COMBUSTION_ENGINE -> bht130 + +Write new families and one new task to represent the above structure. + +Add a description (``[meta]description``) to the ``WATER_VEHICLE`` and +``HOVERCRAFT`` families and a title (``[meta]title``) to the ``bht130`` task. + +.. spoiler:: Solution warning + + .. code-block:: cylc + + [[WATER_VEHICLE]] + inherit = VEHICLE + [[[meta]]] + description = A vehicle which can travel over water. + + [[HOVERCRAFT]] + inherit = LAND_VEHICLE, AIR_VEHICLE, WATER_VEHICLE + [[[meta]]] + description = A vehicle which can travel over ground, water and ice. + + [[bht130]] + inherit = HOVERCRAFT, INTERNAL_COMBUSTION_ENGINE + [[[meta]]] + title = Griffon Hoverwork BHT130 (Isle Of Whight Ferry). + + +Finished Suite +-------------- + +You should now have a suite with an inheritance hierarchy which looks like +this: + +.. digraph:: Example + + size = "7, 5" + + root [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + ENGINE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + root -> ENGINE [color=royalblue]; + VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + root -> VEHICLE [color=royalblue]; + INTERNAL_COMBUSTION_ENGINE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled, + margin="0.3,0.055"]; + ENGINE -> INTERNAL_COMBUSTION_ENGINE [color=royalblue]; + TURBINE_ENGINE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled, + margin="0.3,0.055"]; + ENGINE -> TURBINE_ENGINE [color=royalblue]; + HUMAN_ENGINE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled, + margin="0.3,0.055"]; + ENGINE -> HUMAN_ENGINE [color=royalblue]; + LAND_VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE -> LAND_VEHICLE [color=royalblue]; + WATER_VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE -> WATER_VEHICLE [color=royalblue]; + AIR_VEHICLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + VEHICLE -> AIR_VEHICLE [color=royalblue]; + r44 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + INTERNAL_COMBUSTION_ENGINE -> r44 [color=royalblue]; + bht130 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + INTERNAL_COMBUSTION_ENGINE -> bht130 [color=royalblue]; + v22 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + TURBINE_ENGINE -> v22 [color=royalblue]; + a380 [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + TURBINE_ENGINE -> a380 [color=royalblue]; + penny_farthing [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled, + margin="0.3,0.055"]; + HUMAN_ENGINE -> penny_farthing [color=royalblue]; + AIRPLANE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + AIRPLANE -> v22 [color=royalblue]; + AIRPLANE -> a380 [color=royalblue]; + HELICOPTER [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + HELICOPTER -> v22 [color=royalblue]; + HELICOPTER -> r44 [color=royalblue]; + HOVERCRAFT [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + HOVERCRAFT -> bht130 [color=royalblue]; + LAND_VEHICLE -> HOVERCRAFT [color=royalblue]; + BICYCLE [color=royalblue, + fillcolor=powderblue, + shape=box, + style=filled]; + LAND_VEHICLE -> BICYCLE [color=royalblue]; + WATER_VEHICLE -> HOVERCRAFT [color=royalblue]; + AIR_VEHICLE -> AIRPLANE [color=royalblue]; + AIR_VEHICLE -> HELICOPTER [color=royalblue]; + AIR_VEHICLE -> HOVERCRAFT [color=royalblue]; + BICYCLE -> penny_farthing [color=royalblue]; diff --git a/src/tutorial/furthertopics/queues.rst b/src/tutorial/furthertopics/queues.rst new file mode 100644 index 0000000000..a04dfa48cb --- /dev/null +++ b/src/tutorial/furthertopics/queues.rst @@ -0,0 +1,105 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +Queues +====== + +Queues are used to put a limit on the number of tasks that will be active at +any one time, even if their dependencies are satisfied. This avoids swamping +systems with too many tasks at once. + + +Example +------- + +In this example, our suite manages a particularly understaffed restaurant. + +Create a new suite called ``queues-tutorial``:: + + rose tutorial queues-tutorial + cd ~/cylc-run/queues-tutorial + +You will now have a ``suite.rc`` file that looks like this: + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + open_restaurant => steak1 & steak2 & pasta1 & pasta2 & pasta3 & \ + pizza1 & pizza2 & pizza3 & pizza4 + steak1 => ice_cream1 + steak2 => cheesecake1 + pasta1 => ice_cream2 + pasta2 => sticky_toffee1 + pasta3 => cheesecake2 + pizza1 => ice_cream3 + pizza2 => ice_cream4 + pizza3 => sticky_toffee2 + pizza4 => ice_cream5 + """ + + [runtime] + [[open_restaurant]] + [[MAINS]] + [[DESSERT]] + [[steak1,steak2,pasta1,pasta2,pasta3,pizza1,pizza2,pizza3,pizza4]] + inherit = MAINS + [[ice_cream1,ice_cream2,ice_cream3,ice_cream4,ice_cream5]] + inherit = DESSERT + [[cheesecake1,cheesecake2,sticky_toffee1,sticky_toffee2]] + inherit = DESSERT + +.. note:: + + In graph sections backslash (``\``) is a line continuation character i.e. the + following two examples are equivalent: + + .. code-block:: cylc + + foo => bar & \ + baz + + .. code-block:: cylc + + foo => bar & baz + +Open the ``cylc gui`` then run the suite:: + + cylc gui queues-tutorial & + cylc run queues-tutorial + +You will see that all the ``steak``, ``pasta``, and ``pizza`` tasks are run +at once, swiftly followed by all the ``ice_cream``, ``cheesecake``, +``sticky_toffee`` tasks as the customers order from the dessert menu. + +This will overwhelm our restaurant staff! The chef responsible for ``MAINS`` +can only handle 3 tasks at any given time, and the ``DESSERT`` chef can only +handle 2. + +We need to add some queues. Add a ``[queues]`` section to the ``[scheduling]`` +section like so: + +.. code-block:: cylc + + [scheduling] + [[queues]] + [[[mains_chef_queue]]] + limit = 3 # Only 3 mains dishes at one time. + members = MAINS + [[[dessert_chef_queue]]] + limit = 2 # Only 2 dessert dishes at one time. + members = DESSERT + +Re-open the ``cylc gui`` if you have closed it and re-run the suite. + +You should see that there are now never more than 3 active ``MAINS`` tasks +running and never more than 2 active ``DESSERT`` tasks running. + +The customers will obviously have to wait! + + +Further Reading +--------------- + +For more information, see the `Cylc User Guide`_. diff --git a/src/tutorial/furthertopics/retries.rst b/src/tutorial/furthertopics/retries.rst new file mode 100644 index 0000000000..d412e0ea5c --- /dev/null +++ b/src/tutorial/furthertopics/retries.rst @@ -0,0 +1,156 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +Retries +======= + +Retries allow us to automatically re-submit tasks which have failed due to +failure in submission or execution. + + +Purpose +------- + +Retries can be useful for tasks that may occasionally fail due to external +events, and are routinely fixable when they do - an example would be a task +that is dependent on a system that experiences temporary outages. + +If a task fails, the Cylc retry mechanism can resubmit it after a +pre-determined delay. An environment variable, ``$CYLC_TASK_TRY_NUMBER`` +is incremented and passed into the task - this means you can write your +task script so that it changes behaviour accordingly. + + +Example +------- + +.. image:: https://upload.wikimedia.org/wikipedia/commons/7/73/Double-six-dice.jpg + :width: 200px + :align: right + :alt: Two dice both showing the number six + +Create a new suite by running the following commands:: + + rose tutorial retries-tutorial + cd retries-tutorial + +You will now have a suite with a ``roll_doubles`` task which simulates +trying to roll doubles using two dice: + +.. code-block:: cylc + + [cylc] + UTC mode = True # Ignore DST + + [scheduling] + [[dependencies]] + graph = start => roll_doubles => win + + [runtime] + [[start]] + [[win]] + [[roll_doubles]] + script = """ + sleep 10 + RANDOM=$$ # Seed $RANDOM + DIE_1=$((RANDOM%6 + 1)) + DIE_2=$((RANDOM%6 + 1)) + echo "Rolled $DIE_1 and $DIE_2..." + if (($DIE_1 == $DIE_2)); then + echo "doubles!" + else + exit 1 + fi + """ + + +Running Without Retries +----------------------- + +Let's see what happens when we run the suite as it is. Open the ``cylc gui``:: + + cylc gui retries-tutorial & + +Then run the suite:: + + cylc run retries-tutorial + +Unless you're lucky, the suite should fail at the roll_doubles task. + +Stop the suite:: + + cylc stop retries-tutorial + + +Configuring Retries +------------------- + +We need to tell Cylc to retry it a few times. To do this, add the following +to the end of the ``[[roll_doubles]]`` task section in the ``suite.rc`` file: + +.. code-block:: cylc + + [[[job]]] + execution retry delays = 5*PT6S + +This means that if the ``roll_doubles`` task fails, Cylc expects to +retry running it 5 times before finally failing. Each retry will have +a delay of 6 seconds. + +We can apply multiple retry periods with the ``execution retry delays`` setting +by separating them with commas, for example the following line would tell Cylc +to retry a task four times, once after 15 seconds, then once after 10 minutes, +then once after one hour then once after three hours. + +.. code-block:: cylc + + execution retry delays = PT15S, PT10M, PT1H, PT3H + + +Running With Retries +-------------------- + +If you closed it, re-open the ``cylc gui``:: + + cylc gui retries-tutorial & + +Re-run the suite:: + + cylc run retries-tutorial + +What you should see is Cylc retrying the ``roll_doubles`` task. Hopefully, +it will succeed (there is only about a about a 1 in 3 chance of every task +failing) and the suite will continue. + + +Altering Behaviour +------------------ + +We can alter the behaviour of the task based on the number of retries, using +``$CYLC_TASK_TRY_NUMBER``. + +Change the ``script`` setting for the ``roll_doubles`` task to this:: + + sleep 10 + RANDOM=$$ # Seed $RANDOM + DIE_1=$((RANDOM%6 + 1)) + DIE_2=$((RANDOM%6 + 1)) + echo "Rolled $DIE_1 and $DIE_2..." + if (($DIE_1 == $DIE_2)); then + echo "doubles!" + elif (($CYLC_TASK_TRY_NUMBER >= 2)); then + echo "look over there! ..." + echo "doubles!" # Cheat! + else + exit 1 + fi + +If your suite is still running, stop it, then run it again. + +This time, the task should definitely succeed before the third retry. + + +Further Reading +--------------- + +For more information see the `Cylc User Guide`_. diff --git a/src/tutorial/furthertopics/suicide-triggers.rst b/src/tutorial/furthertopics/suicide-triggers.rst new file mode 100644 index 0000000000..067fb974d8 --- /dev/null +++ b/src/tutorial/furthertopics/suicide-triggers.rst @@ -0,0 +1,676 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + + +.. _tut-cylc-suicide-triggers: + +Suicide Triggers +================ + +Suicide triggers allow us to remove a task from the suite's graph whilst the +suite is running. + +The main use of suicide triggers is for handling failures in the workflow. + + +Stalled Suites +-------------- + +Imagine a bakery which has a workflow that involves making cake. + +.. minicylc:: + :snippet: + :theme: none + + make_cake_mixture => bake_cake => sell_cake + +There is a 50% chance that the cake will turn out fine, and a 50% chance that +it will get burnt. In the case that we burn the cake the workflow gets stuck. + +.. digraph:: Example + :align: center + + make_cake_mixture [style="filled" color="#ada5a5"] + bake_cake [style="filled" color="#ff0000" fontcolor="white"] + sell_cake [color="#88c6ff"] + + make_cake_mixture -> bake_cake -> sell_cake + +In this event the ``sell_cake`` task will be unable to run as it depends on +``bake_cake``. We would say that this suite has :term:`stalled `. +When Cylc detects that a suite has stalled it sends you an email to let you +know that the suite has got stuck and requires human intervention to proceed. + + +Handling Failures +----------------- + +In order to prevent the suite from entering a stalled state we need to handle +the failure of the ``bake_cake`` task. + +At the bakery if they burn a cake they eat it and make another. + +The following diagram outlines this workflow with its two possible pathways, +``:succeed`` in the event that ``bake_cake`` is successful and ``:fail`` +otherwise. + +.. digraph:: Example + :align: center + + make_cake_mixture + bake_cake + + subgraph cluster_1 { + label = ":succeed" + labelloc = "b" + color = "green" + fontcolor = "green" + style = "dashed" + sell_cake + } + + subgraph cluster_2 { + label = ":fail" + labelloc = "b" + color = "red" + fontcolor = "red" + style = "dashed" + eat_cake + } + + make_cake_mixture -> bake_cake + bake_cake -> sell_cake + bake_cake -> eat_cake + +We can add this logic to our workflow using the ``fail`` :term:`qualifier`. + +.. code-block:: cylc-graph + + bake_cake => sell_cake + bake_cake:fail => eat_cake + +.. admonition:: Reminder + :class: hint + + If you don't specify a qualifier Cylc assumes you mean ``:succeed`` so the + following two lines are equivalent: + + .. code-block:: cylc-graph + + foo => bar + foo:succeed => bar + + +Why Do We Need To Remove Tasks From The Graph? +---------------------------------------------- + +Create a new suite called ``suicide-triggers``:: + + mkdir -p ~/cylc-run/suicide-triggers + cd ~/cylc-run/suicide-triggers + +Paste the following code into the ``suite.rc`` file: + +.. code-block:: cylc + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] + graph = """ + make_cake_mixture => bake_cake => sell_cake + bake_cake:fail => eat_cake + """ + [runtime] + [[root]] + script = sleep 2 + [[bake_cake]] + # Random outcome 50% chance of success 50% chance of failure. + script = sleep 2; if (( $RANDOM % 2 )); then true; else false; fi + +Open the ``cylc gui`` and run the suite:: + + cylc gui suicide-triggers & + cylc run suicide-triggers + +The suite will run for three cycles then get stuck. You should see something +similar to the diagram below. As the ``bake_cake`` task fails randomly what +you see might differ slightly. You may receive a "suite stalled" email. + +.. digraph:: Example + :align: center + + size = "7,5" + + subgraph cluster_1 { + label = "1" + style = "dashed" + "make_cake_mixture.1" [ + label="make_cake_mixture\n1", + style="filled", + color="#ada5a5"] + "bake_cake.1" [ + label="bake_cake\n1", + style="filled", + color="#ada5a5"] + "sell_cake.1" [ + label="sell_cake\n1", + style="filled", + color="#ada5a5"] + "eat_cake.1" [ + label="eat_cake\1", + color="#88c6ff"] + } + + subgraph cluster_2 { + label = "2" + style = "dashed" + "make_cake_mixture.2" [ + label="make_cake_mixture\n2", + style="filled", + color="#ada5a5"] + "bake_cake.2" [ + label="bake_cake\n2", + style="filled", + color="#ff0000", + fontcolor="white"] + "sell_cake.2" [ + label="sell_cake\2", + color="#88c6ff"] + "eat_cake.2" [ + label="eat_cake\n2", + color="#888888", + fontcolor="#888888"] + } + + subgraph cluster_3 { + label = "3" + style = "dashed" + "make_cake_mixture.3" [ + label="make_cake_mixture\n3", + style="filled", + color="#ada5a5"] + "bake_cake.3" [ + label="bake_cake\n3", + style="filled", + color="#ff0000", + fontcolor="white"] + "sell_cake.3" [ + label="sell_cake\n3", + color="#888888", + fontcolor="#888888"] + "eat_cake.3" [ + label="eat_cake\3", + color="#888888", + fontcolor="#888888"] + } + + "make_cake_mixture.1" -> "bake_cake.1" -> "sell_cake.1" + "bake_cake.1" -> "eat_cake.1" + + "make_cake_mixture.2" -> "bake_cake.2" -> "sell_cake.2" + "bake_cake.2" -> "eat_cake.2" + + "make_cake_mixture.3" -> "bake_cake.3" -> "sell_cake.3" + "bake_cake.3" -> "eat_cake.3" + +The reason the suite stalls is that, by default, Cylc will run a maximum of +three cycles concurrently. As each cycle has at least one task which hasn't +either succeeded or failed Cylc cannot move onto the next cycle. + +.. tip:: + + For more information search ``max active cycle points`` in the + `Cylc User Guide`_. + +You will also notice that some of the tasks (e.g. ``eat_cake`` in cycle ``2`` +in the above example) are drawn in a faded gray. This is because these tasks +have not yet been run in earlier cycles and as such cannot run. + +.. TODO - Spawn On Demand! + + +Removing Tasks From The Graph +----------------------------- + +In order to get around these problems and prevent the suite from stalling we +must remove the tasks that are no longer needed. We do this using suicide +triggers. + +A suicide trigger is written like a normal dependency but with an exclamation +mark in-front of the task on the right-hand-side of the dependency meaning +*"remove the following task from the graph at the current cycle point."* + +For example the following :term:`graph string` would remove the task ``bar`` +from the graph if the task ``foo`` were to succeed. + +.. code-block:: cylc-graph + + foo => ! bar + +There are three cases where we would need to remove a task in the cake-making +example: + +#. If the ``bake_cake`` task succeeds we don't need the ``eat_cake`` task so + should remove it. + + .. code-block:: cylc-graph + + bake_cake => ! eat_cake + +#. If the ``bake_cake`` task fails we don't need the ``sell_cake`` task so + should remove it. + + .. code-block:: cylc-graph + + bake_cake:fail => ! sell_cake + +#. If the ``bake_cake`` task fails then we will need to remove it else the + suite will stall. We can do this after the ``eat_cake`` task has succeeded. + + .. code-block:: cylc-graph + + eat_cake => ! bake_cake + +Add the following three lines to the suite's graph: + +.. code-block:: cylc-graph + + bake_cake => ! eat_cake + bake_cake:fail => ! sell_cake + eat_cake => ! bake_cake + +We can view suicide triggers in ``cylc graph`` by un-selecting the +:guilabel:`Ignore Suicide Triggers` button in the toolbar. Suicide triggers +will then appear as dashed lines with circular endings. You should see +something like this: + +.. digraph:: Example + :align: center + + make_cake_mixture -> bake_cake + bake_cake -> sell_cake [style="dashed" arrowhead="dot"] + bake_cake -> eat_cake [style="dashed" arrowhead="dot"] + eat_cake -> bake_cake [style="dashed" arrowhead="dot"] + + +Downstream Dependencies +----------------------- + +If we wanted to make the cycles run in order we might write an +:term:`inter-cycle dependency` like this: + +.. code-block:: cylc-graph + + sell_cake[-P1] => make_cake_mixture + +In order to handle the event that the ``sell_cake`` task has been removed from +the graph by a suicide trigger we can write our dependency with an or +symbol ``|`` like so: + +.. code-block:: cylc-graph + + eat_cake[-P1] | sell_cake[-P1] => make_cake_mixture + +Now the ``make_cake_mixture`` task from the next cycle will run after whichever +of the ``sell_cake`` or ``eat_cake`` tasks is run. + +.. digraph:: Example + :align: center + + subgraph cluster_1 { + style="dashed" + label="1" + "make_cake_mixture.1" [label="make_cake_mixture\n1"] + "bake_cake.1" [label="bake_cake\n1"] + "make_cake_mixture.1" -> "bake_cake.1" + "bake_cake.1" -> "sell_cake.1" [style="dashed" arrowhead="dot"] + "bake_cake.1" -> "eat_cake.1" [style="dashed" arrowhead="dot"] + "eat_cake.1" -> "bake_cake.1" [style="dashed" arrowhead="dot"] + subgraph cluster_a { + label = ":fail" + fontcolor = "red" + color = "red" + style = "dashed" + "eat_cake.1" [label="eat_cake\n1" color="red" fontcolor="red"] + } + subgraph cluster_b { + label = ":success" + fontcolor = "green" + color = "green" + style = "dashed" + "sell_cake.1" [label="sell_cake\n1" color="green" fontcolor="green"] + } + } + + subgraph cluster_2 { + style="dashed" + label="2" + "make_cake_mixture.2" [label="make_cake_mixture\n2"] + "bake_cake.2" [label="bake_cake\n2"] + "make_cake_mixture.2" -> "bake_cake.2" + "bake_cake.2" -> "sell_cake.2" [style="dashed" arrowhead="dot"] + "bake_cake.2" -> "eat_cake.2" [style="dashed" arrowhead="dot"] + "eat_cake.2" -> "bake_cake.2" [style="dashed" arrowhead="dot"] + subgraph cluster_c { + label = ":fail" + fontcolor = "red" + color = "red" + style = "dashed" + "eat_cake.2" [label="eat_cake\n2" color="red" fontcolor="red"] + } + subgraph cluster_d { + label = ":success" + fontcolor = "green" + color = "green" + style = "dashed" + "sell_cake.2" [label="sell_cake\n2" color="green" fontcolor="green"] + } + } + + "eat_cake.1" -> "make_cake_mixture.2" [arrowhead="onormal"] + "sell_cake.1" -> "make_cake_mixture.2" [arrowhead="onormal"] + +Add the following :term:`graph string` to your suite. + +.. code-block:: cylc-graph + + eat_cake[-P1] | sell_cake[-P1] => make_cake_mixture + +Open the ``cylc gui`` and run the suite. You should see that if the +``bake_cake`` task fails both it and the ``sell_cake`` task disappear and +are replaced by the ``eat_cake`` task. + + +Comparing "Regular" and "Suicide" Triggers +------------------------------------------ + +In Cylc "regular" and "suicide" triggers both work in the same way. For example +the following graph lines implicitly combine using an ``&`` operator: + +.. highlight:: cylc-graph + +.. list-table:: + :class: grid-table + + * - :: + + foo => pub + bar => pub + - :: + + foo & bar => pub + +Suicide triggers combine in the same way: + +.. list-table:: + :class: grid-table + + * - :: + + foo => !pub + bar => !pub + - :: + + foo & bar => !pub + +.. highlight:: python + +This means that suicide triggers are treated as "invisible tasks" rather than +as "events". Suicide triggers can have pre-requisites just like a normal task. + + +Variations +---------- + +The following sections outline examples of how to use suicide triggers. + +Recovery Task +^^^^^^^^^^^^^ + +A common use case where a ``recover`` task is used to handle a task failure. + +.. digraph:: Example + :align: center + + subgraph cluster_1 { + label = ":fail" + color = "red" + fontcolor = "red" + style = "dashed" + recover + } + + foo -> bar + bar -> recover + recover -> baz [arrowhead="onormal"] + bar -> baz [arrowhead="onormal"] + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + # Regular graph. + foo => bar + + # The fail case. + bar:fail => recover + + # Remove the "recover" task in the success case. + bar => ! recover + + # Remove the "bar" task in the fail case. + recover => ! bar + + # Downstream dependencies. + bar | recover => baz + """ + [runtime] + [[root]] + script = sleep 1 + [[bar]] + script = false + +Branched Workflow +^^^^^^^^^^^^^^^^^ + +A workflow where sub-graphs of tasks are to be run in the success and or fail +cases. + +.. digraph:: Example + :align: center + + foo -> bar + bar -> tar -> par + bar -> jar -> par + bar -> baz -> jaz + + subgraph cluster_1 { + label = ":success" + fontcolor = "green" + color = "green" + style = "dashed" + tar + jar + par + } + + subgraph cluster_2 { + label = ":fail" + fontcolor = "red" + color = "red" + style = "dashed" + baz + jaz + } + + tar -> pub [arrowhead="onormal"] + jaz -> pub [arrowhead="onormal"] + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + # Regular graph. + foo => bar + + # Success case. + bar => tar & jar + + # Fail case. + bar:fail => baz => jaz + + # Remove tasks from the fail branch in the success case. + bar => ! baz & ! jaz + + # Remove tasks from the success branch in the fail case. + bar:fail => ! tar & ! jar & ! par + + # Remove the bar task in the fail case. + baz => ! bar + + # Downstream dependencies. + tar | jaz => pub + """ + [runtime] + [[root]] + script = sleep 1 + [[bar]] + script = true + +Triggering Based On Other States +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +In these examples we have been using suicide triggers to handle task failure. +The suicide trigger mechanism works with other qualifiers as well for example: + +.. code-block:: cylc-graph + + foo:start => ! bar + +Suicide triggers can also be used with custom outputs. In the following example +the task ``showdown`` produces one of three possible custom outputs, ``good``, +``bad`` or ``ugly``. + +.. TODO - link to custom task outputs / write an advanced tutorial for them. + +.. digraph:: Example + :align: center + + subgraph cluster_1 { + label = ":good" + color = "green" + fontcolor = "green" + style = "dashed" + good + } + subgraph cluster_2 { + label = ":bad" + color = "red" + fontcolor = "red" + style = "dashed" + bad + } + subgraph cluster_3 { + label = ":ugly" + color = "purple" + fontcolor = "purple" + style = "dashed" + ugly + } + showdown -> good + showdown -> bad + showdown -> ugly + good -> fin [arrowhead="onormal"] + bad -> fin [arrowhead="onormal"] + ugly -> fin [arrowhead="onormal"] + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + # The "regular" dependencies + showdown:good => good + showdown:bad => bad + showdown:ugly => ugly + good | bad | ugly => fin + + # The "suicide" dependencies for each case + showdown:good | showdown:bad => ! ugly + showdown:bad | showdown:ugly => ! good + showdown:ugly | showdown:good => ! bad + """ + [runtime] + [[root]] + script = sleep 1 + [[showdown]] + # Randomly return one of the three custom outputs. + script = """ + SEED=$RANDOM + if ! (( $SEED % 3 )); then + cylc message 'The-Good' + elif ! (( ( $SEED + 1 ) % 3 )); then + cylc message 'The-Bad' + else + cylc message 'The-Ugly' + fi + """ + [[[outputs]]] + # Register the three custom outputs with cylc. + good = 'The-Good' + bad = 'The-Bad' + ugly = 'The-Ugly' + +Self-Suiciding Task +^^^^^^^^^^^^^^^^^^^ + +An example of a workflow where there are no tasks which are dependent on the +task to suicide trigger. + +.. digraph:: Example + :align: center + + subgraph cluster_1 { + label = "Faulty\nTask" + color = "orange" + fontcolor = "orange" + style = "dashed" + labelloc = "b" + pub + } + + foo -> bar -> baz + bar -> pub + + +It is possible for a task to suicide trigger itself e.g: + +.. code-block:: cylc-graph + + foo:fail => ! foo + +.. warning:: + + This is usually not recommended but in the case where there are no tasks + dependent on the one to remove it is an acceptable approach. + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + foo => bar => baz + bar => pub + + # Remove the "pub" task in the event of failure. + pub:fail => ! pub + """ + [runtime] + [[root]] + script = sleep 1 + [[pub]] + script = false diff --git a/src/tutorial/img/cylc-graph-cluster.png b/src/tutorial/img/cylc-graph-cluster.png new file mode 100644 index 0000000000000000000000000000000000000000..4fb6df22d7b1d6e8b50c1a616dc830c389ac27b7 GIT binary patch literal 6668 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 |hJ(uIM5-|zQVRHpy(gCDGP=*<@W z+|XVrC4>-4XfB@{8X9t3r>nE8rMYGGWu<36A3kg6Pv$x}er|o%83;B@zjkI|=5Rs41m}VHk#CT9$2Dwq>Dw zf!B4>Fl<4v6xr1@PLf4Q6h%>%B%jZxCuHPDj!_g{q>d?O3 zuN*tIe$rpA#@arC=Z4M&U3=6UV2m_P)ijk7>bkD$5<*-;D4|3{fDkT=iy-hk$72pJ zwo*N;E6OD=Nz(dJsEVp8wSQ0#@3jvPzkN8g@Al7V!(I@6R3Z5oV^Lgwx?v?*_wM@Y z@!WII{dQ!8_gaAm54Q*qLS>&Ix_-$|ZLr`7^6q*MutLv|2M-=T0qvI+nNo^5j;)LM zgX_AQ&*z=};9<@h@QT2Lhg-z(kHzA%v$L-2&OLLehA#j{VRm*Vk!W&V$180QaMN>s zJb3W%2^nGthr(fw=O + + + + + +_anonymous_0 +cluster_1 + + +cluster_2 + + + +foo.1 + +foo + + +baz.1 + +baz + + +foo.1->baz.1 + + + + +bar.1 + +bar + + +bar.1->baz.1 + + + + +bar.2 + +bar + + +baz.2 + +baz + + +foo.2->baz.2 + + + + +foo.2 + +foo + + +bar.2->baz.2 + + + + + diff --git a/src/tutorial/img/cylc-graph.png b/src/tutorial/img/cylc-graph.png new file mode 100644 index 0000000000000000000000000000000000000000..65e1ffa957921a8c5e7aacf40c9af66d674249ca GIT binary patch literal 49286 zcmXtg1y~i`_w~>XS3yA2B!;DQS@I?rs6;{vY1&`_1zZ zcer$A%!NA_g$lAfw#_#k+j{cknQx^CUajC)gyR^z-fhz+nGLzonaVsu@HMLq&x56?*)E zFv(+jd9*UHRTgYA!ph_IA{-8ai8zLa>qM=E;4{OMkh(p+K0mlQ>d3-DL-+1o8A_L8 zmi+aX&A%

yqu~C1db|T4E_*GG!W#5=+W5_z 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 I8KHaFBYht-bxl|317|J#Z92f^5M4sG#z4 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�HU9$WoQ*~i^-@Pg?#5AU&%s@vTcj3YS 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 aL}PSVZm#;Gp!hewBxoJe)hHs`kp2fSi0PsL literal 0 HcmV?d00001 diff --git a/src/tutorial/img/cylc-gui-dot.png b/src/tutorial/img/cylc-gui-dot.png new file mode 100644 index 0000000000000000000000000000000000000000..0cfede9f3dd545b78c83ecebf79dbdf294c43b69 GIT binary patch literal 35155 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 z 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 NwA6Lga#byY{vSBYXu<#h literal 0 HcmV?d00001 diff --git a/src/tutorial/img/cylc-gui-suite-start.png b/src/tutorial/img/cylc-gui-suite-start.png new file mode 100644 index 0000000000000000000000000000000000000000..6cbc05681da3bcc092a79c6afb977df6cd5b06d2 GIT binary patch literal 18138 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 literal 0 HcmV?d00001 diff --git a/src/tutorial/img/cylc-gui-view-log.png b/src/tutorial/img/cylc-gui-view-log.png new file mode 100644 index 0000000000000000000000000000000000000000..0b3338fd0b054b5de24eca2cc81b1b1ca518ca4d GIT binary patch literal 19206 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 N002ovPDHLkV1h&^mSO+^ literal 0 HcmV?d00001 diff --git a/src/tutorial/img/cylc-gui.png b/src/tutorial/img/cylc-gui.png new file mode 100644 index 0000000000000000000000000000000000000000..f60097fa2b6d3c37807914e6208a1f579984a050 GIT binary patch literal 153532 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%0Do$Ec#7_8`OXw{w;JxFil?_8q?*f7 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�GKJE4 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 literal 0 HcmV?d00001 diff --git a/src/tutorial/img/gcylc-play.png b/src/tutorial/img/gcylc-play.png new file mode 100644 index 0000000000000000000000000000000000000000..608436508b2069d64a92c594808c1a27e5411847 GIT binary patch literal 1939 zcmV;E2WP)Px#32;bRa{vGf6951U69E94oEQKA00(qQO+^Rc3Iz}&C50)9LI3~P!h!XB+= zM>F@{x$~QIe&=`Y#fuj&LfcwztPR2Tm;j(Q3fls78|Urv=p}ph*>7+8173dl$8D4W zKr}jZE1bI>Fty2Z>Fy&0|0NoKQcETVRPfJ!C&Qa z`MGn?9q&K>g~$4{*$&_LIp?i_LX#$1d%lRsu!Tj|`&Vy{PtFLL00IKd5E%o`7(Zvd7>)V&fWL(!p#H|f(&-3okrc^4ml!va5my`xl zfo0o(>H&3^jj@@`c((zN)V*REg7 zPv%db{t6=d(MvC;-So*PPGgkcz?qa&`HKKGsT zxm@n07k_x*;Qfz2@`&TOuH$U3G{A*)#~SgipWw=7Eh*j@_VxH#$K(wBy&1um<)O+< z_0NC*Xh)}K8X_wV?lZ<}^o(0V9asn2vZYK&DW#O0vwZ%R@B0@n48Hf?yMseRr%pZj z`3E1gENg=jaG9=XAdLF|BI2#JlMn1cT;!@{&kL&YAOAKMYr2&$Qw=8q08n+0Zbo(J zC3v+`w<(MOIODdRluMS7QWEK6sc`7fq5l5kU;Wx?X&Mhdd~EdyjpMHoJX8~SxFqEo zP$mK*0-&Y`T=yJ)^QRA^Sg*KfaQ4uF9>+HOkLO<2c?#y+R0p*pLVpvtpe*2wKO`08ykqwdWI@)xUJC z^vI3L{kyVmQUZYByatid#2M3?iqpZn!{bjpw08sYZq;qWr~z%+c0x+il!jq&&Qr-$ zKA#^L7&v<5=)iXe3?bq;)>?0tqY)6<5-m4`CAFTT34k*knWz9kPp6Zgs&sccJzZ{N zn=sPDW98m1Css6kZL)brTLWm*FdH~pa?VpJry2xWb~WgINROb6UR}t8f;16V!gmZWc*_Wp;~IDmXQYmAVQaKmuJJ$Y`Ckt zGdETF-Csxc>`Z&9gq1J=;Oa+}I8q;sy1m7 z&Yb!BGiRQO;{24WlUP>vnheG72Nc zIcIFM)Dg$=FJJ$a(khOkD2m|Twc2vsfxZsQU`nZsBRo4*nGMH_b5q4w6L7{fX(Grt z<|lhSH)$%R7gW-EfnMdUaTLZ;2>%Dh7(4vw9T`WeTFr%^5j}^wDYI5dMT!j041+Vq zIAe@+&Y2K`@upUcMSI6^ktFZSy0zsU(xkOsI1ttJ2m&H9#uzfj86x7s7Q_}5EdT4~ zroH;Q>pB!YLk?`KH + + + + + + + + + + + + image/svg+xml + + + + + + + + 1985-04-12 + 23:20:30Z + T + Date Components + Time Components + + + + + + + + + + + Separator + Year + Month + Day + Hour + Minute + Second + Time Zone + + + diff --git a/src/tutorial/index.rst b/src/tutorial/index.rst new file mode 100644 index 0000000000..554ca19f93 --- /dev/null +++ b/src/tutorial/index.rst @@ -0,0 +1,21 @@ +.. _Cylc Tutorial: + +Cylc Tutorial +============= + +Cylc is a workflow engine for running suites of inter-dependent jobs. + +.. image:: ../graphics/png/orig/cylc-logo.png + :width: 250px + :align: center + +This section will cover the Cylc framework and writing basic Cylc suites. + +.. toctree:: + :name: cylc-tutorial + :maxdepth: 2 + + introduction + scheduling/index + runtime/index + furthertopics/index diff --git a/src/tutorial/introduction.rst b/src/tutorial/introduction.rst new file mode 100644 index 0000000000..ca9ecc678a --- /dev/null +++ b/src/tutorial/introduction.rst @@ -0,0 +1,94 @@ +.. _cylc-introduction: + +Introduction +============ + + +What Is A Workflow? +------------------- + +.. epigraph:: + + A workflow consists of an orchestrated and repeatable pattern of business + activity enabled by the systematic organization of resources into processes + that transform materials, provide services, or process information. + + -- Wikipedia + +.. ifnotslides:: + + In research, business and other fields we may have processes that we repeat + in the course of our work. At its simplest a workflow is a set of steps that + must be followed in a particular order to achieve some end goal. + + We can represent each "step" in a workflow as a oval and the order with + arrows. + +.. nextslide:: + +.. digraph:: bakery + :align: center + + "purchase ingredients" -> "make dough" -> "bake bread" -> "sell bread" + "bake bread" -> "clean oven" + "pre-heat oven" -> "bake bread" + + +What Is Cylc? +------------- + +.. ifnotslides:: + + Cylc (pronounced silk) is a workflow engine, a system that automatically + executes tasks according to their schedules and dependencies. + + In a Cylc workflow each step is a computational task, a script to execute. + Cylc runs each task as soon as it is appropriate to do so. + +.. minicylc:: + :align: center + :theme: demo + + a => b => c + b => d => f + e => f + +.. nextslide:: + +Cylc can automatically: + +- Submit tasks across computer systems and resource managers. +- Recover from failures. +- Repeat workflows. + +.. ifnotslides:: + + Cylc was originally developed at NIWA (The National Institute of Water and + Atmospheric Research - New Zealand) for running their weather forecasting + workflows. Cylc is now developed by an international partnership including + members from NIWA and the Met Office (UK). Though initially developed for + meteorological purposes Cylc is a general purpose tool as applicable in + business as in scientific research. + +.. nextslide:: + +.. ifslides:: + + * Originally developed at NIWA (New Zealand) + * Now developed by an international partnership including the + Met Office (UK). + * General purpose tool as applicable in business as in + scientific research. + +.. nextslide:: + +Cylc provides a variety of command line and GUI tools for visualising and +interacting with workflows. + +.. image:: img/cylc-gui.png + +.. nextslide:: + +.. ifslides:: + + :ref:`tutorial-cylc-graphing` diff --git a/src/tutorial/runtime/configuration-consolidation/families.rst b/src/tutorial/runtime/configuration-consolidation/families.rst new file mode 100644 index 0000000000..48b8729342 --- /dev/null +++ b/src/tutorial/runtime/configuration-consolidation/families.rst @@ -0,0 +1,333 @@ +.. include:: ../../../../hyperlinks.rst + :start-line: 1 + + +.. _tutorial-cylc-families: + +Families +======== + +:term:`Families ` provide a way of grouping tasks together so they can +be treated as one. + + +Runtime +------- + +.. ifnotslides:: + + :term:`Families ` are groups of tasks which share a common + configuration. In the present example the common configuration is: + + .. code-block:: cylc + + script = get-observations + [[[environment]]] + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + We define a family as a new task consisting of the common configuration. By + convention families are named in upper case: + +.. code-block:: cylc + + [[GET_OBSERVATIONS]] + script = get-observations + [[[environment]]] + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + +.. ifnotslides:: + + We "add" tasks to a family using the ``inherit`` setting: + +.. code-block:: cylc + + [[get_observations_heathrow]] + inherit = GET_OBSERVATIONS + [[[environment]]] + SITE_ID = 3772 + +.. ifnotslides:: + + When we add a task to a family in this way it :term:`inherits ` the configuration from the family, i.e. the above example is + equivalent to: + +.. code-block:: cylc + + [[get_observations_heathrow]] + script = get-observations + [[[environment]]] + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + SITE_ID = 3772 + +.. nextslide:: + +.. ifnotslides:: + + It is possible to override inherited configuration within the task. For + example if we wanted the ``get_observations_heathrow`` task to use a + different API key we could write: + +.. code-block:: cylc + :emphasize-lines: 4 + + [[get_observations_heathrow]] + inherit = GET_OBSERVATIONS + [[[environment]]] + API_KEY = special-api-key + SITE_ID = 3772 + +.. nextslide:: + +.. ifnotslides:: + + Using families the ``get_observations`` tasks could be written like so: + +.. code-block:: cylc + + [runtime] + [[GET_OBSERVATIONS]] + script = get-observations + [[[environment]]] + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + [[get_observations_heathrow]] + inherit = GET_OBSERVATIONS + [[[environment]]] + SITE_ID = 3772 + [[get_observations_camborne]] + inherit = GET_OBSERVATIONS + [[[environment]]] + SITE_ID = 3808 + [[get_observations_shetland]] + inherit = GET_OBSERVATIONS + [[[environment]]] + SITE_ID = 3005 + [[get_observations_belmullet]] + inherit = GET_OBSERVATIONS + [[[environment]]] + SITE_ID = 3976 + + +Graphing +-------- + +.. ifnotslides:: + + :term:`Families ` can be used in the suite's :term:`graph`, e.g: + +.. code-block:: cylc-graph + + GET_OBSERVATIONS:succeed-all => consolidate_observations + +.. ifnotslides:: + + The ``:succeed-all`` is a special :term:`qualifier` which in this example + means that the ``consolidate_observations`` task will run once *all* of the + members of the ``GET_OBSERVATIONS`` family have succeeded. This is + equivalent to: + +.. code-block:: cylc-graph + + get_observations_heathrow => consolidate_observations + get_observations_camborne => consolidate_observations + get_observations_shetland => consolidate_observations + get_observations_belmullet => consolidate_observations + +.. ifnotslides:: + + The ``GET_OBSERVATIONS:succeed-all`` part is referred to as a + :term:`family trigger`. Family triggers use special qualifiers which are + non-optional. The most commonly used ones are: + + ``succeed-all`` + Run if all of the members of the family have succeeded. + ``succeed-any`` + Run as soon as any one family member has succeeded. + ``finish-all`` + Run as soon as all of the family members have completed (i.e. have each + either succeeded or failed). + + For more information on family triggers see the `Cylc User Guide`_. + +.. ifslides:: + + * ``succeed-all`` + * ``succeed-any`` + * ``finish-all`` + + +The ``root`` Family +------------------- + +.. ifnotslides:: + + There is a special family called `root` (in lowercase) which is used only + in the runtime to provide configuration which will be inherited by all + tasks. + + In the following example the task ``bar`` will inherit the environment + variable ``FOO`` from the ``[root]`` section: + +.. code-block:: cylc + + [runtime] + [[root]] + [[[environment]]] + FOO = foo + [[bar]] + script = echo $FOO + + +Families and ``cylc graph`` +--------------------------- + +.. ifnotslides:: + + By default, ``cylc graph`` groups together all members of a family + in the :term:`graph`. To un-group a family right click on it and select + :menuselection:`UnGroup`. + + For instance if the tasks ``bar`` and ``baz`` both + inherited from ``BAR`` ``cylc graph`` would produce: + +.. digraph:: Example + :align: center + + subgraph cluster_1 { + label = "Grouped" + "foo.1" [label="foo"] + "BAR.1" [label="BAR", shape="doubleoctagon"] + } + + subgraph cluster_2 { + label = "Un-Grouped" + "foo.2" [label="foo"] + "bar.2" [label="bar"] + "baz.2" [label="baz"] + } + + "foo.1" -> "BAR.1" + "foo.2" -> "bar.2" + "foo.2" -> "baz.2" + +.. nextslide:: + +.. ifslides:: + + .. rubric:: In this practical we will consolidate the configuration of the + :ref:`weather-forecasting suite ` + from the previous section. + + Next section: :ref:`Jinja2 ` + + +.. _cylc-tutorial-families-practical: + +.. practical:: + + .. rubric:: In this practical we will consolidate the configuration of the + :ref:`weather-forecasting suite ` + from the previous section. + + 1. **Create A New Suite.** + + To make a new copy of the forecasting suite run the following commands: + + .. code-block:: bash + + rose tutorial consolidation-tutorial + cd ~/cylc-run/consolidation-tutorial + + 2. **Move Site-Wide Settings Into The** ``root`` **Family.** + + The following two environment variables are used by multiple tasks: + + .. code-block:: none + + RESOLUTION = 0.2 + DOMAIN = -12,48,5,61 # Do not change! + + Rather than manually adding them to each task individually we could put + them in the ``root`` family, making them accessible to all tasks. + + Add a ``root`` section containing these two environment variables. + Remove the variables from any other task's ``environment`` sections: + + .. code-block:: diff + + [runtime] + + [[root]] + + [[[environment]]] + + # The dimensions of each grid cell in degrees. + + RESOLUTION = 0.2 + + # The area to generate forecasts for (lng1, lat1, lng2, lat2). + + DOMAIN = -12,48,5,61 # Do not change! + + .. code-block:: diff + + [[consolidate_observations]] + script = consolidate-observations + - [[[environment]]] + - # The dimensions of each grid cell in degrees. + - RESOLUTION = 0.2 + - # The area to generate forecasts for (lng1, lat1, lng2, lat2). + - DOMAIN = -12,48,5,61 # Do not change! + + [[get_rainfall]] + script = get-rainfall + [[[environment]]] + # The key required to get weather data from the DataPoint service. + # To use archived data comment this line out. + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + - # The dimensions of each grid cell in degrees. + - RESOLUTION = 0.2 + - # The area to generate forecasts for (lng1, lat1, lng2, lat2). + - DOMAIN = -12,48,5,61 # Do not change! + + [[forecast]] + script = forecast 60 5 # Generate 5 forecasts at 60 minute intervals. + [[[environment]]] + - # The dimensions of each grid cell in degrees. + - RESOLUTION = 0.2 + - # The area to generate forecasts for (lng1, lat1, lng2, lat2) + - DOMAIN = -12,48,5,61 # Do not change! + # The path to the files containing wind data (the {variables} will + # get substituted in the forecast script). + WIND_FILE_TEMPLATE = $CYLC_SUITE_WORK_DIR/{cycle}/consolidate_observations/wind_{xy}.csv + # List of cycle points to process wind data from. + WIND_CYCLES = 0, -3, -6 + + # The path to the rainfall file. + RAINFALL_FILE = $CYLC_SUITE_WORK_DIR/$CYLC_TASK_CYCLE_POINT/get_rainfall/rainfall.csv + # Create the html map file in the task's log directory. + MAP_FILE = "${CYLC_TASK_LOG_ROOT}-map.html" + # The path to the template file used to generate the html map. + MAP_TEMPLATE = "$CYLC_SUITE_RUN_DIR/lib/template/map.html" + + [[post_process_exeter]] + # Generate a forecast for Exeter 60 minutes into the future. + script = post-process exeter 60 + - [[[environment]]] + - # The dimensions of each grid cell in degrees. + - RESOLUTION = 0.2 + - # The area to generate forecasts for (lng1, lat1, lng2, lat2). + - DOMAIN = -12,48,5,61 # Do not change! + + To ensure that the environment variables are being inherited correctly + by the tasks, inspect the ``[runtime]`` section using ``cylc get-config`` + by running the following command: + + .. code-block:: bash + + cylc get-config . --sparse -i "[runtime]" + + You should see the environment variables from the ``[root]`` section + in the ``[environment]`` section for all tasks. + + .. tip:: + + You may find it easier to open the output of this command in a text + editor, e.g:: + + cylc get-config . --sparse -i "[runtime]" | gvim - diff --git a/src/tutorial/runtime/configuration-consolidation/index.rst b/src/tutorial/runtime/configuration-consolidation/index.rst new file mode 100644 index 0000000000..8cb159e1f0 --- /dev/null +++ b/src/tutorial/runtime/configuration-consolidation/index.rst @@ -0,0 +1,191 @@ +.. include:: ../../../../hyperlinks.rst + :start-line: 1 + + +.. _tutorial-cylc-consolidating-configuration: + +Consolidating Configuration +=========================== + +.. ifnotslides:: + + In the last section we wrote out the following code in the ``suite.rc`` file: + +.. slide:: Weather Forecasting Suite + :level: 2 + :inline-contents: True + + .. code-block:: cylc + + [runtime] + [[get_observations_heathrow]] + script = get-observations + [[[environment]]] + SITE_ID = 3772 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_camborne]] + script = get-observations + [[[environment]]] + SITE_ID = 3808 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_shetland]] + script = get-observations + [[[environment]]] + SITE_ID = 3005 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_belmullet]] + script = get-observations + [[[environment]]] + SITE_ID = 3976 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + +.. ifnotslides:: + + In this code the ``script`` item and the ``API_KEY`` environment variable have + been repeated for each task. This is bad practice as it makes the + configuration lengthy and making changes can become difficult. + + Likewise the graphing relating to the ``get_observations`` tasks is highly + repetitive: + +.. ifslides:: + + .. slide:: Weather Forecasting Suite + :level: 2 + + Repetition + + * ``script`` + * ``API_KEY`` + +.. slide:: Weather Forecasting Suite + :level: 2 + :inline-contents: True + + .. code-block:: cylc + + [scheduling] + [[dependencies]] + [[[T00/PT3H]]] + graph = """ + get_observations_belmullet => consolidate_observations + get_observations_camborne => consolidate_observations + get_observations_heathrow => consolidate_observations + get_observations_shetland => consolidate_observations + """ + +.. nextslide:: + +Cylc offers three ways of consolidating configurations to help improve the +structure of a suite and avoid duplication. + +.. toctree:: + :maxdepth: 1 + + families + jinja2 + parameters + + +The ``cylc get-config`` Command +------------------------------- + +.. ifnotslides:: + + The ``cylc get-config`` command reads in then prints out the ``suite.rc`` file + to the terminal. + + Throughout this section we will be introducing methods for consolidating + the ``suite.rc`` file, the ``cylc get-config`` command can be used to + "expand" the ``suite.rc`` file back to its full form. + + .. note:: + + The main use of ``cylc get-config`` is inspecting the + ``[runtime]`` section of a suite. The ``cylc get-config`` command does not + expand :term:`parameterisations ` and + :term:`families ` in the suite's :term:`graph`. To inspect the + graphing use the ``cylc graph`` command. + + Call ``cylc get-config`` with the path of the suite (``.`` if you are already + in the :term:`suite directory`) and the ``--sparse`` option which hides + default values. + +.. code-block:: sub + + cylc get-config --sparse + +.. ifnotslides:: + + To view the configuration of a particular section or setting refer to it by + name using the ``-i`` option (see :ref:`Cylc file format` for details), e.g: + +.. code-block:: sub + + # Print the contents of the [scheduling] section. + cylc get-config --sparse -i '[scheduling]' + # Print the contents of the get_observations_heathrow task. + cylc get-config --sparse -i '[runtime][get_observations_heathrow]' + # Print the value of the script setting in the get_observations_heathrow task + cylc get-config --sparse -i '[runtime][get_observations_heathrow]script' + +.. nextslide:: + +.. ifslides:: + + Note that ``cylc get-config`` doesn't expand families or parameterisations + in the :term:`graph`. Use ``cylc graph`` to visualise these. + + .. TODO - Raise and issue for this, note cylc get-config and cylc view. + + +The Three Approaches +-------------------- + +.. ifnotslides:: + + The next three sections cover the three consolidation approaches and how we + could use them to simplify the suite from the previous tutorial. *Work + through them in order!* + +* :ref:`families ` +* :ref:`jinja2 ` +* :ref:`parameters ` + + +.. _cylc-tutorial-consolidation-conclusion: + +Which Approach To Use +--------------------- + +.. ifnotslides:: + + Each approach has its uses. Cylc permits mixing approaches, allowing us to + use what works best for us. As a rule of thumb: + + * :term:`Families ` work best consolidating runtime configuration by + collecting tasks into broad groups, e.g. groups of tasks which run on a + particular machine or groups of tasks belonging to a particular system. + * `Jinja2`_ is good at configuring settings which apply to the entire suite + rather than just a single task, as we can define variables then use them + throughout the suite. + * :term:`Parameterisation ` works best for describing tasks + which are very similar but which have subtly different configurations + (e.g. different arguments or environment variables). + +.. ifslides:: + + As a rule of thumb each method works best for: + + Families + Collecting tasks into broad groups. + Jinja2 + Configuration settings which apply to the entire suite. + Parameterisation + Tasks which are similar. + +.. nextslide:: + +.. ifslides:: + + Next section: :ref:`Rose Tutorial ` diff --git a/src/tutorial/runtime/configuration-consolidation/jinja2.rst b/src/tutorial/runtime/configuration-consolidation/jinja2.rst new file mode 100644 index 0000000000..4fdf3feda0 --- /dev/null +++ b/src/tutorial/runtime/configuration-consolidation/jinja2.rst @@ -0,0 +1,235 @@ +.. _Jinja2 Tutorial: http://jinja.pocoo.org/docs +.. _shebang: https://en.wikipedia.org/wiki/Shebang_(Unix) + + +.. _tutorial-cylc-jinja2: + +Jinja2 +====== + +`Jinja2`_ is a templating language often used in web design with some +similarities to python. It can be used to make a suite definition more +dynamic. + + +The Jinja2 Language +------------------- + +In Jinja2 statements are wrapped with ``{%`` characters, i.e: + +.. code-block:: none + + {% ... %} + +Variables are initiated using the ``set`` statement, e.g: + +.. code-block:: css+jinja + + {% set foo = 3 %} + +.. nextslide:: + +Expressions wrapped with ``{{`` characters will be replaced with the value of +the evaluation of the expression, e.g: + +.. code-block:: css+jinja + + There are {{ foo }} methods for consolidating the suite.rc file + +Would result in:: + + There are 3 methods for consolidating the suite.rc file + +.. nextslide:: + +Loops are written with ``for`` statements, e.g: + +.. code-block:: css+jinja + + {% for x in range(foo) %} + {{ x }} + {% endfor %} + +Would result in: + +.. code-block:: none + + 0 + 1 + 2 + +.. nextslide:: + +To enable Jinja2 in the ``suite.rc`` file, add the following `shebang`_ to the +top of the file: + +.. code-block:: cylc + + #!Jinja2 + +For more information see the `Jinja2 Tutorial`_. + + +Example +------- + +To consolidate the configuration for the ``get_observations`` tasks we could +define a dictionary of station and ID pairs: + +.. code-block:: css+jinja + + {% set stations = {'belmullet': 3976, + 'camborne': 3808, + 'heathrow': 3772, + 'shetland': 3005} %} + +.. nextslide:: + +We could then loop over the stations like so: + +.. code-block:: css+jinja + + {% for station in stations %} + {{ station }} + {% endfor %} + +After processing, this would result in: + +.. code-block:: none + + belmullet + camborne + heathrow + shetland + +.. nextslide:: + +We could also loop over both the stations and corresponding IDs like so: + +.. code-block:: css+jinja + + {% for station, id in stations.items() %} + {{ station }} - {{ id }} + {% endfor %} + +This would result in: + +.. code-block:: none + + belmullet - 3976 + camborne - 3808 + heathrow - 3772 + shetland - 3005 + +.. nextslide:: + +.. ifnotslides:: + + Putting this all together, the ``get_observations`` configuration could be + written as follows: + +.. code-block:: cylc + + #!Jinja2 + + {% set stations = {'belmullet': 3976, + 'camborne': 3808, + 'heathrow': 3772, + 'shetland': 3005} %} + + [scheduling] + [[dependencies]] + [[[T00/PT3H]]] + graph = """ + {% for station in stations %} + get_observations_{{station}} => consolidate_observations + {% endfor %} + """ + +.. nextslide:: + +.. code-block:: cylc + + [runtime] + {% for station, id in stations.items() %} + [[get_observations_{{station}}]] + script = get-observations + [[[environment]]] + SITE_ID = {{ id }} + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + {% endfor %} + +.. nextslide:: + +.. ifslides:: + + .. rubric:: This practical continues on from the + :ref:`families practical `. + + Next section: :ref:`tutorial-cylc-parameterisation` + + +.. _cylc-tutorial-jinja2-practical: + +.. practical:: + + .. rubric:: This practical continues on from the + :ref:`families practical `. + + 3. **Use Jinja2 To Avoid Duplication.** + + The ``API_KEY`` environment variable is used by both the + ``get_observations`` and ``get_rainfall`` tasks. Rather than writing it + out multiple times we will use Jinja2 to centralise this configuration. + + At the top of the ``suite.rc`` file add the Jinja2 shebang line. Then + copy the value of the ``API_KEY`` environment variable and use it to + define an ``API_KEY`` Jinja2 variable: + + .. code-block:: cylc + + #!Jinja2 + + {% set API_KEY = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' %} + + Next replace the key, where it appears in the suite, with + ``{{ API_KEY }}``: + + .. code-block:: diff + + [runtime] + [[get_observations_heathrow]] + script = get-observations + [[[environment]]] + SITE_ID = 3772 + - API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + API_KEY = {{ API_KEY }} + [[get_observations_camborne]] + script = get-observations + [[[environment]]] + SITE_ID = 3808 + - API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + API_KEY = {{ API_KEY }} + [[get_observations_shetland]] + script = get-observations + [[[environment]]] + SITE_ID = 3005 + - API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + API_KEY = {{ API_KEY }} + [[get_observations_belmullet]] + script = get-observations + [[[environment]]] + SITE_ID = 3976 + - API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + API_KEY = {{ API_KEY }} + [[get_rainfall]] + script = get-rainfall + [[[environment]]] + # The key required to get weather data from the DataPoint service. + # To use archived data comment this line out. + - API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + API_KEY = {{ API_KEY }} + + Check the result with ``cylc get-config``. The Jinja2 will be processed + so you should not see any difference after making these changes. diff --git a/src/tutorial/runtime/configuration-consolidation/parameters.rst b/src/tutorial/runtime/configuration-consolidation/parameters.rst new file mode 100644 index 0000000000..c0329fdd15 --- /dev/null +++ b/src/tutorial/runtime/configuration-consolidation/parameters.rst @@ -0,0 +1,349 @@ +.. include:: ../../../../hyperlinks.rst + :start-line: 1 + +.. _tutorial-cylc-parameterisation: + + +Parameterised Tasks +=================== + +Parameterised tasks (see :term:`parameterisation`) provide a way of implicitly +looping over tasks without the need for Jinja2. + + +Cylc Parameters +--------------- + +.. ifnotslides:: + + Parameters are defined in their own section, e.g: + +.. code-block:: cylc + + [cylc] + [[parameters]] + world = Mercury, Venus, Earth + + +.. ifnotslides:: + + They can then be referenced by writing the name of the parameter in angle + brackets, e.g: + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = start => hello => end + [runtime] + [[hello]] + script = echo 'Hello World!' + +.. nextslide:: + +.. ifnotslides:: + + When the ``suite.rc`` file is read by Cylc, the parameters will be expanded. + For example the code above is equivalent to: + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + start => hello_Mercury => end + start => hello_Venus => end + start => hello_Earth => end + """ + [runtime] + [[hello_Mercury]] + script = echo 'Hello World!' + [[hello_Venus]] + script = echo 'Hello World!' + [[hello_Earth]] + script = echo 'Hello World!' + +.. nextslide:: + +.. ifnotslides:: + + We can refer to a specific parameter by writing it after an ``=`` sign: + +.. code-block:: cylc + + [runtime] + [[hello]] + script = echo 'Greetings Earth!' + + +Environment Variables +--------------------- + +.. ifnotslides:: + + The name of the parameter is provided to the job as an environment variable + called ``CYLC_TASK_PARAM_`` where ```` is the name of + the parameter (in the present case ``world``): + +.. code-block:: cylc + + [runtime] + [[hello]] + script = echo "Hello ${CYLC_TASK_PARAM_world}!" + + +Parameter Types +--------------- + +Parameters can be either words or integers: + +.. code-block:: cylc + + [cylc] + [[parameters]] + foo = 1..5 + bar = 1..5..2 + baz = pub, qux, bol + +.. nextslide:: + +.. hint:: + + Remember that Cylc automatically inserts an underscore between the task and + the parameter, e.g. the following lines are equivalent: + + .. code-block:: cylc-graph + + task + task_pub + +.. nextslide:: + +.. hint:: + + .. ifnotslides:: + + When using integer parameters, to prevent confusion, Cylc prefixes the + parameter value with the parameter name. For example: + + .. ifslides:: + + Cylc prefixes integer parameters with the parameter name: + + .. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + # task would result in: + task_bar1 + task_bar3 + task_bar5 + + # task would result in: + task_pub + task_qux + task_bol + """ + +.. nextslide:: + +.. ifnotslides:: + + Using parameters the ``get_observations`` configuration could be written like + so: + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + [[[T00/PT3H]]] + graph = """ + get_observations => consolidate_observations + """ + [runtime] + [[get_observations]] + script = get-observations + [[[environment]]] + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + [[get_observations]] + [[[environment]]] + SITE_ID = 3976 + [[get_observations]] + [[[environment]]] + SITE_ID = 3808 + [[get_observations]] + [[[environment]]] + SITE_ID = 3772 + [[get_observations]] + [[[environment]]] + SITE_ID = 3005 + +.. nextslide:: + +.. ifnotslides:: + + For more information see the `Cylc User Guide`_. + +.. ifslides:: + + .. rubric:: This practical continues on from the + :ref:`Jinja2 practical `. + + Next section: :ref:`Which approach to use + ` + + +.. _cylc-tutorial-parameters-practical: + +.. practical:: + + .. rubric:: This practical continues on from the + :ref:`Jinja2 practical `. + + 4. **Use Parameterisation To Consolidate The** ``get_observations`` + **Tasks**. + + Next we will parameterise the ``get_observations`` tasks. + + Add a parameter called ``station``: + + .. code-block:: diff + + [cylc] + UTC mode = True + + [[parameters]] + + station = belmullet, camborne, heathrow, shetland + + Remove the four ``get_observations`` tasks and insert the following code + in their place: + + .. code-block:: cylc + + [[get_observations]] + script = get-observations + [[[environment]]] + API_KEY = {{ API_KEY }} + + Using ``cylc get-config`` you should see that Cylc replaces the + ```` with each of the stations in turn, creating a new task for + each: + + .. code-block:: bash + + cylc get-config . --sparse -i "[runtime]" + + The ``get_observations`` tasks are now missing the ``SITE_ID`` + environment variable. Add a new section for each station with a + ``SITE_ID``: + + .. code-block:: cylc + + [[get_observations]] + [[[environment]]] + SITE_ID = 3772 + + .. hint:: + + The relevant IDs are: + + * Belmullet - ``3976`` + * Camborne - ``3808`` + * Heathrow - ``3772`` + * Shetland - ``3005`` + + .. spoiler:: Solution warning + + .. code-block:: cylc + + [[get_observations]] + [[[environment]]] + SITE_ID = 3976 + [[get_observations]] + [[[environment]]] + SITE_ID = 3808 + [[get_observations]] + [[[environment]]] + SITE_ID = 3772 + [[get_observations]] + [[[environment]]] + SITE_ID = 3005 + + Using ``cylc get-config`` you should now see four ``get_observations`` + tasks, each with a ``script``, an ``API_KEY`` and a ``SITE_ID``: + + .. code-block:: bash + + cylc get-config . --sparse -i "[runtime]" + + Finally we can use this parameterisation to simplify the suite's + graphing. Replace the ``get_observations`` lines in the graph with + ``get_observations``: + + .. code-block:: diff + + [[[PT3H]]] + # Repeat every three hours starting at the initial cycle point. + graph = """ + - get_observations_belmullet => consolidate_observations + - get_observations_camborne => consolidate_observations + - get_observations_heathrow => consolidate_observations + - get_observations_shetland => consolidate_observations + + get_observations => consolidate_observations + """ + + .. hint:: + + The ``cylc get-config`` command does not expand parameters or families + in the graph so you must use ``cylc graph`` to inspect changes to the + graphing. + + #. **Use Parameterisation To Consolidate The** ``post_process`` **Tasks**. + + At the moment we only have one ``post_process`` task + (``post_process_exeter``), but suppose we wanted to add a second task for + Edinburgh. + + Create a new parameter called ``site`` and set it to contain ``exeter`` + and ``edinburgh``. Parameterise the ``post_process`` task using this + parameter. + + .. hint:: + + The first argument to the ``post-process`` task is the name of the + site. We can use the ``CYLC_TASK_PARAM_site`` environment variable to + avoid having to write out this section twice. + + .. TODO - use parameter environment templates instead of + CYLC_TASK_PARAM. + + .. spoiler:: Solution warning + + First we must create the ``site`` parameter: + + .. code-block:: diff + + [cylc] + UTC mode = True + [[parameters]] + station = belmullet, camborne, heathrow, shetland + + site = exeter, edinburgh + + Next we parameterise the task in the graph: + + .. code-block:: diff + + + -get_rainfall => forecast => post_process_exeter + +get_rainfall => forecast => post_process + + And also the runtime: + + .. code-block:: diff + + -[[post_process_exeter]] + +[[post_process]] + # Generate a forecast for Exeter 60 minutes in the future. + - script = post-process exeter 60 + + script = post-process $CYLC_TASK_PARAM_site 60 diff --git a/src/tutorial/runtime/index.rst b/src/tutorial/runtime/index.rst new file mode 100644 index 0000000000..2bca48173a --- /dev/null +++ b/src/tutorial/runtime/index.rst @@ -0,0 +1,18 @@ +.. _tutorial-runtime: + +Runtime +======= + +This section covers: + +* Associating tasks with scripts and executables. +* Providing executables with runtime configurations. +* Running Cylc suites. + +.. toctree:: + :name: rug-runtime-toc + :maxdepth: 2 + + introduction + runtime-configuration + configuration-consolidation/index diff --git a/src/tutorial/runtime/introduction.rst b/src/tutorial/runtime/introduction.rst new file mode 100644 index 0000000000..36a1222d9c --- /dev/null +++ b/src/tutorial/runtime/introduction.rst @@ -0,0 +1,518 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + + +.. _tutorial-cylc-runtime-introduction: + +Introduction +============ + +.. ifnotslides:: + + So far we have been working with the ``[scheduling]`` section. This is where + the workflow is defined in terms of :term:`tasks ` and + :term:`dependencies `. + + In order to make the workflow runnable we must associate tasks with scripts + or binaries to be executed when the task runs. This means working with the + ``[runtime]`` section which determines what runs, as well as where and how + it runs. + +.. ifslides:: + + ``[scheduling]`` + Defines the workflow in terms of :term:`tasks ` and + :term:`dependencies `. + ``[runtime]`` + Defines what runs, where and how it runs. + + +The Task Section +---------------- + +.. ifnotslides:: + + The runtime settings for each task are stored in a sub-section of the + ``[runtime]`` section. E.g. for a task called ``hello_world`` we would write + settings inside the following section: + +.. code-block:: cylc + + [runtime] + [[hello_world]] + + +The ``script`` Setting +---------------------- + +.. ifnotslides:: + + We tell Cylc *what* to execute when a task is run using the ``script`` + setting. + + This setting is interpreted as a bash script. The following example defines a + task called ``hello_world`` which writes ``Hello World!`` to stdout upon + execution. + +.. code-block:: cylc + + [runtime] + [[hello_world]] + script = echo 'Hello World!' + +.. note:: + + If you do not set the ``script`` for a task then nothing will be run. + +We can also call other scripts or executables in this way, e.g: + +.. code-block:: cylc + + [runtime] + [[hello_world]] + script = ~/foo/bar/baz/hello_world + + +:envvar:`PATH` and :envvar:`PYTHONPATH` +--------------------------------------- + +.. ifnotslides:: + + It is often a good idea to keep our scripts with the Cylc suite rather than + leaving them somewhere else on the system. + + If you create a ``bin/`` sub-directory within the :term:`suite directory` + Cylc will automatically prepend it to the :envvar:`PATH` environment + variable when the task runs. + +.. code-block:: bash + :caption: bin/hello_world + + #!/usr/bin/bash + echo 'Hello World!' + +.. code-block:: cylc + :caption: suite.rc + + [runtime] + [[hello_world]] + script = hello_world + +.. nextslide:: + +.. ifnotslides:: + + Similarly the ``lib/python/`` directory gets prepended to the + :envvar:`PYTHONPATH` variable. + +.. code-block:: python + :caption: lib/python/hello.py + + def world(): + print('Hello World!') + +.. code-block:: cylc + :caption: suite.rc + + [runtime] + [[hello_world]] + script = python -c 'import hello; hello.world()' + + +.. _tutorial-tasks-and-jobs: + +Tasks And Jobs +-------------- + +.. ifnotslides:: + + When a :term:`task` is "Run" it creates a :term:`job`. The job is a bash + file containing the script you have told the task to run along with + configuration specifications and a system for trapping errors. It is the + :term:`job` which actually gets executed and not the task itself. This + "job file" is called the :term:`job script`. + + During its life a typical :term:`task` goes through the following states: + + Waiting + :term:`Tasks ` wait for their dependencies to be satisfied before + running. In the meantime they are in the "Waiting" state. + Submitted + When a :term:`task's ` dependencies have been met it is ready for + submission. During this phase the :term:`job script` is created. + The :term:`job` is then submitted to the specified batch system. + There is more about this in the :ref:`next section + `. + Running + A :term:`task` is in the "Running" state as soon as the :term:`job` is + executed. + Succeeded + If the :term:`job` submitted by a :term:`task` has successfully + completed (i.e. there is zero return code) then it is said to have + succeeded. + + These descriptions, and a few more (e.g. failed), are called the + :term:`task states `. + +.. ifslides:: + + When a :term:`task` is "Run" it creates a :term:`job`. + + The life-cycle of a job: + + * Waiting + * Submitted + * Running + * Succeeded / Failed + + +The Cylc GUI +------------ + +.. ifnotslides:: + + To help you to keep track of a running suite Cylc has a graphical user + interface (the Cylc GUI) which can be used for monitoring and + interaction. + + The Cylc GUI looks quite like ``cylc graph`` but the tasks are colour-coded + to represent their state, as in the following diagram. + +.. digraph:: example + :align: center + + Waiting [color="#88c6ff"] + Running [style="filled" color="#00c410"] + Succeeded [style="filled" color="#ada5a5"] + +.. minicylc:: + :align: center + + a => b => c + b => d => f + e => f + +.. nextslide:: + +.. ifnotslides:: + + This is the "graph view". The Cylc GUI has two other views called "tree" and + "dot". + +.. figure:: ../img/cylc-gui-graph.png + :figwidth: 75% + :align: center + + Screenshot of the Cylc GUI in "Graph View" mode. + +.. nextslide:: + +.. figure:: ../img/cylc-gui-tree.png + :figwidth: 75% + :align: center + + Screenshot of the Cylc GUI in "Tree View" mode. + +.. nextslide:: + +.. figure:: ../img/cylc-gui-dot.png + :figwidth: 75% + :align: center + + Screenshot of the Cylc GUI in "Dot View" mode. + + +Where Do All The Files Go? +-------------------------- + +.. ifnotslides:: + + The Work Directory + ^^^^^^^^^^^^^^^^^^ + + When a :term:`task` is run Cylc creates a directory for the :term:`job` to + run in. This is called the :term:`work directory`. + + By default the work directory is located in a directory structure + under the relevant :term:`cycle point` and :term:`task` name: + + .. code-block:: sub + + ~/cylc-run//work// + + The Job Log Directory + ^^^^^^^^^^^^^^^^^^^^^ + + When a task is run Cylc generates a :term:`job script` which is stored in the + :term:`job log directory` as the file ``job``. + + When the :term:`job script` is executed the stdout and stderr are redirected + into the ``job.out`` and ``job.err`` files which are also stored in the + :term:`job log directory`. + + The :term:`job log directory` lives in a directory structure under the + :term:`cycle point`, :term:`task` name and :term:`job submission number`: + + .. code-block:: sub + + ~/cylc-run//log/job//// + + The :term:`job submission number` starts at 1 and increments by 1 each time + a task is re-run. + + .. tip:: + + If a task has run and is still visible in the Cylc GUI you can view its + :term:`job log files ` by right-clicking on the task and + selecting "View". + + .. image:: ../img/cylc-gui-view-log.png + :align: center + :scale: 75% + +.. ifslides:: + + The Work Directory + .. code-block:: sub + + ~/cylc-run//work// + The Job Log Directory + .. code-block:: sub + + ~/cylc-run//log/job//// + + .. image:: ../img/cylc-gui-view-log.png + :align: center + :scale: 75% + + +Running A Suite +--------------- + +.. ifnotslides:: + + It is a good idea to check a suite for errors before running it. + Cylc provides a command which automatically checks for any obvious + configuration issues called ``cylc validate``, run via: + +.. code-block:: sub + + cylc validate + +.. ifnotslides:: + + Here ```` is the path to the suite's location within the + filesystem (so if we create a suite in ``~/cylc-run/foo`` we would put + ``~/cylc-run/foo/suite.rc``). + + Next we can run the suite using the ``cylc run`` command. + +.. code-block:: sub + + cylc run + +.. ifnotslides:: + + The ``name`` is the name of the :term:`suite directory` (i.e. ```` + would be ``foo`` in the above example). + +.. note:: + + In this tutorial we are writing our suites in the ``cylc-run`` directory. + + It is possible to write them elsewhere on the system. If we do so we + must register the suite with Cylc before use. + + We do this using the ``cylc reg`` command which we supply with a name which + will be used to refer to the suite in place of the path i.e: + + .. code-block:: sub + + cylc reg + cylc validate + cylc run + + The ``cylc reg`` command will create a directory for the suite in the + ``cylc-run`` directory meaning that we will have separate + :term:`suite directories ` and + :term:`run directories `. + + +Suite Files +----------- + +.. ifnotslides:: + + Cylc generates files and directories when it runs a suite, namely: + + ``log/`` + Directory containing log files, including: + + ``log/db`` + The database which Cylc uses to record the state of the suite; + ``log/job`` + The directory where the :term:`job log files ` live; + ``log/suite`` + The directory where the :term:`suite log files ` live. + These files are written by Cylc as the suite is run and are useful for + debugging purposes in the event of error. + + ``suite.rc.processed`` + A copy of the ``suite.rc`` file made after any `Jinja2`_ has been + processed - we will cover this in the + :ref:`tutorial-cylc-consolidating-configuration` section. + ``share/`` + The :term:`share directory` is a place where :term:`tasks ` can + write files which are intended to be shared within that cycle. + ``work/`` + A directory hierarchy containing task's :term:`work directories + `. + +.. ifslides:: + + * ``log/`` + * ``log/db`` + * ``log/job`` + * ``log/suite`` + * ``suite.rc.processed`` + * ``share/`` + * ``work/`` + + .. nextslide:: + + .. rubric:: In this practical we will add some scripts to, and run, the + :ref:`weather forecasting suite ` + from the :ref:`scheduling tutorial `. + + Next section: :ref:`tutorial-cylc-runtime-configuration` + + +.. practical:: + + .. rubric:: In this practical we will add some scripts to, and run, the + :ref:`weather forecasting suite ` + from the :ref:`scheduling tutorial `. + + #. **Create A New Suite.** + + The following command will copy some files for us to work with into + a new suite called ``runtime-introduction``: + + .. code-block:: bash + + rose tutorial runtime-introduction + cd ~/cylc-run/runtime-introduction + + In this directory we have the ``suite.rc`` file from the + :ref:`weather forecasting suite ` + with some runtime configuration added to it. + + There is also a script called ``get-observations`` located in the bin + directory. + + Take a look at the ``[runtime]`` section in the ``suite.rc`` file. + + #. **Run The Suite.** + + First validate the suite by running: + + .. code-block:: bash + + cylc validate . + + Open the Cylc GUI (in the background) by running the following command: + + .. code-block:: bash + + cylc gui runtime-introduction & + + Finally run the suite by executing: + + .. code-block:: bash + + cylc run runtime-introduction + + The tasks will start to run - you should see them going through the + "Waiting", "Running" and "Succeeded" states. + + When the suite reaches the final cycle point and all tasks have succeeded + it will shutdown automatically and the GUI will go blank. + + .. tip:: + + You can also run a suite from the Cylc GUI by pressing the "play" + button. + + .. image:: ../img/gcylc-play.png + :align: center + + A box will appear. Ensure that "Cold Start" is selected then press + "Start". + + .. image:: ../img/cylc-gui-suite-start.png + :align: center + + #. **Inspect A Job Log.** + + Try opening the file ``job.out`` for one of the + ``get_observations`` jobs in a text editor. The file will be + located within the :term:`job log directory`: + + .. code-block:: sub + + log/job//get_observations_heathrow/01/job.out + + You should see something like this: + + .. code-block:: none + + Suite : runtime-introduction + Task Job : 20000101T0000Z/get_observations_heathrow/01 (try 1) + User@Host: username@hostname + + Guessing Weather Conditions + Writing Out Wind Data + 1970-01-01T00:00:00Z NORMAL - started + 2038-01-19T03:14:08Z NORMAL - succeeded + + * The first three lines are information which Cylc has written to the file + to provide information about the job. + * The last two lines were also written by cylc. They provide timestamps + marking the stages in the job's life. + * The lines in the middle are the stdout of the job itself. + + #. **Inspect A Work Directory.** + + The ``get_rainfall`` task should create a file called ``rainfall`` in its + :term:`work directory`. Try opening this file, recalling that the + format of the relevant path from within the work directory will be: + + .. code-block:: sub + + work//get_rainfall/rainfall + + .. hint:: + + The ``get_rainfall`` task only runs every third cycle. + + #. **Extension: Explore The Cylc GUI** + + * Try re-running the suite. + + * Try changing the current view(s). + + .. tip:: + + You can do this from the "View" menu or from the toolbar: + + .. image:: ../img/cylc-gui-view-selector.png + :align: center + :scale: 75% + + * Try pressing the "Pause" button which is found in the top left-hand + corner of the GUI. + + * Try right-clicking on a task. From the right-click menu you could try: + + * "Trigger (run now)" + * "Reset State" diff --git a/src/tutorial/runtime/runtime-configuration.rst b/src/tutorial/runtime/runtime-configuration.rst new file mode 100644 index 0000000000..91a2ba81ee --- /dev/null +++ b/src/tutorial/runtime/runtime-configuration.rst @@ -0,0 +1,501 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +.. _DataPoint: https://www.metoffice.gov.uk/datapoint + + +.. _tutorial-cylc-runtime-configuration: + +Runtime Configuration +===================== + +In the last section we associated tasks with scripts and ran a simple suite. In +this section we will look at how we can configure these tasks. + + +Environment Variables +--------------------- + +.. ifnotslides:: + + We can specify environment variables in a task's ``[environment]`` section. + These environment variables are then provided to :term:`jobs ` when they + run. + +.. code-block:: cylc + + [runtime] + [[countdown]] + script = seq $START_NUMBER + [[[environment]]] + START_NUMBER = 5 + +.. ifnotslides:: + + Each job is also provided with some standard environment variables e.g: + + ``CYLC_SUITE_RUN_DIR`` + The path to the suite's :term:`run directory` + *(e.g. ~/cylc-run/suite)*. + ``CYLC_TASK_WORK_DIR`` + The path to the associated task's :term:`work directory` + *(e.g. run-directory/work/cycle/task)*. + ``CYLC_TASK_CYCLE_POINT`` + The :term:`cycle point` for the associated task + *(e.g. 20171009T0950)*. + + There are many more environment variables - see the `Cylc User Guide`_ for more + information. + +.. ifslides:: + + * ``CYLC_SUITE_RUN_DIR`` + * ``CYLC_TASK_WORK_DIR`` + * ``CYLC_TASK_CYCLE_POINT`` + + +.. _tutorial-batch-system: + +Job Submission +-------------- + +.. ifnotslides:: + + By default Cylc runs :term:`jobs ` on the machine where the suite is + running. We can tell Cylc to run jobs on other machines by setting the + ``[remote]host`` setting to the name of the host, e.g. to run a task on the + host ``computehost`` you might write: + +.. code-block:: cylc + + [runtime] + [[hello_computehost]] + script = echo "Hello Compute Host" + [[[remote]]] + host = computehost + +.. _background processes: https://en.wikipedia.org/wiki/Background_process +.. _job scheduler: https://en.wikipedia.org/wiki/Job_scheduler + +.. nextslide:: + +.. ifnotslides:: + + Cylc also executes jobs as `background processes`_ by default. + When we are running jobs on other compute hosts we will often want to + use a :term:`batch system` (`job scheduler`_) to submit our job. + Cylc supports the following :term:`batch systems `: + +* at +* loadleveler +* lsf +* pbs +* sge +* slurm +* moab + +.. nextslide:: + +.. ifnotslides:: + + :term:`Batch systems ` typically require + :term:`directives ` in some form. :term:`Directives ` + inform the :term:`batch system` of the requirements of a :term:`job`, for + example how much memory a given job requires or how many CPUs the job will + run on. For example: + +.. code-block:: cylc + + [runtime] + [[big_task]] + script = big-executable + + # Submit to the host "big-computer". + [[[remote]]] + host = big-computer + + # Submit the job using the "slurm" batch system. + [[[job]]] + batch system = slurm + + # Inform "slurm" that this job requires 500MB of RAM and 4 CPUs. + [[[directives]]] + --mem = 500 + --ntasks = 4 + + +Timeouts +-------- + +.. ifnotslides:: + + We can specify a time limit after which a job will be terminated using the + ``[job]execution time limit`` setting. The value of the setting is an + :term:`ISO8601 duration`. Cylc automatically inserts this into a job's + directives as appropriate. + +.. code-block:: cylc + + [runtime] + [[some_task]] + script = some-executable + [[[job]]] + execution time limit = PT15M # 15 minutes. + + +Retries +------- + +Sometimes jobs fail. This can be caused by two factors: + +* Something going wrong with the job's execution e.g: + + * A bug; + * A system error; + * The job hitting the ``execution time limit``. + +* Something going wrong with the job submission e.g: + + * A network problem; + * The :term:`job host` becoming unavailable or overloaded; + * An issue with the directives. + +.. nextslide:: + +.. ifnotslides:: + + In the event of failure Cylc can automatically re-submit (retry) jobs. We + configure retries using the ``[job]execution retry delays`` and + ``[job]submission retry delays`` settings. These settings are both set to an + :term:`ISO8601 duration`, e.g. setting ``execution retry delays`` to ``PT10M`` + would cause the job to retry every 10 minutes in the event of execution + failure. + + We can limit the number of retries by writing a multiple in front of the + duration, e.g: + +.. code-block:: cylc + + [runtime] + [[some-task]] + script = some-script + [[[job]]] + # In the event of execution failure, retry a maximum + # of three times every 15 minutes. + execution retry delays = 3*PT15M + # In the event of submission failure, retry a maximum + # of two times every ten minutes and then every 30 + # minutes thereafter. + submission retry delays = 2*PT10M, PT30M + + +Start, Stop, Restart +-------------------- + +.. ifnotslides:: + + We have seen how to start and stop Cylc suites with ``cylc run`` and + ``cylc stop`` respectively. The ``cylc stop`` command causes Cylc to wait + for all running jobs to finish before it stops the suite. There are two + options which change this behaviour: + + ``cylc stop --kill`` + When the ``--kill`` option is used Cylc will kill all running jobs + before stopping. *Cylc can kill jobs on remote hosts and uses the + appropriate command when a* :term:`batch system` *is used.* + ``cylc stop --now --now`` + When the ``--now`` option is used twice Cylc stops straight away, leaving + any jobs running. + + Once a suite has stopped it is possible to restart it using the + ``cylc restart`` command. When the suite restarts it picks up where it left + off and carries on as normal. + + .. code-block:: bash + + # Run the suite "name". + cylc run + # Stop the suite "name", killing any running tasks. + cylc stop --kill + # Restart the suite "name", picking up where it left off. + cylc restart + +.. ifslides:: + + .. code-block:: sub + + cylc run + cylc stop + cylc restart + + cylc stop --kill + cylc stop --now --now + + .. nextslide:: + + .. rubric:: In this practical we will add runtime configuration to the + :ref:`weather-forecasting suite ` + from the :ref:`scheduling tutorial `. + + Next section: :ref:`tutorial-cylc-consolidating-configuration` + + +.. _tutorial-cylc-runtime-forecasting-suite: + +.. practical:: + + .. rubric:: In this practical we will add runtime configuration to the + :ref:`weather-forecasting suite ` + from the :ref:`scheduling tutorial `. + + #. **Create A New Suite.** + + Create a new suite by running the command: + + .. code-block:: bash + + rose tutorial runtime-tutorial + cd ~/cylc-run/runtime-tutorial + + You will now have a copy of the weather-forecasting suite along with some + executables and python modules. + + #. **Set The Initial And Final Cycle Points.** + + We want the suite to run for 6 hours, starting at least 7 hours ago, on + the hour. + + We could work out the dates and times manually, or we could let Cylc do + the maths for us. + + Set the :term:`initial cycle point`: + + .. code-block:: cylc + + initial cycle point = previous(T-00) - PT7H + + * ``previous(T-00)`` returns the current time ignoring minutes and + seconds. + + *e.g. if the current time is 12:34 this will return 12:00* + + * ``-PT7H`` subtracts 7 hours from this value. + + Set the :term:`final cycle point`: + + .. code-block:: cylc + + final cycle point = +PT6H + + This sets the :term:`final cycle point` six hours after the + :term:`initial cycle point`. + + Run `cylc validate` to check for any errors:: + + cylc validate . + + #. **Add Runtime Configuration For The** ``get_observations`` **Tasks.** + + In the ``bin`` directory is a script called ``get-observations``. This + script gets weather data from the MetOffice `DataPoint`_ service. + It requires two environment variables: + + ``SITE_ID``: + A four digit numerical code which is used to identify a + weather station, e.g. ``3772`` is Heathrow Airport. + ``API_KEY``: + An authentication key required for access to the service. + + .. TODO: Add instructions for offline configuration + + Generate a Datapoint API key:: + + rose tutorial api-key + + Add the following lines to the bottom of the ``suite.rc`` file replacing + ``xxx...`` with your API key: + + .. code-block:: cylc + + [runtime] + [[get_observations_heathrow]] + script = get-observations + [[[environment]]] + SITE_ID = 3772 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + + Add three more ``get_observations`` tasks for each of the remaining + weather stations. + + You will need the codes for the other three weather stations, which are: + + * Camborne - ``3808`` + * Shetland - ``3005`` + * Belmullet - ``3976`` + + .. spoiler:: Solution warning + + .. code-block:: cylc + + [runtime] + [[get_observations_heathrow]] + script = get-observations + [[[environment]]] + SITE_ID = 3772 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_camborne]] + script = get-observations + [[[environment]]] + SITE_ID = 3808 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_shetland]] + script = get-observations + [[[environment]]] + SITE_ID = 3005 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + [[get_observations_belmullet]] + script = get-observations + [[[environment]]] + SITE_ID = 3976 + API_KEY = xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx + + Check the ``suite.rc`` file is valid by running the command: + + .. code-block:: bash + + cylc validate . + + .. TODO: Add advice on what to do if the command fails. + + #. **Test The** ``get_observations`` **Tasks.** + + Next we will test the ``get_observations`` tasks. + + Open the Cylc GUI by running the following command: + + .. code-block:: bash + + cylc gui runtime-tutorial & + + Run the suite either by pressing the play button in the Cylc GUI or by + running the command: + + .. code-block:: bash + + cylc run runtime-tutorial + + If all goes well the suite will startup and the tasks will run and + succeed. Note that the tasks which do not have a ``[runtime]`` section + will still run though they will not do anything as they do not call any + scripts. + + Once the suite has reached the final cycle point and all tasks have + succeeded the suite will automatically shutdown. + + .. TODO: Advise on what to do if all does not go well. + + The ``get-observations`` script produces a file called ``wind.csv`` which + specifies the wind speed and direction. This file is written in the task's + :term:`work directory`. + + Try and open one of the ``wind.csv`` files. Note that the path to the + :term:`work directory` is: + + .. code-block:: sub + + work// + + You should find a file containing four numbers: + + * The longitude of the weather station; + * The latitude of the weather station; + * The wind direction (*the direction the wind is blowing towards*) + in degrees; + * The wind speed in miles per hour. + + .. spoiler:: Hint hint + + If you run ``ls work`` you should see a + list of cycles. Pick one of them and open the file:: + + work//get_observations_heathrow/wind.csv + + #. **Add runtime configuration for the other tasks.** + + The runtime configuration for the remaining tasks has been written out + for you in the ``runtime`` file which you will find in the + :term:`suite directory`. Copy the code in the ``runtime`` file to the + bottom of the ``suite.rc`` file. + + Check the ``suite.rc`` file is valid by running the command: + + .. code-block:: bash + + cylc validate . + + .. TODO: Add advice on what to do if the command fails. + + #. **Run The Suite.** + + Open the Cylc GUI (if not already open) and run the suite. + + .. spoiler:: Hint hint + + .. code-block:: bash + + cylc gui runtime-tutorial & + + Run the suite either by: + + * Pressing the play button in the Cylc GUI. Then, ensuring that + "Cold Start" is selected within the dialogue window, pressing the + "Start" button. + * Running the command ``cylc run runtime-tutorial``. + + #. **View The Forecast Summary.** + + The ``post_process_exeter`` task will produce a one-line summary of the + weather in Exeter, as forecast two hours ahead of time. This summary can + be found in the ``summary.txt`` file in the :term:`work directory`. + + Try opening the summary file - it will be in the last cycle. The path to + the :term:`work directory` is: + + .. code-block:: sub + + work// + + .. spoiler:: Hint hint + + * ``cycle-point`` - this will be the last cycle of the suite, + i.e. the final cycle point. + * ``task-name`` - set this to "post_process_exeter". + + #. **View The Rainfall Data.** + + .. TODO: Skip this if you don't have internet connection. + + The ``forecast`` task will produce a html page where the rainfall + data is rendered on a map. This html file is called ``job-map.html`` and + is saved alongside the :term:`job log`. + + Try opening this file in a web browser, e.g via: + + .. code-block:: sub + + firefox & + + The path to the :term:`job log directory` is: + + .. code-block:: sub + + log/job/// + + .. spoiler:: Hint hint + + * ``cycle-point`` - this will be the last cycle of the suite, + i.e. the final cycle point. + * ``task-name`` - set this to "forecast". + * ``submission-number`` - set this to "01". + diff --git a/src/tutorial/scheduling/datetime-cycling.rst b/src/tutorial/scheduling/datetime-cycling.rst new file mode 100644 index 0000000000..557fb193a8 --- /dev/null +++ b/src/tutorial/scheduling/datetime-cycling.rst @@ -0,0 +1,632 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +.. _nowcasting: https://www.metoffice.gov.uk/research/weather/research-to-operations/convective-scale-data-assimilation-and-nowcasting + +.. _tutorial-datetime-cycling: + +Date-Time Cycling +================= + + +In the last section we looked at writing an :term:`integer cycling` workflow, +one where the :term:`cycle points ` are numbered. + +.. ifnotslides:: + + Typically workflows are repeated at a regular time interval, say every day + or every few hours. To make this easier Cylc has a date-time cycling mode + where the :term:`cycle points ` use date and time specifications + rather than numbers. + +.. admonition:: Reminder + :class: tip + + :term:`Cycle points ` are labels. Cylc runs tasks as soon as + their dependencies are met so cycles do not necessarily run in order. + + +.. _tutorial-iso8601: + +ISO8601 +------- + +In Cylc, dates, times and durations are written using the :term:`ISO8601` format +- an international standard for representing dates and times. + +.. _tutorial-iso8601-datetimes: + +ISO8601 Date-Times +^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + In ISO8601, datetimes are written from the largest unit to the smallest + (i.e: year, month, day, hour, minute, second in succession) with the ``T`` + character separating the date and time components. For example, midnight + on the 1st of January 2000 is written ``20000101T000000``. + + For brevity we may omit seconds (and minutes) from the time i.e: + ``20000101T0000`` (``20000101T00``). + + For readability we may add hyphen (``-``) characters between the date + components and colon (``:``) characters between the time components, i.e: + ``2000-01-01T00:00``. This is the "extended" format. + + Time-zone information can be added onto the end. UTC is written ``Z``, + UTC+1 is written ``+01``, etc. E.G: ``2000-01-01T00:00Z``. + +.. Diagram of an iso8601 datetime's components. + +.. image:: ../img/iso8601-dates.svg + :width: 75% + :align: center + +.. nextslide:: + +.. warning:: + + The "basic" (purely numeric except for ``T``) and "extended" (written with + hyphens and colons) formats cannot be mixed. For example the following + date-times are invalid: + + .. code-block:: none + + 2000-01-01T0000 + 20000101T00:00 + +.. _tutorial-iso8601-durations: + +ISO8601 Durations +^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + In ISO8601, durations are prefixed with a ``P`` and are written with a + character following each unit: + +* ``Y`` for year. +* ``M`` for month. +* ``D`` for day. +* ``W`` for week. +* ``H`` for hour. +* ``M`` for minute. +* ``S`` for second. + +.. nextslide:: + +.. ifnotslides:: + + As with datetimes the components are written in order from largest to + smallest and the date and time components are separated by the ``T`` + character. E.G: + +* ``P1D``: one day. +* ``PT1H``: one hour. +* ``P1DT1H``: one day and one hour. +* ``PT1H30M``: one and a half hours. +* ``P1Y1M1DT1H1M1S``: a year and a month and a day and an hour and a + minute and a second. + + +Date-Time Recurrences +--------------------- + +In :term:`integer cycling`, suites' recurrences are written ``P1``, ``P2``, +etc. + +In :term:`date-time cycling ` there are two ways to write +recurrences: + +1. Using ISO8601 durations (e.g. ``P1D``, ``PT1H``). +2. Using ISO8601 date-times with inferred recurrence. + +Inferred Recurrence +^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + A recurrence can be inferred from a date-time by omitting digits from the + front. For example, if the year is omitted then the recurrence can be + inferred to be annual. E.G: + +.. code-block:: sub + + 2000-01-01T00 # Datetime - midnight on the 1st of January 2000. + + 01-01T00 # Every year on the 1st of January. + 01T00 # Every month on the first of the month. + T00 # Every day at midnight. + T-00 # Every hour at zero minutes past (every hour on the hour). + +.. note:: + + To omit hours from a date time we must place a ``-`` after the + ``T`` character. + +Recurrence Formats +^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + As with integer cycling, recurrences start, by default, at the + :term:`initial cycle point`. We can override this in one of two ways: + +1. By defining an arbitrary cycle point (``datetime/recurrence``): + + * ``2000/P1Y``: every year starting with the year 2000. + * ``2000-01-01T00/T00``: every day at midnight starting on the 1st of January + 2000 + * ``2000-01-01T12/T00``: every day at midnight starting on the first midnight + after the 1st of January at 12:00 (i.e. ``2000-01-02T00``). + +.. nextslide:: + +.. _tutorial-cylc-datetime-offset-icp: + +2. By defining an offset from the initial cycle point (``offset/recurrence``). + This offset is an ISO8601 duration preceded by a plus character: + + * ``+P1Y/P1Y``: every year starting one year after the initial cycle point. + * ``+PT1H/T00``: every day starting on the first midnight after the point one + hour after the initial cycle point. + +Durations And The Initial Cycle Point +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +When using durations, beware that a change in the initial cycle point +might produce different results for the recurrences. + +.. nextslide:: + +.. list-table:: + :class: grid-table + + * - .. code-block:: cylc + :emphasize-lines: 2 + + [scheduling] + initial cycle point = 2000-01-01T00 + [[dependencies]] + [[[P1D]]] + graph = foo[-P1D] => foo + + - .. code-block:: cylc + :emphasize-lines: 2 + + [scheduling] + initial cycle point = 2000-01-01T12 + [[dependencies]] + [[[P1D]]] + graph = foo[-P1D] => foo + + * - .. digraph:: Example + :align: center + + size = "3,3" + + "foo.1" [label="foo\n2000-01-01T00"] + "foo.2" [label="foo\n2000-01-02T00"] + "foo.3" [label="foo\n2000-01-03T00"] + + "foo.1" -> "foo.2" -> "foo.3" + + - .. digraph:: Example + :align: center + + size = "3,3" + + "foo.1" [label="foo\n2000-01-01T12"] + "foo.2" [label="foo\n2000-01-02T12"] + "foo.3" [label="foo\n2000-01-03T12"] + + "foo.1" -> "foo.2" -> "foo.3" + +.. nextslide:: + +We could write the recurrence "every midnight" independent from the initial +cycle point by: + +* Use an `inferred recurrence`_ instead (i.e. ``T00``). +* Overriding the recurrence start point (i.e. ``T00/P1D``) +* Using the ``[scheduling]initial cycle point constraints`` setting to + constrain the initial cycle point (e.g. to a particular time of day). See + the `Cylc User Guide`_ for details. + +The Initial & Final Cycle Points +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + There are two special recurrences for the initial and final cycle points: + +* ``R1``: repeat once at the initial cycle point. +* ``R1/P0Y``: repeat once at the final cycle point. + +.. TODO - change terminology as done in the cylc user guide, "repeat" can be + confusing. Use occur? + +Inter-Cycle Dependencies +^^^^^^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + Inter-cycle dependencies are written as ISO8601 durations, e.g: + +* ``foo[-P1D]``: the task ``foo`` from the cycle one day before. +* ``bar[-PT1H30M]``: the task ``bar`` from the cycle 1 hour 30 minutes before. + +.. ifnotslides:: + + The initial cycle point can be referenced using a caret character ``^``, e.g: + +* ``baz[^]``: the task ``baz`` from the initial cycle point. + + +.. _tutorial-cylc-datetime-utc: + +UTC Mode +-------- + +.. ifnotslides:: + + Due to all of the difficulties caused by time zones, particularly with + respect to daylight savings, we typically use UTC (that's the ``+00`` time + zone) in Cylc suites. + + When a suite uses UTC all of the cycle points will be written in the + ``+00`` time zone. + + To make your suite use UTC set the ``[cylc]UTC mode`` setting to ``True``, + i.e: + +.. code-block:: cylc + + [cylc] + UTC mode = True + + +.. _tutorial-datetime-cycling-practical: + +Putting It All Together +----------------------- + +.. ifslides:: + + We will now develop a simple weather forecasting suite. + +.. ifnotslides:: + + Cylc was originally developed for running operational weather forecasting. In + this section we will outline a basic (dummy) weather-forecasting suite and + explain how to implement it in cylc. + + .. note:: + + Technically the suite outlined in this section is a `nowcasting`_ suite. + We will refer to it as forecasting for simplicity. + + A basic weather-forecasting workflow consists of three main steps: + +1. Gathering Observations +^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + We gather observations from different weather stations and use them to + build a picture of the current weather. Our dummy weather forecast + will get wind observations from four weather stations: + + * Belmullet + * Camborne + * Heathrow + * Shetland + + The tasks which retrieve observation data will be called + ``get_observations_`` where ``site`` is the name of the weather + station in question. + + Next we need to consolidate these observations so that our forecasting + system can work with them. To do this we have a + ``consolidate_observations`` task. + + We will fetch wind observations **every three hours starting from the initial + cycle point**. + + The ``consolidate_observations`` task must run after the + ``get_observations`` tasks. + +.. digraph:: example + :align: center + + size = "7,4" + + get_observations_belmullet -> consolidate_observations + get_observations_camborne -> consolidate_observations + get_observations_heathrow -> consolidate_observations + get_observations_shetland -> consolidate_observations + + hidden [style="invis"] + get_observations_belmullet -> hidden [style="invis"] + get_observations_camborne -> hidden [style="invis"] + hidden -> consolidate_observations [style="invis"] + +.. ifnotslides:: + + We will also use the UK radar network to get rainfall data with a task + called ``get_rainfall``. + + We will fetch rainfall data **every six hours starting six hours after the + initial cycle point**. + +2. Running computer models to generate forecast data +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + We will do this with a task called ``forecast`` which will run + **every six hours starting six hours after the initial cycle point**. + The ``forecast`` task will be dependent on: + + * The ``consolidate_observations`` task from the previous two cycles as well + as from the present cycle. + * The ``get_rainfall`` task from the present cycle. + +.. digraph:: example + :align: center + + size = "7,4" + + subgraph cluster_T00 { + label="+PT0H" + style="dashed" + "observations.t00" [label="consolidate observations\n+PT0H"] + } + + subgraph cluster_T03 { + label="+PT3H" + style="dashed" + "observations.t03" [label="consolidate observations\n+PT3H"] + } + + subgraph cluster_T06 { + label="+PT6H" + style="dashed" + "forecast.t06" [label="forecast\n+PT6H"] + "get_rainfall.t06" [label="get_rainfall\n+PT6H"] + "observations.t06" [label="consolidate observations\n+PT6H"] + } + + "observations.t00" -> "forecast.t06" + "observations.t03" -> "forecast.t06" + "observations.t06" -> "forecast.t06" + "get_rainfall.t06" -> "forecast.t06" + +3. Processing the data output to produce user-friendly forecasts +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. ifnotslides:: + + This will be done with a task called ``post_process_`` where + ``location`` is the place we want to generate the forecast for. For + the moment we will use Exeter. + + The ``post_process_exeter`` task will run **every six hours starting six + hours after the initial cycle point** and will be dependent on the + ``forecast`` task. + +.. digraph:: example + :align: center + + size = "2.5,2" + + "forecast" -> "post_process_exeter" + +.. nextslide:: + +.. ifslides:: + + .. rubric:: Next Steps + + 1. Read through the "Putting It All Together" section. + 2. Complete the practical. + + Next section: :ref:`tutorial-cylc-further-scheduling` + + +.. _datetime cycling practical: + +.. practical:: + + .. rubric:: In this practical we will create a dummy forecasting suite + using date-time cycling. + + #. **Create A New Suite.** + + Within your ``~/cylc-run`` directory create a new directory called + ``datetime-cycling`` and move into it: + + .. code-block:: bash + + mkdir ~/cylc-run/datetime-cycling + cd ~/cylc-run/datetime-cycling + + Create a ``suite.rc`` file and paste the following code into it: + + .. code-block:: cylc + + [cylc] + UTC mode = True + [scheduling] + initial cycle point = 20000101T00Z + [[dependencies]] + + #. **Add The Recurrences.** + + The weather-forecasting suite will require two + recurrences. Add sections under the dependencies section for these, + based on the information given above. + + .. hint:: + + See :ref:`Date-Time Recurrences`. + + .. spoiler:: Solution warning + + The two recurrences you need are + + * ``PT3H``: repeat every three hours starting from the initial cycle + point. + * ``+PT6H/PT6H``: repeat every six hours starting six hours after the + initial cycle point. + + .. code-block:: diff + + [cylc] + UTC mode = True + [scheduling] + initial cycle point = 20000101T00Z + [[dependencies]] + + [[[PT3H]]] + + [[[+PT6H/PT6H]]] + + #. **Write The Graphing.** + + With the help of the graphs and the information above add dependencies to + your suite to implement the weather-forecasting workflow. + + You will need to consider the inter-cycle dependencies between tasks. + + Use ``cylc graph`` to inspect your work. + + .. spoiler:: Hint hint + + The dependencies you will need to formulate are as follows: + + * The ``consolidate_observations`` task is dependent on the + ``get_observations_`` tasks. + * The ``forecast`` task is dependent on: + + * the ``get_rainfall`` task; + * the ``consolidate_observations`` tasks from: + + * the same cycle; + * the cycle 3 hours before (``-PT3H``); + * the cycle 6 hours before (``-PT6H``). + + * The ``post_process_exeter`` task is dependent on the ``forecast`` + task. + + To launch ``cylc graph`` run the command: + + .. code-block:: sub + + cylc graph + + .. spoiler:: Solution warning + + .. code-block:: cylc + + [cylc] + UTC mode = True + [scheduling] + initial cycle point = 20000101T00Z + [[dependencies]] + [[[PT3H]]] + graph = """ + get_observations_belmullet => consolidate_observations + get_observations_camborne => consolidate_observations + get_observations_heathrow => consolidate_observations + get_observations_shetland => consolidate_observations + """ + [[[+PT6H/PT6H]]] + graph = """ + consolidate_observations => forecast + consolidate_observations[-PT3H] => forecast + consolidate_observations[-PT6H] => forecast + get_rainfall => forecast => post_process_exeter + """ + + #. **Inter-Cycle Offsets.** + + To ensure the ``forecast`` tasks for different cycles run in order the + ``forecast`` task will also need to be dependent on the previous run + of ``forecast``. + + .. digraph:: example + :align: center + + size = "4,1.5" + rankdir=LR + + subgraph cluster_T06 { + label="T06" + style="dashed" + "forecast.t06" [label="forecast\nT06"] + } + + subgraph cluster_T12 { + label="T12" + style="dashed" + "forecast.t12" [label="forecast\nT12"] + } + + subgraph cluster_T18 { + label="T18" + style="dashed" + "forecast.t18" [label="forecast\nT18"] + } + + "forecast.t06" -> "forecast.t12" -> "forecast.t18" + + We can express this dependency as ``forecast[-PT6H] => forecast``. + + Try adding this line to your suite then visualising it with ``cylc + graph``. + + .. hint:: + + Try adjusting the number of cycles displayed by ``cylc graph``: + + .. code-block:: console + + $ cylc graph . 2000 20000101T12Z & + + You will notice that there is a dependency which looks like this: + + .. digraph:: example + :align: center + + size = "4,1" + rankdir=LR + + "forecast.t00" [label="forecast\n20000101T0000Z" + color="#888888" + fontcolor="#888888"] + "forecast.t06" [label="forecast\n20000101T0600Z"] + + + "forecast.t00" -> "forecast.t06" + + Note in particular that the ``forecast`` task in the 00:00 cycle is + grey. The reason for this is that this task does not exist. Remember + the forecast task runs every six hours + **starting 6 hours after the initial cycle point**, so the + dependency is only valid from 12:00 onwards. To fix the problem we + must add a new dependency section which repeats every six hours + **starting 12 hours after the initial cycle point**. + + Make the following changes to your suite and the grey task should + disappear: + + .. code-block:: diff + + [[[+PT6H/PT6H]]] + graph = """ + ... + - forecast[-PT6H] => forecast + """ + + [[[+PT12H/PT6H]]] + + graph = """ + + forecast[-PT6H] => forecast + + """ diff --git a/src/tutorial/scheduling/further-scheduling.rst b/src/tutorial/scheduling/further-scheduling.rst new file mode 100644 index 0000000000..fe1071618b --- /dev/null +++ b/src/tutorial/scheduling/further-scheduling.rst @@ -0,0 +1,107 @@ +.. include:: ../../../hyperlinks.rst + :start-line: 1 + +.. _tutorial-cylc-further-scheduling: + +Further Scheduling +================== + +In this section we will quickly run through some of the more advanced features +of Cylc's scheduling logic. + + +.. _tutorial-qualifiers: + +Qualifiers +---------- + +.. ifnotslides:: + + So far we have written dependencies like ``foo => bar``. This is, in fact, + shorthand for ``foo:succeed => bar``. It means that the task ``bar`` will run + once ``foo`` has finished successfully. If ``foo`` were to fail then ``bar`` + would not run. We will talk more about these :term:`task states ` + in the `Runtime Section `_. + + We refer to the ``:succeed`` descriptor as a :term:`qualifier`. + There are qualifiers for different :term:`task states ` e.g: + +.. ifslides:: + + .. code-block:: cylc-graph + + foo => bar + foo:succeed => bar + foo:fail => bar + +``:start`` + When the task has started running. +``:fail`` + When the task finishes if it fails (produces non-zero return code). +``:finish`` + When the task has completed (either succeeded or failed). + +.. nextslide:: + +It is also possible to create your own custom :term:`qualifiers ` +to handle events within your code (custom outputs). + +.. ifnotslides:: + + *For more information see the* `Cylc User Guide`_. + + +Clock Triggers +-------------- + +.. ifnotslides:: + + In Cylc, :term:`cycle points ` are just labels. Tasks are + triggered when their dependencies are met irrespective of the cycle they are + in, but we can force cycles to wait for a particular time before running + using clock triggers. This is necessary for certain operational and + monitoring systems. + + For example in the following suite the cycle ``2000-01-01T12Z`` will wait + until 11:00 on the 1st of January 2000 before running: + +.. code-block:: cylc + + [scheduling] + initial cycle point = 2000-01-01T00Z + [[special tasks]] + clock-trigger = daily(-PT1H) + [[dependencies]] + [[[T12]]] + graph = daily # "daily" will run, at the earliest, one hour + # before midday. + +.. tip:: + + See the :ref:`tutorial-cylc-clock-trigger` tutorial for more information. + + +Alternative Calendars +--------------------- + +.. ifnotslides:: + + By default Cylc uses the Gregorian calendar for :term:`datetime cycling`, + but Cylc also supports the 360-day calendar (12 months of 30 days each in + a year). + +.. code-block:: cylc + + [scheduling] + cycling mode = 360day + +.. ifnotslides:: + + *For more information see the* `Cylc User Guide`_. + +.. nextslide:: + +.. ifslides:: + + Next section: :ref:`Runtime Introduction + ` diff --git a/src/tutorial/scheduling/graphing.rst b/src/tutorial/scheduling/graphing.rst new file mode 100644 index 0000000000..87816438a6 --- /dev/null +++ b/src/tutorial/scheduling/graphing.rst @@ -0,0 +1,408 @@ +.. include:: ../../../hyperlinks.rst + + +.. _tutorial-cylc-graphing: + +Graphing +======== + +In this section we will cover writing basic workflows in cylc. + + +.. _Cylc file format: + +The ``suite.rc`` File Format +---------------------------- + +.. ifnotslides:: + + We refer to a Cylc workflow as a :term:`Cylc suite`. A Cylc suite is a + directory containing a ``suite.rc`` file. This configuration file is where + we define our workflow. The ``suite.rc`` file uses a nested `INI`_-based + format: + +.. ifslides:: + + * Cylc workflow == Cylc suite + * Cylc suite is a directory containing a ``suite.rc`` file + * The ``suite.rc`` file is written in a nested `INI`_-based format + +.. ifnotslides:: + + * Comments start with a ``#`` character. + * Settings are written as ``key = value`` pairs. + * Settings can be contained within sections. + * Sections are written inside square brackets i.e. ``[section-name]``. + * Sections can be nested, by adding an extra square bracket with each level, + so a sub-section would be written ``[[sub-section]]``, a sub-sub-section + ``[[[sub-sub-section]]]``, and so on. + +Example +^^^^^^^ + +.. code-block:: cylc + + # Comment + [section] + key = value + [[sub-section]] + another-key = another-value # Inline comment + yet-another-key = """ + A + Multi-line + String + """ + +Shorthand +^^^^^^^^^ + +Throughout this tutorial we will refer to settings in the following format: + +``[section]`` + Refers to the entire section. +``[section]key`` + Refers to a setting within the section. +``[section]key=value`` + Expresses the value of the setting. +``[section][sub-section]another-key`` + Note we only use one set of square brackets with nested sections. + +Duplicate Items +^^^^^^^^^^^^^^^ + +Duplicate sections get merged: + +.. list-table:: + :class: grid-table + + * - + .. code-block:: cylc + :caption: input + + [a] + c = C + [b] + d = D + [a] # duplicate + e = E + + - + .. code-block:: cylc + :caption: result + + [a] + c = C + e = E + [b] + d = D + +.. nextslide:: + +Duplicate settings get overwritten: + +.. list-table:: + :class: grid-table + + * - + .. code-block:: cylc + :caption: input + + a = foo + a = bar # duplicate + + - + .. code-block:: cylc + :caption: result + + a = bar + +Indentation +^^^^^^^^^^^ + +It is advisable to indent ``suite.rc`` files. + +However, Cylc ignores this indentation meaning the following two examples +are equivalent: + +.. list-table:: + :class: grid-table + + * - + .. code-block:: cylc + :caption: input + + [section] + a = A + [[sub-section]] + b = B + b = C + # this setting is still + # in [[sub-section]] + + + - + .. code-block:: cylc + :caption: result + + [section] + a = A + [[sub-section]] + b = C + + +Graph Strings +------------- + +In Cylc we consider workflows in terms of :term:`tasks ` and +:term:`dependencies `. + +.. ifnotslides:: + + Task are represented as words and dependencies as arrows (``=>``), so the + following text defines two tasks where ``make_dough`` is dependent on + ``purchase_ingredients``: + +.. minicylc:: + :align: center + :snippet: + :theme: demo + + purchase_ingredients => make_dough + +.. nextslide:: + +.. ifnotslides:: + + In a Cylc workflow this would mean that ``make_dough`` would only run when + ``purchase_ingredients`` has succeeded. These :term:`dependencies + ` can be chained together: + +.. minicylc:: + :align: center + :snippet: + :theme: demo + + purchase_ingredients => make_dough => bake_bread => sell_bread + +.. nextslide:: + +.. ifnotslides:: + + This line of text is referred to as a :term:`graph string`. These graph + strings can be combined to form more complex workflows: + +.. minicylc:: + :align: center + :snippet: + :theme: demo + + purchase_ingredients => make_dough => bake_bread => sell_bread + pre_heat_oven => bake_bread + bake_bread => clean_oven + +.. nextslide:: + +.. ifnotslides:: + + Graph strings can also contain "and" (``&``) and "or" (``|``) operators, for + instance the following lines are equivalent to the ones just above: + +.. code-block:: cylc-graph + + purchase_ingredients => make_dough + pre_heat_oven & make_dough => bake_bread => sell_bread & clean_oven + +.. nextslide:: + +Collectively these :term:`graph strings` are referred to as a +:term:`graph`. + +.. admonition:: Note + :class: tip + + .. ifnotslides:: + + The order in which lines appear in the graph section doesn't matter, for + instance the following examples are the same as each other: + + .. code-block:: cylc-graph + + foo => bar + bar => baz + + .. code-block:: cylc-graph + + bar => baz + foo => bar + + +Cylc Graphs +----------- + +.. ifnotslides:: + + In a :term:`Cylc suite` the :term:`graph` is stored under the + ``[scheduling][dependencies]graph`` setting, i.e: + +.. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + purchase_ingredients => make_dough + pre_heat_oven & make_dough => bake_bread => sell_bread & clean_oven + """ + +.. nextslide:: + +.. ifnotslides:: + + This is a minimal :term:`Cylc suite`, in which we have defined a + :term:`graph` representing a workflow for Cylc to run. + We have not yet provided Cylc with the scripts or binaries to run for + each task. This will be covered later in the + :ref:`runtime tutorial `. + + Cylc provides a GUI for visualising :term:`graphs `. It is run on the + command line using the ``cylc graph `` command where the path ``path`` + is to the ``suite.rc`` file you wish to visualise. + + When run, ``cylc graph`` will display a diagram similar to the ones you have + seen so far. The number ``1`` which appears below each task is the + :term:`cycle point`. We will explain what this means in the next section. + +.. image:: ../img/cylc-graph.png + :align: center + +.. nextslide:: + +.. hint:: + + .. ifnotslides:: + + A graph can be drawn in multiple ways, for instance the following two + examples are equivalent: + + .. ifslides:: + + A graph can be drawn in multiple ways: + + .. image:: ../img/cylc-graph-reversible.svg + :align: center + + .. ifnotslides:: + + The graph drawn by ``cylc graph`` may vary slightly from one run to + another but the tasks and dependencies will always be the same. + +.. nextslide:: + +.. ifslides:: + + .. rubric:: In this practical we will create a new Cylc suite and write a + graph for it to use. + + Next session: :ref:`tutorial-integer-cycling` + +.. practical:: + + .. rubric:: In this practical we will create a new Cylc suite and write a + graph for it to use. + + #. **Create a Cylc suite.** + + A Cylc suite is just a directory containing a ``suite.rc`` file. + + If you don't have one already, create a ``cylc-run`` directory in your + user space i.e:: + + ~/cylc-run + + Within this directory create a new folder called ``graph-introduction``, + which is to be our :term:`suite directory`. Move into it: + + .. code-block:: bash + + mkdir ~/cylc-run/graph-introduction + cd ~/cylc-run/graph-introduction + + Inside this directory create a ``suite.rc`` file and paste in the + following text: + + .. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + # Write graph strings here! + """ + + #. **Write a graph.** + + We now have a blank Cylc suite, next we need to define a workflow. + + Edit your ``suite.rc`` file to add graph strings representing the + following graph: + + .. digraph:: graph_tutorial + :align: center + + foo -> bar -> baz -> qux + pub -> bar -> wop + + #. **Use** ``cylc graph`` **to visualise the workflow.** + + Once you have written some graph strings try using ``cylc graph`` to + display the workflow. Run the following command: + + .. code-block:: bash + + cylc graph . + + .. admonition:: Note + :class: hint + + ``cylc graph`` takes the path to the suite as an argument. As we are + inside the :term:`suite directory` we can run ``cylc graph .``. + + If the results don't match the diagram above try going back to the + suite.rc file and making changes. + + .. tip:: + + In the top right-hand corner of the ``cylc graph`` window there is a + refresh button which will reload the GUI with any changes you have + made. + + .. image:: ../img/cylc-graph-refresh.png + :align: center + + + .. spoiler:: Solution warning + + There are multiple correct ways to write this graph. So long as what + you see in ``cylc graph`` matches the above diagram then you have a + correct solution. + + Two valid examples: + + .. code-block:: cylc-graph + + foo & pub => bar => baz & wop + baz => qux + + .. code-block:: cylc-graph + + foo => bar => baz => qux + pub => bar => wop + + The whole suite should look something like this: + + .. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + foo & pub => bar => baz & wop + baz => qux + """ diff --git a/src/tutorial/scheduling/index.rst b/src/tutorial/scheduling/index.rst new file mode 100644 index 0000000000..f52df39fa2 --- /dev/null +++ b/src/tutorial/scheduling/index.rst @@ -0,0 +1,15 @@ +.. _tutorial-scheduling: + +Scheduling +========== + +This section looks at how to write workflows in cylc. + +.. toctree:: + :name: rug-scheduling-toc + :maxdepth: 2 + + graphing + integer-cycling + datetime-cycling + further-scheduling diff --git a/src/tutorial/scheduling/integer-cycling.rst b/src/tutorial/scheduling/integer-cycling.rst new file mode 100644 index 0000000000..db15986453 --- /dev/null +++ b/src/tutorial/scheduling/integer-cycling.rst @@ -0,0 +1,612 @@ +.. _tutorial-integer-cycling: + +Basic Cycling +============= + + +In this section we will look at how to write :term:`cycling` (repeating) +workflows. + + +Repeating Workflows +------------------- + +.. ifnotslides:: + + Often, we will want to repeat the same workflow multiple times. In Cylc this + "repetition" is called :term:`cycling` and each repetition of the workflow is + referred to as a :term:`cycle`. + + Each :term:`cycle` is given a unique label. This is called a + :term:`cycle point`. For now these :term:`cycle points` will be + integers *(they can also be dates as we will see in the next section)*. + +To make a workflow repeat we must tell Cylc three things: + +.. ifslides:: + + * :term:`recurrence` + * :term:`initial cycle point` + * :term:`final cycle point` + +.. ifnotslides:: + + The :term:`recurrence` + How often we want the workflow to repeat. + The :term:`initial cycle point` + At what cycle point we want to start the workflow. + The :term:`final cycle point` + *Optionally* we can also tell Cylc what cycle point we want to stop the + workflow. + +.. nextslide:: + +.. ifnotslides:: + + Let's take the bakery example from the previous section. Bread is + produced in batches so the bakery will repeat this workflow for each + batch of bread they bake. We can make this workflow repeat with the addition + of three lines: + +.. code-block:: diff + + [scheduling] + + cycling mode = integer + + initial cycle point = 1 + [[dependencies]] + + [[[P1]]] + graph = """ + purchase_ingredients => make_dough + pre_heat_oven & make_dough => bake_bread => sell_bread & clean_oven + """ + +.. nextslide:: + +.. ifnotslides:: + + * The ``cycling mode = integer`` setting tells Cylc that we want our + :term:`cycle points ` to be numbered. + * The ``initial cycle point = 1`` setting tells Cylc to start counting + from 1. + * ``P1`` is the :term:`recurrence`. The :term:`graph` within the ``[[[P1]]]`` + section will be repeated at each :term:`cycle point`. + + The first three :term:`cycles` would look like this, with the entire + workflow repeated at each cycle point: + +.. digraph:: example + :align: center + + size = "7,15" + + subgraph cluster_1 { + label = 1 + style = dashed + "pur.1" [label="purchase_ingredients\n1"] + "mak.1" [label="make_dough\n1"] + "bak.1" [label="bake_bread\n1"] + "sel.1" [label="sell_bread\n1"] + "cle.1" [label="clean_oven\n1"] + "pre.1" [label="pre_heat_oven\n1"] + } + + subgraph cluster_2 { + label = 2 + style = dashed + "pur.2" [label="purchase_ingredients\n2"] + "mak.2" [label="make_dough\n2"] + "bak.2" [label="bake_bread\n2"] + "sel.2" [label="sell_bread\n2"] + "cle.2" [label="clean_oven\n2"] + "pre.2" [label="pre_heat_oven\n2"] + } + + subgraph cluster_3 { + label = 3 + style = dashed + "pur.3" [label="purchase_ingredients\n3"] + "mak.3" [label="make_dough\n3"] + "bak.3" [label="bake_bread\n3"] + "sel.3" [label="sell_bread\n3"] + "cle.3" [label="clean_oven\n3"] + "pre.3" [label="pre_heat_oven\n3"] + } + + "pur.1" -> "mak.1" -> "bak.1" -> "sel.1" + "pre.1" -> "bak.1" -> "cle.1" + "pur.2" -> "mak.2" -> "bak.2" -> "sel.2" + "pre.2" -> "bak.2" -> "cle.2" + "pur.3" -> "mak.3" -> "bak.3" -> "sel.3" + "pre.3" -> "bak.3" -> "cle.3" + +.. ifnotslides:: + + Note the numbers under each task which represent the :term:`cycle point` each + task is in. + + +Inter-Cycle Dependencies +------------------------ + +.. ifnotslides:: + + We've just seen how to write a workflow that repeats every :term:`cycle`. + + Cylc runs tasks as soon as their dependencies are met so cycles are not + necessarily run in order. This could cause problems, for instance we could + find ourselves pre-heating the oven in one cycle whist we are still + cleaning it in another. + + To resolve this we must add :term:`dependencies` *between* the + cycles. We do this by adding lines to the :term:`graph`. Tasks in the + previous cycle can be referred to by suffixing their name with ``[-P1]``, + for example. So to ensure the ``clean_oven`` task has been completed before + the start of the ``pre_heat_oven`` task in the next cycle, we would write + the following dependency: + + .. code-block:: cylc-graph + + clean_oven[-P1] => pre_heat_oven + + This dependency can be added to the suite by adding it to the other graph + lines: + +.. code-block:: diff + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] + graph = """ + purchase_ingredients => make_dough + pre_heat_oven & make_dough => bake_bread => sell_bread & clean_oven + + clean_oven[-P1] => pre_heat_oven + """ + +.. nextslide:: + +.. ifnotslides:: + + The resulting suite would look like this: + +.. digraph:: example + :align: center + + size = "7,15" + + subgraph cluster_1 { + label = 1 + style = dashed + "pur.1" [label="purchase_ingredients\n1"] + "mak.1" [label="make_dough\n1"] + "bak.1" [label="bake_bread\n1"] + "sel.1" [label="sell_bread\n1"] + "cle.1" [label="clean_oven\n1"] + "pre.1" [label="pre_heat_oven\n1"] + } + + subgraph cluster_2 { + label = 2 + style = dashed + "pur.2" [label="purchase_ingredients\n2"] + "mak.2" [label="make_dough\n2"] + "bak.2" [label="bake_bread\n2"] + "sel.2" [label="sell_bread\n2"] + "cle.2" [label="clean_oven\n2"] + "pre.2" [label="pre_heat_oven\n2"] + } + + subgraph cluster_3 { + label = 3 + style = dashed + "pur.3" [label="purchase_ingredients\n3"] + "mak.3" [label="make_dough\n3"] + "bak.3" [label="bake_bread\n3"] + "sel.3" [label="sell_bread\n3"] + "cle.3" [label="clean_oven\n3"] + "pre.3" [label="pre_heat_oven\n3"] + } + + "pur.1" -> "mak.1" -> "bak.1" -> "sel.1" + "pre.1" -> "bak.1" -> "cle.1" + "cle.1" -> "pre.2" + "pur.2" -> "mak.2" -> "bak.2" -> "sel.2" + "pre.2" -> "bak.2" -> "cle.2" + "cle.2" -> "pre.3" + "pur.3" -> "mak.3" -> "bak.3" -> "sel.3" + "pre.3" -> "bak.3" -> "cle.3" + +.. nextslide:: + +.. ifnotslides:: + + Adding this dependency "strings together" the cycles, forcing them to run in + order. We refer to dependencies between cycles as + :term:`inter-cycle dependencies`. + + In the dependency the ``[-P1]`` suffix tells Cylc that we are referring to a + task in the previous cycle. Equally ``[-P2]`` would refer to a task two + cycles ago. + + Note that the ``purchase_ingredients`` task has no arrows pointing at it + meaning that it has no dependencies. Consequently the ``purchase_ingredients`` + tasks will all run straight away. This could cause our bakery to run into + cash-flow problems as they would be purchasing ingredients well in advance + of using them. + + To solve this, but still make sure that they never run out of + ingredients, the bakery wants to purchase ingredients two batches ahead. + This can be achieved by adding the following dependency: + +.. ifslides:: + + We need ``purchase_ingredients`` to be dependent on ``sell_bread`` from + two cycles before. + +.. nextslide:: + +.. code-block:: diff + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] + graph = """ + purchase_ingredients => make_dough + pre_heat_oven & make_dough => bake_bread => sell_bread & clean_oven + clean_oven[-P1] => pre_heat_oven + + sell_bread[-P2] => purchase_ingredients + """ + +.. nextslide:: + +.. ifnotslides:: + + This dependency means that the ``purchase_ingredients`` task will run after + the ``sell_bread`` task two cycles before. + +.. note:: + + The ``[-P2]`` suffix is used to reference a task two cycles before. For the + first two cycles this doesn't make sense as there was no cycle two cycles + before, so this dependency will be ignored. + + Any inter-cycle dependencies stretching back to before the + :term:`initial cycle point` will be ignored. + +.. digraph:: example + :align: center + + size = "4.5,15" + + subgraph cluster_1 { + label = 1 + style = dashed + "pur.1" [label="purchase_ingredients\n1"] + "mak.1" [label="make_dough\n1"] + "bak.1" [label="bake_bread\n1"] + "sel.1" [label="sell_bread\n1"] + "cle.1" [label="clean_oven\n1"] + "pre.1" [label="pre_heat_oven\n1"] + } + + subgraph cluster_2 { + label = 2 + style = dashed + "pur.2" [label="purchase_ingredients\n2"] + "mak.2" [label="make_dough\n2"] + "bak.2" [label="bake_bread\n2"] + "sel.2" [label="sell_bread\n2"] + "cle.2" [label="clean_oven\n2"] + "pre.2" [label="pre_heat_oven\n2"] + } + + subgraph cluster_3 { + label = 3 + style = dashed + "pur.3" [label="purchase_ingredients\n3"] + "mak.3" [label="make_dough\n3"] + "bak.3" [label="bake_bread\n3"] + "sel.3" [label="sell_bread\n3"] + "cle.3" [label="clean_oven\n3"] + "pre.3" [label="pre_heat_oven\n3"] + } + + subgraph cluster_4 { + label = 4 + style = dashed + "pur.4" [label="purchase_ingredients\n4"] + "mak.4" [label="make_dough\n4"] + "bak.4" [label="bake_bread\n4"] + "sel.4" [label="sell_bread\n4"] + "cle.4" [label="clean_oven\n4"] + "pre.4" [label="pre_heat_oven\n4"] + } + + "pur.1" -> "mak.1" -> "bak.1" -> "sel.1" + "pre.1" -> "bak.1" -> "cle.1" + "cle.1" -> "pre.2" + "sel.1" -> "pur.3" + "pur.2" -> "mak.2" -> "bak.2" -> "sel.2" + "pre.2" -> "bak.2" -> "cle.2" + "cle.2" -> "pre.3" + "sel.2" -> "pur.4" + "pur.3" -> "mak.3" -> "bak.3" -> "sel.3" + "pre.3" -> "bak.3" -> "cle.3" + "cle.3" -> "pre.4" + "pur.4" -> "mak.4" -> "bak.4" -> "sel.4" + "pre.4" -> "bak.4" -> "cle.4" + + +Recurrence Sections +------------------- + +.. ifnotslides:: + + In the previous examples we made the workflow repeat by placing the graph + within the ``[[[P1]]]`` section. Here ``P1`` is a :term:`recurrence` meaning + repeat every cycle, where ``P1`` means every cycle, ``P2`` means every + *other* cycle, and so on. To build more complex workflows we can use multiple + recurrences: + +.. code-block:: cylc + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] # Repeat every cycle. + graph = foo + [[[P2]]] # Repeat every second cycle. + graph = bar + [[[P3]]] # Repeat every third cycle. + graph = baz + +.. digraph:: example + :align: center + + subgraph cluster_1 { + label = 1 + style = dashed + "foo.1" [label="foo\n1"] + "bar.1" [label="bar\n1"] + "baz.1" [label="baz\n1"] + } + + subgraph cluster_2 { + label = 2 + style = dashed + "foo.2" [label="foo\n2"] + } + + subgraph cluster_3 { + label = 3 + style = dashed + "foo.3" [label="foo\n3"] + "bar.3" [label="bar\n3"] + } + +.. nextslide:: + +.. ifnotslides:: + + By default recurrences start at the :term:`initial cycle point`, however it + is possible to make them start at an arbitrary cycle point. This is done by + writing the cycle point and the recurrence separated by a forward slash + (``/``), e.g. ``5/P3`` means repeat every third cycle starting *from* cycle + number 5. + + The start point of a recurrence can also be defined as an offset from the + :term:`initial cycle point`, e.g. ``+P5/P3`` means repeat every third cycle + starting 5 cycles *after* the initial cycle point. + +.. ifslides:: + + ``5/P3`` + Repeat every third cycle starting *from* cycle number 5. + ``+P5/P3`` + Repeat every third cycle starting 5 cycles *after* the initial cycle + point. + + .. nextslide:: + + .. rubric:: In this practical we will take the :term:`suite ` + we wrote in the previous section and turn it into a + :term:`cycling suite `. + + Next section: :ref:`tutorial-datetime-cycling` + +.. _basic cycling practical: + +.. practical:: + + .. rubric:: In this practical we will take the :term:`suite ` + we wrote in the previous section and turn it into a + :term:`cycling suite `. + + If you have not completed the previous practical use the following code for + your ``suite.rc`` file. + + .. code-block:: cylc + + [scheduling] + [[dependencies]] + graph = """ + foo & pub => bar => baz & wop + baz => qux + """ + + #. **Create a new suite.** + + Within your ``~/cylc-run/`` directory create a new (sub-)directory called + ``integer-cycling`` and move into it: + + .. code-block:: bash + + mkdir -p ~/cylc-run/integer-cycling + cd ~/cylc-run/integer-cycling + + Copy the above code into a ``suite.rc`` file in that directory. + + #. **Make the suite cycle.** + + Add in the following lines. + + .. code-block:: diff + + [scheduling] + + cycling mode = integer + + initial cycle point = 1 + [[dependencies]] + + [[[P1]]] + graph = """ + foo & pub => bar => baz & wop + baz => qux + """ + + #. **Visualise the suite.** + + Try visualising the suite using ``cylc graph``. + + .. code-block:: none + + cylc graph . + + .. tip:: + + You can get Cylc graph to draw dotted boxes around the cycles by + clicking the "Organise by cycle point" button on the toolbar: + + .. image:: ../img/cylc-graph-cluster.png + :align: center + + .. tip:: + + By default ``cylc graph`` displays the first three cycles of a suite. + You can tell ``cylc graph`` to visualise the cycles between two points + by providing them as arguments, for instance the following example + would show all cycles between ``1`` and ``5`` (inclusive):: + + cylc graph . 1 5 & + + #. **Add another recurrence.** + + Suppose we wanted the ``qux`` task to run every *other* cycle as opposed + to every cycle. We can do this by adding another recurrence. + + Make the following changes to your ``suite.rc`` file. + + .. code-block:: diff + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] + graph = """ + foo & pub => bar => baz & wop + - baz => qux + """ + + [[[P2]]] + + graph = """ + + baz => qux + + """ + + Use ``cylc graph`` to see the effect this has on the workflow. + + #. **Inter-cycle dependencies.** + + Next we need to add some inter-cycle dependencies. We are going to add + three inter-cycle dependencies: + + #. Between ``wop`` from the previous cycle and ``pub``. + #. Between ``baz`` from the previous cycle and ``foo`` + *every odd cycle* (e.g. baz.2 => foo.3). + #. Between ``qux`` from the previous cycle and ``foo`` + *every even cycle* (e.g. qux.1 => foo.2). + + Have a go at adding inter-cycle dependencies to your ``suite.rc`` file to + make your workflow match the diagram below. + + .. hint:: + + * ``P2`` means every odd cycle. + * ``2/P2`` means every even cycle. + + .. digraph:: example + :align: center + + size = "4.5,7" + + subgraph cluster_1 { + label = 1 + style = dashed + "foo.1" [label="foo\n1"] + "bar.1" [label="bar\n1"] + "baz.1" [label="baz\n1"] + "wop.1" [label="wop\n1"] + "pub.1" [label="pub\n1"] + "qux.1" [label="qux\n1"] + } + + subgraph cluster_2 { + label = 2 + style = dashed + "foo.2" [label="foo\n2"] + "bar.2" [label="bar\n2"] + "baz.2" [label="baz\n2"] + "wop.2" [label="wop\n2"] + "pub.2" [label="pub\n2"] + } + + subgraph cluster_3 { + label = 3 + style = dashed + "foo.3" [label="foo\n3"] + "bar.3" [label="bar\n3"] + "baz.3" [label="baz\n3"] + "wop.3" [label="wop\n3"] + "pub.3" [label="pub\n3"] + "qux.3" [label="qux\n3"] + } + + "foo.1" -> "bar.1" -> "wop.1" + "bar.1" -> "baz.1" + "pub.1" -> "bar.1" + "foo.2" -> "bar.2" -> "wop.2" + "bar.2" -> "baz.2" + "pub.2" -> "bar.2" + "foo.3" -> "bar.3" -> "wop.3" + "bar.3" -> "baz.3" + "pub.3" -> "bar.3" + "baz.1" -> "qux.1" -> "foo.2" + "baz.3" -> "qux.3" + "baz.2" -> "foo.3" + "wop.1" -> "pub.2" + "wop.2" -> "pub.3" + + .. spoiler:: Solution warning + + .. code-block:: cylc + + + [scheduling] + cycling mode = integer + initial cycle point = 1 + [[dependencies]] + [[[P1]]] + graph = """ + foo & pub => bar => baz & wop + wop[-P1] => pub # (1) + """ + [[[P2]]] + graph = """ + baz => qux + baz[-P1] => foo # (2) + """ + [[[2/P2]]] + graph = """ + qux[-P1] => foo # (3) + """ From 5d8891d29f1d6f08deb8af50a37c8e9ac97157f4 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 12:51:21 +0100 Subject: [PATCH 04/22] copy glossary from rose documentation --- src/glossary.rst | 884 ++++++++++++++++++++++++++++++++++++++++++++ src/index.rst | 2 +- src/terminology.rst | 28 -- 3 files changed, 885 insertions(+), 29 deletions(-) create mode 100644 src/glossary.rst delete mode 100644 src/terminology.rst diff --git a/src/glossary.rst b/src/glossary.rst new file mode 100644 index 0000000000..71ee9cfa5a --- /dev/null +++ b/src/glossary.rst @@ -0,0 +1,884 @@ +.. include:: hyperlinks.rst + :start-line: 1 + +Glossary +======== + +.. glossary:: + :sorted: + + suite + Cylc suite + A Cylc suite is a directory containing a ``suite.rc`` file which contains + :term:`graphing` representing a workflow. + + See also: + + * :ref:`Relationship between Cylc suites, Rose suite configurations and + Rosie suites ` + + + suite directory + The suite directory contains all of the configuration for a suite (e.g. + the ``suite.rc`` file and for Rose suites the :rose:file:`rose-suite.conf` + file). + + This is the directory which is registered using ``cylc reg`` or, for Rose + suites, it is the one in which the :ref:`command-rose-suite-run` command + is executed. + + .. note:: + + If a suite is written in the ``cylc-run`` directory the suite + directory is also the :term:`run directory`. + + See also: + + * :term:`run directory` + * :ref:`Rose suite installation diagram + ` + + graph + The graph of a :term:`suite` refers to the + :term:`graph strings` contained within the + ``[scheduling][dependencies]`` section. For example the following is, + collectively, a graph: + + .. code-block:: cylc + + [P1D] + graph = foo => bar + [PT12H] + graph = baz + + .. digraph:: example + :align: center + + size = "7,15" + + subgraph cluster_1 { + label = "2000-01-01T00:00Z" + style = dashed + "foo.01T00" [label="foo\n2000-01-01T00:00Z"] + "bar.01T00" [label="bar\n2000-01-01T00:00Z"] + "baz.01T00" [label="baz\n2000-01-01T00:00Z"] + } + + subgraph cluster_2 { + label = "2000-01-01T12:00Z" + style = dashed + "baz.01T12" [label="baz\n2000-01-01T12:00Z"] + } + + subgraph cluster_3 { + label = "2000-01-02T00:00Z" + style = dashed + "foo.02T00" [label="foo\n2000-01-02T00:00Z"] + "bar.02T00" [label="bar\n2000-01-02T00:00Z"] + "baz.02T00" [label="baz\n2000-01-02T00:00Z"] + } + + "foo.01T00" -> "bar.01T00" + "foo.02T00" -> "bar.02T00" + + graph string + A graph string is a collection of dependencies which are placed under a + ``graph`` section in the ``suite.rc`` file. E.G: + + .. code-block:: cylc-graph + + foo => bar => baz & pub => qux + pub => bool + + dependency + A dependency is a relationship between two :term:`tasks` which + describes a constraint on one. + + For example the dependency + ``foo => bar`` means that the :term:`task` ``bar`` is *dependent* on the + task ``foo``. This means that the task ``bar`` will only run once the + task ``foo`` has successfully completed. + + See also: + + * :term:`task trigger` + + task trigger + :term:`Dependency ` relationships can be thought of the other + way around as "triggers". + + For example the dependency ``foo => bar`` could be described in two ways: + + * "``bar`` is dependent on ``foo``" + * "``foo`` is triggered by ``bar``" + + In practice a trigger is the left-hand side of a dependency (``foo`` in + this example). + + See also: + + * :term:`dependency` + * :term:`qualifier` + * :term:`family trigger` + + cycle + In a :term:`cycling suite` one cycle is one repetition of the + workflow. + + For example, in the following workflow each dotted box represents a cycle + and the :term:`tasks` within it are the :term:`tasks` + belonging to that cycle. The numbers (i.e. ``1``, ``2``, ``3``) are the + :term:`cycle points`. + + .. digraph:: example + :align: center + + size = "3,5" + + subgraph cluster_1 { + label = "1" + style = dashed + "foo.1" [label="foo\n1"] + "bar.1" [label="bar\n1"] + "baz.1" [label="baz\n1"] + } + + subgraph cluster_2 { + label = "2" + style = dashed + "foo.2" [label="foo\n2"] + "bar.2" [label="bar\n2"] + "baz.2" [label="baz\n2"] + } + + subgraph cluster_3 { + label = "3" + style = dashed + "foo.3" [label="foo\n3"] + "bar.3" [label="bar\n3"] + "baz.3" [label="baz\n3"] + } + + "foo.1" -> "bar.1" -> "baz.1" + "foo.2" -> "bar.2" -> "baz.2" + "foo.3" -> "bar.3" -> "baz.3" + "bar.1" -> "bar.2" -> "bar.3" + + cycling + A cycling :term:`suite` is one in which the workflow repeats. + + See also: + + * :term:`cycle` + * :term:`cycle point` + + cycle point + A cycle point is the unique label given to a particular :term:`cycle`. + If the :term:`suite` is using :term:`integer cycling` then + the cycle points will be numbers e.g. ``1``, ``2``, ``3``, etc. If the + :term:`suite` is using :term:`datetime cycling` then the + labels will be :term:`ISO8601` datetimes e.g. ``2000-01-01T00:00Z``. + + See also: + + * :term:`initial cycle point` + * :term:`final cycle point` + + initial cycle point + In a :term:`cycling suite ` the initial cycle point is the point + from which cycling begins. + + If the initial cycle point were 2000 then the first cycle would + be on the 1st of January 2000. + + See also: + + * :term:`cycle point` + * :term:`final cycle point` + + final cycle point + In a :term:`cycling suite ` the final cycle point is the point + at which cycling ends. + + If the final cycle point were 2001 then the final cycle would be no later + than the 1st of January 2001. + + See also: + + * :term:`cycle point` + * :term:`initial cycle point` + + integer cycling + An integer cycling suite is a :term:`cycling suite` which has + been configured to use integer cycling. When a suite uses integer cycling + integer :term:`recurrences ` may be used in the :term:`graph`, + e.g. ``P3`` means every third cycle. This is configured by setting + ``[scheduling]cycling mode = integer`` in the ``suite.rc`` file. + + See also: + + * :ref:`Cylc tutorial ` + + datetime cycling + A datetime cycling is the default for a :term:`cycling suite`. + When using datetime cycling :term:`cycle points` will be + :term:`ISO8601 datetimes ` e.g. ``2000-01-01T00:00Z`` + and ISO8601 :term:`recurrences` can be used e.g. ``P3D`` + means every third day. + + See also: + + * :ref:`Cylc tutorial ` + + wall-clock time + In a Cylc suite the wall-clock time refers to the actual time (in the + real world). + + See also: + + * :term:`datetime cycling` + * :ref:`Clock Trigger Tutorial ` + + ISO8601 + ISO8601 is an international standard for writing dates and times which is + used in Cylc with :term:`datetime cycling`. + + See also: + + * :term:`ISO8601 datetime` + * :term:`recurrence` + * `Wikipedia (ISO8601) `_ + * `International Organisation For Standardisation + `_ + * `a summary of the international standard date and time notation + `_ + + ISO8601 datetime + A date-time written in the ISO8601 + format, e.g: + + * ``2000-01-01T00:00Z``: midnight on the 1st of January 2000 + + See also: + + * :ref:`Cylc tutorial ` + * :term:`ISO8601` + + ISO8601 duration + A duration written in the ISO8601 format e.g: + + * ``PT1H30M``: one hour and thirty minutes. + + See also: + + * :ref:`Cylc tutorial ` + * :term:`ISO8601` + + recurrence + A recurrence is a repeating sequence which may be used to define a + :term:`cycling suite`. Recurrences determine how often something + repeats and take one of two forms depending on whether the + :term:`suite` is configured to use :term:`integer cycling` + or :term:`datetime cycling`. + + See also: + + * :term:`integer cycling` + * :term:`datetime cycling` + + inter-cycle dependency + In a :term:`cycling suite ` an inter-cycle dependency + is a :term:`dependency` between two tasks in different cycles. + + For example in the following suite the task ``bar`` is dependent on + its previous occurrence: + + .. code-block:: cylc + + [scheduling] + initial cycle point = 1 + cycling mode = integer + [[dependencies]] + [[[P1]]] + graph = """ + foo => bar => baz + bar[-P1] => bar + """ + + .. digraph:: example + :align: center + + size = "3,5" + + subgraph cluster_1 { + label = "1" + style = dashed + "foo.1" [label="foo\n1"] + "bar.1" [label="bar\n1"] + "baz.1" [label="baz\n1"] + } + + subgraph cluster_2 { + label = "2" + style = dashed + "foo.2" [label="foo\n2"] + "bar.2" [label="bar\n2"] + "baz.2" [label="baz\n2"] + } + + subgraph cluster_3 { + label = "3" + style = dashed + "foo.3" [label="foo\n3"] + "bar.3" [label="bar\n3"] + "baz.3" [label="baz\n3"] + } + + "foo.1" -> "bar.1" -> "baz.1" + "foo.2" -> "bar.2" -> "baz.2" + "foo.3" -> "bar.3" -> "baz.3" + "bar.1" -> "bar.2" -> "bar.3" + + qualifier + A qualifier is used to determine the :term:`task state` to which a + :term:`dependency` relates. + + See also: + + * :ref:`Cylc tutorial ` + * :term:`task state` + + task + A task represents an activity in a workflow. It is a specification of + that activity consisting of the script or executable to run and certain + details of the environment it is run in. + + The task specification is used to create a :term:`job` which is executed + on behalf of the task. + + Tasks submit :term:`jobs ` and therefore each :term:`job` belongs + to one task. Each task can submit multiple :term:`jobs `. + + See also: + + * :term:`job` + * :term:`job script` + + task state + During a :term:`task's ` life it will proceed through various + states. These include: + + * waiting + * running + * succeeded + + See also: + + * :ref:`Cylc tutorial ` + * :term:`task` + * :term:`job` + * :term:`qualifier` + + run directory + When a :term:`suite ` is run a directory is created for all + of the files generated whilst the suite is running. This is called the + run directory and typically resides in the ``cylc-run`` directory: + + ``~/cylc-run/`` + + .. note:: + + If a suite is written in the ``cylc-run`` directory the run + directory is also the :term:`suite directory`. + + The run directory can be accessed by a running suite using the + environment variable ``CYLC_SUITE_RUN_DIR``. + + See also: + + * :term:`suite directory` + * :ref:`Suite Directory Vs Run Directory` + * :term:`work directory` + * :term:`share directory` + * :term:`job log directory` + + work directory + When Cylc executes a :term:`job` it does so inside the + :term:`job's ` working directory. This directory is created by Cylc + and lies within the directory tree inside the relevant suite's + :term:`run directory`. + + .. code-block:: sub + + /work// + + The location of the work directory can be accessed by a :term:`job` via + the environment variable ``CYLC_TASK_WORK_DIR``. + + Any files installed by :term:`Rose apps ` will be placed within + this directory. + + See also: + + * :term:`run directory` + * :term:`share directory` + * :ref:`Rose suite installation diagram + ` + + share directory + The share directory resides within a suite's :term:`run directory`. It + serves the purpose of providing a storage place for any files which need + to be shared between different tasks. + + .. code-block:: sub + + /share + + The location of the share directory can be accessed by a :term:`job` via + the environment variable ``CYLC_SUITE_SHARE_DIR``. + + In cycling suites files are typically stored in cycle sub-directories. + + See also: + + * :term:`run directory` + * :term:`work directory` + + suite log + suite log directory + A Cylc suite logs events and other information to the suite log files + when it runs. There are three log files: + + * ``out`` - the stdout of the suite. + * ``err`` - the stderr of the suite, which may contain useful debugging + information in the event of any error(s). + * ``log`` - a log of suite events, consisting of information about + user interaction. + + The suite log directory lies within the :term:`run directory`: + + .. code-block:: sub + + /log/suite + + job log + job log directory + When Cylc executes a :term:`job`, stdout and stderr are redirected to the + ``job.out`` and ``job.err`` files which are stored in the job log + directory. + + The job log directory lies within the :term:`run directory`: + + .. code-block:: sub + + /log/job/// + + Other files stored in the job log directory: + + * `job`: the :term:`job script`. + * `job-activity.log`: a log file containing details of the + :term:`job's ` progress. + * `job.status`: a file holding Cylc's most up-to-date + understanding of the :term:`job's ` present status. + + job + A job is the realisation of a :term:`task` consisting of a file called + the :term:`job script` which is executed when the job "runs". + + See also: + + * :term:`task` + * :term:`job script` + + job script + A job script is the file containing a bash script which is executed when + a :term:`job` runs. A task's job script can be found in the + :term:`job log directory`. + + See also: + + * :term:`task` + * :term:`job` + * :term:`job submission number` + + job host + The job host is the compute platform that a :term:`job` runs on. For + example ``some-host`` would be the job host for the task ``some-task`` in + the following suite: + + .. code-block:: cylc + + [runtime] + [[some-task]] + [[[remote]]] + host = some-host + + job submission number + Cylc may run multiple :term:`jobs ` per :term:`task` (e.g. if the + task failed and was re-tried). Each time Cylc runs a :term:`job` it is + assigned a submission number. The submission number starts at 1, + incrementing with each submission. + + See also: + + * :term:`job` + * :term:`job script` + + batch system + A batch system or job scheduler is a system for submitting + :term:`jobs ` onto a compute platform. + + See also: + + * `Wikipedia (job scheduler) + `_ + * :term:`directive` + + directive + Directives are used by :term:`batch systems ` to determine + what a :term:`job's ` requirements are, e.g. how much memory + it requires. + + Directives are set in the ``suite.rc`` file in the ``[runtime]`` section + (``[runtime][][directives]``). + + See also: + + * :term:`batch system` + + + + suite server program + When we say that a :term:`suite` is "running" we mean that the cylc + suite server program is running. + + The suite server program is responsible for running the suite. It submits + :term:`jobs `, monitors their status and maintains the suite state. + + .. _daemon: https://en.wikipedia.org/wiki/Daemon_(computing) + + By default a suite server program is a `daemon`_ meaning that it runs in + the background (potentially on another host). + + start + startup + When a :term:`suite` starts the Cylc :term:`suite server program` is + run. This program controls the suite and is what we refer to as + "running". + + * A :term:`Cylc suite` is started using ``cylc run``. + * A :term:`Rose suite configuration` (or :term:`Rosie Suite`) is started + using :ref:`command-rose-suite-run`. + + A suite start can be either :term:`cold ` or :term:`warm ` (cold by default). + + See also: + + * :ref:`Starting Suites` + * :term:`suite server program` + * :term:`warm start` + * :term:`cold start` + * :term:`shutdown` + * :term:`restart` + * :term:`reload` + + cold start + A cold start is one in which the :term:`suite` :term:`starts ` + from the :term:`initial cycle point`. This is the default behaviour of + ``cylc run``. + + See also: + + * :term:`warm start` + + warm start + In a :term:`cycling suite ` + a warm start is one in which the :term:`suite` :term:`starts ` + from a :term:`cycle point` after the :term:`initial cycle point`. + Tasks in cycles before this point as assumed to have succeeded. + + See also: + + * :term:`cold start` + + stop + shutdown + When a :term:`suite` is shutdown the :term:`suite server program` is + stopped. This means that no further :term:`jobs ` will be submitted. + + By default Cylc waits for any submitted or running :term:`jobs ` to + complete (either succeed or fail) before shutting down. + + See also: + + * :ref:`Stopping Suites` + * :term:`start` + * :term:`restart` + * :term:`reload` + + restart + When a :term:`stopped ` :term:`suite` is "restarted" Cylc will pick + up where it left off. Cylc will detect any :term:`jobs ` which + have changed state (e.g. succeeded) during the period in which the + :term:`suite` was :term:`shutdown`. + + See also: + + * :ref:`Restarting Suites` + * :term:`start` + * :term:`Stop` + * :term:`Reload` + + reload + Any changes made to the ``suite.rc`` file whilst the suite is running + will not have any effect until the suite is either: + + * :term:`Shutdown` and :term:`rerun ` + * :term:`Shutdown` and :term:`restarted ` + * "Reloaded" + + Reloading does not require the suite to be :term:`shutdown`. When a suite + is reloaded any currently "active" :term:`tasks ` will continue with + their "pre-reload" configuration, whilst new tasks will use the new + configuration. + + Reloading changes is safe providing they don't affect the + :term:`suite's ` :term:`graph`. Changes to the graph have certain + caveats attached, see the `Cylc User Guide`_ for details. + + See also: + + * :ref:`Reloading Suites` + * `Cylc User Guide`_ + + parameterisation + Parameterisation is a way to consolidate configuration in the Cylc + ``suite.rc`` file by implicitly looping over a set of pre-defined + variables e.g: + + .. code-block:: cylc + + [cylc] + [[parameters]] + foo = 1..3 + [scheduling] + [[dependencies]] + graph = bar => baz + + .. minicylc:: + :theme: none + + bar_foo1 => baz_foo1 + bar_foo2 => baz_foo2 + bar_foo3 => baz_foo3 + + See also: + + * :ref:`Cylc tutorial ` + + family + In Cylc a family is a collection of :term:`tasks ` which share a + common configuration and which can be referred to collectively in the + :term:`graph`. + + By convention families are named in upper case with the exception of the + special ``root`` family from which all tasks inherit. + + See also: + + * :ref:`Cylc tutorial ` + * :term:`family inheritance` + * :term:`family trigger` + + family inheritance + A :term:`task` can be "added" to a :term:`family` by "inheriting" from + it. + + For example the :term:`task` ``task`` "belongs" to the :term:`family` + ``FAMILY`` in the following snippet: + + .. code-block:: cylc + + [runtime] + [[FAMILY]] + [[[environment]]] + FOO = foo + [[task]] + inherit = FAMILY + + A task can inherit from multiple families by writing a comma-separated + list e.g: + + .. code-block:: cylc + + inherit = foo, bar, baz + + See also: + + * `Cylc User Guide`_ + * :term:`family` + * :term:`family trigger` + + family trigger + :term:`Tasks ` which "belong" to + (:term:`inherit ` from) a :term:`family` can be + referred to collectively in the :term:`graph` using a family trigger. + + A family trigger is written using the name of the family followed by a + special qualifier i.e. ``FAMILY_NAME:qualifier``. The most commonly used + qualifiers are: + + ``succeed-all`` + The dependency will only be met when **all** of the tasks in the + family have **succeeded**. + ``succeed-any`` + The dependency will be met as soon as **any one** of the tasks in the + family has **succeeded**. + ``finish-all`` + The dependency will only be met once **all** of the tasks in the + family have **finished** (either succeeded or failed). + + See also: + + * `Cylc User Guide`_ + * :term:`family` + * :term:`task trigger` + * :term:`dependency` + * :ref:`Family Trigger Tutorial ` + + stalled suite + stalled state + If Cylc is unable to proceed running a workflow due to unmet dependencies + the suite is said to be *stalled*. + + This usually happens because of a task failure as in the following + diagram: + + .. digraph:: Example + :align: center + + foo [style="filled" color="#ada5a5"] + bar [style="filled" color="#ff0000" fontcolor="white"] + baz [color="#88c6ff"] + + foo -> bar -> baz + + In this example the task ``bar`` has failed meaning that ``baz`` is + unable to run as its dependency (``bar:succeed``) has not been met. + + When a Cylc detects that a suite has stalled an email will be sent to the + user. Human interaction is required to escape a stalled state. + + Rose configuration + Rose configurations are directories containing a Rose configuration + file along with other optional files and directories. + + The two types of Rose configuration relevant to Cylc suites are: + + * :term:`Rose application configuration` + * :term:`Rose suite configuration` + + See also: + + * :ref:`Rose Configuration Format` + * :ref:`Rose Configuration Tutorial ` + * :ref:`Optional Configuration Tutorial + ` + + Rose app + Rose application + Rose application configuration + A Rose application configuration (or Rose app) is a directory containing + a :rose:file:`rose-app.conf` file along with some other optional files + and directories. + + An application can configure: + + * The command to run (:rose:conf:`rose-app.conf[command]`). + * Any environment variables to provide it with + (:rose:conf:`rose-app.conf[env]`) + * Input files e.g. namelists (:rose:conf:`rose-app.conf[namelist:NAME]`) + * Metadata for the application (:rose:file:`rose-meta.conf`). + + See also: + + * :ref:`Rose Applications` + + application directory + The application directory is the folder in which the + :rose:file:`rose-app.conf` file is located in a :term:`Rose application + configuration`. + + Rose built-in application + A Rose built-in application is a generic :term:`Rose application` + providing common functionality which is provided in the Rose installation. + + See also: + + * :ref:`Rose Built-In Applications` + + Rose suite configuration + A Rose suite configuration is a :rose:file:`rose-suite.conf` file along + with other optional files and directories which configure the way in + which a :term:`Cylc suite` is run. E.g: + + * Jinja2 variables to be passed into the ``suite.rc`` file ( + :rose:conf:`rose-suite.conf[jinja2:suite.rc]`). + * Environment variables to be provided to ``cylc run`` ( + :rose:conf:`rose-suite.conf[env]`). + * Installation configuration (e.g. + :rose:conf:`rose-suite.conf|root-dir`, + :rose:conf:`rose-suite.conf[file:NAME]`). + + See also: + + * :ref:`Rose Suites` + + metadata + Rose metadata + Rose metadata provides information about settings in + :term:`Rose application configurations ` + and :term:`Rose suite configurations `. This + information is stored in a :rose:file:`rose-meta.conf` file in a + ``meta/`` directory alongside the configuration it applies to. + + This information can include: + + * Documentation and help text, e.g. + :rose:conf:`rose-meta.conf[SETTING]title` + provides a short title to describe a setting. + * Information about permitted values for the setting, e.g. + :rose:conf:`rose-meta.conf[SETTING]type` can be used to specify the + data type a setting requires (integer, string, boolean, etc). + * Settings affecting how the configurations are displayed in + :ref:`command-rose-config-edit` (e.g. + :rose:conf:`rose-meta.conf[SETTING]sort-key`). + * Metadata which defines how settings should behave in different states + (e.g. :rose:conf:`rose-meta.conf[SETTING]trigger`). + + This information is used for: + + * Presentation and validation in the :ref:`command-rose-config-edit` + GUI. + * Validation using the :ref:`command-rose-macro` command. + + Metadata does not affect the running of an + :term:`application ` or :term:`Cylc suite`. + + See also: + + * :ref:`Metadata` + + Rosie Suite + A Rosie suite is a :term:`Rose suite configuration` which is managed + using the Rosie system. + + When a suite is managed using Rosie: + + * The :term:`suite directory` is added to version control. + * The suite is registered in a database. + + See also: + + * :ref:`Rosie Tutorial ` diff --git a/src/index.rst b/src/index.rst index 8c8248f014..2c9e619861 100644 --- a/src/index.rst +++ b/src/index.rst @@ -28,7 +28,7 @@ indefinitely. introduction installation tutorial/index - terminology + glossary workflows global-flow-conf suite-name-reg diff --git a/src/terminology.rst b/src/terminology.rst deleted file mode 100644 index 031fb9b704..0000000000 --- a/src/terminology.rst +++ /dev/null @@ -1,28 +0,0 @@ -Cylc Terminology -================ - - -Jobs and Tasks --------------- - -A *job* is a program or script that runs on a computer, and a *task* is -a workflow abstraction - a node in the suite dependency graph - that represents -a job. - - -Cycle Points ------------- - -A *cycle point* is a particular date-time (or integer) point in a sequence -of date-time (or integer) points. Each cylc task has a private cycle point and -can advance independently to subsequent cycle points. It may sometimes be -convenient, however, to refer to the "current cycle point" of a suite (or the -previous or next one, etc.) with reference to a particular task, or in the -sense of all tasks instances that "belong to" a particular cycle point. But -keep in mind that different tasks may pass through the "current cycle point" -(etc.) at different times as the suite evolves. - - -.. only:: builder_html - - .. include:: custom/whitespace_include From f49bea80f11536af030b99dd25e3b4e83dfc5efb Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 12:56:10 +0100 Subject: [PATCH 05/22] global hyperlinks * hyperlinks ing hyperlinks.rst can be used globally --- src/conf.py | 2 ++ src/glossary.rst | 3 --- src/hyperlinks.rst.include | 19 +++++++++++++++++++ src/suite-config.rst | 3 +-- .../furthertopics/clock-triggered-tasks.rst | 3 --- src/tutorial/furthertopics/queues.rst | 3 --- src/tutorial/furthertopics/retries.rst | 3 --- .../furthertopics/suicide-triggers.rst | 4 ---- .../configuration-consolidation/families.rst | 4 ---- .../configuration-consolidation/index.rst | 4 ---- .../parameters.rst | 3 --- src/tutorial/runtime/introduction.rst | 4 ---- .../runtime/runtime-configuration.rst | 6 ------ src/tutorial/scheduling/datetime-cycling.rst | 3 --- .../scheduling/further-scheduling.rst | 3 --- src/tutorial/scheduling/graphing.rst | 3 --- 16 files changed, 22 insertions(+), 48 deletions(-) create mode 100644 src/hyperlinks.rst.include diff --git a/src/conf.py b/src/conf.py index ce2e48f2d0..75a9ddd171 100644 --- a/src/conf.py +++ b/src/conf.py @@ -43,6 +43,8 @@ 'hieroglyph_patch' # https://github.com/nyergler/hieroglyph/issues/148 ] +rst_epilog = open('hyperlinks.rst.include', 'r').read() + # Add any paths that contain templates. templates_path = ['_templates'] diff --git a/src/glossary.rst b/src/glossary.rst index 71ee9cfa5a..866644e661 100644 --- a/src/glossary.rst +++ b/src/glossary.rst @@ -1,6 +1,3 @@ -.. include:: hyperlinks.rst - :start-line: 1 - Glossary ======== diff --git a/src/hyperlinks.rst.include b/src/hyperlinks.rst.include new file mode 100644 index 0000000000..109cee08b0 --- /dev/null +++ b/src/hyperlinks.rst.include @@ -0,0 +1,19 @@ +.. This document contains hyperlink references to be used throughout the + documentation. + +.. _Cylc: https://cylc.github.io/ +.. _Cylc User Guide: https://cylc.github.io/documentation.html#the-cylc-user-guide +.. _Cylc Suite Design Guide: https://cylc.github.io/doc/built-sphinx/suite-design-guide/suite-design-guide-master.html +.. _DataPoint: https://www.metoffice.gov.uk/datapoint +.. _EmPy: http://www.alcyone.com/software/empy/ +.. _extglob pattern matching: https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html#Pattern-Matching +.. _FCM: https://metomi.github.io/fcm/doc/ +.. _FCM User Guide: http://metomi.github.io/fcm/doc/user_guide/ +.. _INI: https://en.wikipedia.org/wiki/INI_file +.. _Jinja2: http://jinja.pocoo.org/ +.. _metomi-vms: https://github.com/metomi/metomi-vms +.. _PyGTK: http://www.pygtk.org/ +.. _Python: https://www.python.org/ +.. _Python Regular Expressions: https://docs.python.org/2/library/re.html#regular-expression-syntax +.. _SRS: https://code.metoffice.gov.uk/ +.. _SVN: https://subversion.apache.org/ diff --git a/src/suite-config.rst b/src/suite-config.rst index f69de218c1..410f5c936f 100644 --- a/src/suite-config.rst +++ b/src/suite-config.rst @@ -87,8 +87,7 @@ Suite.rc files are an extended-INI format with section nesting. Embedded template processor expressions may also be used in the file, to programatically generate the final suite configuration seen by -cylc. Currently the `Jinja2 `_ and -`EmPy `_ template processors are +cylc. Currently the `Jinja2`_ and `EmPy`_ template processors are supported; see :ref:`Jinja` and :ref:`EmPylabel` for examples. In the future cylc may provide a plug-in interface to allow use of other template engines too. diff --git a/src/tutorial/furthertopics/clock-triggered-tasks.rst b/src/tutorial/furthertopics/clock-triggered-tasks.rst index 43181eebf1..782a9d0ec1 100644 --- a/src/tutorial/furthertopics/clock-triggered-tasks.rst +++ b/src/tutorial/furthertopics/clock-triggered-tasks.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - .. _tutorial-cylc-clock-trigger: Clock Triggered Tasks diff --git a/src/tutorial/furthertopics/queues.rst b/src/tutorial/furthertopics/queues.rst index a04dfa48cb..be7f16be90 100644 --- a/src/tutorial/furthertopics/queues.rst +++ b/src/tutorial/furthertopics/queues.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - Queues ====== diff --git a/src/tutorial/furthertopics/retries.rst b/src/tutorial/furthertopics/retries.rst index d412e0ea5c..196da7d86a 100644 --- a/src/tutorial/furthertopics/retries.rst +++ b/src/tutorial/furthertopics/retries.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - Retries ======= diff --git a/src/tutorial/furthertopics/suicide-triggers.rst b/src/tutorial/furthertopics/suicide-triggers.rst index 067fb974d8..ec66ceee06 100644 --- a/src/tutorial/furthertopics/suicide-triggers.rst +++ b/src/tutorial/furthertopics/suicide-triggers.rst @@ -1,7 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - - .. _tut-cylc-suicide-triggers: Suicide Triggers diff --git a/src/tutorial/runtime/configuration-consolidation/families.rst b/src/tutorial/runtime/configuration-consolidation/families.rst index 48b8729342..8d28a8b550 100644 --- a/src/tutorial/runtime/configuration-consolidation/families.rst +++ b/src/tutorial/runtime/configuration-consolidation/families.rst @@ -1,7 +1,3 @@ -.. include:: ../../../../hyperlinks.rst - :start-line: 1 - - .. _tutorial-cylc-families: Families diff --git a/src/tutorial/runtime/configuration-consolidation/index.rst b/src/tutorial/runtime/configuration-consolidation/index.rst index 8cb159e1f0..d1a828c5cb 100644 --- a/src/tutorial/runtime/configuration-consolidation/index.rst +++ b/src/tutorial/runtime/configuration-consolidation/index.rst @@ -1,7 +1,3 @@ -.. include:: ../../../../hyperlinks.rst - :start-line: 1 - - .. _tutorial-cylc-consolidating-configuration: Consolidating Configuration diff --git a/src/tutorial/runtime/configuration-consolidation/parameters.rst b/src/tutorial/runtime/configuration-consolidation/parameters.rst index c0329fdd15..6fdf58b48e 100644 --- a/src/tutorial/runtime/configuration-consolidation/parameters.rst +++ b/src/tutorial/runtime/configuration-consolidation/parameters.rst @@ -1,6 +1,3 @@ -.. include:: ../../../../hyperlinks.rst - :start-line: 1 - .. _tutorial-cylc-parameterisation: diff --git a/src/tutorial/runtime/introduction.rst b/src/tutorial/runtime/introduction.rst index 36a1222d9c..bf5e8251d8 100644 --- a/src/tutorial/runtime/introduction.rst +++ b/src/tutorial/runtime/introduction.rst @@ -1,7 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - - .. _tutorial-cylc-runtime-introduction: Introduction diff --git a/src/tutorial/runtime/runtime-configuration.rst b/src/tutorial/runtime/runtime-configuration.rst index 91a2ba81ee..c0400c6754 100644 --- a/src/tutorial/runtime/runtime-configuration.rst +++ b/src/tutorial/runtime/runtime-configuration.rst @@ -1,9 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - -.. _DataPoint: https://www.metoffice.gov.uk/datapoint - - .. _tutorial-cylc-runtime-configuration: Runtime Configuration diff --git a/src/tutorial/scheduling/datetime-cycling.rst b/src/tutorial/scheduling/datetime-cycling.rst index 557fb193a8..d7bb76798c 100644 --- a/src/tutorial/scheduling/datetime-cycling.rst +++ b/src/tutorial/scheduling/datetime-cycling.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - .. _nowcasting: https://www.metoffice.gov.uk/research/weather/research-to-operations/convective-scale-data-assimilation-and-nowcasting .. _tutorial-datetime-cycling: diff --git a/src/tutorial/scheduling/further-scheduling.rst b/src/tutorial/scheduling/further-scheduling.rst index fe1071618b..3148443313 100644 --- a/src/tutorial/scheduling/further-scheduling.rst +++ b/src/tutorial/scheduling/further-scheduling.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - :start-line: 1 - .. _tutorial-cylc-further-scheduling: Further Scheduling diff --git a/src/tutorial/scheduling/graphing.rst b/src/tutorial/scheduling/graphing.rst index 87816438a6..5592b25581 100644 --- a/src/tutorial/scheduling/graphing.rst +++ b/src/tutorial/scheduling/graphing.rst @@ -1,6 +1,3 @@ -.. include:: ../../../hyperlinks.rst - - .. _tutorial-cylc-graphing: Graphing From cbd66986b5a70f9d03a264d674f3ee71b3ad93ea Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 13:46:02 +0100 Subject: [PATCH 06/22] intersphinx mapping - rose --- src/conf.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/conf.py b/src/conf.py index 75a9ddd171..a57fb75059 100644 --- a/src/conf.py +++ b/src/conf.py @@ -62,6 +62,12 @@ version = '.'.join(CYLC_VERSION.split('.')[:2]) # The short X.Y version. release = CYLC_VERSION # The full version, including alpha/beta/rc tags. +intersphinx_mapping = { + 'rose': ( + 'http://metomi.github.io/rose/doc/html', None + ) +} + # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] From 08029bff16ebc9f9bb01dc174d7c6279b01d67c7 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 14:00:25 +0100 Subject: [PATCH 07/22] remove rose stuff from the glossary --- src/glossary.rst | 138 ++--------------------------------------------- 1 file changed, 3 insertions(+), 135 deletions(-) diff --git a/src/glossary.rst b/src/glossary.rst index 866644e661..52c73ff210 100644 --- a/src/glossary.rst +++ b/src/glossary.rst @@ -9,20 +9,12 @@ Glossary A Cylc suite is a directory containing a ``suite.rc`` file which contains :term:`graphing` representing a workflow. - See also: - - * :ref:`Relationship between Cylc suites, Rose suite configurations and - Rosie suites ` - suite directory - The suite directory contains all of the configuration for a suite (e.g. - the ``suite.rc`` file and for Rose suites the :rose:file:`rose-suite.conf` - file). + The suite directory contains all of the configuration for a suite e.g. + the ``suite.rc`` file. - This is the directory which is registered using ``cylc reg`` or, for Rose - suites, it is the one in which the :ref:`command-rose-suite-run` command - is executed. + This is the directory which is registered using ``cylc reg``. .. note:: @@ -32,8 +24,6 @@ Glossary See also: * :term:`run directory` - * :ref:`Rose suite installation diagram - ` graph The graph of a :term:`suite` refers to the @@ -412,15 +402,10 @@ Glossary The location of the work directory can be accessed by a :term:`job` via the environment variable ``CYLC_TASK_WORK_DIR``. - Any files installed by :term:`Rose apps ` will be placed within - this directory. - See also: * :term:`run directory` * :term:`share directory` - * :ref:`Rose suite installation diagram - ` share directory The share directory resides within a suite's :term:`run directory`. It @@ -563,10 +548,6 @@ Glossary run. This program controls the suite and is what we refer to as "running". - * A :term:`Cylc suite` is started using ``cylc run``. - * A :term:`Rose suite configuration` (or :term:`Rosie Suite`) is started - using :ref:`command-rose-suite-run`. - A suite start can be either :term:`cold ` or :term:`warm ` (cold by default). @@ -766,116 +747,3 @@ Glossary When a Cylc detects that a suite has stalled an email will be sent to the user. Human interaction is required to escape a stalled state. - - Rose configuration - Rose configurations are directories containing a Rose configuration - file along with other optional files and directories. - - The two types of Rose configuration relevant to Cylc suites are: - - * :term:`Rose application configuration` - * :term:`Rose suite configuration` - - See also: - - * :ref:`Rose Configuration Format` - * :ref:`Rose Configuration Tutorial ` - * :ref:`Optional Configuration Tutorial - ` - - Rose app - Rose application - Rose application configuration - A Rose application configuration (or Rose app) is a directory containing - a :rose:file:`rose-app.conf` file along with some other optional files - and directories. - - An application can configure: - - * The command to run (:rose:conf:`rose-app.conf[command]`). - * Any environment variables to provide it with - (:rose:conf:`rose-app.conf[env]`) - * Input files e.g. namelists (:rose:conf:`rose-app.conf[namelist:NAME]`) - * Metadata for the application (:rose:file:`rose-meta.conf`). - - See also: - - * :ref:`Rose Applications` - - application directory - The application directory is the folder in which the - :rose:file:`rose-app.conf` file is located in a :term:`Rose application - configuration`. - - Rose built-in application - A Rose built-in application is a generic :term:`Rose application` - providing common functionality which is provided in the Rose installation. - - See also: - - * :ref:`Rose Built-In Applications` - - Rose suite configuration - A Rose suite configuration is a :rose:file:`rose-suite.conf` file along - with other optional files and directories which configure the way in - which a :term:`Cylc suite` is run. E.g: - - * Jinja2 variables to be passed into the ``suite.rc`` file ( - :rose:conf:`rose-suite.conf[jinja2:suite.rc]`). - * Environment variables to be provided to ``cylc run`` ( - :rose:conf:`rose-suite.conf[env]`). - * Installation configuration (e.g. - :rose:conf:`rose-suite.conf|root-dir`, - :rose:conf:`rose-suite.conf[file:NAME]`). - - See also: - - * :ref:`Rose Suites` - - metadata - Rose metadata - Rose metadata provides information about settings in - :term:`Rose application configurations ` - and :term:`Rose suite configurations `. This - information is stored in a :rose:file:`rose-meta.conf` file in a - ``meta/`` directory alongside the configuration it applies to. - - This information can include: - - * Documentation and help text, e.g. - :rose:conf:`rose-meta.conf[SETTING]title` - provides a short title to describe a setting. - * Information about permitted values for the setting, e.g. - :rose:conf:`rose-meta.conf[SETTING]type` can be used to specify the - data type a setting requires (integer, string, boolean, etc). - * Settings affecting how the configurations are displayed in - :ref:`command-rose-config-edit` (e.g. - :rose:conf:`rose-meta.conf[SETTING]sort-key`). - * Metadata which defines how settings should behave in different states - (e.g. :rose:conf:`rose-meta.conf[SETTING]trigger`). - - This information is used for: - - * Presentation and validation in the :ref:`command-rose-config-edit` - GUI. - * Validation using the :ref:`command-rose-macro` command. - - Metadata does not affect the running of an - :term:`application ` or :term:`Cylc suite`. - - See also: - - * :ref:`Metadata` - - Rosie Suite - A Rosie suite is a :term:`Rose suite configuration` which is managed - using the Rosie system. - - When a suite is managed using Rosie: - - * The :term:`suite directory` is added to version control. - * The suite is registered in a database. - - See also: - - * :ref:`Rosie Tutorial ` From 3a2bb292ba6f9927ec0ae142af8289b350e55e27 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 14:14:25 +0100 Subject: [PATCH 08/22] add svg support * plugins provide sphinx with svg manipulation tools and * allow sphinx to handle svg conversion where necessary --- setup.py | 3 +++ src/conf.py | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/setup.py b/setup.py index acc3c31716..8d3436ad1e 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,9 @@ INSTALL_REQUIRES = [ 'sphinx==2.0.*', + 'sphinx_rtd_theme', + 'sphinxcontrib-svg2pdfconverter' + 'hieroglyph' ] EXTRAS_REQUIRE = { diff --git a/src/conf.py b/src/conf.py index a57fb75059..615c47f215 100644 --- a/src/conf.py +++ b/src/conf.py @@ -14,6 +14,7 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . +from distutils.spawn import find_executable as which import sys import os from cylc.flow import __version__ as CYLC_VERSION @@ -45,6 +46,24 @@ rst_epilog = open('hyperlinks.rst.include', 'r').read() +# Select best available SVG image converter. +for svg_converter, extension in [ + ('rsvg', 'sphinxcontrib.rsvgconverter'), + ('inkscape', 'sphinxcontrib.inkscapeconverter')]: + if which(svg_converter): + try: + __import__(extension) + except (AssertionError, ImportError): + # converter or extension not available + pass + else: + extensions.append(extension) + break +else: + # no extensions or converters available, fall-back to default + # vector graphics will be converted to bitmaps in all documents + extensions.append('sphinx.ext.imgconverter') + # Add any paths that contain templates. templates_path = ['_templates'] @@ -80,6 +99,7 @@ numfig_secnum_depth = 0 # Global configuration for graphviz diagrams. +graphviz_output_format = 'svg' graphviz_dot_args = ['-Gfontname=sans', '-Gbgcolor=none', '-Nfontname=sans'] From b8426985310368c3ddd11dbc86241341bc2c5b57 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 14:26:51 +0100 Subject: [PATCH 09/22] use read the docs theme * required for plugins used by the cylc tutorial --- setup.py | 1 - src/appendices/appendices-master.rst | 5 --- src/appendices/known-issues.rst | 5 --- src/appendices/licensing.rst | 5 --- src/conf.py | 35 +++++------------- src/ext/whitespace_include | 33 ----------------- src/graphics/png/orig/test5.png | Bin 25918 -> 25919 bytes src/index.rst | 22 ++--------- .../suite-design-guide-master.rst | 16 ++------ src/suite-name-reg.rst | 5 --- src/suite-storage-etc.rst | 5 --- src/tutorial/index.rst | 2 +- 12 files changed, 16 insertions(+), 118 deletions(-) delete mode 100644 src/ext/whitespace_include diff --git a/setup.py b/setup.py index 8d3436ad1e..d612833927 100644 --- a/setup.py +++ b/setup.py @@ -25,7 +25,6 @@ 'sphinx==2.0.*', 'sphinx_rtd_theme', 'sphinxcontrib-svg2pdfconverter' - 'hieroglyph' ] EXTRAS_REQUIRE = { diff --git a/src/appendices/appendices-master.rst b/src/appendices/appendices-master.rst index 388324d38e..187fd098d7 100644 --- a/src/appendices/appendices-master.rst +++ b/src/appendices/appendices-master.rst @@ -14,8 +14,3 @@ Appendices dev-history-major-changes known-issues licensing - - -.. only:: builder_html - - .. include:: ../custom/whitespace_include diff --git a/src/appendices/known-issues.rst b/src/appendices/known-issues.rst index e7865d09ce..25ebc34747 100644 --- a/src/appendices/known-issues.rst +++ b/src/appendices/known-issues.rst @@ -37,8 +37,3 @@ the job file will trap the failure of the individual commands, as well as the whole pipeline, and will attempt to report a failure back to the suite twice. The second message is ignored by the suite, and so the behaviour can be safely ignored. (You should probably still investigate the failure, however!) - - -.. only:: builder_html - - .. include:: ../custom/whitespace_include diff --git a/src/appendices/licensing.rst b/src/appendices/licensing.rst index 13e96516c0..b26330c141 100644 --- a/src/appendices/licensing.rst +++ b/src/appendices/licensing.rst @@ -2,8 +2,3 @@ GNU GENERAL PUBLIC LICENSE v3.0 =============================== See the `GNU GENERAL PUBLIC LICENSE v3.0 `_. - - -.. only:: builder_html - - .. include:: ../custom/whitespace_include diff --git a/src/conf.py b/src/conf.py index 615c47f215..7b5ce87e40 100644 --- a/src/conf.py +++ b/src/conf.py @@ -36,6 +36,7 @@ 'sphinx.ext.todo', # sphinx user community extensions 'hieroglyph', + 'sphinx_rtd_theme', # custom project extensions (located in ext/) 'cylc_lang', 'minicylc', @@ -106,26 +107,16 @@ # -- Options for HTML output ---------------------------------------------- -# The builtin HTML theme to build upon, with customisations to it. Notably -# customise with a white 'sticky' sidebar; make headings & links text the Cylc -# logo colours & make code block background the logo green made much lighter. -html_theme = "classic" +# Theme +html_theme = 'sphinx_rtd_theme' html_theme_options = { - "stickysidebar": True, - "sidebarwidth": 250, - "relbarbgcolor": "black", - "footerbgcolor": "white", # single-page HTML flashes this colour on scroll - "footertextcolor": "black", - "sidebarbgcolor": "white", - "sidebartextcolor": "black", - "sidebarlinkcolor": "#0000EE;", - "headbgcolor": "white", - "headtextcolor": "#FF5966", - "linkcolor": "#0000EE;", - "visitedlinkcolor": "#551A8B;", - "headlinkcolor": "#0000EE;", - "codebgcolor": "#ebf9f6", + 'logo_only': True, + 'navigation_depth': 4 } +html_logo = "graphics/png/orig/cylc-logo.png" +html_favicon = "graphics/cylc-favicon.ico" # sphinx specifies .ico format +html_show_sphinx = False +html_show_copyright = True # Custom sidebar templates, maps document names to template names. html_sidebars = { @@ -137,17 +128,9 @@ ], } -# Logo and favicon to display. -html_logo = "graphics/png/orig/cylc-logo.png" -# sphinx specifies this should be .ico format -html_favicon = "graphics/cylc-favicon.ico" - # Disable timestamp otherwise inserted at bottom of every page. html_last_updated_fmt = '' -# Remove "Created using Sphinx" text in footer. -html_show_sphinx = False - # Output file base name for HTML help builder. htmlhelp_basename = 'cylcdoc' diff --git a/src/ext/whitespace_include b/src/ext/whitespace_include deleted file mode 100644 index 9b68f4016f..0000000000 --- a/src/ext/whitespace_include +++ /dev/null @@ -1,33 +0,0 @@ - -.. insert vertical whitespace else sidebar menu overhangs short page (ugly) - -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| diff --git a/src/graphics/png/orig/test5.png b/src/graphics/png/orig/test5.png index 120ef2d568003ebf1cd72533290031008cc29e06..f0940ea6820f656a42bc4a1b6b6cb16f7accd307 100644 GIT binary patch delta 11 ScmdmYigEub#tn9`_ - `Rose source repository `_ - - -.. only:: builder_html - - .. include:: custom/whitespace_include diff --git a/src/tutorial/index.rst b/src/tutorial/index.rst index 554ca19f93..c103432af2 100644 --- a/src/tutorial/index.rst +++ b/src/tutorial/index.rst @@ -1,6 +1,6 @@ .. _Cylc Tutorial: -Cylc Tutorial +Tutorial ============= Cylc is a workflow engine for running suites of inter-dependent jobs. From 0391fedd6d69c4aa19bcaae251d9231842c77373 Mon Sep 17 00:00:00 2001 From: Oliver Sanders Date: Tue, 23 Jul 2019 15:44:56 +0100 Subject: [PATCH 10/22] use rose css/js addons * these scripts/styles underpin the extensions used in the cylc tutorial --- src/_static/css/cylc.css | 135 +++++++++++++++++ src/_static/js/cylc.js | 120 +++++++++++++++ src/_static/js/minicylc.js | 294 +++++++++++++++++++++++++++++++++++++ src/_static/js/spoiler.js | 49 +++++++ src/conf.py | 8 + src/ext/minicylc.py | 2 +- src/ext/practical.py | 2 +- 7 files changed, 608 insertions(+), 2 deletions(-) create mode 100644 src/_static/css/cylc.css create mode 100644 src/_static/js/cylc.js create mode 100644 src/_static/js/minicylc.js create mode 100644 src/_static/js/spoiler.js diff --git a/src/_static/css/cylc.css b/src/_static/css/cylc.css new file mode 100644 index 0000000000..1a54892f8a --- /dev/null +++ b/src/_static/css/cylc.css @@ -0,0 +1,135 @@ +/* Correct the behaviour of the read the docs theme which greedily overides + * sphinx's `pygments_style` option by placing its own syntax in the + * stylesheet - https://github.com/rtfd/sphinx_rtd_theme/issues/166 */ +.highlight * { + color: black; + font-weight: normal; + font-style: normal; + background-color: transparent; +} + +/* Correct the behaviour of nested admonitions. Sometimes the admonition-header + * inherits its parents styling. */ +.rst-content .error .admonition-title, .rst-content .danger .admonition-title { + background: red +} +.rst-content .warning .admonition-title, +.rst-content .caution .admonition-title, +.rst-content .attention .admonition-title { + background: orange +} + +/* Enable theme handling of pilcrow symbols for code-block captions and + * admonitions. */ +.rst-content p.admonition-title .pull-left.headerlink, +.rst-content div.code-block-caption .pull-left.headerlink { + margin-right:.3em +} +.rst-content p.admonition-title .pull-right.headerlink, +.rst-content div.code-block-caption .pull-right.headerlink { + margin-left:.3em +} +.rst-content p.admonition-title .headerlink:before, +.rst-content div.code-block-caption .headerlink:before { + font-family:"FontAwesome"; + display:inline-block; + font-style:normal; + font-weight:normal; + line-height:1; + text-decoration:inherit; + font-size:14px; + vertical-align:-15% + -webkit-font-smoothing:antialiased +} +.rst-content p.admonition-title .headerlink:after, +.rst-content div.code-block-caption .headerlink:after { + visibility:visible; + content:""; + font-family:FontAwesome; + display:inline-block; + color:#2980B9 +} +.rst-content p.admonition-title:hover .headerlink, +.rst-content div.code-block-caption:hover .headerlink { + display:inline-block +} +.rst-content p.admonition-title .headerlink, +.rst-content div.code-block-caption .headerlink { + font:normal normal normal 14px/1 FontAwesome; + text-rendering:auto; + -webkit-font-smoothing:antialiased; + -moz-osx-font-smoothing:grayscale; + display:none; + visibility:hidden; + font-size:14px; + color:#fcfcfc; + text-decoration:inherit +} + +/* Fix the lack of space underneath lists inside admonitions. */ +.rst-content div.admonition ul, +.rst-content div.admonition ol > li { + padding-bottom: 0.5em; +} + +/* Add warning symbol before deprecated items. */ +.deprecated p:before { + font-family:FontAwesome; + content:"\f071 "; + color: rgb(200, 90, 70); +} + +.deprecated p span.versionmodified{ + font-weight: bold; +} + +/* Implement grid-table class for plain style grid layouts. */ +.grid-table { + width: 100% !important; + border: 0 !important; /* Remove table border. */ +} +.grid-table tbody tr td:first-child { + padding-left: 0 !important; /* Grid flush with the left-hand content edge. */ +} +.grid-table tbody tr td:last-child { + padding-right: 0 !important; /* Grid flush with the right-hand edge */ +} +.grid-table tbody tr td { + background-color: rgba(255,255,255,0) !important; + border: 0 !important; /* Remove cell border. */ + vertical-align: top !important; /* All content should float to the top. */ +} +.grid-table td { + /* docutils sticks tables inside an align-center class, correct this */ + text-align: left; +} + +/* Tables handle their own margin, this prevents getting a double margin. */ +.grid-table div.highlight { + margin-bottom: 0; +} + +/* Place code-block captions in italics. */ +.code-block-caption { + font-style: italic; + color: #808080; +} + +/* Block an element from being included in text selections. */ +.noselect { + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +/* Extension to Pygments to insert the "added" and "unchanged" characters in + * a "diff" code block using CSS so that they aren't included when coppied as + * text. */ +.highlight-diff .gi:before { + content: '+'; +} +.highlight-diff .gn:before { + content: ' '; +} diff --git a/src/_static/js/cylc.js b/src/_static/js/cylc.js new file mode 100644 index 0000000000..127e816d2f --- /dev/null +++ b/src/_static/js/cylc.js @@ -0,0 +1,120 @@ +/* Return a list of matches for the provided string, see also String.indexOf. */ +String.prototype.indiciesOf = function (sub) { + var str = String(this); + var index = str.indexOf(sub); + var count = 0; + var ret = []; + while (index != -1) { + str = str.substr(index + 1); + ret.push(index + count); + count += index + 1; + index = str.indexOf(sub); + } + return ret; +} + + +/* Split a text node on the newline character, see also Text.splitText. */ +Text.prototype.splitLines = function () { + var indicies = $(this).text().indiciesOf('\n'); + if (indicies && indicies[0] == 0) { + // ignore leading new line characters + indicies.shift(); + } + if (indicies.length < 1) { + // no line breaks - skip + return []; + } + var node = this; + var offset = 0; + for (let index of indicies) { + node = node.splitText(index - offset); + offset = index; + } +} + + +// Make admonitions linkable. +$(document).ready(function() { + var id; + $('p.admonition-title').each(function(itt, element) { + id = 'admonition-' + itt; + $(element).attr({'id': id}); + $(element).append($('') + .attr({'href': '#' + id}) + .addClass('headerlink') + .append('¶') + ); + }); +}); + + +// Remove the leading (+| ) character from each line of a diff block and +// re-insert them with CSS so that they are not included in the copy selection. +// +// Add the ".noselect" class to lines prefixed (-) to make them disappear from +// copied text. +$(document).ready(function() { + $('div.highlight-diff pre').each(function () { + // Unformatted text is represented as text nodes which don't fit into + // the DOM in the way regular HTML elements do so we cannot iterate + // over .children() but must use childNodes instead. + for (let node of this.childNodes) { + if (node.nodeName == '#text') { // "unchanged" line. + // Split multi-line text nodes into separate lines so we can + // remove the leading whitespace. + node.splitLines(); + } else { + text = $(node).html().substr(1); + if ($(node).hasClass('gi')) { // "added" line. + // Remove leading character. + $(node).html($(node).html().substr(1)); + } else if ($(node).hasClass('gd')) { // "removed" line. + // Make un-selectable. + $(node).addClass('noselect'); + } + } + } + }); + + // Iterate again to remove the leading whitespace from unchanged lines. + var node, text, newnode; + $('div.highlight-diff pre').each(function () { + node = this.childNodes[0]; + while (node) { + // Skip nodes if they just contain whitespace (including new + // line characters). + if (node.nodeName == '#text' && $(node).text().trim()) { + text = $(node).text(); + if (text[0] == '\n') { + // Move leading new lines onto the end of the string. + text = text.substr(1); + node = node.splitText(1); + } + if (text[0] == ' ') { + // Remove leading whitespace, this will be provided via + // CSS. + text = text.substr(1); + } + + // Create a new span to represent this text node. Apply the 'gn' + // class which will provide leading whitespace. + $('') + .append(text) + .addClass('gn') + .insertBefore(node); + + // Move on to the next node and remove the current text node. + newnode = node.nextSibling; + $(node).remove(); + node = newnode; + } else { + // To avoid iterating over any nodes we are adding (infinite loop) + // we use node.nextSibling to get the next node and insert any + // new nodes before the current one. + node = node.nextSibling; + } + } + }); + +}); diff --git a/src/_static/js/minicylc.js b/src/_static/js/minicylc.js new file mode 100644 index 0000000000..aa9af3e3d7 --- /dev/null +++ b/src/_static/js/minicylc.js @@ -0,0 +1,294 @@ +/*eslint no-console: off*/ + +// Default Cylc colour theme. +var minicylc_default_theme = { + 'waiting_fill': 'none', + 'waiting_stroke': '#88c6ff', + 'running_fill': '#00c410', + 'running_stroke': 'black', + 'succeed_fill': '#ada5a5', + 'succeed_stroke': 'black' +} + +// Demo colour theme for demmonstrating workflow logic. +var minicylc_demo_theme = { + 'succeed_fill': '#aabbff', + 'succeed_stroke': 'black' +} + + +class MiniCylc { + /** + * Class for animating SVG graphs. + * + * Attributes: + * - nodes: A dictionary of task names against a list of SVG nodes. + * - edges: A dictionary of task edges against a list SVG nodes. + * - dependencies: A dictionary of task names against a list of + * conditional expressions. + */ + + constructor(div) { + /** + * Initiate the object. + * @param div The
element containing the SVG. + * */ + + // Obtain nodes and edges from svg. + var svg = ($(div).find('object:first')[0]).contentDocument; + this._find_svg_elements(svg); + + // Parse dependencies. + var deps = this._get_dependencies_from_graph(div); + this._construct_dependency_map(deps); + + // Process colour theme. + this.setup_colours($(div).data('theme')); + } + + setup_colours(theme) { + /** + * Set the colour theme. + * @param theme The name of a colour theme as a string. + */ + if (!theme || theme == 'default') { + this.theme = minicylc_default_theme; + } else if (theme == 'demo') { + this.theme = minicylc_demo_theme; + } else { + console.log('Warning: Invalid theme detected "' + theme + + '", defaulting to black.'); + this.theme = {}; + } + } + + _find_svg_elements(svg) { + /** + * Associate task/dependency names with SVG nodes. + * + * Associations stored as dicionaries this.nodes and this.edges. + * @param svg The element containg the workflow. + */ + var nodes = {}; + var edges = {}; + $(svg).find('.graph g').each(function() { + var node = $(this)[0]; + var node_class = $(node).attr('class'); + if (node_class == 'node') { + nodes[node.textContent.split('\n')[0]] = node; + } else if (node_class == 'edge') { + edges[node.textContent.split('\n')[0]] = node; + } + }); + this.nodes = nodes; + this.edges = edges; + } + + _get_dependencies_from_graph(div) { + /** + * Extract, parse and return a list of dependencies. + * @param div The minicylc
element. + * @return A list of [left, right] lists e.g. ['a & b', 'c']. + */ + var deps = []; + var ind = 0; + var parts; + for (let dep of $(div).data('dependencies').split('//')) { + parts = dep.split('=>'); + if (parts.length == 0) { + continue; // Graph line does not contain a dependency => skip. + } + for(ind = 0; ind < parts.length-1; ind++) { + deps.push([parts[ind], parts[ind + 1]]); // [left, right]. + } + } + + return deps; + } + + _construct_dependency_map(deps) { + /** + * Associate tasks with conditional expressions. + * + * Associations stored as a dictionary - this.dependencies. + * @param deps A list of dependencies in the form [[left, right], ...]. + */ + var condition; + var conditional_regex = /[()&]/; + var conditional_regex2 = /([()&|])/; + var conditional_chars = ['(', ')', '|', '&']; + this.dependencies = {}; + for (let dep of deps) { + // Build a javascript parsable conditional statement. + condition = []; + for (let left of dep[0].split(conditional_regex2)) { + left = left.trim(); + if (left) { + if (!conditional_chars.includes(left)) { + // All dependencies are :succeed by default, + // dependencies are checked using + // this.succeed.has(task). + condition.push('this.succeed.has("' + left + '")'); + } else { + // conditional character. + condition.push(left); + } + } + } + condition = condition.join(' '); + + // Associate conditional statements with tasks. + for (let right of dep[1].split(conditional_regex)) { + right = right.trim(); + if (!this.dependencies[right]) { + this.dependencies[right] = []; + } + this.dependencies[right].push(condition); + } + } + } + + evaluate_dependencies(task) { + /** + * Check if a task's dependencies are satisfied. + * @param task The name of the task to evaluate. + * @return true if satisfied else false. + */ + var deps = this.dependencies[task]; + if (!deps) { + return true; + } + for (let dep of deps) { + if (eval(dep) == 0) { + return false; + } + } + return true; + } + + _style_node(node, fill, stroke) { + /** + * Style a graphviz node. + * @param fill The fill colour for SVG e.g. 'none', '#aabbcc', 'black'. + * @param stroke The stroke colour for SVG. + */ + if (!fill) { + fill = 'none'; // Default to an unfilled node. + } + if (!stroke) { + stroke = 'black'; // Default to a black border. + } + // Style nodes. + $($(this.nodes[node]).find('ellipse:first')).attr({ + 'fill': fill, + 'stroke': stroke + }); + } + + _style() { + /** + * Refresh the style of graph nodes based on their state. + */ + for (let task of this.waiting) { + this._style_node(task, + this.theme['waiting_fill'], + this.theme['waiting_stroke']); + } + for (let task of this.running) { + this._style_node(task, + this.theme['running_fill'], + this.theme['running_stroke']); + } + for (let task of this.succeed) { + this._style_node(task, + this.theme['succeed_fill'], + this.theme['succeed_stroke']); + } + } + + _init() { + /** + * Initiate the simulation / animation. + */ + this.waiting = new Set(); + this.running = new Set(); + this.succeed = new Set(); + for (let task in this.nodes) { + this.waiting.add(task); + } + this._style(); + } + + _advance() { + /* + * To be called with each main loop. + * @return true if the task pool has changed else false. + */ + var changed = false; + for (let task of this.running) { + this.running.delete(task); + this.succeed.add(task); + changed = true; + } + for (let task of this.waiting) { + if (this.evaluate_dependencies(task)) { + this.waiting.delete(task); + this.running.add(task); + changed = true; + } + } + return changed; + } + + _main_loop(itt) { + /* + * The main loop - runs the simulation and handles restyling of nodes. + * Note function calls itself reccursively. + */ + var exit = false; + + // Action. + if (this._advance()) { // Advance the task pool. + // If anything has changed restyle. + this._style(); + } else { + // If nothing has changed... + if (this.waiting.size == 0 && this.running.size == 0) { + // The simulation has ended, reset and restart. + this._init(); + } else { + // The suite is stalled, log a console message and do nothing. + exit = true; + console.log('Suite stalled :('); + } + } + + // Callback. + if (!exit) { + var self_ref = this; + setTimeout(function(){ + self_ref._main_loop(itt + 1); + }, 3000); + } + } + + run() { + /* + * Run this simulation. + */ + this._init(); + this._main_loop(0); + } + +} + + +// Activate minicylc. +$(document).ready(function() { + $('.minicylc').each(function() { + var obj = this; + $(this).find('object:first').on('load', function() { + new MiniCylc(obj).run(); + }); + }); +}); diff --git a/src/_static/js/spoiler.js b/src/_static/js/spoiler.js new file mode 100644 index 0000000000..2f0842db89 --- /dev/null +++ b/src/_static/js/spoiler.js @@ -0,0 +1,49 @@ +/* This file implements spoiler sections which are hidden by default. */ + +// sphinx_admonition_class: bootstrap_button_class +const sphinx_admonition_classes = { + 'attention': 'warning', + 'caution': 'warning', + 'error': 'danger', + 'hint': 'success', + 'important': 'success', + 'note': 'info', + 'tip': 'success', + 'warning': 'warning', + 'danger': 'danger' +} + +$(document).ready(function() { + var button_class; + var spoilers = $('.spoiler'); + for (let spoiler of spoilers) { + // Hide content. + $(spoiler).children().hide(); + $(spoiler).find('.admonition-title').show(); + + // Determine button class. + button_class = 'default'; + for (let css_class of $(spoiler).attr('class').split(' ')) { + if (css_class in sphinx_admonition_classes) { + button_class = sphinx_admonition_classes[css_class]; + break; + } + } + + // Add button + $(spoiler).append( + $('