def mk_cache(spec): Subsystem.reset() self.set_options_for_scope(CacheSetup.subscope(DummyTask.options_scope), read_from=spec, compression=1) self.context(for_task_types=[DummyTask]) # Force option initialization. cache_factory = CacheSetup.create_cache_factory_for_task(DummyTask) return cache_factory.get_read_cache()
def mk_cache(spec, resolver=None): Subsystem.reset() self.set_options_for_scope(CacheSetup.subscope(DummyTask.options_scope), read_from=spec, compression=1) self.context(for_task_types=[DummyTask]) # Force option initialization. cache_factory = CacheSetup.create_cache_factory_for_task(DummyTask, pinger=self.pinger, resolver=resolver) return cache_factory.get_read_cache()
def mk_cache(spec): Subsystem.reset() self.set_options_for_scope(CacheSetup.subscope( DummyTask.options_scope), read_from=spec, compression=1) self.context(for_task_types=[DummyTask ]) # Force option initialization. cache_factory = CacheSetup.create_cache_factory_for_task( DummyTask, pinger=MockPinger({ 'host1': 5, 'host2:666': 3, 'host3': 7 })) return cache_factory.get_read_cache()
def __init__(self, context, workdir): """Subclass __init__ methods, if defined, *must* follow this idiom: class MyTask(Task): def __init__(self, *args, **kwargs): super(MyTask, self).__init__(*args, **kwargs) ... This allows us to change Task.__init__()'s arguments without changing every subclass. If the subclass does not need its own initialization, this method can (and should) be omitted entirely. """ super(TaskBase, self).__init__() self.context = context self._workdir = workdir # TODO: It would be nice to use self.get_options().cache_key_gen_version here, because then # we could have a separate value for each scope if we really wanted to. However we can't # access per-task options in Task.__init__ because GroupTask.__init__ calls it with the # group task's scope, which isn't currently in the known scopes we generate options for. self._cache_key_generator = CacheKeyGenerator( self.context.options.for_global_scope().cache_key_gen_version) self._cache_key_errors = set() self._build_invalidator_dir = os.path.join( self.context.options.for_global_scope().pants_workdir, 'build_invalidator', self.stable_name()) self._cache_factory = CacheSetup.create_cache_factory_for_task(self) self._options_fingerprinter = OptionsFingerprinter( self.context.build_graph) self._fingerprint = None
def __init__(self, context, workdir): """Subclass __init__ methods, if defined, *must* follow this idiom: class MyTask(Task): def __init__(self, *args, **kwargs): super(MyTask, self).__init__(*args, **kwargs) ... This allows us to change Task.__init__()'s arguments without changing every subclass. If the subclass does not need its own initialization, this method can (and should) be omitted entirely. :API: public """ super(TaskBase, self).__init__() self.context = context self._workdir = workdir self._cache_key_errors = set() self._build_invalidator_dir = os.path.join( self.context.options.for_global_scope().pants_workdir, 'build_invalidator', self.stable_name()) self._cache_factory = CacheSetup.create_cache_factory_for_task(self) self._options_fingerprinter = OptionsFingerprinter(self.context.build_graph)
def __init__(self, context, workdir): """Subclass __init__ methods, if defined, *must* follow this idiom: class MyTask(Task): def __init__(self, *args, **kwargs): super(MyTask, self).__init__(*args, **kwargs) ... This allows us to change Task.__init__()'s arguments without changing every subclass. If the subclass does not need its own initialization, this method can (and should) be omitted entirely. """ super(TaskBase, self).__init__() self.context = context self._workdir = workdir # TODO: It would be nice to use self.get_options().cache_key_gen_version here, because then # we could have a separate value for each scope if we really wanted to. However we can't # access per-task options in Task.__init__ because GroupTask.__init__ calls it with the # group task's scope, which isn't currently in the known scopes we generate options for. self._cache_key_generator = CacheKeyGenerator(self.context.options.for_global_scope().cache_key_gen_version) self._cache_key_errors = set() self._build_invalidator_dir = os.path.join( self.context.options.for_global_scope().pants_workdir, "build_invalidator", self.stable_name() ) self._cache_factory = CacheSetup.create_cache_factory_for_task(self)
def __init__(self, context, workdir): """Subclass __init__ methods, if defined, *must* follow this idiom: class MyTask(Task): def __init__(self, *args, **kwargs): super(MyTask, self).__init__(*args, **kwargs) ... This allows us to change Task.__init__()'s arguments without changing every subclass. If the subclass does not need its own initialization, this method can (and should) be omitted entirely. :API: public """ super(TaskBase, self).__init__() self.context = context self._workdir = workdir self._cache_key_errors = set() self._build_invalidator_dir = os.path.join( self.context.options.for_global_scope().pants_workdir, 'build_invalidator', self.stable_name()) self._cache_factory = CacheSetup.create_cache_factory_for_task(self) self._options_fingerprinter = OptionsFingerprinter( self.context.build_graph)
def subsystem_dependencies(cls): # NB: `Goal.Options` implements `SubsystemClientMixin` in order to allow v1 `Tasks` to # depend on v2 Goals, and for `Goals` to declare a deprecated dependency on a `CacheSetup` # instance for backwards compatibility purposes. But v2 Goals should _not_ have subsystem # dependencies: instead, the @rules participating (transitively) in a Goal should directly # declare their Subsystem deps. if outer_cls.deprecated_cache_setup_removal_version: dep = CacheSetup.scoped( cls, removal_version=outer_cls.deprecated_cache_setup_removal_version, removal_hint='Goal `{}` uses an independent caching implementation, and ignores `{}`.'.format( cls.options_scope, CacheSetup.subscope(cls.options_scope), ) ) return (dep,) return tuple()
def __init__(self, context, workdir): """Subclass __init__ methods, if defined, *must* follow this idiom: class MyTask(Task): def __init__(self, *args, **kwargs): super(MyTask, self).__init__(*args, **kwargs) ... This allows us to change Task.__init__()'s arguments without changing every subclass. If the subclass does not need its own initialization, this method can (and should) be omitted entirely. :API: public """ super(TaskBase, self).__init__() self.context = context self._workdir = workdir self._task_name = type(self).__name__ self._cache_key_errors = set() self._cache_factory = CacheSetup.create_cache_factory_for_task(self) self._force_invalidated = False
def subsystem_dependencies(cls): return (super().subsystem_dependencies() + (CacheSetup.scoped(cls), BuildInvalidator.Factory, SourceRootConfig) + ((TargetFilter.scoped(cls), ) if cls.target_filtering_enabled else tuple()))
def subsystem_dependencies(cls): return (super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls), BuildInvalidator.Factory, SourceRootConfig))
def subsystem_dependencies(cls): return super(TaskBase, cls).subsystem_dependencies() + ( CacheSetup.scoped(cls), BuildInvalidator.Factory)
def subsystem_dependencies(cls): return super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls), BuildInvalidator.Factory)
def subsystem_dependencies(cls): return super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls), )
def subsystem_dependencies(cls): return (super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls), BuildInvalidator.Factory, SourceRootConfig) + ((TargetFilter.scoped(cls),) if cls.target_filtering_enabled else tuple()))
def subsystem_dependencies(cls): return super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls),)
def subsystem_dependencies(cls): dep = CacheSetup.scoped( Zinc.Factory, removal_version='1.20.0.dev0', removal_hint='Cache options for `zinc` should move to `rsc`.') return super().subsystem_dependencies() + (Rsc, dep.optionable_cls)