def __init__(self, options, run_tracker, target_roots, requested_goals=None, target_base=None, build_graph=None, build_file_parser=None, address_mapper=None, console_outstream=None, scm=None, workspace=None, spec_excludes=None, invalidation_report=None): self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.address_mapper = address_mapper self.run_tracker = run_tracker self._log = self.Log(run_tracker) self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._lock = OwnerPrintingPIDLockFile( os.path.join(self._buildroot, '.pants.run')) self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self._spec_excludes = spec_excludes self._replace_targets(target_roots) self._synthetic_targets = defaultdict(list) self._invalidation_report = invalidation_report
def __init__(self, options, run_tracker, target_roots, requested_goals=None, target_base=None, build_graph=None, build_file_parser=None, build_configuration=None, address_mapper=None, console_outstream=None, scm=None, workspace=None, invalidation_report=None, scheduler=None): self._options = options # We register a callback that will cause build graph edits to invalidate our caches, and we hold # a handle directly to the callback function to ensure that it is not GC'd until the context is. self.build_graph = build_graph self._clear_target_cache_handle = self._clear_target_cache self._targets_cache = dict() self.build_graph.add_invalidation_callback(self._clear_target_cache_handle) self._build_file_parser = build_file_parser self.build_configuration = build_configuration self.address_mapper = address_mapper self.run_tracker = run_tracker self._log = run_tracker.logger self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._source_roots = SourceRootConfig.global_instance().get_source_roots() self._lock = OwnerPrintingInterProcessFileLock(os.path.join(self._buildroot, '.pants.workdir.file_lock')) self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout.buffer self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self._replace_targets(target_roots) self._invalidation_report = invalidation_report self._scheduler = scheduler
def __init__(self, options, run_tracker, target_roots, requested_goals=None, target_base=None, build_graph=None, build_file_parser=None, address_mapper=None, console_outstream=None, scm=None, workspace=None, invalidation_report=None): self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.address_mapper = address_mapper self.run_tracker = run_tracker self._log = self.Log(run_tracker) self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._source_roots = SourceRootConfig.global_instance( ).get_source_roots() self._lock = OwnerPrintingInterProcessFileLock( os.path.join(self._buildroot, '.pants.workdir.file_lock')) self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self._replace_targets(target_roots) self._invalidation_report = invalidation_report
def __init__(self, config, options, run_tracker, target_roots, requested_goals=None, lock=None, log=None, target_base=None, build_graph=None, build_file_parser=None): self._config = config self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.run_tracker = run_tracker self._lock = lock or Lock.unlocked() self._log = log or Context.Log(run_tracker) self._target_base = target_base or Target self._state = {} self._products = Products() self._buildroot = get_buildroot() self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self.replace_targets(target_roots)
def __init__(self, config, options, run_tracker, target_roots, requested_goals=None, lock=None, log=None, target_base=None, build_graph=None, build_file_parser=None, address_mapper=None, console_outstream=None, scm=None, workspace=None): self._config = config self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.address_mapper = address_mapper self.run_tracker = run_tracker self._lock = lock or Lock.unlocked() self._log = log or Context.Log(run_tracker) self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self.replace_targets(target_roots)
def __init__(self, options, run_tracker, target_roots, requested_goals=None, target_base=None, build_graph=None, build_file_parser=None, address_mapper=None, console_outstream=None, scm=None, workspace=None, spec_excludes=None, invalidation_report=None): """ :API: public """ deprecated_conditional( lambda: spec_excludes is not None, '0.0.75', 'Use address_mapper#build_ignore_patterns instead.') self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.address_mapper = address_mapper self.run_tracker = run_tracker self._log = self.Log(run_tracker) self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._source_roots = SourceRootConfig.global_instance( ).get_source_roots() self._lock = OwnerPrintingPIDLockFile( os.path.join(self._buildroot, '.pants.run')) self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self._spec_excludes = spec_excludes self._replace_targets(target_roots) self._invalidation_report = invalidation_report
def __init__(self, config, options, run_tracker, target_roots, requested_goals=None, log=None, target_base=None, build_graph=None, build_file_parser=None, address_mapper=None, console_outstream=None, scm=None, workspace=None, spec_excludes=None): self._config = config self._options = options self.build_graph = build_graph self.build_file_parser = build_file_parser self.address_mapper = address_mapper self.run_tracker = run_tracker self._log = log or Context.Log(run_tracker) self._target_base = target_base or Target self._products = Products() self._buildroot = get_buildroot() self._lock = OwnerPrintingPIDLockFile( os.path.join(self._buildroot, '.pants.run')) self._java_sysprops = None # Computed lazily. self.requested_goals = requested_goals or [] self._console_outstream = console_outstream or sys.stdout self._scm = scm or get_scm() self._workspace = workspace or (ScmWorkspace(self._scm) if self._scm else None) self._spec_excludes = spec_excludes self._target_roots_have_been_accessed = False self.replace_targets(target_roots)
def setUp(self): super().setUp() self.products = Products()
class ProductsTest(TestBase): def setUp(self): super().setUp() self.products = Products() def test_require(self): self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) # require should not cross-contaminate require_data self.assertFalse(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) def test_get(self): foo_product_mapping1 = self.products.get('foo') foo_product_mapping2 = self.products.get('foo') self.assertIsInstance(foo_product_mapping1, Products.ProductMapping) self.assertIs(foo_product_mapping1, foo_product_mapping2) def test_get_does_not_require(self): self.assertFalse(self.products.isrequired('foo')) self.products.get('foo') self.assertFalse(self.products.isrequired('foo')) self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) def test_require_data(self): self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) # require_data should not cross-contaminate require self.assertFalse(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) def test_get_data(self): self.assertIsNone(self.products.get_data('foo')) data1 = self.products.get_data('foo', dict) data2 = self.products.get_data('foo', dict) self.assertIsInstance(data1, dict) self.assertIs(data1, data2) def test_get_data_does_not_require_data(self): self.assertFalse(self.products.is_required_data('foo')) self.products.get_data('foo') self.assertFalse(self.products.is_required_data('foo')) self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) def test_register_data(self): data = {} self.assertIs(data, self.products.register_data('foo', data)) with self.assertRaises(ProductError): self.products.register_data('foo', data) def test_empty_products(self): foo_product_mapping = self.products.get('foo') self.assertFalse(foo_product_mapping) @contextmanager def add_products(self, context_products, product_type, target, *products): product_mapping = context_products.get(product_type) with temporary_dir() as outdir: def create_product(product): with safe_open(os.path.join(outdir, product), mode='w') as fp: fp.write(product) return product product_mapping.add( target, outdir, [create_product(product) for product in products]) yield temporary_dir def test_non_empty_products(self): target = self.make_target('c') with self.add_products(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get('foo') self.assertTrue(foo_product_mapping) def test_empty_data(self): foo_product_mapping = self.products.get_data('foo') self.assertFalse(foo_product_mapping) @contextmanager def add_data(self, context_products, data_type, target, *products): make_products = lambda: defaultdict(MultipleRootedProducts) data_by_target = context_products.get_data(data_type, make_products) with temporary_dir() as outdir: def create_product(product): abspath = os.path.join(outdir, product) with safe_open(abspath, mode='w') as fp: fp.write(product) return abspath data_by_target[target].add_abs_paths( outdir, [create_product(product) for product in products]) yield temporary_dir def test_non_empty_data(self): target = self.make_target('c') with self.add_data(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get_data('foo') self.assertTrue(foo_product_mapping)
def setUp(self): super(ProductsTest, self).setUp() self.products = Products()
class ProductsTest(BaseTest): def setUp(self): super(ProductsTest, self).setUp() self.products = Products() def test_require(self): self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) # require should not cross-contaminate require_data self.assertFalse(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) def test_get(self): foo_product_mapping1 = self.products.get('foo') foo_product_mapping2 = self.products.get('foo') self.assertIsInstance(foo_product_mapping1, Products.ProductMapping) self.assertIs(foo_product_mapping1, foo_product_mapping2) def test_get_does_not_require(self): self.assertFalse(self.products.isrequired('foo')) self.products.get('foo') self.assertFalse(self.products.isrequired('foo')) self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) def test_require_data(self): self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) # require_data should not cross-contaminate require self.assertFalse(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) def test_get_data(self): self.assertIsNone(self.products.get_data('foo')) data1 = self.products.get_data('foo', dict) data2 = self.products.get_data('foo', dict) self.assertIsInstance(data1, dict) self.assertIs(data1, data2) def test_get_data_does_not_require_data(self): self.assertFalse(self.products.is_required_data('foo')) self.products.get_data('foo') self.assertFalse(self.products.is_required_data('foo')) self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) def test_empty_products(self): foo_product_mapping = self.products.get('foo') self.assertFalse(foo_product_mapping) def test_non_empty_products(self): target = self.make_target('c') with self.add_products(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get('foo') self.assertTrue(foo_product_mapping) def test_empty_data(self): foo_product_mapping = self.products.get_data('foo') self.assertFalse(foo_product_mapping) def test_non_empty_data(self): target = self.make_target('c') with self.add_data(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get_data('foo') self.assertTrue(foo_product_mapping)
class ProductsTest(TestBase): def setUp(self): super(ProductsTest, self).setUp() self.products = Products() def test_require(self): self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) # require should not cross-contaminate require_data self.assertFalse(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) def test_get(self): foo_product_mapping1 = self.products.get('foo') foo_product_mapping2 = self.products.get('foo') self.assertIsInstance(foo_product_mapping1, Products.ProductMapping) self.assertIs(foo_product_mapping1, foo_product_mapping2) def test_get_does_not_require(self): self.assertFalse(self.products.isrequired('foo')) self.products.get('foo') self.assertFalse(self.products.isrequired('foo')) self.products.require('foo') self.assertTrue(self.products.isrequired('foo')) def test_require_data(self): self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) # require_data should not cross-contaminate require self.assertFalse(self.products.isrequired('foo')) self.assertFalse(self.products.isrequired('bar')) def test_get_data(self): self.assertIsNone(self.products.get_data('foo')) data1 = self.products.get_data('foo', dict) data2 = self.products.get_data('foo', dict) self.assertIsInstance(data1, dict) self.assertIs(data1, data2) def test_get_data_does_not_require_data(self): self.assertFalse(self.products.is_required_data('foo')) self.products.get_data('foo') self.assertFalse(self.products.is_required_data('foo')) self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) def test_register_data(self): data = {} self.assertIs(data, self.products.register_data('foo', data)) with self.assertRaises(ProductError): self.products.register_data('foo', data) def test_empty_products(self): foo_product_mapping = self.products.get('foo') self.assertFalse(foo_product_mapping) @contextmanager def add_products(self, context_products, product_type, target, *products): product_mapping = context_products.get(product_type) with temporary_dir() as outdir: def create_product(product): with safe_open(os.path.join(outdir, product), mode='w') as fp: fp.write(product) return product product_mapping.add(target, outdir, [create_product(product) for product in products]) yield temporary_dir def test_non_empty_products(self): target = self.make_target('c') with self.add_products(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get('foo') self.assertTrue(foo_product_mapping) def test_empty_data(self): foo_product_mapping = self.products.get_data('foo') self.assertFalse(foo_product_mapping) @contextmanager def add_data(self, context_products, data_type, target, *products): make_products = lambda: defaultdict(MultipleRootedProducts) data_by_target = context_products.get_data(data_type, make_products) with temporary_dir() as outdir: def create_product(product): abspath = os.path.join(outdir, product) with safe_open(abspath, mode='w') as fp: fp.write(product) return abspath data_by_target[target].add_abs_paths(outdir, [create_product(product) for product in products]) yield temporary_dir def test_non_empty_data(self): target = self.make_target('c') with self.add_data(self.products, 'foo', target, 'a.class'): foo_product_mapping = self.products.get_data('foo') self.assertTrue(foo_product_mapping)
def setUp(self): self.products = Products()
class ProductsTest(unittest.TestCase): def setUp(self): self.products = Products() def test_require(self): self.products.require('foo') predicate = self.products.isrequired('foo') self.assertIsNotNone(predicate) self.assertFalse(predicate(42)) self.assertIsNone(self.products.isrequired('bar')) # require should not cross-contaminate require_data self.assertFalse(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) def test_require_predicate(self): self.products.require('foo', predicate=lambda x: x == 42) predicate = self.products.isrequired('foo') self.assertIsNotNone(predicate) self.assertTrue(predicate(42)) self.assertFalse(predicate(0)) def test_require_multiple_predicates(self): self.products.require('foo', predicate=lambda x: x == 1) self.products.require('foo', predicate=lambda x: x == 2) self.products.require('foo', predicate=lambda x: x == 3) predicate = self.products.isrequired('foo') self.assertIsNotNone(predicate) self.assertFalse(predicate(0)) self.assertTrue(predicate(1)) self.assertTrue(predicate(2)) self.assertTrue(predicate(3)) self.assertFalse(predicate(4)) def test_get(self): foo_product_mapping1 = self.products.get('foo') foo_product_mapping2 = self.products.get('foo') self.assertIsInstance(foo_product_mapping1, Products.ProductMapping) self.assertIs(foo_product_mapping1, foo_product_mapping2) def test_get_does_not_require(self): self.assertIsNone(self.products.isrequired('foo')) self.products.get('foo') self.assertIsNone(self.products.isrequired('foo')) self.products.require('foo') self.assertIsNotNone(self.products.isrequired('foo')) def test_require_data(self): self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo')) self.assertFalse(self.products.is_required_data('bar')) # require_data should not cross-contaminate require self.assertIsNone(self.products.isrequired('foo')) self.assertIsNone(self.products.isrequired('bar')) def test_get_data(self): self.assertIsNone(self.products.get_data('foo')) data1 = self.products.get_data('foo', dict) data2 = self.products.get_data('foo', dict) self.assertIsInstance(data1, dict) self.assertIs(data1, data2) def test_get_data_does_not_require_data(self): self.assertFalse(self.products.is_required_data('foo')) self.products.get_data('foo') self.assertFalse(self.products.is_required_data('foo')) self.products.require_data('foo') self.assertTrue(self.products.is_required_data('foo'))