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):
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_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'))
