Incremental strategy for running/skipping targets via tag

src/python/pants/engine/round_engine.py

@@ -43,8 +43,6 @@ def attempt(self, explain):
         with self._context.new_workunit(name=name, labels=[WorkUnitLabel.TASK], log_config=log_config):
           if explain:
             self._context.log.debug('Skipping execution of {} in explain mode'.format(name))
-          elif task.skip_execution:
-            self._context.log.info('Skipping {}'.format(name))
           else:
             task.execute()
 

src/python/pants/task/target_restriction_mixins.py

@@ -55,6 +55,10 @@ class HasSkipOptionMixin(object):
   def skip_execution(self):
     return self.get_options().skip
 
+  @property
+  def supports_skipping_target_by_tag(self):
+    return True
+
 
 class SkipOptionRegistrar(object):
   """Registrar of --skip."""

src/python/pants/task/task.py

@@ -210,6 +210,15 @@ def skip_execution(self):
     """
     return False
 
+  @property
+  def supports_skipping_target_by_tag(self):
+    """
+    Whether this task supports forced skip/no-skip on targets based on tags.
+
+    :API: public
+    """
+    return False
+
   @property
   def act_transitively(self):
     """Whether this task should act on the transitive closure of the target roots.
@@ -237,8 +246,32 @@ def get_targets(self, predicate=None):
 
     :API: public
     """
-    return (self.context.targets(predicate) if self.act_transitively
-            else list(filter(predicate, self.context.target_roots)))
+    relevant_targets = self.context.targets(predicate) if self.act_transitively else list(
+      filter(predicate, self.context.target_roots))
+    if not self.supports_skipping_target_by_tag:
+      return relevant_targets
+
+    force_run_tag = 'no-{}.skip'.format(self.options_scope)
+    force_run_targets = set(t for t in relevant_targets if force_run_tag in t.tags)
+
+    if self.skip_execution:
+      if not force_run_targets:
+        self.context.log.debug('Skipping by returning empty targets '
+                               'because task level is skipped and there is no forced run targets')
+
+      return force_run_targets
+
+    force_skip_tag = '{}.skip'.format(self.options_scope)
+    force_skip_targets = set(t for t in relevant_targets if force_skip_tag in t.tags)
+
+    if force_skip_targets:
+      self.context.log.debug("Force skipping targets by tag: {}\n{}".format(force_skip_tag, force_skip_targets))
+    if force_run_targets:
+      self.context.log.debug("Force running targets by tag: {}\n{}".format(force_run_tag, force_run_targets))
+
+    final_targets = list(set(relevant_targets).union(force_run_targets).difference(force_skip_targets))
+
+    return final_targets
 
   @memoized_property
   def workdir(self):

tests/python/pants_test/task/echo_plugin/register.py

@@ -19,8 +19,10 @@ class EchoTaskBase(HasSkipAndTransitiveGoalOptionsMixin, Task):
   prefix = None
 
   def execute(self):
-    with open(os.path.join(self.workdir, 'output'), 'w') as fp:
-      fp.write('\n'.join(t.address.spec for t in self.get_targets()))
+    relevant_targets = self.get_targets()
+    if relevant_targets:
+      with open(os.path.join(self.workdir, 'output'), 'w') as fp:
+        fp.write('\n'.join(t.address.spec for t in relevant_targets))
 
 
 class EchoOne(EchoTaskBase):

tests/python/pants_test/task/test_goal_options_mixin_integration.py

@@ -18,15 +18,15 @@ class TestGoalOptionsMixinIntegration(PantsRunIntegrationTest):
   def hermetic(cls):
     return True
 
-  def _do_test_goal_options(self, flags, expected_one, expected_two):
+  def _do_test_goal_options(self, flags, expected_one, expected_two, a_tag=set(), b_tag=set()):
     with temporary_dir(root_dir=get_buildroot()) as src_dir:
       foo_dir = os.path.join(src_dir, 'foo')
       os.mkdir(foo_dir)
       with open(os.path.join(foo_dir, 'BUILD'), 'w') as fp:
         fp.write(textwrap.dedent("""
-        target(name='a', dependencies=[':b'])
-        target(name='b')
-        """))
+        target(name='a', dependencies=[':b'], tags={})
+        target(name='b', tags={})
+        """).format(a_tag, b_tag))
 
       config = {
         'GLOBAL': {
@@ -43,21 +43,42 @@ def get_echo(which):
             return None
           else:
             with open(path, 'r') as fp:
-              return [os.path.basename(x.strip()) for x in fp.readlines()]
-        self.assertEqual(expected_one, get_echo('one'))
-        self.assertEqual(expected_two, get_echo('two'))
+              return {os.path.basename(x.strip()) for x in fp.readlines()}
+
+        self.assertEqual(expected_one, get_echo('one'),
+                         'one expected {}, but got {}'.format(expected_one, get_echo('one')))
+        self.assertEqual(expected_two, get_echo('two'),
+                         'two expected {}, but got {}'.format(expected_two, get_echo('two')))
 
   def test_defaults(self):
-    self._do_test_goal_options([], ['foo:a', 'foo:b'], ['foo:a', 'foo:b'])
+    self._do_test_goal_options([], {'foo:a', 'foo:b'}, {'foo:a', 'foo:b'})
 
   def test_set_at_goal_level(self):
     self._do_test_goal_options(['--skip'], None, None)
 
   def test_set_at_task_level(self):
-    self._do_test_goal_options(['--echo-one-skip'], None, ['foo:a', 'foo:b'])
-    self._do_test_goal_options(['--no-echo-two-transitive'], ['foo:a', 'foo:b'], ['foo:a'])
+    self._do_test_goal_options(['--echo-one-skip'], None, {'foo:a', 'foo:b'})
+    self._do_test_goal_options(['--no-echo-two-transitive'], {'foo:a', 'foo:b'}, {'foo:a'})
 
   def test_set_at_goal_and_task_level(self):
-    self._do_test_goal_options(['--skip', '--no-echo-one-skip'], ['foo:a', 'foo:b'], None)
+    self._do_test_goal_options(['--skip', '--no-echo-one-skip'], {'foo:a', 'foo:b'}, None)
     self._do_test_goal_options(['--no-transitive', '--echo-two-transitive'],
-                               ['foo:a'], ['foo:a', 'foo:b'])
+                               {'foo:a'}, {'foo:a', 'foo:b'})
+
+  def test_task_skip_but_target_tag_no_skip(self):
+    self._do_test_goal_options(['--echo-one-skip', '--echo-two-skip'],
+                               expected_one={'foo:a'},
+                               expected_two={'foo:a'},
+                               a_tag={"no-echo.one.skip", "no-echo.two.skip"})
+
+  def test_task_no_skip_but_target_tag_skip_a(self):
+    self._do_test_goal_options(['--no-echo-one-skip', '--no-echo-two-skip'],
+                               expected_one={'foo:b'},
+                               expected_two={'foo:b'},
+                               a_tag={"echo.one.skip", "echo.two.skip"})
+
+  def test_task_no_skip_but_target_tag_skip_b(self):
+    self._do_test_goal_options(['--no-echo-one-skip', '--no-echo-two-skip'],
+                               expected_one={'foo:a'},
+                               expected_two={'foo:a'},
+                               b_tag={"echo.one.skip", "echo.two.skip"})