| """ Custom rule to generate OSGi Manifest """ |
| |
| load("@rules_java//java:defs.bzl", "JavaInfo", "java_library") |
| |
| # Note that this rule is currently agnostic of protobuf concerns and could be |
| # pulled out as a general purpose helper to allow migrations from maven to bazel |
| # for OSS release builds. |
| # |
| # There are (at least) 3 things that would nice to fix about this rule: |
| # 1. `deps` are captured by wrapping the java_library target into the |
| # osgi_java_library target -- if possible, it would be better to get |
| # the deps from the JavaInfo or some other provider from any java_library |
| # target. |
| # 2. imports are probably not being calculated properly for deps that are more |
| # than 1 step deep in the dependency chain. For example: //java:core depends |
| # on //java/core:lite_runtime_only but does not calculate the need for |
| # "sun.misc" like the //java/core:lite target does (even though the same code |
| # is transitively included. Those imports can be explicitly added through |
| # `bundle_additional_imports`, but it would be better if the calculation |
| # applied correctly to transitive dependencies. |
| # 3. Versioned imports didn't work properly when an ijar is used as the |
| # "compile_jar". Thus, this rule uses the full jar as the compile_jar, |
| # which is probably sub-optimal. |
| def osgi_java_library( |
| name, |
| automatic_module_name, |
| bundle_description, |
| bundle_doc_url, |
| bundle_license, |
| bundle_name, |
| bundle_symbolic_name, |
| bundle_version, |
| bundle_additional_imports = [], |
| bundle_additional_exports = [], |
| deps = [], |
| exports = [], |
| exported_plugins = [], |
| neverlink = False, |
| runtime_deps = [], |
| visibility = [], |
| **kwargs): |
| """Extends `java_library` to add OSGi headers to the MANIFEST.MF using bndlib |
| |
| This macro should be usable as a drop-in replacement for java_library. |
| |
| The additional arguments are given the bndlib tool to generate an OSGi-compliant manifest file. |
| See [bnd documentation](https://bnd.bndtools.org/chapters/110-introduction.html) |
| |
| Args: |
| name: (required) A unique name for this target. |
| bundle_description: (required) The Bundle-Description header defines a short |
| description of this bundle. |
| bundle_doc_url: (required) The Bundle-DocURL headers must contain a URL pointing |
| to documentation about this bundle. |
| bundle_license: (required) The Bundle-License header provides an optional machine |
| readable form of license information. |
| bundle_name: (required) The Bundle-Name header defines a readable name for this |
| bundle. This should be a short, human-readable name that can |
| contain spaces. |
| bundle_symbolic_name: (required) The Bundle-SymbolicName header specifies a |
| non-localizable name for this bundle. The bundle symbolic name |
| together with a version must identify a unique bundle though it can |
| be installed multiple times in a framework. The bundle symbolic |
| name should be based on the reverse domain name convention. |
| bundle_version: (required) The Bundle-Version header specifies the version string |
| for this bundle. The version string is expected to follow semantic |
| versioning conventions MAJOR.MINOR.PATCH[.BUILD] |
| bundle_additional_exports: The Export-Package header contains a |
| declaration of exported packages. These are additional export |
| package statements to be added before the default wildcard export |
| "*;version={$Bundle-Version}". |
| bundle_additional_imports: The Import-Package header declares the |
| imported packages for this bundle. These are additional import |
| package statements to be added before the default wildcard import |
| "*". |
| deps: The list of libraries to link into this library. See general |
| comments about deps at Typical attributes defined by most build |
| rules. The jars built by java_library rules listed in deps will be |
| on the compile-time classpath of this rule. Furthermore the |
| transitive closure of their deps, runtime_deps and exports will be |
| on the runtime classpath. By contrast, targets in the data |
| attribute are included in the runfiles but on neither the |
| compile-time nor runtime classpath. |
| exports: Exported libraries. |
| exported_plugins: The list of java_plugins (e.g. annotation processors) |
| to export to libraries that directly depend on this library. The |
| specified list of java_plugins will be applied to any library which |
| directly depends on this library, just as if that library had |
| explicitly declared these labels in plugins. |
| neverlink: Whether this library should only be used for compilation and |
| not at runtime. Useful if the library will be provided by the runtime |
| environment during execution. Examples of such libraries are the IDE |
| APIs for IDE plug-ins or tools.jar for anything running on a standard |
| JDK. |
| runtime_deps: Libraries to make available to the final binary or test |
| at runtime only. Like ordinary deps, these will appear on the runtime |
| classpath, but unlike them, not on the compile-time classpath. |
| Dependencies needed only at runtime should be listed here. |
| Dependency-analysis tools should ignore targets that appear in both |
| runtime_deps and deps |
| visibility: The visibility attribute on a target controls whether the |
| target can be used in other packages. See the documentation for |
| visibility. |
| **kwargs: Additional key-word arguments that are passed to the internal |
| java_library target. |
| """ |
| |
| # Build the private jar without the OSGI manifest |
| private_library_name = "%s-no-manifest-do-not-use" % name |
| java_library( |
| name = private_library_name, |
| deps = deps, |
| runtime_deps = runtime_deps, |
| neverlink = True, |
| exported_plugins = exported_plugins, |
| visibility = ["//visibility:private"], |
| **kwargs |
| ) |
| |
| # Repackage the jar with an OSGI manifest |
| _osgi_jar( |
| name = name, |
| automatic_module_name = automatic_module_name, |
| bundle_description = bundle_description, |
| bundle_doc_url = bundle_doc_url, |
| bundle_license = bundle_license, |
| bundle_name = bundle_name, |
| bundle_symbolic_name = bundle_symbolic_name, |
| bundle_version = bundle_version, |
| export_package = bundle_additional_exports + ["*;version=${Bundle-Version}"], |
| import_package = bundle_additional_imports + ["*"], |
| target = private_library_name, |
| deps = deps, |
| runtime_deps = runtime_deps, |
| exported_plugins = exported_plugins, |
| neverlink = neverlink, |
| exports = exports, |
| visibility = visibility, |
| ) |
| |
| def _run_osgi_wrapper(ctx, input_jar, classpath_jars, output_jar): |
| args = ctx.actions.args() |
| args.add_joined("--classpath", classpath_jars, join_with = ":") |
| args.add("--input_jar", input_jar.path) |
| args.add("--output_jar", output_jar.path) |
| args.add("--automatic_module_name", ctx.attr.automatic_module_name) |
| args.add("--bundle_copyright", ctx.attr.bundle_copyright) |
| args.add("--bundle_description", ctx.attr.bundle_description) |
| args.add("--bundle_doc_url", ctx.attr.bundle_doc_url) |
| args.add("--bundle_license", ctx.attr.bundle_license) |
| args.add("--bundle_name", ctx.attr.bundle_name) |
| args.add("--bundle_version", ctx.attr.bundle_version) |
| args.add("--bundle_symbolic_name", ctx.attr.bundle_symbolic_name) |
| args.add_joined("--export_package", ctx.attr.export_package, join_with = ",") |
| args.add_joined("--import_package", ctx.attr.import_package, join_with = ",") |
| |
| ctx.actions.run( |
| inputs = [input_jar] + classpath_jars, |
| executable = ctx.executable._osgi_wrapper_exe, |
| arguments = [args], |
| outputs = [output_jar], |
| progress_message = "Generating OSGi bundle Manifest for %s" % input_jar.path, |
| ) |
| |
| def _osgi_jar_impl(ctx): |
| if len(ctx.attr.target[JavaInfo].java_outputs) != 1: |
| fail("osgi_jar rule can only be used on a single java target.") |
| target_java_output = ctx.attr.target[JavaInfo].java_outputs[0] |
| |
| # source_jars may be a list or a Depset due to: |
| # https://github.com/bazelbuild/bazel/issues/18966 |
| source_jars = target_java_output.source_jars |
| if hasattr(source_jars, "to_list"): |
| source_jars = source_jars.to_list() |
| if len(source_jars) > 1: |
| fail("osgi_jar rule doesn't know how to deal with more than one source jar.") |
| source_jar = source_jars[0] |
| |
| output_jar = ctx.outputs.output_jar |
| |
| input_jar = target_java_output.class_jar |
| classpath_jars = ctx.attr.target[JavaInfo].compilation_info.compilation_classpath.to_list() |
| |
| _run_osgi_wrapper(ctx, input_jar, classpath_jars, output_jar) |
| |
| return [ |
| DefaultInfo( |
| files = depset([output_jar]), |
| # Workaround for https://github.com/bazelbuild/bazel/issues/15043 |
| # Bazel's native rule such as sh_test do not pick up 'files' in |
| # DefaultInfo for a target in 'data'. |
| data_runfiles = ctx.runfiles([output_jar]), |
| ), |
| JavaInfo( |
| output_jar = output_jar, |
| |
| # compile_jar should be an ijar, but using an ijar results in |
| # missing protobuf import version. |
| compile_jar = output_jar, |
| source_jar = source_jar, |
| compile_jdeps = target_java_output.compile_jdeps, |
| generated_class_jar = target_java_output.generated_class_jar, |
| generated_source_jar = target_java_output.generated_source_jar, |
| native_headers_jar = target_java_output.native_headers_jar, |
| manifest_proto = target_java_output.manifest_proto, |
| neverlink = ctx.attr.neverlink, |
| deps = [dep[JavaInfo] for dep in ctx.attr.deps], |
| runtime_deps = [dep[JavaInfo] for dep in ctx.attr.runtime_deps], |
| exports = [exp[JavaInfo] for exp in ctx.attr.exports], |
| exported_plugins = ctx.attr.exported_plugins, |
| jdeps = target_java_output.jdeps, |
| ), |
| ] |
| |
| _osgi_jar = rule( |
| implementation = _osgi_jar_impl, |
| outputs = { |
| "output_jar": "lib%{name}.jar", |
| }, |
| attrs = { |
| "automatic_module_name": attr.string(), |
| "bundle_copyright": attr.string(), |
| "bundle_description": attr.string(), |
| "bundle_doc_url": attr.string(), |
| "bundle_license": attr.string(), |
| "bundle_name": attr.string(), |
| "bundle_version": attr.string(), |
| "bundle_symbolic_name": attr.string(), |
| "export_package": attr.string_list(), |
| "import_package": attr.string_list(), |
| "target": attr.label(), |
| "deps": attr.label_list(), |
| "runtime_deps": attr.label_list(), |
| "exports": attr.label_list(), |
| "neverlink": attr.bool(), |
| "exported_plugins": attr.label_list(), |
| "_osgi_wrapper_exe": attr.label( |
| executable = True, |
| cfg = "exec", |
| allow_files = True, |
| default = Label("//java/osgi:osgi_wrapper"), |
| ), |
| }, |
| ) |
