def test_simple(self): target = self.make_target(':foo', JvmBinary, main='com.example.Foo', basename='foo-base') self.assertEquals('com.example.Foo', target.main) self.assertEquals('com.example.Foo', target.payload.main) self.assertEquals('foo-base', target.basename) self.assertEquals('foo-base', target.payload.basename) self.assertEquals([], target.deploy_excludes) self.assertEquals([], target.payload.deploy_excludes) self.assertEquals(JarRules.default(), target.deploy_jar_rules) self.assertEquals(JarRules.default(), target.payload.deploy_jar_rules) self.assertEquals({}, target.payload.manifest_entries.entries)
def test_simple(self): self.add_to_build_file( "", 'jvm_binary(name = "foo", main = "com.example.Foo", basename = "foo-base")', ) target = self.target(":foo") self.assertEqual("com.example.Foo", target.main) self.assertEqual("com.example.Foo", target.payload.main) self.assertEqual("foo-base", target.basename) self.assertEqual("foo-base", target.payload.basename) self.assertEqual([], target.deploy_excludes) self.assertEqual([], target.payload.deploy_excludes) self.assertEqual(JarRules.default(), target.deploy_jar_rules) self.assertEqual(JarRules.default(), target.payload.deploy_jar_rules) self.assertEqual({}, target.payload.manifest_entries.entries)
def test_simple(self): self.add_to_build_file( '', 'jvm_binary(name = "foo", main = "com.example.Foo", basename = "foo-base")', ) target = self.target(':foo') self.assertEquals('com.example.Foo', target.main) self.assertEquals('com.example.Foo', target.payload.main) self.assertEquals('foo-base', target.basename) self.assertEquals('foo-base', target.payload.basename) self.assertEquals([], target.deploy_excludes) self.assertEquals([], target.payload.deploy_excludes) self.assertEquals(JarRules.default(), target.deploy_jar_rules) self.assertEquals(JarRules.default(), target.payload.deploy_jar_rules) self.assertEquals({}, target.payload.manifest_entries.entries)
def open_jar(self, path, overwrite=False, compressed=True, jar_rules=None): """Yields a Jar that will be written when the context exits. :param string path: the path to the jar file :param bool overwrite: overwrite the file at ``path`` if it exists; ``False`` by default; ie: update the pre-existing jar at ``path`` :param bool compressed: entries added to the jar should be compressed; ``True`` by default :param jar_rules: an optional set of rules for handling jar exclusions and duplicates """ jar = Jar() try: yield jar except jar.Error as e: raise TaskError('Failed to write to jar at %s: %s' % (path, e)) with jar._render_jar_tool_args() as args: if args: # Don't build an empty jar args.append('-update=%s' % self._flag(not overwrite)) args.append('-compress=%s' % self._flag(compressed)) jar_rules = jar_rules or JarRules.default() args.append('-default_action=%s' % self._action_name(jar_rules.default_dup_action)) skip_patterns = [] duplicate_actions = [] for rule in jar_rules.rules: if isinstance(rule, Skip): skip_patterns.append(rule.apply_pattern) elif isinstance(rule, Duplicate): duplicate_actions.append( '%s=%s' % (rule.apply_pattern.pattern, self._action_name(rule.action))) else: raise ValueError('Unrecognized rule: %s' % rule) if skip_patterns: args.append('-skip=%s' % ','.join(p.pattern for p in skip_patterns)) if duplicate_actions: args.append('-policies=%s' % ','.join(duplicate_actions)) args.append(path) jvm_args = self.context.config.getlist('jar-tool', 'jvm_args', default=['-Xmx64M']) self.runjava(self.tool_classpath('jar-tool'), 'com.twitter.common.jar.tool.Main', jvm_options=jvm_args, args=args, workunit_name='jar-tool', workunit_labels=[ WorkUnit.TOOL, WorkUnit.JVM, WorkUnit.NAILGUN ])
def test_simple(self): self.add_to_build_file('BUILD', dedent(''' jvm_binary(name='foo', main='com.example.Foo', basename='foo-base', ) ''')) target = self.target('//:foo') self.assertEquals('com.example.Foo', target.main) self.assertEquals('com.example.Foo', target.payload.main) self.assertEquals('foo-base', target.basename) self.assertEquals('foo-base', target.payload.basename) self.assertEquals([], target.deploy_excludes) self.assertEquals([], target.payload.deploy_excludes) self.assertEquals(JarRules.default(), target.deploy_jar_rules) self.assertEquals(JarRules.default(), target.payload.deploy_jar_rules) self.assertEquals({}, target.payload.manifest_entries.entries);
def test_deploy_jar_rules(self): target = self.make_target(':foo', JvmBinary, main='com.example.Foo', deploy_jar_rules=JarRules([Duplicate('foo', Duplicate.SKIP)], default_dup_action=Duplicate.FAIL)) jar_rules = target.deploy_jar_rules self.assertEquals(1, len(jar_rules.rules)) self.assertEquals('foo', jar_rules.rules[0].apply_pattern.pattern) self.assertEquals(repr(Duplicate.SKIP), repr(jar_rules.rules[0].action)) # <object object at 0x...> self.assertEquals(Duplicate.FAIL, jar_rules.default_dup_action)
def test_duplicate_rule_no_match(self): self.set_options(fail_fast=False) task, jvm_binary = self._setup_external_duplicate_with_rules( rules=JarRules([Skip('^com/twitter/commons/DoesNotExist.class$')])) conflicts_by_binary = task.execute() expected = { jvm_binary: { ('org.example-dups-0.0.1.jar', 'org.example-test-0.0.1.jar'): {'com/twitter/commons/Duplicate.class'} } } self.assertEqual(expected, conflicts_by_binary)
def open_jar(self, path, overwrite=False, compressed=True, jar_rules=None): """Yields a Jar that will be written when the context exits. :param string path: the path to the jar file :param bool overwrite: overwrite the file at ``path`` if it exists; ``False`` by default; ie: update the pre-existing jar at ``path`` :param bool compressed: entries added to the jar should be compressed; ``True`` by default :param jar_rules: an optional set of rules for handling jar exclusions and duplicates """ jar = Jar() try: yield jar except jar.Error as e: raise TaskError('Failed to write to jar at {}: {}'.format(path, e)) with jar._render_jar_tool_args() as args: if args: # Don't build an empty jar args.append('-update={}'.format(self._flag(not overwrite))) args.append('-compress={}'.format(self._flag(compressed))) jar_rules = jar_rules or JarRules.default() args.append('-default_action={}'.format(self._action_name(jar_rules.default_dup_action))) skip_patterns = [] duplicate_actions = [] for rule in jar_rules.rules: if isinstance(rule, Skip): skip_patterns.append(rule.apply_pattern) elif isinstance(rule, Duplicate): duplicate_actions.append('{}={}'.format( rule.apply_pattern.pattern, self._action_name(rule.action))) else: raise ValueError('Unrecognized rule: {}'.format(rule)) if skip_patterns: args.append('-skip={}'.format(','.join(p.pattern for p in skip_patterns))) if duplicate_actions: args.append('-policies={}'.format(','.join(duplicate_actions))) args.append(path) # TODO(Eric Ayers): This needs to be migrated with some thought behind it. Consider # that The jar-tool nailgun instance is shared between tasks and doesn't necessarily # need the same JVM args as its parent. jvm_options = self.context.config.getlist('jar-tool', 'jvm_args', default=['-Xmx64M']) self.runjava(self.tool_classpath('jar-tool'), 'com.twitter.common.jar.tool.Main', jvm_options=jvm_options, args=args, workunit_name='jar-tool', workunit_labels=[WorkUnit.TOOL, WorkUnit.JVM, WorkUnit.NAILGUN])
def open_jar(self, path, overwrite=False, compressed=True, jar_rules=None): """Yields a Jar that will be written when the context exits. :API: public :param string path: the path to the jar file :param bool overwrite: overwrite the file at ``path`` if it exists; ``False`` by default; ie: update the pre-existing jar at ``path`` :param bool compressed: entries added to the jar should be compressed; ``True`` by default :param jar_rules: an optional set of rules for handling jar exclusions and duplicates """ jar = Jar(path) try: yield jar except jar.Error as e: raise TaskError(f"Failed to write to jar at {path}: {e!r}") with jar._render_jar_tool_args(self.get_options()) as args: if args: # Don't build an empty jar args.append(f"-update={self._flag(not overwrite)}") args.append(f"-compress={self._flag(compressed)}") jar_rules = jar_rules or JarRules.default() args.append( f"-default_action={self._action_name(jar_rules.default_dup_action)}" ) skip_patterns = [] duplicate_actions = [] for rule in jar_rules.rules: if isinstance(rule, Skip): skip_patterns.append(rule.apply_pattern) elif isinstance(rule, Duplicate): duplicate_actions.append("{}={}".format( rule.apply_pattern.pattern, self._action_name(rule.action))) else: raise ValueError(f"Unrecognized rule: {rule}") if skip_patterns: args.append( f"-skip={','.join(p.pattern for p in skip_patterns)}") if duplicate_actions: args.append(f"-policies={','.join(duplicate_actions)}") args.append(path) if JarTool.global_instance().run(context=self.context, runjava=self.runjava, args=args): raise TaskError("jar-tool failed")
def open_jar(self, path, overwrite=False, compressed=True, jar_rules=None): """Yields a Jar that will be written when the context exits. :param string path: the path to the jar file :param bool overwrite: overwrite the file at ``path`` if it exists; ``False`` by default; ie: update the pre-existing jar at ``path`` :param bool compressed: entries added to the jar should be compressed; ``True`` by default :param jar_rules: an optional set of rules for handling jar exclusions and duplicates """ jar = Jar() try: yield jar except jar.Error as e: raise TaskError('Failed to write to jar at %s: %s' % (path, e)) with jar._render_jar_tool_args() as args: if args: # Don't build an empty jar args.append('-update=%s' % self._flag(not overwrite)) args.append('-compress=%s' % self._flag(compressed)) jar_rules = jar_rules or JarRules.default() args.append('-default_action=%s' % self._action_name(jar_rules.default_dup_action)) skip_patterns = [] duplicate_actions = [] for rule in jar_rules.rules: if isinstance(rule, Skip): skip_patterns.append(rule.apply_pattern) elif isinstance(rule, Duplicate): duplicate_actions.append('%s=%s' % (rule.apply_pattern.pattern, self._action_name(rule.action))) else: raise ValueError('Unrecognized rule: %s' % rule) if skip_patterns: args.append('-skip=%s' % ','.join(p.pattern for p in skip_patterns)) if duplicate_actions: args.append('-policies=%s' % ','.join(duplicate_actions)) args.append(path) jvm_args = self.context.config.getlist('jar-tool', 'jvm_args', default=['-Xmx64M']) self.runjava(self.tool_classpath(self._JAR_TOOL_CLASSPATH_KEY), 'com.twitter.common.jar.tool.Main', jvm_options=jvm_args, args=args, workunit_name='jar-tool', workunit_labels=[WorkUnit.TOOL, WorkUnit.JVM, WorkUnit.NAILGUN])
def open_jar(self, path, overwrite=False, compressed=True, jar_rules=None): """Yields a Jar that will be written when the context exits. :API: public :param string path: the path to the jar file :param bool overwrite: overwrite the file at ``path`` if it exists; ``False`` by default; ie: update the pre-existing jar at ``path`` :param bool compressed: entries added to the jar should be compressed; ``True`` by default :param jar_rules: an optional set of rules for handling jar exclusions and duplicates """ jar = Jar(path) try: yield jar except jar.Error as e: raise TaskError("Failed to write to jar at {}: {}".format(path, e)) with jar._render_jar_tool_args(self.get_options()) as args: if args: # Don't build an empty jar args.append("-update={}".format(self._flag(not overwrite))) args.append("-compress={}".format(self._flag(compressed))) jar_rules = jar_rules or JarRules.default() args.append("-default_action={}".format(self._action_name(jar_rules.default_dup_action))) skip_patterns = [] duplicate_actions = [] for rule in jar_rules.rules: if isinstance(rule, Skip): skip_patterns.append(rule.apply_pattern) elif isinstance(rule, Duplicate): duplicate_actions.append( "{}={}".format(rule.apply_pattern.pattern, self._action_name(rule.action)) ) else: raise ValueError("Unrecognized rule: {}".format(rule)) if skip_patterns: args.append("-skip={}".format(",".join(p.pattern for p in skip_patterns))) if duplicate_actions: args.append("-policies={}".format(",".join(duplicate_actions))) args.append(path) if JarTool.global_instance().run(context=self.context, runjava=self.runjava, args=args): raise TaskError("jar-tool failed")
def test_set_bad_default(self): with self.assertRaisesRegexp(ValueError, r'The default rules must be a JarRules'): JarRules.set_default(None)
def test_default(self): jar_rules = JarRules.default() self.assertTrue(4, len(jar_rules.rules)) for rule in jar_rules.rules: self.assertTrue( rule.apply_pattern.pattern.startswith(r'^META-INF'))
def test_jar_rules_field(self): field1 = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.SKIP)])) field1_same = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.SKIP)])) field2 = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.CONCAT)])) field3 = FingerprintedField( JarRules(rules=[Duplicate('bar', Duplicate.SKIP)])) field4 = FingerprintedField( JarRules(rules=[ Duplicate('foo', Duplicate.SKIP), Duplicate('bar', Duplicate.SKIP) ])) field5 = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.SKIP), Skip('foo')])) field6 = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.SKIP)], default_dup_action=Duplicate.FAIL)) field6_same = FingerprintedField( JarRules(rules=[Duplicate('foo', Duplicate.SKIP)], default_dup_action=Duplicate.FAIL)) field7 = FingerprintedField(JarRules(rules=[Skip('foo')])) field8 = FingerprintedField(JarRules(rules=[Skip('bar')])) field8_same = FingerprintedField(JarRules(rules=[Skip('bar')])) self.assertEquals(field1.fingerprint(), field1_same.fingerprint()) self.assertEquals(field6.fingerprint(), field6_same.fingerprint()) self.assertEquals(field8.fingerprint(), field8_same.fingerprint()) self._assert_fingerprints_not_equal( [field1, field2, field3, field4, field5, field6, field7])
def test_duplicate_rule_skip(self): self.set_options(fail_fast=False) task, _ = self._setup_external_duplicate_with_rules( rules=JarRules([Skip('^com/twitter/commons/Duplicate.class$')])) conflicts_by_binary = task.execute() self.assertEqual({}, conflicts_by_binary)
def test_default(self): jar_rules = JarRules.default() self.assertTrue(4, len(jar_rules.rules)) for rule in jar_rules.rules: self.assertTrue(rule.apply_pattern.pattern.startswith(r'^META-INF'))