Amaan Dhar

Enough said. Critically, this ensures that we don't stray outside of the restricted feature-set of the Starlark language (the Buck runtime is currently much more permissive).

Take a look at the doc in antlir/bzl/TARGETS. This is kind of a chore, but it helps kick off the right CI jobs when we edit .bzl files, so it's worth doing.

Ideally, we would just write a linter to do this on our behalf. However, we haven't yet found time.

Note: The vmtest macros have not yet been updated to follow this pattern, help is welcome!

This convention follows fbcode/folly/. One concrete benefit is that it's easier to spot when a python_binary is being used as a library without the -library suffix to reference the implicit library target.

The failure mode here is writing something that is neither clearly a function nor a macro, but a mix.

If you define a module-level a = , and mutate it from your macros, this is a sure-fire way to get non-deterministic builds.

The precise reason is that Buck doesn't guarantee order of evaluation of your macros across files, so a macro that updates order-sensitive mutable globals can create non-determinism that breaks target determinators for the entire repo, potentially costing many human-days to triage & fix.

If you're not sure whether some container or traversal is guaranteed to be deterministically ordered in Buck, sort it (or check).

Keep in mind that Buck currently supports at least two frontends for .bzl files: python3 and Starlark (and the default differs between FB-internal and open-source). You must write code that is compatible with both.

To check both back-ends, run:

If your macro defines a purely internal target, make sure it's namespaced so that, ideally: - It does not show up in buck TAB-completion (put your magic in the prefix, not suffix) - The magic prefix should discourages people from typing it manually into their TARGETS files or .bzl files -- provide an accessor method when this is necessary, see e.g. the FB-internal fetched_layer in fbpkg.bzl.

There are exceptions to this, which are magic target names that we expect users to type as part of a buck command-line on a regular basis. Reference Helper Buck Targets for a list of examples.

There are a lot of failure-modes here, from quoting to error-handling, to mis-uses of command substitution via \$(), to mis-uses of $(exe) vs $(location), to errors in cacheability. For now, treat any diff with such code as blocked on a review from @lesha. We need a second domain expert ASAP.

To get a taste of some potential problems, carefully study _wrap_bash_build_in_common_boilerplate and maybe_wrap_runtime_deps_as_build_time_deps. This is not exhaustive.

You know what "$(ls)" does in bash. Now you want this in the bash = field of your genrule. Unfortunately, this is hard. You have to do this two-liner:

Understanding what follows starts with carefully reading the genrule docs.

You have to use exe instead of location because the latter will rebuild your genrule if the runtime dependencies of the executable target change, while the former will only rebuild if the content of the executable change. Specifically, in @mode/dev, if the executable is a PAR, its content is just a symlink, which never changes, so your genrule never rebuilds. Even with C++, you would fail to rebuild on changes to any libraries that are linked into your code, since in @mode/dev those are .sos that are not part of the target's "content".

You have to use a bash array because $(exe) expands to multiple shell words, Because Buck (TM). E.g. for PARs, the expansion of $(exe) might look like something like python3 "/path to/the actual/binary".

The out field is not user-visible, it is just an implementation detail of the filesystem layout under buck-out. As such, its value does not matter. Unfortunately, Buck requires it. To minimize cognitive overhead and naming discussions, we prefer for it to always say out = "out". Feel free to update legacy callsites as you find them -- there is no risk.

If your macro takes an argument that is a target, and that target might sometimes be an in-repo file, use maybe_export_file.

This shim exists to bridge the differences between the semantics of FB-internal build rules, and those of OSS Buck. If you bypass it, you will either break Antlir for FB-internal users, or for OSS users.

Note that any newly shimmed rules have to follow a few basic practices:

All Buck rules used within Antlir have an antlir_rule kwarg.

You can declare Buck rules in one of three contexts. The context corresponds to the value of the antlir_rule kwarg:

Marking rules "user-internal" is important, since FB on-diff CI only runs builds & test within a certain dependency distance from the modified sources, and "user-internal" targets get excluded from this distance calculation to ensure that the right CI targets get triggered.

To ensure that all user-instantiated ("user-facing" / "user-internal") rules are annotated, un-annotated rules will fail to instantiate from inside a user project. That is, if your rule doesn't set antlir_rule, it defaults to "antlir-private", which triggers _assert_package(), which will fail if the Buck package path does not start with antlir/. This has two desirable effects:

The implementation details and more specific docs can be found in antlir/bzl/oss_shim_impl.bzl.

Shape types should be named with a trailing _t to indicate that it is a shape type. Shape instance variable names should conform to the local style conventions.

For example, the type and instance for installing a tarball might look like this:

Let the Bad Times Roll: Directed by Kevin McKidd With Ellen Pompeo, Sandra Oh, Justin Chambers, Chandra Wilson Six hours after their oral boards ,

Unfortunately, Quora's partner program is invite-only That means you have to be asked by Quora themselves to participate They usually only ask users of their

Dharmapuri temple Timings, Opening and Closing Hours, Darshan and Pooja details, Ticket Cost, Online Booking, Contact number, Waiting time today