tools/build_rules/java_rules_skylark.bzl - bazel - Git at Google

 # Copyright 2014 The Bazel Authors. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #    http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.

 java_filetype = FileType([".java"])
 jar_filetype = FileType([".jar"])
 srcjar_filetype = FileType([".jar", ".srcjar"])

 # This is a quick and dirty rule to make Bazel compile itself. It's not
 # production ready.

 def java_library_impl(ctx):
   javac_options = ctx.fragments.java.default_javac_flags
   class_jar = ctx.outputs.class_jar
   compile_time_jars = depset(order="topological")
   runtime_jars = depset(order="topological")
   for dep in ctx.attr.deps:
     compile_time_jars += dep.compile_time_jars
     runtime_jars += dep.runtime_jars

   jars = jar_filetype.filter(ctx.files.jars)
   neverlink_jars = jar_filetype.filter(ctx.files.neverlink_jars)
   compile_time_jars += jars + neverlink_jars
   runtime_jars += jars
   compile_time_jars_list = list(compile_time_jars) # TODO: This is weird.

   build_output = class_jar.path + ".build_output"
   java_output = class_jar.path + ".build_java"
   javalist_output = class_jar.path + ".build_java_list"
   sources = ctx.files.srcs

   sources_param_file = ctx.new_file(ctx.bin_dir, class_jar, "-2.params")
   ctx.file_action(
       output = sources_param_file,
       content = cmd_helper.join_paths("\n", depset(sources)),
       executable = False)

   # Cleaning build output directory
   cmd = "set -e;rm -rf " + build_output + " " + java_output + " " + javalist_output + "\n"
   cmd += "mkdir " + build_output + " " + java_output + "\n"
   files = " @" + sources_param_file.path

   if ctx.files.srcjars:
     files += " @" + javalist_output
     for file in ctx.files.srcjars:
       cmd += "%s tf %s | grep '\.java$' | sed 's|^|%s/|' >> %s\n" % (ctx.file._jar.path, file.path, java_output, javalist_output)
       cmd += "unzip %s -d %s >/dev/null\n" % (file.path, java_output)

   if ctx.files.srcs or ctx.files.srcjars:
     cmd += ctx.file._javac.path
     cmd += " " + " ".join(javac_options)
     if compile_time_jars:
       cmd += " -classpath '" + cmd_helper.join_paths(ctx.configuration.host_path_separator, compile_time_jars) + "'"
     cmd += " -d " + build_output + files + "\n"

   # We haven't got a good story for where these should end up, so
   # stick them in the root of the jar.
   for r in ctx.files.resources:
     cmd += "cp %s %s\n" % (r.path, build_output)
   cmd += (ctx.file._jar.path + " cf " + class_jar.path + " -C " + build_output + " .\n" +
          "touch " + build_output + "\n")
   ctx.action(
     inputs = (sources + compile_time_jars_list + [sources_param_file] +
               [ctx.file._jar] + ctx.files._jdk + ctx.files.resources + ctx.files.srcjars),
     outputs = [class_jar],
     mnemonic='JavacBootstrap',
     command=cmd,
     use_default_shell_env=True)

   runfiles = ctx.runfiles(collect_data = True)

   return struct(files = depset([class_jar]),
                 compile_time_jars = compile_time_jars + [class_jar],
                 runtime_jars = runtime_jars + [class_jar],
                 runfiles = runfiles)


 def java_binary_impl(ctx):
   library_result = java_library_impl(ctx)

   deploy_jar = ctx.outputs.deploy_jar
   manifest = ctx.outputs.manifest
   build_output = deploy_jar.path + ".build_output"
   main_class = ctx.attr.main_class
   ctx.file_action(
     output = manifest,
     content = "Main-Class: " + main_class + "\n",
     executable = False)

   # Cleaning build output directory
   cmd = "set -e;rm -rf " + build_output + ";mkdir " + build_output + "\n"
   for jar in library_result.runtime_jars:
     cmd += "unzip -qn " + jar.path + " -d " + build_output + "\n"
   cmd += (ctx.file._jar.path + " cmf " + manifest.path + " " +
          deploy_jar.path + " -C " + build_output + " .\n" +
          "touch " + build_output + "\n")

   ctx.action(
     inputs=list(library_result.runtime_jars) + [manifest] + ctx.files._jdk,
     outputs=[deploy_jar],
     mnemonic='Deployjar',
     command=cmd,
     use_default_shell_env=True)

   # Write the wrapper.
   executable = ctx.outputs.executable
   ctx.file_action(
     output = executable,
     content = '\n'.join([
         "#!/bin/bash",
         "# autogenerated - do not edit.",
         "case \"$0\" in",
         "/*) self=\"$0\" ;;",
         "*)  self=\"$PWD/$0\";;",
         "esac",
         "",
         "if [[ -z \"$JAVA_RUNFILES\" ]]; then",
         "  if [[ -e \"${self}.runfiles\" ]]; then",
         "    export JAVA_RUNFILES=\"${self}.runfiles\"",
         "  fi",
         "  if [[ -n \"$JAVA_RUNFILES\" ]]; then",
         "    export TEST_SRCDIR=${TEST_SRCDIR:-$JAVA_RUNFILES}",
         "  fi",
         "fi",
         "",

         "jvm_bin=%s" % (ctx.file._java.path),
         "if [[ ! -x ${jvm_bin} ]]; then",
         "  jvm_bin=$(which java)",
         "fi",

         # We extract the .so into a temp dir. If only we could mmap
         # directly from the zip file.
         "DEPLOY=$(dirname $self)/$(basename %s)" % deploy_jar.path,

         # This works both on Darwin and Linux, with the darwin path
         # looking like tmp.XXXXXXXX.{random}
         "SO_DIR=$(mktemp -d -t tmp.XXXXXXXXX)",
         "function cleanup() {",
         "  rm -rf ${SO_DIR}",
         "}",
         "trap cleanup EXIT",
         "unzip -q -d ${SO_DIR} ${DEPLOY} \"*.so\" \"*.dll\" \"*.dylib\" >& /dev/null",
         ("${jvm_bin} -Djava.library.path=${SO_DIR} %s -jar $DEPLOY \"$@\""
          % ' '.join(ctx.attr.jvm_flags)) ,
         "",
         ]),
     executable = True)

   runfiles = ctx.runfiles(files = [deploy_jar, executable] + ctx.files._jdk, collect_data = True)
   files_to_build = depset([deploy_jar, manifest, executable])
   files_to_build += library_result.files

   return struct(files = files_to_build, runfiles = runfiles)


 def java_import_impl(ctx):
   # TODO(bazel-team): Why do we need to filter here? The attribute
   # already says only jars are allowed.
   jars = depset(jar_filetype.filter(ctx.files.jars))
   neverlink_jars = depset(jar_filetype.filter(ctx.files.neverlink_jars))
   runfiles = ctx.runfiles(collect_data = True)
   return struct(files = jars,
                 compile_time_jars = jars + neverlink_jars,
                 runtime_jars = jars,
                 runfiles = runfiles)


 java_library_attrs = {
     "_java": attr.label(default=Label("//tools/jdk:java"), single_file=True),
     "_javac": attr.label(default=Label("//tools/jdk:javac"), single_file=True),
     "_jar": attr.label(default=Label("//tools/jdk:jar"), single_file=True),
     "_jdk": attr.label(default=Label("//tools/jdk:jdk"), allow_files=True),
     "data": attr.label_list(allow_files=True, cfg="data"),
     "resources": attr.label_list(allow_files=True),
     "srcs": attr.label_list(allow_files=java_filetype),
     "jars": attr.label_list(allow_files=jar_filetype),
     "neverlink_jars": attr.label_list(allow_files=jar_filetype),
     "srcjars": attr.label_list(allow_files=srcjar_filetype),
     "deps": attr.label_list(
         allow_files=False,
         providers = ["compile_time_jars", "runtime_jars"]),
     }

 java_library = rule(
     java_library_impl,
     attrs = java_library_attrs,
     outputs = {
         "class_jar": "lib%{name}.jar",
     },
     fragments = ['java', 'cpp'],
 )

 # A copy to avoid conflict with native rule.
 bootstrap_java_library = rule(
     java_library_impl,
     attrs = java_library_attrs,
     outputs = {
         "class_jar": "lib%{name}.jar",
     },
     fragments = ['java'],
 )

 java_binary_attrs_common = dict(java_library_attrs)
 java_binary_attrs_common.update({
     "jvm_flags": attr.string_list(),
     "jvm": attr.label(default=Label("//tools/jdk:jdk"), allow_files=True),
 })

 java_binary_attrs = dict(java_binary_attrs_common)
 java_binary_attrs["main_class"] = attr.string(mandatory=True)

 java_binary_outputs = {
     "class_jar": "lib%{name}.jar",
     "deploy_jar": "%{name}_deploy.jar",
     "manifest": "%{name}_MANIFEST.MF"
 }

 java_binary = rule(java_binary_impl,
    executable = True,
    attrs = java_binary_attrs,
    outputs = java_binary_outputs,
    fragments = ['java', 'cpp'],
 )

 # A copy to avoid conflict with native rule
 bootstrap_java_binary = rule(java_binary_impl,
    executable = True,
    attrs = java_binary_attrs,
    outputs = java_binary_outputs,
    fragments = ['java'],
 )

 java_test = rule(java_binary_impl,
    executable = True,
    attrs = dict(java_binary_attrs_common.items() + [
        ("main_class", attr.string(default="org.junit.runner.JUnitCore")),
        # TODO(bazel-team): it would be better if we could offer a
        # test_class attribute, but the "args" attribute is hard
        # coded in the bazel infrastructure.
    ]),
    outputs = java_binary_outputs,
    test = True,
    fragments = ['java', 'cpp'],
 )

 java_import = rule(
     java_import_impl,
     attrs = {
         "jars": attr.label_list(allow_files=jar_filetype),
         "srcjar": attr.label(allow_files=srcjar_filetype),
         "neverlink_jars": attr.label_list(allow_files=jar_filetype, default=[]),
     })
	# Copyright 2014 The Bazel Authors. All rights reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	java_filetype = FileType([".java"])
	jar_filetype = FileType([".jar"])
	srcjar_filetype = FileType([".jar", ".srcjar"])

	# This is a quick and dirty rule to make Bazel compile itself. It's not
	# production ready.

	def java_library_impl(ctx):
	javac_options = ctx.fragments.java.default_javac_flags
	class_jar = ctx.outputs.class_jar
	compile_time_jars = depset(order="topological")
	runtime_jars = depset(order="topological")
	for dep in ctx.attr.deps:
	compile_time_jars += dep.compile_time_jars
	runtime_jars += dep.runtime_jars

	jars = jar_filetype.filter(ctx.files.jars)
	neverlink_jars = jar_filetype.filter(ctx.files.neverlink_jars)
	compile_time_jars += jars + neverlink_jars
	runtime_jars += jars
	compile_time_jars_list = list(compile_time_jars) # TODO: This is weird.

	build_output = class_jar.path + ".build_output"
	java_output = class_jar.path + ".build_java"
	javalist_output = class_jar.path + ".build_java_list"
	sources = ctx.files.srcs

	sources_param_file = ctx.new_file(ctx.bin_dir, class_jar, "-2.params")
	ctx.file_action(
	output = sources_param_file,
	content = cmd_helper.join_paths("\n", depset(sources)),
	executable = False)

	# Cleaning build output directory
	cmd = "set -e;rm -rf " + build_output + " " + java_output + " " + javalist_output + "\n"
	cmd += "mkdir " + build_output + " " + java_output + "\n"
	files = " @" + sources_param_file.path

	if ctx.files.srcjars:
	files += " @" + javalist_output
	for file in ctx.files.srcjars:
	cmd += "%s tf %s \| grep '\.java$' \| sed 's\|^\|%s/\|' >> %s\n" % (ctx.file._jar.path, file.path, java_output, javalist_output)
	cmd += "unzip %s -d %s >/dev/null\n" % (file.path, java_output)

	if ctx.files.srcs or ctx.files.srcjars:
	cmd += ctx.file._javac.path
	cmd += " " + " ".join(javac_options)
	if compile_time_jars:
	cmd += " -classpath '" + cmd_helper.join_paths(ctx.configuration.host_path_separator, compile_time_jars) + "'"
	cmd += " -d " + build_output + files + "\n"

	# We haven't got a good story for where these should end up, so
	# stick them in the root of the jar.
	for r in ctx.files.resources:
	cmd += "cp %s %s\n" % (r.path, build_output)
	cmd += (ctx.file._jar.path + " cf " + class_jar.path + " -C " + build_output + " .\n" +
	"touch " + build_output + "\n")
	ctx.action(
	inputs = (sources + compile_time_jars_list + [sources_param_file] +
	[ctx.file._jar] + ctx.files._jdk + ctx.files.resources + ctx.files.srcjars),
	outputs = [class_jar],
	mnemonic='JavacBootstrap',
	command=cmd,
	use_default_shell_env=True)

	runfiles = ctx.runfiles(collect_data = True)

	return struct(files = depset([class_jar]),
	compile_time_jars = compile_time_jars + [class_jar],
	runtime_jars = runtime_jars + [class_jar],
	runfiles = runfiles)


	def java_binary_impl(ctx):
	library_result = java_library_impl(ctx)

	deploy_jar = ctx.outputs.deploy_jar
	manifest = ctx.outputs.manifest
	build_output = deploy_jar.path + ".build_output"
	main_class = ctx.attr.main_class
	ctx.file_action(
	output = manifest,
	content = "Main-Class: " + main_class + "\n",
	executable = False)

	# Cleaning build output directory
	cmd = "set -e;rm -rf " + build_output + ";mkdir " + build_output + "\n"
	for jar in library_result.runtime_jars:
	cmd += "unzip -qn " + jar.path + " -d " + build_output + "\n"
	cmd += (ctx.file._jar.path + " cmf " + manifest.path + " " +
	deploy_jar.path + " -C " + build_output + " .\n" +
	"touch " + build_output + "\n")

	ctx.action(
	inputs=list(library_result.runtime_jars) + [manifest] + ctx.files._jdk,
	outputs=[deploy_jar],
	mnemonic='Deployjar',
	command=cmd,
	use_default_shell_env=True)

	# Write the wrapper.
	executable = ctx.outputs.executable
	ctx.file_action(
	output = executable,
	content = '\n'.join([
	"#!/bin/bash",
	"# autogenerated - do not edit.",
	"case \"$0\" in",
	"/*) self=\"$0\" ;;",
	"*) self=\"$PWD/$0\";;",
	"esac",
	"",
	"if [[ -z \"$JAVA_RUNFILES\" ]]; then",
	" if [[ -e \"${self}.runfiles\" ]]; then",
	" export JAVA_RUNFILES=\"${self}.runfiles\"",
	" fi",
	" if [[ -n \"$JAVA_RUNFILES\" ]]; then",
	" export TEST_SRCDIR=${TEST_SRCDIR:-$JAVA_RUNFILES}",
	" fi",
	"fi",
	"",

	"jvm_bin=%s" % (ctx.file._java.path),
	"if [[ ! -x ${jvm_bin} ]]; then",
	" jvm_bin=$(which java)",
	"fi",

	# We extract the .so into a temp dir. If only we could mmap
	# directly from the zip file.
	"DEPLOY=$(dirname $self)/$(basename %s)" % deploy_jar.path,

	# This works both on Darwin and Linux, with the darwin path
	# looking like tmp.XXXXXXXX.{random}
	"SO_DIR=$(mktemp -d -t tmp.XXXXXXXXX)",
	"function cleanup() {",
	" rm -rf ${SO_DIR}",
	"}",
	"trap cleanup EXIT",
	"unzip -q -d ${SO_DIR} ${DEPLOY} \".so\" \".dll\" \"*.dylib\" >& /dev/null",
	("${jvm_bin} -Djava.library.path=${SO_DIR} %s -jar $DEPLOY \"$@\""
	% ' '.join(ctx.attr.jvm_flags)) ,
	"",
	]),
	executable = True)

	runfiles = ctx.runfiles(files = [deploy_jar, executable] + ctx.files._jdk, collect_data = True)
	files_to_build = depset([deploy_jar, manifest, executable])
	files_to_build += library_result.files

	return struct(files = files_to_build, runfiles = runfiles)


	def java_import_impl(ctx):
	# TODO(bazel-team): Why do we need to filter here? The attribute
	# already says only jars are allowed.
	jars = depset(jar_filetype.filter(ctx.files.jars))
	neverlink_jars = depset(jar_filetype.filter(ctx.files.neverlink_jars))
	runfiles = ctx.runfiles(collect_data = True)
	return struct(files = jars,
	compile_time_jars = jars + neverlink_jars,
	runtime_jars = jars,
	runfiles = runfiles)


	java_library_attrs = {
	"_java": attr.label(default=Label("//tools/jdk:java"), single_file=True),
	"_javac": attr.label(default=Label("//tools/jdk:javac"), single_file=True),
	"_jar": attr.label(default=Label("//tools/jdk:jar"), single_file=True),
	"_jdk": attr.label(default=Label("//tools/jdk:jdk"), allow_files=True),
	"data": attr.label_list(allow_files=True, cfg="data"),
	"resources": attr.label_list(allow_files=True),
	"srcs": attr.label_list(allow_files=java_filetype),
	"jars": attr.label_list(allow_files=jar_filetype),
	"neverlink_jars": attr.label_list(allow_files=jar_filetype),
	"srcjars": attr.label_list(allow_files=srcjar_filetype),
	"deps": attr.label_list(
	allow_files=False,
	providers = ["compile_time_jars", "runtime_jars"]),
	}

	java_library = rule(
	java_library_impl,
	attrs = java_library_attrs,
	outputs = {
	"class_jar": "lib%{name}.jar",
	},
	fragments = ['java', 'cpp'],
	)

	# A copy to avoid conflict with native rule.
	bootstrap_java_library = rule(
	java_library_impl,
	attrs = java_library_attrs,
	outputs = {
	"class_jar": "lib%{name}.jar",
	},
	fragments = ['java'],
	)

	java_binary_attrs_common = dict(java_library_attrs)
	java_binary_attrs_common.update({
	"jvm_flags": attr.string_list(),
	"jvm": attr.label(default=Label("//tools/jdk:jdk"), allow_files=True),
	})

	java_binary_attrs = dict(java_binary_attrs_common)
	java_binary_attrs["main_class"] = attr.string(mandatory=True)

	java_binary_outputs = {
	"class_jar": "lib%{name}.jar",
	"deploy_jar": "%{name}_deploy.jar",
	"manifest": "%{name}_MANIFEST.MF"
	}

	java_binary = rule(java_binary_impl,
	executable = True,
	attrs = java_binary_attrs,
	outputs = java_binary_outputs,
	fragments = ['java', 'cpp'],
	)

	# A copy to avoid conflict with native rule
	bootstrap_java_binary = rule(java_binary_impl,
	executable = True,
	attrs = java_binary_attrs,
	outputs = java_binary_outputs,
	fragments = ['java'],
	)

	java_test = rule(java_binary_impl,
	executable = True,
	attrs = dict(java_binary_attrs_common.items() + [
	("main_class", attr.string(default="org.junit.runner.JUnitCore")),
	# TODO(bazel-team): it would be better if we could offer a
	# test_class attribute, but the "args" attribute is hard
	# coded in the bazel infrastructure.
	]),
	outputs = java_binary_outputs,
	test = True,
	fragments = ['java', 'cpp'],
	)

	java_import = rule(
	java_import_impl,
	attrs = {
	"jars": attr.label_list(allow_files=jar_filetype),
	"srcjar": attr.label(allow_files=srcjar_filetype),
	"neverlink_jars": attr.label_list(allow_files=jar_filetype, default=[]),
	})