6hY SrSSKJr SSKrSSKrSSKJr SSKJrJ r J r J r J r J r JrJrJrJr SSKJr SrSrS r0r\R0"\5r0r\R4"\5r\"S S S S 9 \"S S\S 9 \"S SS S 9 \"S SSS 9 \"S SSS 9 \"S SSS 9 \"S SSS 9 \"S SSS 9 \"SSS S 9 SrSrSr"SS5r"SS\5r "S S!\5r!"S"S#\5r"S$r#S%r$S&r%S'r&S(r'S)r(S?S*jr)S+r*S,r+S-r,S.r-S/r.S0r/S1r0S2r1S3r2S4r3\"\3/S55S65r4S7r5S8r6\"S9S5S:S \"S;54/S55S@SAS<jj5r7\"S=/S55SAS>j5r8g)Ba6advertise pre-generated bundles to seed clones "clonebundles" is a server-side extension used to advertise the existence of pre-generated, externally hosted bundle files to clients that are cloning so that cloning can be faster, more reliable, and require less resources on the server. "pullbundles" is a related feature for sending pre-generated bundle files to clients as part of pull operations. Cloning can be a CPU and I/O intensive operation on servers. Traditionally, the server, in response to a client's request to clone, dynamically generates a bundle containing the entire repository content and sends it to the client. There is no caching on the server and the server will have to redundantly generate the same outgoing bundle in response to each clone request. For servers with large repositories or with high clone volume, the load from clones can make scaling the server challenging and costly. This extension provides server operators the ability to offload potentially expensive clone load to an external service. Pre-generated bundles also allow using more CPU intensive compression, reducing the effective bandwidth requirements. Here's how clone bundles work: 1. A server operator establishes a mechanism for making bundle files available on a hosting service where Mercurial clients can fetch them. 2. A manifest file listing available bundle URLs and some optional metadata is added to the Mercurial repository on the server. 3. A client initiates a clone against a clone bundles aware server. 4. The client sees the server is advertising clone bundles and fetches the manifest listing available bundles. 5. The client filters and sorts the available bundles based on what it supports and prefers. 6. The client downloads and applies an available bundle from the server-specified URL. 7. The client reconnects to the original server and performs the equivalent of :hg:`pull` to retrieve all repository data not in the bundle. (The repository could have been updated between when the bundle was created and when the client started the clone.) This may use "pullbundles". Instead of the server generating full repository bundles for every clone request, it generates full bundles once and they are subsequently reused to bootstrap new clones. The server may still transfer data at clone time. However, this is only data that has been added/changed since the bundle was created. For large, established repositories, this can reduce server load for clones to less than 1% of original. Here's how pullbundles work: 1. A manifest file listing available bundles and describing the revisions is added to the Mercurial repository on the server. 2. A new-enough client informs the server that it supports partial pulls and initiates a pull. 3. If the server has pull bundles enabled and sees the client advertising partial pulls, it checks for a matching pull bundle in the manifest. A bundle matches if the format is supported by the client, the client has the required revisions already and needs something from the bundle. 4. If there is at least one matching bundle, the server sends it to the client. 5. The client applies the bundle and notices that the server reply was incomplete. It initiates another pull. To work, this extension requires the following of server operators: * Generating bundle files of repository content (typically periodically, such as once per day). * Clone bundles: A file server that clients have network access to and that Python knows how to talk to through its normal URL handling facility (typically an HTTP/HTTPS server). * A process for keeping the bundles manifest in sync with available bundle files. Strictly speaking, using a static file hosting server isn't required: a server operator could use a dynamic service for retrieving bundle data. However, static file hosting services are simple and scalable and should be sufficient for most needs. Bundle files can be generated with the :hg:`bundle` command. Typically :hg:`bundle --all` is used to produce a bundle of the entire repository. The bundlespec option `stream` (see :hg:`help bundlespec`) can be used to produce a special *streaming clonebundle*, typically using :hg:`bundle --all --type="none-streamv2"`. These are bundle files that are extremely efficient to produce and consume (read: fast). However, they are larger than traditional bundle formats and require that clients support the exact set of repository data store formats in use by the repository that created them. Typically, a newer server can serve data that is compatible with older clients. However, *streaming clone bundles* don't have this guarantee. **Server operators need to be aware that newer versions of Mercurial may produce streaming clone bundles incompatible with older Mercurial versions.** A server operator is responsible for creating a ``.hg/clonebundles.manifest`` file containing the list of available bundle files suitable for seeding clones. If this file does not exist, the repository will not advertise the existence of clone bundles when clients connect. For pull bundles, ``.hg/pullbundles.manifest`` is used. The manifest file contains a newline (\n) delimited list of entries. Each line in this file defines an available bundle. Lines have the format: [=[ =]] That is, a URL followed by an optional, space-delimited list of key=value pairs describing additional properties of this bundle. Both keys and values are URI encoded. For pull bundles, the URL is a path under the ``.hg`` directory of the repository. Keys in UPPERCASE are reserved for use by Mercurial and are defined below. All non-uppercase keys can be used by site installations. An example use for custom properties is to use the *datacenter* attribute to define which data center a file is hosted in. Clients could then prefer a server in the data center closest to them. The following reserved keys are currently defined: BUNDLESPEC A "bundle specification" string that describes the type of the bundle. These are string values that are accepted by the "--type" argument of :hg:`bundle`. The values are parsed in strict mode, which means they must be of the "-" form. See mercurial.exchange.parsebundlespec() for more details. :hg:`debugbundle --spec` can be used to print the bundle specification string for a bundle file. The output of this command can be used verbatim for the value of ``BUNDLESPEC`` (it is already escaped). Clients will automatically filter out specifications that are unknown or unsupported so they won't attempt to download something that likely won't apply. The actual value doesn't impact client behavior beyond filtering: clients will still sniff the bundle type from the header of downloaded files. **Use of this key is highly recommended**, as it allows clients to easily skip unsupported bundles. If this key is not defined, an old client may attempt to apply a bundle that it is incapable of reading. REQUIRESNI Whether Server Name Indication (SNI) is required to connect to the URL. SNI allows servers to use multiple certificates on the same IP. It is somewhat common in CDNs and other hosting providers. Older Python versions do not support SNI. Defining this attribute enables clients with older Python versions to filter this entry without experiencing an opaque SSL failure at connection time. If this is defined, it is important to advertise a non-SNI fallback URL or clients running old Python releases may not be able to clone with the clonebundles facility. Value should be "true". REQUIREDRAM Value specifies expected memory requirements to decode the payload. Values can have suffixes for common bytes sizes. e.g. "64MB". This key is often used with zstd-compressed bundles using a high compression level / window size, which can require 100+ MB of memory to decode. heads Used for pull bundles. This contains the ``;`` separated changeset hashes of the heads of the bundle content. bases Used for pull bundles. This contains the ``;`` separated changeset hashes of the roots of the bundle content. This can be skipped if the bundle was created without ``--base``. Manifests can contain multiple entries. Assuming metadata is defined, clients will filter entries from the manifest that they don't support. The remaining entries are optionally sorted by client preferences (``ui.clonebundleprefers`` config option). The client then attempts to fetch the bundle at the first URL in the remaining list. **Errors when downloading a bundle will fail the entire clone operation: clients do not automatically fall back to a traditional clone.** The reason for this is that if a server is using clone bundles, it is probably doing so because the feature is necessary to help it scale. In other words, there is an assumption that clone load will be offloaded to another service and that the Mercurial server isn't responsible for serving this clone load. If that other service experiences issues and clients start mass falling back to the original Mercurial server, the added clone load could overwhelm the server due to unexpected load and effectively take it offline. Not having clients automatically fall back to cloning from the original server mitigates this scenario. Because there is no automatic Mercurial server fallback on failure of the bundle hosting service, it is important for server operators to view the bundle hosting service as an extension of the Mercurial server in terms of availability and service level agreements: if the bundle hosting service goes down, so does the ability for clients to clone. Note: clients will see a message informing them how to bypass the clone bundles facility when a failure occurs. So server operators should prepare for some people to follow these instructions when a failure occurs, thus driving more load to the original Mercurial server when the bundle hosting service fails. inline clonebundles ------------------- It is possible to transmit clonebundles inline in case repositories are accessed over SSH. This avoids having to setup an external HTTPS server and results in the same access control as already present for the SSH setup. Inline clonebundles should be placed into the `.hg/bundle-cache` directory. A clonebundle at `.hg/bundle-cache/mybundle.bundle` is referred to in the `clonebundles.manifest` file as `peer-bundle-cache://mybundle.bundle`. auto-generation of clone bundles -------------------------------- It is possible to set Mercurial to automatically re-generate clone bundles when enough new content is available. Mercurial will take care of the process asynchronously. The defined list of bundle-type will be generated, uploaded, and advertised. Older bundles will get decommissioned as newer ones replace them. Bundles Generation: ................... The extension can generate multiple variants of the clone bundle. Each different variant will be defined by the "bundle-spec" they use:: [clone-bundles] auto-generate.formats= zstd-v2, gzip-v2 See `hg help bundlespec` for details about available options. By default, new bundles are generated when 5% of the repository contents or at least 1000 revisions are not contained in the cached bundles. This option can be controlled by the `clone-bundles.trigger.below-bundled-ratio` option (default 0.95) and the `clone-bundles.trigger.revs` option (default 1000):: [clone-bundles] trigger.below-bundled-ratio=0.95 trigger.revs=1000 This logic can be manually triggered using the `admin::clone-bundles-refresh` command, or automatically on each repository change if `clone-bundles.auto-generate.on-change` is set to `yes`:: [clone-bundles] auto-generate.on-change=yes auto-generate.formats= zstd-v2, gzip-v2 Automatic Inline serving ........................ The simplest way to serve the generated bundle is through the Mercurial protocol. However it is not the most efficient as request will still be served by that main server. It is useful in case where authentication is complexe or when an efficient mirror system is already in use anyway. See the `inline clonebundles` section above for details about inline clonebundles To automatically serve generated bundle through inline clonebundle, simply set the following option:: auto-generate.serve-inline=yes Enabling this option disable the managed upload and serving explained below. Bundles Upload and Serving: ........................... This is the most efficient way to serve automatically generated clone bundles, but requires some setup. The generated bundles need to be made available to users through a "public" URL. This should be donne through `clone-bundles.upload-command` configuration. The value of this command should be a shell command. It will have access to the bundle file path through the `$HGCB_BUNDLE_PATH` variable. And the expected basename in the "public" URL is accessible at:: [clone-bundles] upload-command=sftp put $HGCB_BUNDLE_PATH sftp://bundles.host/clone-bundles/$HGCB_BUNDLE_BASENAME If the file was already uploaded, the command must still succeed. After upload, the file should be available at an url defined by `clone-bundles.url-template`. [clone-bundles] url-template=https://bundles.host/cache/clone-bundles/{basename} Old bundles cleanup: .................... When new bundles are generated, the older ones are no longer necessary and can be removed from storage. This is done through the `clone-bundles.delete-command` configuration. The command is given the url of the artifact to delete through the `$HGCB_BUNDLE_URL` environment variable. [clone-bundles] delete-command=sftp rm sftp://bundles.host/clone-bundles/$HGCB_BUNDLE_BASENAME If the file was already deleted, the command must still succeed. ) annotationsN)_) bundlecachescommandserror extensions localrepolocknode registrarutilwireprotov1server)procutilsships-with-hg-corecU"X5nURR[R5(a"UR S5 UR S5 U$)Ns clonebundlessclonebundles_manifest)vfsexistsrCB_MANIFEST_FILEappend)origrepoprotocapss 4/usr/lib/python3/dist-packages/hgext/clonebundles.py capabilitiesrSsE  D  xx|4455 O$ ,- KcD[R"[S[5 g)N _capabilities)r wrapfunctionrr)uis rextsetupr `s- Mr clone-bundlesauto-generate.on-changeF)defaultauto-generate.formatsauto-generate.serve-inlinetrigger.below-bundled-ratiogffffff? trigger.revsiupload-commanddelete-command url-templatedeveldebug.clonebundlessclonebundles-autobundlessAfull-%(bundle_type)s-%(revs)d_revs-%(tip_short)s_tip-%(op_id)s.hgsclonebundles.auto-genc:\rSrSrSrSrSrSrSrSr Sr S r g ) BundleBaseiajrepresents the core of properties that matters for us in a bundle :bundle_type: the bundlespec (see hg help bundlespec) :revs: the number of revisions in the repo at bundle creation time :tip_rev: the rev-num of the tip revision :tip_node: the node id of the tip-most revision in the bundle :ready: True if the bundle is ready to be served Fc4XlX lX0lX@lgN) bundle_typerevstip_revtip_node)selfr1r2r3r4s r__init__BundleBase.__init__s&   rc[R"UR5nURRR U5UR :H$)zxis this bundle applicable to the current repository This is useful for detecting bundles made irrelevant by stripping. )r binr4 changelogindexget_revr3)r5rr4s r valid_forBundleBase.valid_fors: 88DMM*~~##++H5EErcURURURUR4nURURURUR4nX#:H$r0)readyr1r3r4)r5otherleftrights r__eq__BundleBase.__eq__sJ D,,dllDMMJe//O}rc X:X+$r0r5rAs r__neq__BundleBase.__neq__s   rcX:Xagg)NrrGrHs r__cmp__BundleBase.__cmp__s =r)r1r2r4r3N) __name__ __module__ __qualname____firstlineno____doc__r@r6r=rDrIrM__static_attributes__rGrrr.r.s( E! F !rr.cL^\rSrSrSrU4Sjr\S5rSrSSjr Sr U=r $) RequestedBundleizA bundle that should be generated. Additional attributes compared to BundleBase :heads: list of head revisions (as rev-num) :op_id: a "unique" identifier for the operation triggering the change cB>XPlX`l[TU] UUUU5 gr0) head_revsop_idsuperr6)r5r1r2r3r4rXrY __class__s rr6RequestedBundle.__init__s&"        rcURURURURURURSSUR S.n[ U-$)z4A filename that can be used for the generated bundleN )s bundle_typesrevssheadsstip_revstip_nodes tip_shortsop_id)r1r2rXr3r4rY BUNDLE_MASK)r5datas rsuggested_filename"RequestedBundle.suggested_filenamesR!,,YYnn --,jj T!!rc v[R"URUUS/URURSS9 g)z!generate the bundle at `filepath`snullT)baserevtypequietN)rbundlerrXr1)r5r file_paths rgenerate_bundleRequestedBundle.generate_bundles3 GG  !! rc Uc[R"5nUc[R"5n[ UR UR URURUUU5$)z1return a GeneratingBundle object from this object) osgetpidr _getlockprefixGeneratingBundler1r2r3r4)r5rihostnamepids r generatingRequestedBundle.generatingsZ ;))+C  **,H    II LL MM     r)rXrY)NN) rOrPrQrRrSr6propertyrarjrsrT __classcell__r[s@rrVrVs0  " "    rrVcX^\rSrSrSrSrU4Sjr\S5rSr U4Sjr Sr S r U=r $) rpia+A bundle being generated extra attributes compared to BundleBase: :hostname: the hostname of the machine generating the bundle :pid: the pid of the process generating the bundle :filepath: the target filename of the bundle These attributes exist to help detect stalled generation processes. FcJ>XPlX`lXpl[TU]XX45 gr0)rqrrfilepathrZr6) r5r1r2r3r4rqrrrzr[s rr6GeneratingBundle.__init__s#!   G>rc 8URS5(deUR5unnnnnnnn [RR U5n[RR U 5n [ U5n[ U5n[ U5nU"X4XVXxU 5$);create an object by deserializing a line from AUTO_GEN_FILE PENDING-v1 ) startswithsplitr urlrequnquoteint) clsline__r1r2r3r4rqrrrzs r from_lineGeneratingBundle.from_lines~.... JJL        ;;&&x0;;&&x04yg,#h w(  rc  SnURURURUR[R R UR5UR[R R UR54nX-$):serialize the object to include as a line in AUTO_GEN_FILEsPENDING-v1 %s %d %d %s %s %d %s) r1r2r3r4r rquoterqrrrzr5templr`s rto_lineGeneratingBundle.to_linesi2    II LL MM KK  dmm , HH KK  dmm , |rc>[TU]U5(dgURURUR4nURURUR4nX#:H$NF)rZrDrqrrrz)r5rArBrCr[s rrDGeneratingBundle.__eq__*sMw~e$$ txx7ENN;}rcr[URURURURUU5$)z)return a GeneratedBundle from this object)GeneratedBundler1r2r3r4)r5urlbasenames ruploadedGeneratingBundle.uploaded1s3    II LL MM     r)rzrqrr)rOrPrQrRrSr@r6 classmethodrrrDrrTrvrws@rrprps<  E?  ,    rrpcX^\rSrSrSrSrU4Sjr\S5rSr Sr U4Sjr S r U=r $) ri=a%A bundle that is done being generated and can be served extra attributes compared to BundleBase: :file_url: the url where the bundle is available. :basename: the "basename" used to upload (useful for deletion) These attributes exist to generate a bundle manifest (.hg/pullbundles.manifest) Tc>>XPlX`l[TU] XX45 gr0)file_urlrrZr6)r5r1r2r3r4rrr[s rr6GeneratedBundle.__init__Ks!   G>rcURS5(deUR5unnnnnnn[U5n[U5n[RR U5nU"X4XVXx5$)r}DONE-v1 )rrrr rr) rrrr1r2r3r4rrs rrGeneratedBundle.from_lineRss{++++ JJL       4yg,;;&&x0;gLLrcSnURURURUR[R R UR5UR4nX-$)rsDONE-v1 %s %d %d %s %s %s) r1r2r3r4r rrrrrs rrGeneratedBundle.to_linedsS,    II LL MM KK  dmm , MM  |rcSnURRS5(aUS- nXRUR4-$)zAserialize the object to include as a line in pullbundles.manifests%s BUNDLESPEC=%sshttps REQUIRESNI=true)rrr1)r5rs r manifest_lineGeneratedBundle.manifest_lineqs?# == # #G , , ( (E t'7'7888rc`>[TU]U5(dgURUR:H$r)rZrDr)r5rAr[s rrDGeneratedBundle.__eq__xs(w~e$$}}..r)rr)rOrPrQrRrSr@r6rrrrrDrTrvrws@rrr=s>  E?MM" 9//rrc(/nUR5H{nURS5(a&UR[R U55 M?URS5(dMWUR[ R U55 M} U$)z9parse the AUTO_GEN_FILE to return a list of Bundle objectr~r) splitlinesrrrprr)contentbundlesrs rparse_auto_genr~snG""$ ??> * * NN+55d; < __[ ) ) NN?44T: ; % Nrc/nUH%nURSUR5-5 M' UR5 SRU5$)z5serialize a list of Bundle as a AUTO_GEN_FILE content%s r)rrsortjoinrlinesbs rdumps_auto_genrs? E  Wqyy{*+ JJL 88E?rchURR[5nU(d/$[U5$)z=read the AUTO_GEN_FILE for the a list of Bundle object)rtryread AUTO_GEN_FILEr)rr`s r read_auto_genrs) 88  M *D  $ rcURce[U5nUR[SSS9nUR U5 SSS5 g!,(df  g=f) = =s A  Ac[U5nURSS9 /nUH%nURSUR5-5 M' SR U5$)rcUR$r0)r1rs r#generate_manifest..sq}}r)keyrr)listrrrrrs rgenerate_manifestrsO7mG LL,L- E  Wq001 88E?rc,UR5 [U5n0nUHtnUR(aURU5(dM,UR UR 5nUbUR UR :aMfX2UR 'Mv [UR55nUR[RSSS9nURU5 SSS5 SSS5 g!,(df  N=f!,(df  g=f)z/update the clonebundle manifest with latest urlNrTr) clonebundles_lockrr@r=getr1r2rvaluesrrrr)rr per_typesrcurrentmanifestrs rupdate_ondisk_manifestrs   !% AGG D 1 1mmAMM2G"w||qvv'='(amm $ %Y%5%5%78 XX  ) )$  GGH   " !   " !s$CDC4#D4 D >D DcUR5 [U5nU(aUVs/sH oDU;dM UPM nnUVs/sH oDU;dM UPM nnURU5 [X5 /nURU5 URU5 [ SU55(a [ U5 SSS5 gs snfs snf!,(df  g=f)zcmodify the repo's AUTO_GEN_FILE This method also regenerates the clone bundle manifest when neededc38# UHoRv M g7fr0)r@).0rs r %update_bundle_list..s, 1ww sN)rrextendranyr)r new_bundles del_bundlesrr all_changeds rupdate_bundle_listrs    !% ")B'Qk-Aq'GB"-B+Q'1Aq+ B{#t% ;';' , , , , "4 ( " !CB " !s3C  CCC  CCA$C  C  CcUR(aeUR5 URRUR5 [ X/S9 SSS5 g!,(df  g=f)z(remove a GeneratingBundle file and entryrN)r@rr tryunlinkrzr)rtargets rcleanup_tmp_bundlersG||    ! 6??+4X6 " ! !s 0A A+cUR5 [U5nX;a+URU5(a[X5n[ X/S9 SSS5 [ X5 g!,(df  N=f)zGupload a generated bundle and advertise it in the clonebundles.manifestrN)rrr= upload_bundlerr)rrrresults rfinalize_one_bundlersZ   !%  !1!1$!7!7"40F t : " t$ " !s .s166rT)rreverseN)r=r setdefaultr1sortedlenrr)rroldsrrlralls rfind_outdated_bundlesrs DI {{4  KKN    3   i n s8a< HH)4H 8 KKAB ! KrcUR5 [U5n[X5nUHn[X5 M [ XS9 SSS5 g!,(df  g=f)z+finds outdated bundles and get them deletedrN)rrr delete_bundler)rrros rcollect_garbagersH   !%$T3A $ "42 " ! !s 4A AcURRSS5nURRUR5nU(aURRSS5nURR U5nURR U5 URR XS5n[R"URUSS9 [RU-nURXs5$URRSS5nURRSS5nURUS .n [R"U S 9n URRXS 9n U (a[R "S X4-5eUR#S 5R%UR#S 5S 9R'S 5nURXs5$)zupload the result of a GeneratingBundle and return a GeneratedBundle The upload is done using the `clone-bundles.upload-command` r!r%serverpeer-bundle-cache-rootT)hardlinkr(r*)sHGCB_BUNDLE_PATHsHGCB_BUNDLE_BASENAMEenvironcommand returned status %d: %sutf8)r)rconfigrrrzrmakedirsr copyfilesrCLONEBUNDLESCHEMErr shellenvironsystemrAbortdecodeformatencode) rrhinlinerbundle_cache_rootdest_dirdestrcmd variablesenvrets rrrsq WW^^,.K LFxx  1H  GGNN96OP88==!23 (#xx}}X0 vt<,,x7s--ggnn-/@Aggnn-?!'%- ##I6ggnnSn. ++?3*LM M JJv  VX__V4V 5 VF^ s--rc$UR(deURR[R5nU(aSnOSnX1R -nUR RSS5(aUR RU5 OUR RU5 U(aXUR RSS5nURRXAR 5n[R"U5 g UR RSS5nURUR S .n[R "US 9nUR R#XhS 9n U (a[$R&"S X4-5eg ) zdelete a bundle from storages)clone-bundles: deleting inline bundle %s s"clone-bundles: deleting bundle %s r+r,rrr!r))sHGCB_BUNDLE_URLs HGCB_BASENAMErrN)r@rrrrrr configboolrdebugrrrr rrrrrr) rrhr msgr  inline_pathrrrrs rrr"s% <<< __ ' ' (F(F GF ;4??C ww($9::  c  c  GGNN96OPhhmm$5G  {#ggnn-/@A &$oo ##I6ggnnSn. ++?3*LM M rc /n/nURS5nURRSS5n[URR SS55nURR SS5n[ UR5nUURR5URR5[R"URR55US.n UHjn [R"X SS9R5n [!XXgX5(dM:U R#5n XS '[%S 0U D6n UR'U 5 Ml UR)[+X55 X44$) z|find the list of bundles that need action returns a list of RequestedBundle objects that need to be generated and uploaded.s immutabler!r$r&r')r2rXr3r4rYF)strictr1rG)filteredr configlistfloatr configintrr:headrevstiprevr hextiprparsebundlespecas_specnew_bundle_neededcopyrVrrr) rrrYcreate_bundlesdelete_bundlestargetsratioabs_revsr2 generic_datatr`rs rauto_bundle_needed_actionsr,BsE NN == &Dgg  !13KLG  ')GH Eww  !1?CH t~~ D^^,,.>>((*HHT^^//12 L  ( ( ? G G I TEQ E E$$&D"# '$'A  ! !! $ />?  ))rc[XR-XS- 5nUH=nURU5(aURU:waM+URU:dM= g g)zEconsider the current cached content and trigger new bundles if neededFT)maxr=r1r2)rrr(r)r1r2 thresholdrs rr#r#bsMT\T_6I {{4  AMM[$@  66I   rc \[RRU5n[R"5SUR [ /n[R"5nSnSnSn/nSn URRSS5(aT[Rn[RnURRXQR-5 URn O'URRXQR-5 [R n U "UUUUUU S9 UH n U "5 M g)zstart the generation of a single bundle file the `bundle` argument should be a RequestedBundle object. This data is passed to the `debugmakeclonebundles` "as is". s--cwd.clone-bundles: starting bundle generation: %s Nr+r,) stdin_bytesstdoutstderr record_wait)r pickledumpsr hgexecutablepath INTERNAL_CMDrrrr3r4rr1rr runbgcommand) rrhr`rrrr3r4waitsr5bgrs rstart_one_bundler>ms ;;  V $D  "Hdii FC    !C T"5nUce[U5n[XS[U5-5up4UHn[X5 M g)Ns%d_txn)rr,idr>)trrrnewrr`reporefs r autobundle%make_auto_bundler..autobundlesLy%,TI2^\rSrSrUU4Sjr\R SSj5rSrU=r $)"reposetup..autobundlesrepoic>>[TU]"U0UD6nTRRSS5nTRR SS5nU(aLU(d&TRR [ S55 U$UR[[U55 U$)Nr!r"r$sSclone-bundle auto-generate enabled, but no formats specified: disabling generation ) rZ transactionrrrwarnr addpostclose CAT_POSTCLOSErT)r5argskwargsrLenabledr'r[rs rrY.reposetup..autobundlesrepo.transactions$d5f5Bgg(( *Ggg(( ":GGGLLPIOOM3DT3JKIrc 4[US5(dSUlURUR5nUbUR5 U$UR UR SUSS[ S5UR-S9n[R"U5UlU$)z1Lock the repository file related to clone bundlesrNsclonebundleslocks repository %s)rlocknamewait releasefn acquirefndesc) hasattrr _currentlockr _lockrrorigrootrQrR)r5rcrs rr4reposetup..autobundlesrepo.clonebundles_locks400$(!!!$"3"34A} HH,'(4==8 A!( AD Hr)r)T) rOrPrQrRrYr unfilteredmethodrrTrv)r[rs@rautobundlesreporWs" *  # #  $ rrm)localr[_wlockfreeprefixaddrrr)rrrms ` r reposetuprqs[ ::<<)$..)V m,l;;<$DNrsadmin::clone-bundles-refreshs backgrounds)start bundle generation in the backgroundcURRSS5nURRSS5n[U5nUcS[R "5-n[ XU5upgU(aU(dUHn[X5 M [XS9 U(aURRS5n U(aUHn [X5 M gUHn U(a)Sn URRXR-5 U Rn URRSU 5n U R!U 5n [X/S 9 U R#X5 [%X5n[X/S 9 ['U5 [)X5 M g) zgenerate clone bundles according to the configuration This runs the logic for automatic generation, removing outdated bundles and generating new ones if necessary. See :hg:`help -e clone-bundles` for details about how to configure this feature. r+r,s"clonebundles.override-operation-idNs%d_acbrrr@r1r)rrrrrmrnr,rrrrr>rr1rarrsrjrrr)rr backgroundrrYrcreatedeleterrGrErrFgenerating_bundlers rcmd_admin_clone_bundles_refreshrwsH. GG  x)> ?E GGNN8%J KED!G }RYY[(/uENF 6A $ "44 !!.1 &  T 4!'!' H c$@$@@A$77EHHMM.%8E 0 ; ;E B  t1D E  , ,T 9"4;F t : "4 ( t 7!'rsadmin::clone-bundles-clearc[U5nUVs/sHo3R(dMUPM nnUHn[X5 M [XS9 gs snf)zremove existing clone bundle caches See `hg help admin::clone-bundles-refresh` for details on how to regenerate them. This command will only affect bundles currently available, it will not affect bundles being asynchronously generated. rN)rr@rr)rrrrrurs rcmd_admin_clone_bundles_clearry1sED!G ,AGGaF , dt0-s AA)rGrG)F)rzlocalrepo.localrepository)9rS __future__rrmrQmercurial.i18nr mercurialrrrrr r r r r rmercurial.utilsr testedwithrr configtable configitemcmdtablecommandrr\r_rr.rVrprrrrrrrrrrrrrrr,r#r>r:rHrTrqrwryrGrrrs#qf #    #  N  ! !+ .    H % 7G 5tD :EJ ;TJ _d; .= .= _d; 8*E:, I ) &&R: j: zK zK \>/j>/B ()$7%$3.DN@*@  F5  r3& && 7%t #    : ;   28 #28 28j &C0 11 1r