diff --git a/CREDITS b/CREDITS
index 805a715e8..50b347468 100644
--- a/CREDITS
+++ b/CREDITS
@@ -23043,6 +23043,673 @@ For more information on this, and how to apply and follow the GNU AGPL, see
================================================================
+github.com/minio/pkg/v3
+https://github.com/minio/pkg/v3
+----------------------------------------------------------------
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+ A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+ The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+ An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU Affero General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Remote Network Interaction; Use with the GNU General Public License.
+
+ Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+.
+
+================================================================
+
github.com/minio/selfupdate
https://github.com/minio/selfupdate
----------------------------------------------------------------
@@ -33171,39 +33838,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================================
-golang.org/x/exp
-https://golang.org/x/exp
-----------------------------------------------------------------
-Copyright 2009 The Go Authors.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google LLC nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-================================================================
-
golang.org/x/mod
https://golang.org/x/mod
----------------------------------------------------------------
@@ -33950,6 +34584,214 @@ https://google.golang.org/genproto/googleapis/api
================================================================
+google.golang.org/genproto/googleapis/api
+https://google.golang.org/genproto/googleapis/api
+----------------------------------------------------------------
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ 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.
+
+================================================================
+
google.golang.org/genproto/googleapis/rpc
https://google.golang.org/genproto/googleapis/rpc
----------------------------------------------------------------
@@ -34607,6 +35449,39 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================================
+google.golang.org/protobuf
+https://google.golang.org/protobuf
+----------------------------------------------------------------
+Copyright (c) 2018 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+================================================================
+
gopkg.in/check.v1
https://gopkg.in/check.v1
----------------------------------------------------------------
diff --git a/Makefile b/Makefile
index ef6bf84d8..e8077fc02 100644
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,7 @@ help: ## print this help
getdeps: ## fetch necessary dependencies
@mkdir -p ${GOPATH}/bin
@echo "Installing golangci-lint" && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOLANGCI_DIR)
- @echo "Installing msgp" && go install -v github.com/tinylib/msgp@v1.2.3-0.20241022140105-4558fbf3a223
+ @echo "Installing msgp" && go install -v github.com/tinylib/msgp@v1.2.5
@echo "Installing stringer" && go install -v golang.org/x/tools/cmd/stringer@latest
crosscompile: ## cross compile minio
diff --git a/cmd/data-usage-cache_gen.go b/cmd/data-usage-cache_gen.go
index 4543ee276..63c2815d2 100644
--- a/cmd/data-usage-cache_gen.go
+++ b/cmd/data-usage-cache_gen.go
@@ -1721,11 +1721,93 @@ func (z *dataUsageEntry) DecodeMsg(dc *msgp.Reader) (err error) {
if z.AllTierStats == nil {
z.AllTierStats = new(allTierStats)
}
- err = z.AllTierStats.DecodeMsg(dc)
+ var zb0004 uint32
+ zb0004, err = dc.ReadMapHeader()
if err != nil {
err = msgp.WrapError(err, "AllTierStats")
return
}
+ for zb0004 > 0 {
+ zb0004--
+ field, err = dc.ReadMapKeyPtr()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ var zb0005 uint32
+ zb0005, err = dc.ReadMapHeader()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ if z.AllTierStats.Tiers == nil {
+ z.AllTierStats.Tiers = make(map[string]tierStats, zb0005)
+ } else if len(z.AllTierStats.Tiers) > 0 {
+ for key := range z.AllTierStats.Tiers {
+ delete(z.AllTierStats.Tiers, key)
+ }
+ }
+ for zb0005 > 0 {
+ zb0005--
+ var za0003 string
+ var za0004 tierStats
+ za0003, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ var zb0006 uint32
+ zb0006, err = dc.ReadMapHeader()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, err = dc.ReadMapKeyPtr()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ za0004.TotalSize, err = dc.ReadUint64()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "TotalSize")
+ return
+ }
+ case "nv":
+ za0004.NumVersions, err = dc.ReadInt()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumVersions")
+ return
+ }
+ case "no":
+ za0004.NumObjects, err = dc.ReadInt()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumObjects")
+ return
+ }
+ default:
+ err = dc.Skip()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ }
+ }
+ z.AllTierStats.Tiers[za0003] = za0004
+ }
+ default:
+ err = dc.Skip()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ }
+ }
}
zb0001Mask |= 0x1
case "c":
@@ -1743,11 +1825,10 @@ func (z *dataUsageEntry) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.AllTierStats = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.AllTierStats = nil
}
+
return
}
@@ -1766,121 +1847,166 @@ func (z *dataUsageEntry) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "ch"
- err = en.Append(0xa2, 0x63, 0x68)
- if err != nil {
- return
- }
- err = z.Children.EncodeMsg(en)
- if err != nil {
- err = msgp.WrapError(err, "Children")
- return
- }
- // write "sz"
- err = en.Append(0xa2, 0x73, 0x7a)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.Size)
- if err != nil {
- err = msgp.WrapError(err, "Size")
- return
- }
- // write "os"
- err = en.Append(0xa2, 0x6f, 0x73)
- if err != nil {
- return
- }
- err = en.WriteUint64(z.Objects)
- if err != nil {
- err = msgp.WrapError(err, "Objects")
- return
- }
- // write "vs"
- err = en.Append(0xa2, 0x76, 0x73)
- if err != nil {
- return
- }
- err = en.WriteUint64(z.Versions)
- if err != nil {
- err = msgp.WrapError(err, "Versions")
- return
- }
- // write "dms"
- err = en.Append(0xa3, 0x64, 0x6d, 0x73)
- if err != nil {
- return
- }
- err = en.WriteUint64(z.DeleteMarkers)
- if err != nil {
- err = msgp.WrapError(err, "DeleteMarkers")
- return
- }
- // write "szs"
- err = en.Append(0xa3, 0x73, 0x7a, 0x73)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(dataUsageBucketLen))
- if err != nil {
- err = msgp.WrapError(err, "ObjSizes")
- return
- }
- for za0001 := range z.ObjSizes {
- err = en.WriteUint64(z.ObjSizes[za0001])
- if err != nil {
- err = msgp.WrapError(err, "ObjSizes", za0001)
- return
- }
- }
- // write "vh"
- err = en.Append(0xa2, 0x76, 0x68)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(dataUsageVersionLen))
- if err != nil {
- err = msgp.WrapError(err, "ObjVersions")
- return
- }
- for za0002 := range z.ObjVersions {
- err = en.WriteUint64(z.ObjVersions[za0002])
- if err != nil {
- err = msgp.WrapError(err, "ObjVersions", za0002)
- return
- }
- }
- if (zb0001Mask & 0x80) == 0 { // if not omitted
- // write "ats"
- err = en.Append(0xa3, 0x61, 0x74, 0x73)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "ch"
+ err = en.Append(0xa2, 0x63, 0x68)
if err != nil {
return
}
- if z.AllTierStats == nil {
- err = en.WriteNil()
+ err = z.Children.EncodeMsg(en)
+ if err != nil {
+ err = msgp.WrapError(err, "Children")
+ return
+ }
+ // write "sz"
+ err = en.Append(0xa2, 0x73, 0x7a)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.Size)
+ if err != nil {
+ err = msgp.WrapError(err, "Size")
+ return
+ }
+ // write "os"
+ err = en.Append(0xa2, 0x6f, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteUint64(z.Objects)
+ if err != nil {
+ err = msgp.WrapError(err, "Objects")
+ return
+ }
+ // write "vs"
+ err = en.Append(0xa2, 0x76, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteUint64(z.Versions)
+ if err != nil {
+ err = msgp.WrapError(err, "Versions")
+ return
+ }
+ // write "dms"
+ err = en.Append(0xa3, 0x64, 0x6d, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteUint64(z.DeleteMarkers)
+ if err != nil {
+ err = msgp.WrapError(err, "DeleteMarkers")
+ return
+ }
+ // write "szs"
+ err = en.Append(0xa3, 0x73, 0x7a, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(dataUsageBucketLen))
+ if err != nil {
+ err = msgp.WrapError(err, "ObjSizes")
+ return
+ }
+ for za0001 := range z.ObjSizes {
+ err = en.WriteUint64(z.ObjSizes[za0001])
if err != nil {
- return
- }
- } else {
- err = z.AllTierStats.EncodeMsg(en)
- if err != nil {
- err = msgp.WrapError(err, "AllTierStats")
+ err = msgp.WrapError(err, "ObjSizes", za0001)
return
}
}
- }
- // write "c"
- err = en.Append(0xa1, 0x63)
- if err != nil {
- return
- }
- err = en.WriteBool(z.Compacted)
- if err != nil {
- err = msgp.WrapError(err, "Compacted")
- return
+ // write "vh"
+ err = en.Append(0xa2, 0x76, 0x68)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(dataUsageVersionLen))
+ if err != nil {
+ err = msgp.WrapError(err, "ObjVersions")
+ return
+ }
+ for za0002 := range z.ObjVersions {
+ err = en.WriteUint64(z.ObjVersions[za0002])
+ if err != nil {
+ err = msgp.WrapError(err, "ObjVersions", za0002)
+ return
+ }
+ }
+ if (zb0001Mask & 0x80) == 0 { // if not omitted
+ // write "ats"
+ err = en.Append(0xa3, 0x61, 0x74, 0x73)
+ if err != nil {
+ return
+ }
+ if z.AllTierStats == nil {
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ // map header, size 1
+ // write "ts"
+ err = en.Append(0x81, 0xa2, 0x74, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteMapHeader(uint32(len(z.AllTierStats.Tiers)))
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ for za0003, za0004 := range z.AllTierStats.Tiers {
+ err = en.WriteString(za0003)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ // map header, size 3
+ // write "ts"
+ err = en.Append(0x83, 0xa2, 0x74, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteUint64(za0004.TotalSize)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "TotalSize")
+ return
+ }
+ // write "nv"
+ err = en.Append(0xa2, 0x6e, 0x76)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(za0004.NumVersions)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumVersions")
+ return
+ }
+ // write "no"
+ err = en.Append(0xa2, 0x6e, 0x6f)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(za0004.NumObjects)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumObjects")
+ return
+ }
+ }
+ }
+ }
+ // write "c"
+ err = en.Append(0xa1, 0x63)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.Compacted)
+ if err != nil {
+ err = msgp.WrapError(err, "Compacted")
+ return
+ }
}
return
}
@@ -1898,56 +2024,69 @@ func (z *dataUsageEntry) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
- // string "ch"
- o = append(o, 0xa2, 0x63, 0x68)
- o, err = z.Children.MarshalMsg(o)
- if err != nil {
- err = msgp.WrapError(err, "Children")
- return
- }
- // string "sz"
- o = append(o, 0xa2, 0x73, 0x7a)
- o = msgp.AppendInt64(o, z.Size)
- // string "os"
- o = append(o, 0xa2, 0x6f, 0x73)
- o = msgp.AppendUint64(o, z.Objects)
- // string "vs"
- o = append(o, 0xa2, 0x76, 0x73)
- o = msgp.AppendUint64(o, z.Versions)
- // string "dms"
- o = append(o, 0xa3, 0x64, 0x6d, 0x73)
- o = msgp.AppendUint64(o, z.DeleteMarkers)
- // string "szs"
- o = append(o, 0xa3, 0x73, 0x7a, 0x73)
- o = msgp.AppendArrayHeader(o, uint32(dataUsageBucketLen))
- for za0001 := range z.ObjSizes {
- o = msgp.AppendUint64(o, z.ObjSizes[za0001])
- }
- // string "vh"
- o = append(o, 0xa2, 0x76, 0x68)
- o = msgp.AppendArrayHeader(o, uint32(dataUsageVersionLen))
- for za0002 := range z.ObjVersions {
- o = msgp.AppendUint64(o, z.ObjVersions[za0002])
- }
- if (zb0001Mask & 0x80) == 0 { // if not omitted
- // string "ats"
- o = append(o, 0xa3, 0x61, 0x74, 0x73)
- if z.AllTierStats == nil {
- o = msgp.AppendNil(o)
- } else {
- o, err = z.AllTierStats.MarshalMsg(o)
- if err != nil {
- err = msgp.WrapError(err, "AllTierStats")
- return
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "ch"
+ o = append(o, 0xa2, 0x63, 0x68)
+ o, err = z.Children.MarshalMsg(o)
+ if err != nil {
+ err = msgp.WrapError(err, "Children")
+ return
+ }
+ // string "sz"
+ o = append(o, 0xa2, 0x73, 0x7a)
+ o = msgp.AppendInt64(o, z.Size)
+ // string "os"
+ o = append(o, 0xa2, 0x6f, 0x73)
+ o = msgp.AppendUint64(o, z.Objects)
+ // string "vs"
+ o = append(o, 0xa2, 0x76, 0x73)
+ o = msgp.AppendUint64(o, z.Versions)
+ // string "dms"
+ o = append(o, 0xa3, 0x64, 0x6d, 0x73)
+ o = msgp.AppendUint64(o, z.DeleteMarkers)
+ // string "szs"
+ o = append(o, 0xa3, 0x73, 0x7a, 0x73)
+ o = msgp.AppendArrayHeader(o, uint32(dataUsageBucketLen))
+ for za0001 := range z.ObjSizes {
+ o = msgp.AppendUint64(o, z.ObjSizes[za0001])
+ }
+ // string "vh"
+ o = append(o, 0xa2, 0x76, 0x68)
+ o = msgp.AppendArrayHeader(o, uint32(dataUsageVersionLen))
+ for za0002 := range z.ObjVersions {
+ o = msgp.AppendUint64(o, z.ObjVersions[za0002])
+ }
+ if (zb0001Mask & 0x80) == 0 { // if not omitted
+ // string "ats"
+ o = append(o, 0xa3, 0x61, 0x74, 0x73)
+ if z.AllTierStats == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ // map header, size 1
+ // string "ts"
+ o = append(o, 0x81, 0xa2, 0x74, 0x73)
+ o = msgp.AppendMapHeader(o, uint32(len(z.AllTierStats.Tiers)))
+ for za0003, za0004 := range z.AllTierStats.Tiers {
+ o = msgp.AppendString(o, za0003)
+ // map header, size 3
+ // string "ts"
+ o = append(o, 0x83, 0xa2, 0x74, 0x73)
+ o = msgp.AppendUint64(o, za0004.TotalSize)
+ // string "nv"
+ o = append(o, 0xa2, 0x6e, 0x76)
+ o = msgp.AppendInt(o, za0004.NumVersions)
+ // string "no"
+ o = append(o, 0xa2, 0x6e, 0x6f)
+ o = msgp.AppendInt(o, za0004.NumObjects)
+ }
}
}
+ // string "c"
+ o = append(o, 0xa1, 0x63)
+ o = msgp.AppendBool(o, z.Compacted)
}
- // string "c"
- o = append(o, 0xa1, 0x63)
- o = msgp.AppendBool(o, z.Compacted)
return
}
@@ -2048,11 +2187,93 @@ func (z *dataUsageEntry) UnmarshalMsg(bts []byte) (o []byte, err error) {
if z.AllTierStats == nil {
z.AllTierStats = new(allTierStats)
}
- bts, err = z.AllTierStats.UnmarshalMsg(bts)
+ var zb0004 uint32
+ zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AllTierStats")
return
}
+ for zb0004 > 0 {
+ zb0004--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ var zb0005 uint32
+ zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ if z.AllTierStats.Tiers == nil {
+ z.AllTierStats.Tiers = make(map[string]tierStats, zb0005)
+ } else if len(z.AllTierStats.Tiers) > 0 {
+ for key := range z.AllTierStats.Tiers {
+ delete(z.AllTierStats.Tiers, key)
+ }
+ }
+ for zb0005 > 0 {
+ var za0003 string
+ var za0004 tierStats
+ zb0005--
+ za0003, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ var zb0006 uint32
+ zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ za0004.TotalSize, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "TotalSize")
+ return
+ }
+ case "nv":
+ za0004.NumVersions, bts, err = msgp.ReadIntBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumVersions")
+ return
+ }
+ case "no":
+ za0004.NumObjects, bts, err = msgp.ReadIntBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumObjects")
+ return
+ }
+ default:
+ bts, err = msgp.Skip(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ }
+ }
+ z.AllTierStats.Tiers[za0003] = za0004
+ }
+ default:
+ bts, err = msgp.Skip(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ }
+ }
}
zb0001Mask |= 0x1
case "c":
@@ -2070,11 +2291,10 @@ func (z *dataUsageEntry) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.AllTierStats = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.AllTierStats = nil
}
+
o = bts
return
}
@@ -2085,7 +2305,13 @@ func (z *dataUsageEntry) Msgsize() (s int) {
if z.AllTierStats == nil {
s += msgp.NilSize
} else {
- s += z.AllTierStats.Msgsize()
+ s += 1 + 3 + msgp.MapHeaderSize
+ if z.AllTierStats.Tiers != nil {
+ for za0003, za0004 := range z.AllTierStats.Tiers {
+ _ = za0004
+ s += msgp.StringPrefixSize + len(za0003) + 1 + 3 + msgp.Uint64Size + 3 + msgp.IntSize + 3 + msgp.IntSize
+ }
+ }
}
s += 2 + msgp.BoolSize
return
@@ -2734,11 +2960,93 @@ func (z *dataUsageEntryV7) DecodeMsg(dc *msgp.Reader) (err error) {
if z.AllTierStats == nil {
z.AllTierStats = new(allTierStats)
}
- err = z.AllTierStats.DecodeMsg(dc)
+ var zb0004 uint32
+ zb0004, err = dc.ReadMapHeader()
if err != nil {
err = msgp.WrapError(err, "AllTierStats")
return
}
+ for zb0004 > 0 {
+ zb0004--
+ field, err = dc.ReadMapKeyPtr()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ var zb0005 uint32
+ zb0005, err = dc.ReadMapHeader()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ if z.AllTierStats.Tiers == nil {
+ z.AllTierStats.Tiers = make(map[string]tierStats, zb0005)
+ } else if len(z.AllTierStats.Tiers) > 0 {
+ for key := range z.AllTierStats.Tiers {
+ delete(z.AllTierStats.Tiers, key)
+ }
+ }
+ for zb0005 > 0 {
+ zb0005--
+ var za0003 string
+ var za0004 tierStats
+ za0003, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ var zb0006 uint32
+ zb0006, err = dc.ReadMapHeader()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, err = dc.ReadMapKeyPtr()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ za0004.TotalSize, err = dc.ReadUint64()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "TotalSize")
+ return
+ }
+ case "nv":
+ za0004.NumVersions, err = dc.ReadInt()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumVersions")
+ return
+ }
+ case "no":
+ za0004.NumObjects, err = dc.ReadInt()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumObjects")
+ return
+ }
+ default:
+ err = dc.Skip()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ }
+ }
+ z.AllTierStats.Tiers[za0003] = za0004
+ }
+ default:
+ err = dc.Skip()
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ }
+ }
}
zb0001Mask |= 0x1
case "c":
@@ -2756,11 +3064,10 @@ func (z *dataUsageEntryV7) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.AllTierStats = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.AllTierStats = nil
}
+
return
}
@@ -2861,11 +3168,93 @@ func (z *dataUsageEntryV7) UnmarshalMsg(bts []byte) (o []byte, err error) {
if z.AllTierStats == nil {
z.AllTierStats = new(allTierStats)
}
- bts, err = z.AllTierStats.UnmarshalMsg(bts)
+ var zb0004 uint32
+ zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AllTierStats")
return
}
+ for zb0004 > 0 {
+ zb0004--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ var zb0005 uint32
+ zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ if z.AllTierStats.Tiers == nil {
+ z.AllTierStats.Tiers = make(map[string]tierStats, zb0005)
+ } else if len(z.AllTierStats.Tiers) > 0 {
+ for key := range z.AllTierStats.Tiers {
+ delete(z.AllTierStats.Tiers, key)
+ }
+ }
+ for zb0005 > 0 {
+ var za0003 string
+ var za0004 tierStats
+ zb0005--
+ za0003, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers")
+ return
+ }
+ var zb0006 uint32
+ zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ts":
+ za0004.TotalSize, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "TotalSize")
+ return
+ }
+ case "nv":
+ za0004.NumVersions, bts, err = msgp.ReadIntBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumVersions")
+ return
+ }
+ case "no":
+ za0004.NumObjects, bts, err = msgp.ReadIntBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003, "NumObjects")
+ return
+ }
+ default:
+ bts, err = msgp.Skip(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats", "Tiers", za0003)
+ return
+ }
+ }
+ }
+ z.AllTierStats.Tiers[za0003] = za0004
+ }
+ default:
+ bts, err = msgp.Skip(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "AllTierStats")
+ return
+ }
+ }
+ }
}
zb0001Mask |= 0x1
case "c":
@@ -2883,11 +3272,10 @@ func (z *dataUsageEntryV7) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.AllTierStats = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.AllTierStats = nil
}
+
o = bts
return
}
@@ -2898,7 +3286,13 @@ func (z *dataUsageEntryV7) Msgsize() (s int) {
if z.AllTierStats == nil {
s += msgp.NilSize
} else {
- s += z.AllTierStats.Msgsize()
+ s += 1 + 3 + msgp.MapHeaderSize
+ if z.AllTierStats.Tiers != nil {
+ for za0003, za0004 := range z.AllTierStats.Tiers {
+ _ = za0004
+ s += msgp.StringPrefixSize + len(za0003) + 1 + 3 + msgp.Uint64Size + 3 + msgp.IntSize + 3 + msgp.IntSize
+ }
+ }
}
s += 2 + msgp.BoolSize
return
diff --git a/cmd/erasure-multipart.go b/cmd/erasure-multipart.go
index af642dfc7..f8a3bcdf4 100644
--- a/cmd/erasure-multipart.go
+++ b/cmd/erasure-multipart.go
@@ -744,6 +744,15 @@ func (er erasureObjects) PutObjectPart(ctx context.Context, bucket, object, uplo
ctx = plkctx.Context()
defer partIDLock.Unlock(plkctx)
+ // Read lock for upload id, only held while reading the upload metadata.
+ uploadIDRLock := er.NewNSLock(bucket, pathJoin(object, uploadID))
+ rlkctx, err := uploadIDRLock.GetRLock(ctx, globalOperationTimeout)
+ if err != nil {
+ return PartInfo{}, err
+ }
+ ctx = rlkctx.Context()
+ defer uploadIDRLock.RUnlock(rlkctx)
+
onlineDisks, err = er.renamePart(ctx, onlineDisks, minioMetaTmpBucket, tmpPartPath, minioMetaMultipartBucket, partPath, partFI, writeQuorum)
if err != nil {
if errors.Is(err, errFileNotFound) {
diff --git a/cmd/erasure-server-pool.go b/cmd/erasure-server-pool.go
index 6fa593aa1..f87cd4797 100644
--- a/cmd/erasure-server-pool.go
+++ b/cmd/erasure-server-pool.go
@@ -256,7 +256,7 @@ func (z *erasureServerPools) NewNSLock(bucket string, objects ...string) RWLocke
// GetDisksID will return disks by their ID.
func (z *erasureServerPools) GetDisksID(ids ...string) []StorageAPI {
- idMap := make(map[string]struct{})
+ idMap := make(map[string]struct{}, len(ids))
for _, id := range ids {
idMap[id] = struct{}{}
}
@@ -1858,16 +1858,6 @@ func (z *erasureServerPools) PutObjectPart(ctx context.Context, bucket, object,
return PartInfo{}, err
}
- // Read lock for upload id.
- // Only held while reading the upload metadata.
- uploadIDRLock := z.NewNSLock(bucket, pathJoin(object, uploadID))
- rlkctx, err := uploadIDRLock.GetRLock(ctx, globalOperationTimeout)
- if err != nil {
- return PartInfo{}, err
- }
- ctx = rlkctx.Context()
- defer uploadIDRLock.RUnlock(rlkctx)
-
if z.SinglePool() {
return z.serverPools[0].PutObjectPart(ctx, bucket, object, uploadID, partID, data, opts)
}
diff --git a/cmd/metacache-set.go b/cmd/metacache-set.go
index 509d451da..91c31d320 100644
--- a/cmd/metacache-set.go
+++ b/cmd/metacache-set.go
@@ -29,6 +29,7 @@ import (
"strconv"
"strings"
"sync"
+ "sync/atomic"
"time"
jsoniter "github.com/json-iterator/go"
@@ -182,8 +183,7 @@ func (o *listPathOptions) gatherResults(ctx context.Context, in <-chan metaCache
resultsDone := make(chan metaCacheEntriesSorted)
// Copy so we can mutate
resCh := resultsDone
- var done bool
- var mu sync.Mutex
+ var done atomic.Bool
resErr := io.EOF
go func() {
@@ -194,9 +194,7 @@ func (o *listPathOptions) gatherResults(ctx context.Context, in <-chan metaCache
// past limit
continue
}
- mu.Lock()
- returned = done
- mu.Unlock()
+ returned = done.Load()
if returned {
resCh = nil
continue
@@ -250,9 +248,7 @@ func (o *listPathOptions) gatherResults(ctx context.Context, in <-chan metaCache
return func() (metaCacheEntriesSorted, error) {
select {
case <-ctx.Done():
- mu.Lock()
- done = true
- mu.Unlock()
+ done.Store(true)
return metaCacheEntriesSorted{}, ctx.Err()
case r := <-resultsDone:
return r, resErr
diff --git a/cmd/object-handlers.go b/cmd/object-handlers.go
index e017e6777..b918f2485 100644
--- a/cmd/object-handlers.go
+++ b/cmd/object-handlers.go
@@ -1191,6 +1191,9 @@ func (api objectAPIHandlers) CopyObjectHandler(w http.ResponseWriter, r *http.Re
return
}
+ // Sanitize the source object name similar to NewMultipart and PutObject API
+ srcObject = trimLeadingSlash(srcObject)
+
if vid != "" && vid != nullVersionID {
_, err := uuid.Parse(vid)
if err != nil {
diff --git a/cmd/signature-v4.go b/cmd/signature-v4.go
index f2386cc8e..ceb8b4b2f 100644
--- a/cmd/signature-v4.go
+++ b/cmd/signature-v4.go
@@ -60,7 +60,7 @@ const (
// getCanonicalHeaders generate a list of request headers with their values
func getCanonicalHeaders(signedHeaders http.Header) string {
var headers []string
- vals := make(http.Header)
+ vals := make(http.Header, len(signedHeaders))
for k, vv := range signedHeaders {
k = strings.ToLower(k)
headers = append(headers, k)
diff --git a/cmd/storage-datatypes_gen.go b/cmd/storage-datatypes_gen.go
index 426eca8f5..192aef9cb 100644
--- a/cmd/storage-datatypes_gen.go
+++ b/cmd/storage-datatypes_gen.go
@@ -813,11 +813,10 @@ func (z *DeleteOptions) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.OldDataDir = ""
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.OldDataDir = ""
}
+
return
}
@@ -836,61 +835,62 @@ func (z *DeleteOptions) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "BaseOptions"
- err = en.Append(0xab, 0x42, 0x61, 0x73, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73)
- if err != nil {
- return
- }
- // map header, size 0
- _ = z.BaseOptions
- err = en.Append(0x80)
- if err != nil {
- return
- }
- // write "r"
- err = en.Append(0xa1, 0x72)
- if err != nil {
- return
- }
- err = en.WriteBool(z.Recursive)
- if err != nil {
- err = msgp.WrapError(err, "Recursive")
- return
- }
- // write "i"
- err = en.Append(0xa1, 0x69)
- if err != nil {
- return
- }
- err = en.WriteBool(z.Immediate)
- if err != nil {
- err = msgp.WrapError(err, "Immediate")
- return
- }
- // write "u"
- err = en.Append(0xa1, 0x75)
- if err != nil {
- return
- }
- err = en.WriteBool(z.UndoWrite)
- if err != nil {
- err = msgp.WrapError(err, "UndoWrite")
- return
- }
- if (zb0001Mask & 0x10) == 0 { // if not omitted
- // write "o"
- err = en.Append(0xa1, 0x6f)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "BaseOptions"
+ err = en.Append(0xab, 0x42, 0x61, 0x73, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73)
if err != nil {
return
}
- err = en.WriteString(z.OldDataDir)
+ // map header, size 0
+ _ = z.BaseOptions
+ err = en.Append(0x80)
if err != nil {
- err = msgp.WrapError(err, "OldDataDir")
return
}
+ // write "r"
+ err = en.Append(0xa1, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.Recursive)
+ if err != nil {
+ err = msgp.WrapError(err, "Recursive")
+ return
+ }
+ // write "i"
+ err = en.Append(0xa1, 0x69)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.Immediate)
+ if err != nil {
+ err = msgp.WrapError(err, "Immediate")
+ return
+ }
+ // write "u"
+ err = en.Append(0xa1, 0x75)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.UndoWrite)
+ if err != nil {
+ err = msgp.WrapError(err, "UndoWrite")
+ return
+ }
+ if (zb0001Mask & 0x10) == 0 { // if not omitted
+ // write "o"
+ err = en.Append(0xa1, 0x6f)
+ if err != nil {
+ return
+ }
+ err = en.WriteString(z.OldDataDir)
+ if err != nil {
+ err = msgp.WrapError(err, "OldDataDir")
+ return
+ }
+ }
}
return
}
@@ -908,27 +908,28 @@ func (z *DeleteOptions) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
- // string "BaseOptions"
- o = append(o, 0xab, 0x42, 0x61, 0x73, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73)
- // map header, size 0
- _ = z.BaseOptions
- o = append(o, 0x80)
- // string "r"
- o = append(o, 0xa1, 0x72)
- o = msgp.AppendBool(o, z.Recursive)
- // string "i"
- o = append(o, 0xa1, 0x69)
- o = msgp.AppendBool(o, z.Immediate)
- // string "u"
- o = append(o, 0xa1, 0x75)
- o = msgp.AppendBool(o, z.UndoWrite)
- if (zb0001Mask & 0x10) == 0 { // if not omitted
- // string "o"
- o = append(o, 0xa1, 0x6f)
- o = msgp.AppendString(o, z.OldDataDir)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "BaseOptions"
+ o = append(o, 0xab, 0x42, 0x61, 0x73, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73)
+ // map header, size 0
+ _ = z.BaseOptions
+ o = append(o, 0x80)
+ // string "r"
+ o = append(o, 0xa1, 0x72)
+ o = msgp.AppendBool(o, z.Recursive)
+ // string "i"
+ o = append(o, 0xa1, 0x69)
+ o = msgp.AppendBool(o, z.Immediate)
+ // string "u"
+ o = append(o, 0xa1, 0x75)
+ o = msgp.AppendBool(o, z.UndoWrite)
+ if (zb0001Mask & 0x10) == 0 { // if not omitted
+ // string "o"
+ o = append(o, 0xa1, 0x6f)
+ o = msgp.AppendString(o, z.OldDataDir)
+ }
}
return
}
@@ -1010,11 +1011,10 @@ func (z *DeleteOptions) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.OldDataDir = ""
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.OldDataDir = ""
}
+
o = bts
return
}
@@ -4331,11 +4331,10 @@ func (z *ReadMultipleReq) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.Prefix = ""
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.Prefix = ""
}
+
return
}
@@ -4354,87 +4353,88 @@ func (z *ReadMultipleReq) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "bk"
- err = en.Append(0xa2, 0x62, 0x6b)
- if err != nil {
- return
- }
- err = en.WriteString(z.Bucket)
- if err != nil {
- err = msgp.WrapError(err, "Bucket")
- return
- }
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // write "pr"
- err = en.Append(0xa2, 0x70, 0x72)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "bk"
+ err = en.Append(0xa2, 0x62, 0x6b)
if err != nil {
return
}
- err = en.WriteString(z.Prefix)
+ err = en.WriteString(z.Bucket)
if err != nil {
- err = msgp.WrapError(err, "Prefix")
+ err = msgp.WrapError(err, "Bucket")
return
}
- }
- // write "fl"
- err = en.Append(0xa2, 0x66, 0x6c)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(len(z.Files)))
- if err != nil {
- err = msgp.WrapError(err, "Files")
- return
- }
- for za0001 := range z.Files {
- err = en.WriteString(z.Files[za0001])
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // write "pr"
+ err = en.Append(0xa2, 0x70, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteString(z.Prefix)
+ if err != nil {
+ err = msgp.WrapError(err, "Prefix")
+ return
+ }
+ }
+ // write "fl"
+ err = en.Append(0xa2, 0x66, 0x6c)
if err != nil {
- err = msgp.WrapError(err, "Files", za0001)
return
}
- }
- // write "ms"
- err = en.Append(0xa2, 0x6d, 0x73)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.MaxSize)
- if err != nil {
- err = msgp.WrapError(err, "MaxSize")
- return
- }
- // write "mo"
- err = en.Append(0xa2, 0x6d, 0x6f)
- if err != nil {
- return
- }
- err = en.WriteBool(z.MetadataOnly)
- if err != nil {
- err = msgp.WrapError(err, "MetadataOnly")
- return
- }
- // write "ab"
- err = en.Append(0xa2, 0x61, 0x62)
- if err != nil {
- return
- }
- err = en.WriteBool(z.AbortOn404)
- if err != nil {
- err = msgp.WrapError(err, "AbortOn404")
- return
- }
- // write "mr"
- err = en.Append(0xa2, 0x6d, 0x72)
- if err != nil {
- return
- }
- err = en.WriteInt(z.MaxResults)
- if err != nil {
- err = msgp.WrapError(err, "MaxResults")
- return
+ err = en.WriteArrayHeader(uint32(len(z.Files)))
+ if err != nil {
+ err = msgp.WrapError(err, "Files")
+ return
+ }
+ for za0001 := range z.Files {
+ err = en.WriteString(z.Files[za0001])
+ if err != nil {
+ err = msgp.WrapError(err, "Files", za0001)
+ return
+ }
+ }
+ // write "ms"
+ err = en.Append(0xa2, 0x6d, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.MaxSize)
+ if err != nil {
+ err = msgp.WrapError(err, "MaxSize")
+ return
+ }
+ // write "mo"
+ err = en.Append(0xa2, 0x6d, 0x6f)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.MetadataOnly)
+ if err != nil {
+ err = msgp.WrapError(err, "MetadataOnly")
+ return
+ }
+ // write "ab"
+ err = en.Append(0xa2, 0x61, 0x62)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.AbortOn404)
+ if err != nil {
+ err = msgp.WrapError(err, "AbortOn404")
+ return
+ }
+ // write "mr"
+ err = en.Append(0xa2, 0x6d, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(z.MaxResults)
+ if err != nil {
+ err = msgp.WrapError(err, "MaxResults")
+ return
+ }
}
return
}
@@ -4452,35 +4452,36 @@ func (z *ReadMultipleReq) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "bk"
+ o = append(o, 0xa2, 0x62, 0x6b)
+ o = msgp.AppendString(o, z.Bucket)
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // string "pr"
+ o = append(o, 0xa2, 0x70, 0x72)
+ o = msgp.AppendString(o, z.Prefix)
+ }
+ // string "fl"
+ o = append(o, 0xa2, 0x66, 0x6c)
+ o = msgp.AppendArrayHeader(o, uint32(len(z.Files)))
+ for za0001 := range z.Files {
+ o = msgp.AppendString(o, z.Files[za0001])
+ }
+ // string "ms"
+ o = append(o, 0xa2, 0x6d, 0x73)
+ o = msgp.AppendInt64(o, z.MaxSize)
+ // string "mo"
+ o = append(o, 0xa2, 0x6d, 0x6f)
+ o = msgp.AppendBool(o, z.MetadataOnly)
+ // string "ab"
+ o = append(o, 0xa2, 0x61, 0x62)
+ o = msgp.AppendBool(o, z.AbortOn404)
+ // string "mr"
+ o = append(o, 0xa2, 0x6d, 0x72)
+ o = msgp.AppendInt(o, z.MaxResults)
}
- // string "bk"
- o = append(o, 0xa2, 0x62, 0x6b)
- o = msgp.AppendString(o, z.Bucket)
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // string "pr"
- o = append(o, 0xa2, 0x70, 0x72)
- o = msgp.AppendString(o, z.Prefix)
- }
- // string "fl"
- o = append(o, 0xa2, 0x66, 0x6c)
- o = msgp.AppendArrayHeader(o, uint32(len(z.Files)))
- for za0001 := range z.Files {
- o = msgp.AppendString(o, z.Files[za0001])
- }
- // string "ms"
- o = append(o, 0xa2, 0x6d, 0x73)
- o = msgp.AppendInt64(o, z.MaxSize)
- // string "mo"
- o = append(o, 0xa2, 0x6d, 0x6f)
- o = msgp.AppendBool(o, z.MetadataOnly)
- // string "ab"
- o = append(o, 0xa2, 0x61, 0x62)
- o = msgp.AppendBool(o, z.AbortOn404)
- // string "mr"
- o = append(o, 0xa2, 0x6d, 0x72)
- o = msgp.AppendInt(o, z.MaxResults)
return
}
@@ -4569,11 +4570,10 @@ func (z *ReadMultipleReq) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.Prefix = ""
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.Prefix = ""
}
+
o = bts
return
}
@@ -4691,82 +4691,83 @@ func (z *ReadMultipleResp) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "bk"
- err = en.Append(0xa2, 0x62, 0x6b)
- if err != nil {
- return
- }
- err = en.WriteString(z.Bucket)
- if err != nil {
- err = msgp.WrapError(err, "Bucket")
- return
- }
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // write "pr"
- err = en.Append(0xa2, 0x70, 0x72)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "bk"
+ err = en.Append(0xa2, 0x62, 0x6b)
if err != nil {
return
}
- err = en.WriteString(z.Prefix)
+ err = en.WriteString(z.Bucket)
if err != nil {
- err = msgp.WrapError(err, "Prefix")
+ err = msgp.WrapError(err, "Bucket")
return
}
- }
- // write "fl"
- err = en.Append(0xa2, 0x66, 0x6c)
- if err != nil {
- return
- }
- err = en.WriteString(z.File)
- if err != nil {
- err = msgp.WrapError(err, "File")
- return
- }
- // write "ex"
- err = en.Append(0xa2, 0x65, 0x78)
- if err != nil {
- return
- }
- err = en.WriteBool(z.Exists)
- if err != nil {
- err = msgp.WrapError(err, "Exists")
- return
- }
- if (zb0001Mask & 0x10) == 0 { // if not omitted
- // write "er"
- err = en.Append(0xa2, 0x65, 0x72)
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // write "pr"
+ err = en.Append(0xa2, 0x70, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteString(z.Prefix)
+ if err != nil {
+ err = msgp.WrapError(err, "Prefix")
+ return
+ }
+ }
+ // write "fl"
+ err = en.Append(0xa2, 0x66, 0x6c)
if err != nil {
return
}
- err = en.WriteString(z.Error)
+ err = en.WriteString(z.File)
if err != nil {
- err = msgp.WrapError(err, "Error")
+ err = msgp.WrapError(err, "File")
+ return
+ }
+ // write "ex"
+ err = en.Append(0xa2, 0x65, 0x78)
+ if err != nil {
+ return
+ }
+ err = en.WriteBool(z.Exists)
+ if err != nil {
+ err = msgp.WrapError(err, "Exists")
+ return
+ }
+ if (zb0001Mask & 0x10) == 0 { // if not omitted
+ // write "er"
+ err = en.Append(0xa2, 0x65, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteString(z.Error)
+ if err != nil {
+ err = msgp.WrapError(err, "Error")
+ return
+ }
+ }
+ // write "d"
+ err = en.Append(0xa1, 0x64)
+ if err != nil {
+ return
+ }
+ err = en.WriteBytes(z.Data)
+ if err != nil {
+ err = msgp.WrapError(err, "Data")
+ return
+ }
+ // write "m"
+ err = en.Append(0xa1, 0x6d)
+ if err != nil {
+ return
+ }
+ err = en.WriteTime(z.Modtime)
+ if err != nil {
+ err = msgp.WrapError(err, "Modtime")
return
}
- }
- // write "d"
- err = en.Append(0xa1, 0x64)
- if err != nil {
- return
- }
- err = en.WriteBytes(z.Data)
- if err != nil {
- err = msgp.WrapError(err, "Data")
- return
- }
- // write "m"
- err = en.Append(0xa1, 0x6d)
- if err != nil {
- return
- }
- err = en.WriteTime(z.Modtime)
- if err != nil {
- err = msgp.WrapError(err, "Modtime")
- return
}
return
}
@@ -4788,34 +4789,35 @@ func (z *ReadMultipleResp) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "bk"
+ o = append(o, 0xa2, 0x62, 0x6b)
+ o = msgp.AppendString(o, z.Bucket)
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // string "pr"
+ o = append(o, 0xa2, 0x70, 0x72)
+ o = msgp.AppendString(o, z.Prefix)
+ }
+ // string "fl"
+ o = append(o, 0xa2, 0x66, 0x6c)
+ o = msgp.AppendString(o, z.File)
+ // string "ex"
+ o = append(o, 0xa2, 0x65, 0x78)
+ o = msgp.AppendBool(o, z.Exists)
+ if (zb0001Mask & 0x10) == 0 { // if not omitted
+ // string "er"
+ o = append(o, 0xa2, 0x65, 0x72)
+ o = msgp.AppendString(o, z.Error)
+ }
+ // string "d"
+ o = append(o, 0xa1, 0x64)
+ o = msgp.AppendBytes(o, z.Data)
+ // string "m"
+ o = append(o, 0xa1, 0x6d)
+ o = msgp.AppendTime(o, z.Modtime)
}
- // string "bk"
- o = append(o, 0xa2, 0x62, 0x6b)
- o = msgp.AppendString(o, z.Bucket)
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // string "pr"
- o = append(o, 0xa2, 0x70, 0x72)
- o = msgp.AppendString(o, z.Prefix)
- }
- // string "fl"
- o = append(o, 0xa2, 0x66, 0x6c)
- o = msgp.AppendString(o, z.File)
- // string "ex"
- o = append(o, 0xa2, 0x65, 0x78)
- o = msgp.AppendBool(o, z.Exists)
- if (zb0001Mask & 0x10) == 0 { // if not omitted
- // string "er"
- o = append(o, 0xa2, 0x65, 0x72)
- o = msgp.AppendString(o, z.Error)
- }
- // string "d"
- o = append(o, 0xa1, 0x64)
- o = msgp.AppendBytes(o, z.Data)
- // string "m"
- o = append(o, 0xa1, 0x6d)
- o = msgp.AppendTime(o, z.Modtime)
return
}
diff --git a/cmd/xl-storage-format-v1_gen.go b/cmd/xl-storage-format-v1_gen.go
index 96cffdce4..fb2642813 100644
--- a/cmd/xl-storage-format-v1_gen.go
+++ b/cmd/xl-storage-format-v1_gen.go
@@ -692,105 +692,106 @@ func (z *ObjectPartInfo) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "e"
- err = en.Append(0xa1, 0x65)
- if err != nil {
- return
- }
- err = en.WriteString(z.ETag)
- if err != nil {
- err = msgp.WrapError(err, "ETag")
- return
- }
- // write "n"
- err = en.Append(0xa1, 0x6e)
- if err != nil {
- return
- }
- err = en.WriteInt(z.Number)
- if err != nil {
- err = msgp.WrapError(err, "Number")
- return
- }
- // write "s"
- err = en.Append(0xa1, 0x73)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.Size)
- if err != nil {
- err = msgp.WrapError(err, "Size")
- return
- }
- // write "as"
- err = en.Append(0xa2, 0x61, 0x73)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.ActualSize)
- if err != nil {
- err = msgp.WrapError(err, "ActualSize")
- return
- }
- // write "mt"
- err = en.Append(0xa2, 0x6d, 0x74)
- if err != nil {
- return
- }
- err = en.WriteTime(z.ModTime)
- if err != nil {
- err = msgp.WrapError(err, "ModTime")
- return
- }
- if (zb0001Mask & 0x20) == 0 { // if not omitted
- // write "i"
- err = en.Append(0xa1, 0x69)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "e"
+ err = en.Append(0xa1, 0x65)
if err != nil {
return
}
- err = en.WriteBytes(z.Index)
+ err = en.WriteString(z.ETag)
if err != nil {
- err = msgp.WrapError(err, "Index")
+ err = msgp.WrapError(err, "ETag")
return
}
- }
- if (zb0001Mask & 0x40) == 0 { // if not omitted
- // write "crc"
- err = en.Append(0xa3, 0x63, 0x72, 0x63)
+ // write "n"
+ err = en.Append(0xa1, 0x6e)
if err != nil {
return
}
- err = en.WriteMapHeader(uint32(len(z.Checksums)))
+ err = en.WriteInt(z.Number)
if err != nil {
- err = msgp.WrapError(err, "Checksums")
+ err = msgp.WrapError(err, "Number")
return
}
- for za0001, za0002 := range z.Checksums {
- err = en.WriteString(za0001)
+ // write "s"
+ err = en.Append(0xa1, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.Size)
+ if err != nil {
+ err = msgp.WrapError(err, "Size")
+ return
+ }
+ // write "as"
+ err = en.Append(0xa2, 0x61, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.ActualSize)
+ if err != nil {
+ err = msgp.WrapError(err, "ActualSize")
+ return
+ }
+ // write "mt"
+ err = en.Append(0xa2, 0x6d, 0x74)
+ if err != nil {
+ return
+ }
+ err = en.WriteTime(z.ModTime)
+ if err != nil {
+ err = msgp.WrapError(err, "ModTime")
+ return
+ }
+ if (zb0001Mask & 0x20) == 0 { // if not omitted
+ // write "i"
+ err = en.Append(0xa1, 0x69)
+ if err != nil {
+ return
+ }
+ err = en.WriteBytes(z.Index)
+ if err != nil {
+ err = msgp.WrapError(err, "Index")
+ return
+ }
+ }
+ if (zb0001Mask & 0x40) == 0 { // if not omitted
+ // write "crc"
+ err = en.Append(0xa3, 0x63, 0x72, 0x63)
+ if err != nil {
+ return
+ }
+ err = en.WriteMapHeader(uint32(len(z.Checksums)))
if err != nil {
err = msgp.WrapError(err, "Checksums")
return
}
- err = en.WriteString(za0002)
- if err != nil {
- err = msgp.WrapError(err, "Checksums", za0001)
- return
+ for za0001, za0002 := range z.Checksums {
+ err = en.WriteString(za0001)
+ if err != nil {
+ err = msgp.WrapError(err, "Checksums")
+ return
+ }
+ err = en.WriteString(za0002)
+ if err != nil {
+ err = msgp.WrapError(err, "Checksums", za0001)
+ return
+ }
}
}
- }
- if (zb0001Mask & 0x80) == 0 { // if not omitted
- // write "err"
- err = en.Append(0xa3, 0x65, 0x72, 0x72)
- if err != nil {
- return
- }
- err = en.WriteString(z.Error)
- if err != nil {
- err = msgp.WrapError(err, "Error")
- return
+ if (zb0001Mask & 0x80) == 0 { // if not omitted
+ // write "err"
+ err = en.Append(0xa3, 0x65, 0x72, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteString(z.Error)
+ if err != nil {
+ err = msgp.WrapError(err, "Error")
+ return
+ }
}
}
return
@@ -817,42 +818,43 @@ func (z *ObjectPartInfo) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
- // string "e"
- o = append(o, 0xa1, 0x65)
- o = msgp.AppendString(o, z.ETag)
- // string "n"
- o = append(o, 0xa1, 0x6e)
- o = msgp.AppendInt(o, z.Number)
- // string "s"
- o = append(o, 0xa1, 0x73)
- o = msgp.AppendInt64(o, z.Size)
- // string "as"
- o = append(o, 0xa2, 0x61, 0x73)
- o = msgp.AppendInt64(o, z.ActualSize)
- // string "mt"
- o = append(o, 0xa2, 0x6d, 0x74)
- o = msgp.AppendTime(o, z.ModTime)
- if (zb0001Mask & 0x20) == 0 { // if not omitted
- // string "i"
- o = append(o, 0xa1, 0x69)
- o = msgp.AppendBytes(o, z.Index)
- }
- if (zb0001Mask & 0x40) == 0 { // if not omitted
- // string "crc"
- o = append(o, 0xa3, 0x63, 0x72, 0x63)
- o = msgp.AppendMapHeader(o, uint32(len(z.Checksums)))
- for za0001, za0002 := range z.Checksums {
- o = msgp.AppendString(o, za0001)
- o = msgp.AppendString(o, za0002)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "e"
+ o = append(o, 0xa1, 0x65)
+ o = msgp.AppendString(o, z.ETag)
+ // string "n"
+ o = append(o, 0xa1, 0x6e)
+ o = msgp.AppendInt(o, z.Number)
+ // string "s"
+ o = append(o, 0xa1, 0x73)
+ o = msgp.AppendInt64(o, z.Size)
+ // string "as"
+ o = append(o, 0xa2, 0x61, 0x73)
+ o = msgp.AppendInt64(o, z.ActualSize)
+ // string "mt"
+ o = append(o, 0xa2, 0x6d, 0x74)
+ o = msgp.AppendTime(o, z.ModTime)
+ if (zb0001Mask & 0x20) == 0 { // if not omitted
+ // string "i"
+ o = append(o, 0xa1, 0x69)
+ o = msgp.AppendBytes(o, z.Index)
+ }
+ if (zb0001Mask & 0x40) == 0 { // if not omitted
+ // string "crc"
+ o = append(o, 0xa3, 0x63, 0x72, 0x63)
+ o = msgp.AppendMapHeader(o, uint32(len(z.Checksums)))
+ for za0001, za0002 := range z.Checksums {
+ o = msgp.AppendString(o, za0001)
+ o = msgp.AppendString(o, za0002)
+ }
+ }
+ if (zb0001Mask & 0x80) == 0 { // if not omitted
+ // string "err"
+ o = append(o, 0xa3, 0x65, 0x72, 0x72)
+ o = msgp.AppendString(o, z.Error)
}
- }
- if (zb0001Mask & 0x80) == 0 { // if not omitted
- // string "err"
- o = append(o, 0xa3, 0x65, 0x72, 0x72)
- o = msgp.AppendString(o, z.Error)
}
return
}
diff --git a/cmd/xl-storage-format-v2_gen.go b/cmd/xl-storage-format-v2_gen.go
index 7f917fa42..d97ee5594 100644
--- a/cmd/xl-storage-format-v2_gen.go
+++ b/cmd/xl-storage-format-v2_gen.go
@@ -339,11 +339,10 @@ func (z *xlMetaDataDirDecoder) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.ObjectV2 = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.ObjectV2 = nil
}
+
return
}
@@ -362,9 +361,6 @@ func (z *xlMetaDataDirDecoder) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
if (zb0001Mask & 0x1) == 0 { // if not omitted
// write "V2Obj"
err = en.Append(0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
@@ -406,9 +402,6 @@ func (z *xlMetaDataDirDecoder) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
if (zb0001Mask & 0x1) == 0 { // if not omitted
// string "V2Obj"
o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
@@ -496,11 +489,10 @@ func (z *xlMetaDataDirDecoder) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.ObjectV2 = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.ObjectV2 = nil
}
+
o = bts
return
}
@@ -588,11 +580,10 @@ func (z *xlMetaV2DeleteMarker) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.MetaSys = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.MetaSys = nil
}
+
return
}
@@ -611,50 +602,51 @@ func (z *xlMetaV2DeleteMarker) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "ID"
- err = en.Append(0xa2, 0x49, 0x44)
- if err != nil {
- return
- }
- err = en.WriteBytes((z.VersionID)[:])
- if err != nil {
- err = msgp.WrapError(err, "VersionID")
- return
- }
- // write "MTime"
- err = en.Append(0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.ModTime)
- if err != nil {
- err = msgp.WrapError(err, "ModTime")
- return
- }
- if (zb0001Mask & 0x4) == 0 { // if not omitted
- // write "MetaSys"
- err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "ID"
+ err = en.Append(0xa2, 0x49, 0x44)
if err != nil {
return
}
- err = en.WriteMapHeader(uint32(len(z.MetaSys)))
+ err = en.WriteBytes((z.VersionID)[:])
if err != nil {
- err = msgp.WrapError(err, "MetaSys")
+ err = msgp.WrapError(err, "VersionID")
return
}
- for za0002, za0003 := range z.MetaSys {
- err = en.WriteString(za0002)
+ // write "MTime"
+ err = en.Append(0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.ModTime)
+ if err != nil {
+ err = msgp.WrapError(err, "ModTime")
+ return
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not omitted
+ // write "MetaSys"
+ err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteMapHeader(uint32(len(z.MetaSys)))
if err != nil {
err = msgp.WrapError(err, "MetaSys")
return
}
- err = en.WriteBytes(za0003)
- if err != nil {
- err = msgp.WrapError(err, "MetaSys", za0002)
- return
+ for za0002, za0003 := range z.MetaSys {
+ err = en.WriteString(za0002)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaSys")
+ return
+ }
+ err = en.WriteBytes(za0003)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaSys", za0002)
+ return
+ }
}
}
}
@@ -674,22 +666,23 @@ func (z *xlMetaV2DeleteMarker) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
- // string "ID"
- o = append(o, 0xa2, 0x49, 0x44)
- o = msgp.AppendBytes(o, (z.VersionID)[:])
- // string "MTime"
- o = append(o, 0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
- o = msgp.AppendInt64(o, z.ModTime)
- if (zb0001Mask & 0x4) == 0 { // if not omitted
- // string "MetaSys"
- o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
- o = msgp.AppendMapHeader(o, uint32(len(z.MetaSys)))
- for za0002, za0003 := range z.MetaSys {
- o = msgp.AppendString(o, za0002)
- o = msgp.AppendBytes(o, za0003)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "ID"
+ o = append(o, 0xa2, 0x49, 0x44)
+ o = msgp.AppendBytes(o, (z.VersionID)[:])
+ // string "MTime"
+ o = append(o, 0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
+ o = msgp.AppendInt64(o, z.ModTime)
+ if (zb0001Mask & 0x4) == 0 { // if not omitted
+ // string "MetaSys"
+ o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
+ o = msgp.AppendMapHeader(o, uint32(len(z.MetaSys)))
+ for za0002, za0003 := range z.MetaSys {
+ o = msgp.AppendString(o, za0002)
+ o = msgp.AppendBytes(o, za0003)
+ }
}
}
return
@@ -767,11 +760,10 @@ func (z *xlMetaV2DeleteMarker) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.MetaSys = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.MetaSys = nil
}
+
o = bts
return
}
@@ -1096,11 +1088,10 @@ func (z *xlMetaV2Object) DecodeMsg(dc *msgp.Reader) (err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.PartIndices = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.PartIndices = nil
}
+
return
}
@@ -1119,282 +1110,283 @@ func (z *xlMetaV2Object) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "ID"
- err = en.Append(0xa2, 0x49, 0x44)
- if err != nil {
- return
- }
- err = en.WriteBytes((z.VersionID)[:])
- if err != nil {
- err = msgp.WrapError(err, "VersionID")
- return
- }
- // write "DDir"
- err = en.Append(0xa4, 0x44, 0x44, 0x69, 0x72)
- if err != nil {
- return
- }
- err = en.WriteBytes((z.DataDir)[:])
- if err != nil {
- err = msgp.WrapError(err, "DataDir")
- return
- }
- // write "EcAlgo"
- err = en.Append(0xa6, 0x45, 0x63, 0x41, 0x6c, 0x67, 0x6f)
- if err != nil {
- return
- }
- err = en.WriteUint8(uint8(z.ErasureAlgorithm))
- if err != nil {
- err = msgp.WrapError(err, "ErasureAlgorithm")
- return
- }
- // write "EcM"
- err = en.Append(0xa3, 0x45, 0x63, 0x4d)
- if err != nil {
- return
- }
- err = en.WriteInt(z.ErasureM)
- if err != nil {
- err = msgp.WrapError(err, "ErasureM")
- return
- }
- // write "EcN"
- err = en.Append(0xa3, 0x45, 0x63, 0x4e)
- if err != nil {
- return
- }
- err = en.WriteInt(z.ErasureN)
- if err != nil {
- err = msgp.WrapError(err, "ErasureN")
- return
- }
- // write "EcBSize"
- err = en.Append(0xa7, 0x45, 0x63, 0x42, 0x53, 0x69, 0x7a, 0x65)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.ErasureBlockSize)
- if err != nil {
- err = msgp.WrapError(err, "ErasureBlockSize")
- return
- }
- // write "EcIndex"
- err = en.Append(0xa7, 0x45, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78)
- if err != nil {
- return
- }
- err = en.WriteInt(z.ErasureIndex)
- if err != nil {
- err = msgp.WrapError(err, "ErasureIndex")
- return
- }
- // write "EcDist"
- err = en.Append(0xa6, 0x45, 0x63, 0x44, 0x69, 0x73, 0x74)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(len(z.ErasureDist)))
- if err != nil {
- err = msgp.WrapError(err, "ErasureDist")
- return
- }
- for za0003 := range z.ErasureDist {
- err = en.WriteUint8(z.ErasureDist[za0003])
- if err != nil {
- err = msgp.WrapError(err, "ErasureDist", za0003)
- return
- }
- }
- // write "CSumAlgo"
- err = en.Append(0xa8, 0x43, 0x53, 0x75, 0x6d, 0x41, 0x6c, 0x67, 0x6f)
- if err != nil {
- return
- }
- err = en.WriteUint8(uint8(z.BitrotChecksumAlgo))
- if err != nil {
- err = msgp.WrapError(err, "BitrotChecksumAlgo")
- return
- }
- // write "PartNums"
- err = en.Append(0xa8, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x73)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(len(z.PartNumbers)))
- if err != nil {
- err = msgp.WrapError(err, "PartNumbers")
- return
- }
- for za0004 := range z.PartNumbers {
- err = en.WriteInt(z.PartNumbers[za0004])
- if err != nil {
- err = msgp.WrapError(err, "PartNumbers", za0004)
- return
- }
- }
- // write "PartETags"
- err = en.Append(0xa9, 0x50, 0x61, 0x72, 0x74, 0x45, 0x54, 0x61, 0x67, 0x73)
- if err != nil {
- return
- }
- if z.PartETags == nil { // allownil: if nil
- err = en.WriteNil()
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "ID"
+ err = en.Append(0xa2, 0x49, 0x44)
if err != nil {
return
}
- } else {
- err = en.WriteArrayHeader(uint32(len(z.PartETags)))
+ err = en.WriteBytes((z.VersionID)[:])
if err != nil {
- err = msgp.WrapError(err, "PartETags")
+ err = msgp.WrapError(err, "VersionID")
return
}
- for za0005 := range z.PartETags {
- err = en.WriteString(z.PartETags[za0005])
+ // write "DDir"
+ err = en.Append(0xa4, 0x44, 0x44, 0x69, 0x72)
+ if err != nil {
+ return
+ }
+ err = en.WriteBytes((z.DataDir)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "DataDir")
+ return
+ }
+ // write "EcAlgo"
+ err = en.Append(0xa6, 0x45, 0x63, 0x41, 0x6c, 0x67, 0x6f)
+ if err != nil {
+ return
+ }
+ err = en.WriteUint8(uint8(z.ErasureAlgorithm))
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureAlgorithm")
+ return
+ }
+ // write "EcM"
+ err = en.Append(0xa3, 0x45, 0x63, 0x4d)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(z.ErasureM)
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureM")
+ return
+ }
+ // write "EcN"
+ err = en.Append(0xa3, 0x45, 0x63, 0x4e)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(z.ErasureN)
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureN")
+ return
+ }
+ // write "EcBSize"
+ err = en.Append(0xa7, 0x45, 0x63, 0x42, 0x53, 0x69, 0x7a, 0x65)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.ErasureBlockSize)
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureBlockSize")
+ return
+ }
+ // write "EcIndex"
+ err = en.Append(0xa7, 0x45, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt(z.ErasureIndex)
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureIndex")
+ return
+ }
+ // write "EcDist"
+ err = en.Append(0xa6, 0x45, 0x63, 0x44, 0x69, 0x73, 0x74)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(len(z.ErasureDist)))
+ if err != nil {
+ err = msgp.WrapError(err, "ErasureDist")
+ return
+ }
+ for za0003 := range z.ErasureDist {
+ err = en.WriteUint8(z.ErasureDist[za0003])
if err != nil {
- err = msgp.WrapError(err, "PartETags", za0005)
+ err = msgp.WrapError(err, "ErasureDist", za0003)
return
}
}
- }
- // write "PartSizes"
- err = en.Append(0xa9, 0x50, 0x61, 0x72, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x73)
- if err != nil {
- return
- }
- err = en.WriteArrayHeader(uint32(len(z.PartSizes)))
- if err != nil {
- err = msgp.WrapError(err, "PartSizes")
- return
- }
- for za0006 := range z.PartSizes {
- err = en.WriteInt64(z.PartSizes[za0006])
- if err != nil {
- err = msgp.WrapError(err, "PartSizes", za0006)
- return
- }
- }
- // write "PartASizes"
- err = en.Append(0xaa, 0x50, 0x61, 0x72, 0x74, 0x41, 0x53, 0x69, 0x7a, 0x65, 0x73)
- if err != nil {
- return
- }
- if z.PartActualSizes == nil { // allownil: if nil
- err = en.WriteNil()
+ // write "CSumAlgo"
+ err = en.Append(0xa8, 0x43, 0x53, 0x75, 0x6d, 0x41, 0x6c, 0x67, 0x6f)
if err != nil {
return
}
- } else {
- err = en.WriteArrayHeader(uint32(len(z.PartActualSizes)))
+ err = en.WriteUint8(uint8(z.BitrotChecksumAlgo))
if err != nil {
- err = msgp.WrapError(err, "PartActualSizes")
+ err = msgp.WrapError(err, "BitrotChecksumAlgo")
return
}
- for za0007 := range z.PartActualSizes {
- err = en.WriteInt64(z.PartActualSizes[za0007])
+ // write "PartNums"
+ err = en.Append(0xa8, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(len(z.PartNumbers)))
+ if err != nil {
+ err = msgp.WrapError(err, "PartNumbers")
+ return
+ }
+ for za0004 := range z.PartNumbers {
+ err = en.WriteInt(z.PartNumbers[za0004])
if err != nil {
- err = msgp.WrapError(err, "PartActualSizes", za0007)
+ err = msgp.WrapError(err, "PartNumbers", za0004)
return
}
}
- }
- if (zb0001Mask & 0x2000) == 0 { // if not omitted
- // write "PartIdx"
- err = en.Append(0xa7, 0x50, 0x61, 0x72, 0x74, 0x49, 0x64, 0x78)
+ // write "PartETags"
+ err = en.Append(0xa9, 0x50, 0x61, 0x72, 0x74, 0x45, 0x54, 0x61, 0x67, 0x73)
if err != nil {
return
}
- err = en.WriteArrayHeader(uint32(len(z.PartIndices)))
- if err != nil {
- err = msgp.WrapError(err, "PartIndices")
- return
- }
- for za0008 := range z.PartIndices {
- err = en.WriteBytes(z.PartIndices[za0008])
+ if z.PartETags == nil { // allownil: if nil
+ err = en.WriteNil()
if err != nil {
- err = msgp.WrapError(err, "PartIndices", za0008)
+ return
+ }
+ } else {
+ err = en.WriteArrayHeader(uint32(len(z.PartETags)))
+ if err != nil {
+ err = msgp.WrapError(err, "PartETags")
+ return
+ }
+ for za0005 := range z.PartETags {
+ err = en.WriteString(z.PartETags[za0005])
+ if err != nil {
+ err = msgp.WrapError(err, "PartETags", za0005)
+ return
+ }
+ }
+ }
+ // write "PartSizes"
+ err = en.Append(0xa9, 0x50, 0x61, 0x72, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x73)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(len(z.PartSizes)))
+ if err != nil {
+ err = msgp.WrapError(err, "PartSizes")
+ return
+ }
+ for za0006 := range z.PartSizes {
+ err = en.WriteInt64(z.PartSizes[za0006])
+ if err != nil {
+ err = msgp.WrapError(err, "PartSizes", za0006)
return
}
}
- }
- // write "Size"
- err = en.Append(0xa4, 0x53, 0x69, 0x7a, 0x65)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.Size)
- if err != nil {
- err = msgp.WrapError(err, "Size")
- return
- }
- // write "MTime"
- err = en.Append(0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
- if err != nil {
- return
- }
- err = en.WriteInt64(z.ModTime)
- if err != nil {
- err = msgp.WrapError(err, "ModTime")
- return
- }
- // write "MetaSys"
- err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
- if err != nil {
- return
- }
- if z.MetaSys == nil { // allownil: if nil
- err = en.WriteNil()
+ // write "PartASizes"
+ err = en.Append(0xaa, 0x50, 0x61, 0x72, 0x74, 0x41, 0x53, 0x69, 0x7a, 0x65, 0x73)
if err != nil {
return
}
- } else {
- err = en.WriteMapHeader(uint32(len(z.MetaSys)))
+ if z.PartActualSizes == nil { // allownil: if nil
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = en.WriteArrayHeader(uint32(len(z.PartActualSizes)))
+ if err != nil {
+ err = msgp.WrapError(err, "PartActualSizes")
+ return
+ }
+ for za0007 := range z.PartActualSizes {
+ err = en.WriteInt64(z.PartActualSizes[za0007])
+ if err != nil {
+ err = msgp.WrapError(err, "PartActualSizes", za0007)
+ return
+ }
+ }
+ }
+ if (zb0001Mask & 0x2000) == 0 { // if not omitted
+ // write "PartIdx"
+ err = en.Append(0xa7, 0x50, 0x61, 0x72, 0x74, 0x49, 0x64, 0x78)
+ if err != nil {
+ return
+ }
+ err = en.WriteArrayHeader(uint32(len(z.PartIndices)))
+ if err != nil {
+ err = msgp.WrapError(err, "PartIndices")
+ return
+ }
+ for za0008 := range z.PartIndices {
+ err = en.WriteBytes(z.PartIndices[za0008])
+ if err != nil {
+ err = msgp.WrapError(err, "PartIndices", za0008)
+ return
+ }
+ }
+ }
+ // write "Size"
+ err = en.Append(0xa4, 0x53, 0x69, 0x7a, 0x65)
if err != nil {
- err = msgp.WrapError(err, "MetaSys")
return
}
- for za0009, za0010 := range z.MetaSys {
- err = en.WriteString(za0009)
+ err = en.WriteInt64(z.Size)
+ if err != nil {
+ err = msgp.WrapError(err, "Size")
+ return
+ }
+ // write "MTime"
+ err = en.Append(0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
+ if err != nil {
+ return
+ }
+ err = en.WriteInt64(z.ModTime)
+ if err != nil {
+ err = msgp.WrapError(err, "ModTime")
+ return
+ }
+ // write "MetaSys"
+ err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
+ if err != nil {
+ return
+ }
+ if z.MetaSys == nil { // allownil: if nil
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = en.WriteMapHeader(uint32(len(z.MetaSys)))
if err != nil {
err = msgp.WrapError(err, "MetaSys")
return
}
- err = en.WriteBytes(za0010)
- if err != nil {
- err = msgp.WrapError(err, "MetaSys", za0009)
- return
+ for za0009, za0010 := range z.MetaSys {
+ err = en.WriteString(za0009)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaSys")
+ return
+ }
+ err = en.WriteBytes(za0010)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaSys", za0009)
+ return
+ }
}
}
- }
- // write "MetaUsr"
- err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x55, 0x73, 0x72)
- if err != nil {
- return
- }
- if z.MetaUser == nil { // allownil: if nil
- err = en.WriteNil()
+ // write "MetaUsr"
+ err = en.Append(0xa7, 0x4d, 0x65, 0x74, 0x61, 0x55, 0x73, 0x72)
if err != nil {
return
}
- } else {
- err = en.WriteMapHeader(uint32(len(z.MetaUser)))
- if err != nil {
- err = msgp.WrapError(err, "MetaUser")
- return
- }
- for za0011, za0012 := range z.MetaUser {
- err = en.WriteString(za0011)
+ if z.MetaUser == nil { // allownil: if nil
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = en.WriteMapHeader(uint32(len(z.MetaUser)))
if err != nil {
err = msgp.WrapError(err, "MetaUser")
return
}
- err = en.WriteString(za0012)
- if err != nil {
- err = msgp.WrapError(err, "MetaUser", za0011)
- return
+ for za0011, za0012 := range z.MetaUser {
+ err = en.WriteString(za0011)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaUser")
+ return
+ }
+ err = en.WriteString(za0012)
+ if err != nil {
+ err = msgp.WrapError(err, "MetaUser", za0011)
+ return
+ }
}
}
}
@@ -1414,105 +1406,106 @@ func (z *xlMetaV2Object) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = msgp.AppendMapHeader(o, zb0001Len)
- if zb0001Len == 0 {
- return
- }
- // string "ID"
- o = append(o, 0xa2, 0x49, 0x44)
- o = msgp.AppendBytes(o, (z.VersionID)[:])
- // string "DDir"
- o = append(o, 0xa4, 0x44, 0x44, 0x69, 0x72)
- o = msgp.AppendBytes(o, (z.DataDir)[:])
- // string "EcAlgo"
- o = append(o, 0xa6, 0x45, 0x63, 0x41, 0x6c, 0x67, 0x6f)
- o = msgp.AppendUint8(o, uint8(z.ErasureAlgorithm))
- // string "EcM"
- o = append(o, 0xa3, 0x45, 0x63, 0x4d)
- o = msgp.AppendInt(o, z.ErasureM)
- // string "EcN"
- o = append(o, 0xa3, 0x45, 0x63, 0x4e)
- o = msgp.AppendInt(o, z.ErasureN)
- // string "EcBSize"
- o = append(o, 0xa7, 0x45, 0x63, 0x42, 0x53, 0x69, 0x7a, 0x65)
- o = msgp.AppendInt64(o, z.ErasureBlockSize)
- // string "EcIndex"
- o = append(o, 0xa7, 0x45, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78)
- o = msgp.AppendInt(o, z.ErasureIndex)
- // string "EcDist"
- o = append(o, 0xa6, 0x45, 0x63, 0x44, 0x69, 0x73, 0x74)
- o = msgp.AppendArrayHeader(o, uint32(len(z.ErasureDist)))
- for za0003 := range z.ErasureDist {
- o = msgp.AppendUint8(o, z.ErasureDist[za0003])
- }
- // string "CSumAlgo"
- o = append(o, 0xa8, 0x43, 0x53, 0x75, 0x6d, 0x41, 0x6c, 0x67, 0x6f)
- o = msgp.AppendUint8(o, uint8(z.BitrotChecksumAlgo))
- // string "PartNums"
- o = append(o, 0xa8, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x73)
- o = msgp.AppendArrayHeader(o, uint32(len(z.PartNumbers)))
- for za0004 := range z.PartNumbers {
- o = msgp.AppendInt(o, z.PartNumbers[za0004])
- }
- // string "PartETags"
- o = append(o, 0xa9, 0x50, 0x61, 0x72, 0x74, 0x45, 0x54, 0x61, 0x67, 0x73)
- if z.PartETags == nil { // allownil: if nil
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendArrayHeader(o, uint32(len(z.PartETags)))
- for za0005 := range z.PartETags {
- o = msgp.AppendString(o, z.PartETags[za0005])
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "ID"
+ o = append(o, 0xa2, 0x49, 0x44)
+ o = msgp.AppendBytes(o, (z.VersionID)[:])
+ // string "DDir"
+ o = append(o, 0xa4, 0x44, 0x44, 0x69, 0x72)
+ o = msgp.AppendBytes(o, (z.DataDir)[:])
+ // string "EcAlgo"
+ o = append(o, 0xa6, 0x45, 0x63, 0x41, 0x6c, 0x67, 0x6f)
+ o = msgp.AppendUint8(o, uint8(z.ErasureAlgorithm))
+ // string "EcM"
+ o = append(o, 0xa3, 0x45, 0x63, 0x4d)
+ o = msgp.AppendInt(o, z.ErasureM)
+ // string "EcN"
+ o = append(o, 0xa3, 0x45, 0x63, 0x4e)
+ o = msgp.AppendInt(o, z.ErasureN)
+ // string "EcBSize"
+ o = append(o, 0xa7, 0x45, 0x63, 0x42, 0x53, 0x69, 0x7a, 0x65)
+ o = msgp.AppendInt64(o, z.ErasureBlockSize)
+ // string "EcIndex"
+ o = append(o, 0xa7, 0x45, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78)
+ o = msgp.AppendInt(o, z.ErasureIndex)
+ // string "EcDist"
+ o = append(o, 0xa6, 0x45, 0x63, 0x44, 0x69, 0x73, 0x74)
+ o = msgp.AppendArrayHeader(o, uint32(len(z.ErasureDist)))
+ for za0003 := range z.ErasureDist {
+ o = msgp.AppendUint8(o, z.ErasureDist[za0003])
}
- }
- // string "PartSizes"
- o = append(o, 0xa9, 0x50, 0x61, 0x72, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x73)
- o = msgp.AppendArrayHeader(o, uint32(len(z.PartSizes)))
- for za0006 := range z.PartSizes {
- o = msgp.AppendInt64(o, z.PartSizes[za0006])
- }
- // string "PartASizes"
- o = append(o, 0xaa, 0x50, 0x61, 0x72, 0x74, 0x41, 0x53, 0x69, 0x7a, 0x65, 0x73)
- if z.PartActualSizes == nil { // allownil: if nil
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendArrayHeader(o, uint32(len(z.PartActualSizes)))
- for za0007 := range z.PartActualSizes {
- o = msgp.AppendInt64(o, z.PartActualSizes[za0007])
+ // string "CSumAlgo"
+ o = append(o, 0xa8, 0x43, 0x53, 0x75, 0x6d, 0x41, 0x6c, 0x67, 0x6f)
+ o = msgp.AppendUint8(o, uint8(z.BitrotChecksumAlgo))
+ // string "PartNums"
+ o = append(o, 0xa8, 0x50, 0x61, 0x72, 0x74, 0x4e, 0x75, 0x6d, 0x73)
+ o = msgp.AppendArrayHeader(o, uint32(len(z.PartNumbers)))
+ for za0004 := range z.PartNumbers {
+ o = msgp.AppendInt(o, z.PartNumbers[za0004])
}
- }
- if (zb0001Mask & 0x2000) == 0 { // if not omitted
- // string "PartIdx"
- o = append(o, 0xa7, 0x50, 0x61, 0x72, 0x74, 0x49, 0x64, 0x78)
- o = msgp.AppendArrayHeader(o, uint32(len(z.PartIndices)))
- for za0008 := range z.PartIndices {
- o = msgp.AppendBytes(o, z.PartIndices[za0008])
+ // string "PartETags"
+ o = append(o, 0xa9, 0x50, 0x61, 0x72, 0x74, 0x45, 0x54, 0x61, 0x67, 0x73)
+ if z.PartETags == nil { // allownil: if nil
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len(z.PartETags)))
+ for za0005 := range z.PartETags {
+ o = msgp.AppendString(o, z.PartETags[za0005])
+ }
}
- }
- // string "Size"
- o = append(o, 0xa4, 0x53, 0x69, 0x7a, 0x65)
- o = msgp.AppendInt64(o, z.Size)
- // string "MTime"
- o = append(o, 0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
- o = msgp.AppendInt64(o, z.ModTime)
- // string "MetaSys"
- o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
- if z.MetaSys == nil { // allownil: if nil
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendMapHeader(o, uint32(len(z.MetaSys)))
- for za0009, za0010 := range z.MetaSys {
- o = msgp.AppendString(o, za0009)
- o = msgp.AppendBytes(o, za0010)
+ // string "PartSizes"
+ o = append(o, 0xa9, 0x50, 0x61, 0x72, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x73)
+ o = msgp.AppendArrayHeader(o, uint32(len(z.PartSizes)))
+ for za0006 := range z.PartSizes {
+ o = msgp.AppendInt64(o, z.PartSizes[za0006])
}
- }
- // string "MetaUsr"
- o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x55, 0x73, 0x72)
- if z.MetaUser == nil { // allownil: if nil
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendMapHeader(o, uint32(len(z.MetaUser)))
- for za0011, za0012 := range z.MetaUser {
- o = msgp.AppendString(o, za0011)
- o = msgp.AppendString(o, za0012)
+ // string "PartASizes"
+ o = append(o, 0xaa, 0x50, 0x61, 0x72, 0x74, 0x41, 0x53, 0x69, 0x7a, 0x65, 0x73)
+ if z.PartActualSizes == nil { // allownil: if nil
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len(z.PartActualSizes)))
+ for za0007 := range z.PartActualSizes {
+ o = msgp.AppendInt64(o, z.PartActualSizes[za0007])
+ }
+ }
+ if (zb0001Mask & 0x2000) == 0 { // if not omitted
+ // string "PartIdx"
+ o = append(o, 0xa7, 0x50, 0x61, 0x72, 0x74, 0x49, 0x64, 0x78)
+ o = msgp.AppendArrayHeader(o, uint32(len(z.PartIndices)))
+ for za0008 := range z.PartIndices {
+ o = msgp.AppendBytes(o, z.PartIndices[za0008])
+ }
+ }
+ // string "Size"
+ o = append(o, 0xa4, 0x53, 0x69, 0x7a, 0x65)
+ o = msgp.AppendInt64(o, z.Size)
+ // string "MTime"
+ o = append(o, 0xa5, 0x4d, 0x54, 0x69, 0x6d, 0x65)
+ o = msgp.AppendInt64(o, z.ModTime)
+ // string "MetaSys"
+ o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x53, 0x79, 0x73)
+ if z.MetaSys == nil { // allownil: if nil
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendMapHeader(o, uint32(len(z.MetaSys)))
+ for za0009, za0010 := range z.MetaSys {
+ o = msgp.AppendString(o, za0009)
+ o = msgp.AppendBytes(o, za0010)
+ }
+ }
+ // string "MetaUsr"
+ o = append(o, 0xa7, 0x4d, 0x65, 0x74, 0x61, 0x55, 0x73, 0x72)
+ if z.MetaUser == nil { // allownil: if nil
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendMapHeader(o, uint32(len(z.MetaUser)))
+ for za0011, za0012 := range z.MetaUser {
+ o = msgp.AppendString(o, za0011)
+ o = msgp.AppendString(o, za0012)
+ }
}
}
return
@@ -1810,11 +1803,10 @@ func (z *xlMetaV2Object) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
// Clear omitted fields.
- if zb0001Mask != 0x1 {
- if (zb0001Mask & 0x1) == 0 {
- z.PartIndices = nil
- }
+ if (zb0001Mask & 0x1) == 0 {
+ z.PartIndices = nil
}
+
o = bts
return
}
@@ -1985,85 +1977,86 @@ func (z *xlMetaV2Version) EncodeMsg(en *msgp.Writer) (err error) {
if err != nil {
return
}
- if zb0001Len == 0 {
- return
- }
- // write "Type"
- err = en.Append(0xa4, 0x54, 0x79, 0x70, 0x65)
- if err != nil {
- return
- }
- err = en.WriteUint8(uint8(z.Type))
- if err != nil {
- err = msgp.WrapError(err, "Type")
- return
- }
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // write "V1Obj"
- err = en.Append(0xa5, 0x56, 0x31, 0x4f, 0x62, 0x6a)
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // write "Type"
+ err = en.Append(0xa4, 0x54, 0x79, 0x70, 0x65)
if err != nil {
return
}
- if z.ObjectV1 == nil {
- err = en.WriteNil()
+ err = en.WriteUint8(uint8(z.Type))
+ if err != nil {
+ err = msgp.WrapError(err, "Type")
+ return
+ }
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // write "V1Obj"
+ err = en.Append(0xa5, 0x56, 0x31, 0x4f, 0x62, 0x6a)
if err != nil {
return
}
- } else {
- err = z.ObjectV1.EncodeMsg(en)
- if err != nil {
- err = msgp.WrapError(err, "ObjectV1")
- return
+ if z.ObjectV1 == nil {
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = z.ObjectV1.EncodeMsg(en)
+ if err != nil {
+ err = msgp.WrapError(err, "ObjectV1")
+ return
+ }
}
}
- }
- if (zb0001Mask & 0x4) == 0 { // if not omitted
- // write "V2Obj"
- err = en.Append(0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
+ if (zb0001Mask & 0x4) == 0 { // if not omitted
+ // write "V2Obj"
+ err = en.Append(0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
+ if err != nil {
+ return
+ }
+ if z.ObjectV2 == nil {
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = z.ObjectV2.EncodeMsg(en)
+ if err != nil {
+ err = msgp.WrapError(err, "ObjectV2")
+ return
+ }
+ }
+ }
+ if (zb0001Mask & 0x8) == 0 { // if not omitted
+ // write "DelObj"
+ err = en.Append(0xa6, 0x44, 0x65, 0x6c, 0x4f, 0x62, 0x6a)
+ if err != nil {
+ return
+ }
+ if z.DeleteMarker == nil {
+ err = en.WriteNil()
+ if err != nil {
+ return
+ }
+ } else {
+ err = z.DeleteMarker.EncodeMsg(en)
+ if err != nil {
+ err = msgp.WrapError(err, "DeleteMarker")
+ return
+ }
+ }
+ }
+ // write "v"
+ err = en.Append(0xa1, 0x76)
if err != nil {
return
}
- if z.ObjectV2 == nil {
- err = en.WriteNil()
- if err != nil {
- return
- }
- } else {
- err = z.ObjectV2.EncodeMsg(en)
- if err != nil {
- err = msgp.WrapError(err, "ObjectV2")
- return
- }
- }
- }
- if (zb0001Mask & 0x8) == 0 { // if not omitted
- // write "DelObj"
- err = en.Append(0xa6, 0x44, 0x65, 0x6c, 0x4f, 0x62, 0x6a)
+ err = en.WriteUint64(z.WrittenByVersion)
if err != nil {
+ err = msgp.WrapError(err, "WrittenByVersion")
return
}
- if z.DeleteMarker == nil {
- err = en.WriteNil()
- if err != nil {
- return
- }
- } else {
- err = z.DeleteMarker.EncodeMsg(en)
- if err != nil {
- err = msgp.WrapError(err, "DeleteMarker")
- return
- }
- }
- }
- // write "v"
- err = en.Append(0xa1, 0x76)
- if err != nil {
- return
- }
- err = en.WriteUint64(z.WrittenByVersion)
- if err != nil {
- err = msgp.WrapError(err, "WrittenByVersion")
- return
}
return
}
@@ -2089,54 +2082,55 @@ func (z *xlMetaV2Version) MarshalMsg(b []byte) (o []byte, err error) {
}
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len == 0 {
- return
- }
- // string "Type"
- o = append(o, 0xa4, 0x54, 0x79, 0x70, 0x65)
- o = msgp.AppendUint8(o, uint8(z.Type))
- if (zb0001Mask & 0x2) == 0 { // if not omitted
- // string "V1Obj"
- o = append(o, 0xa5, 0x56, 0x31, 0x4f, 0x62, 0x6a)
- if z.ObjectV1 == nil {
- o = msgp.AppendNil(o)
- } else {
- o, err = z.ObjectV1.MarshalMsg(o)
- if err != nil {
- err = msgp.WrapError(err, "ObjectV1")
- return
+
+ // skip if no fields are to be emitted
+ if zb0001Len != 0 {
+ // string "Type"
+ o = append(o, 0xa4, 0x54, 0x79, 0x70, 0x65)
+ o = msgp.AppendUint8(o, uint8(z.Type))
+ if (zb0001Mask & 0x2) == 0 { // if not omitted
+ // string "V1Obj"
+ o = append(o, 0xa5, 0x56, 0x31, 0x4f, 0x62, 0x6a)
+ if z.ObjectV1 == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o, err = z.ObjectV1.MarshalMsg(o)
+ if err != nil {
+ err = msgp.WrapError(err, "ObjectV1")
+ return
+ }
}
}
- }
- if (zb0001Mask & 0x4) == 0 { // if not omitted
- // string "V2Obj"
- o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
- if z.ObjectV2 == nil {
- o = msgp.AppendNil(o)
- } else {
- o, err = z.ObjectV2.MarshalMsg(o)
- if err != nil {
- err = msgp.WrapError(err, "ObjectV2")
- return
+ if (zb0001Mask & 0x4) == 0 { // if not omitted
+ // string "V2Obj"
+ o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
+ if z.ObjectV2 == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o, err = z.ObjectV2.MarshalMsg(o)
+ if err != nil {
+ err = msgp.WrapError(err, "ObjectV2")
+ return
+ }
}
}
- }
- if (zb0001Mask & 0x8) == 0 { // if not omitted
- // string "DelObj"
- o = append(o, 0xa6, 0x44, 0x65, 0x6c, 0x4f, 0x62, 0x6a)
- if z.DeleteMarker == nil {
- o = msgp.AppendNil(o)
- } else {
- o, err = z.DeleteMarker.MarshalMsg(o)
- if err != nil {
- err = msgp.WrapError(err, "DeleteMarker")
- return
+ if (zb0001Mask & 0x8) == 0 { // if not omitted
+ // string "DelObj"
+ o = append(o, 0xa6, 0x44, 0x65, 0x6c, 0x4f, 0x62, 0x6a)
+ if z.DeleteMarker == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o, err = z.DeleteMarker.MarshalMsg(o)
+ if err != nil {
+ err = msgp.WrapError(err, "DeleteMarker")
+ return
+ }
}
}
+ // string "v"
+ o = append(o, 0xa1, 0x76)
+ o = msgp.AppendUint64(o, z.WrittenByVersion)
}
- // string "v"
- o = append(o, 0xa1, 0x76)
- o = msgp.AppendUint64(o, z.WrittenByVersion)
return
}
diff --git a/docs/debugging/inspect/go.mod b/docs/debugging/inspect/go.mod
index 3ca5c7444..ebeb3b893 100644
--- a/docs/debugging/inspect/go.mod
+++ b/docs/debugging/inspect/go.mod
@@ -18,6 +18,6 @@ require (
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/minio/pkg/v3 v3.0.1 // indirect
github.com/philhofer/fwd v1.1.2 // indirect
- golang.org/x/crypto v0.23.0 // indirect
- golang.org/x/sys v0.20.0 // indirect
+ golang.org/x/crypto v0.31.0 // indirect
+ golang.org/x/sys v0.28.0 // indirect
)
diff --git a/docs/debugging/inspect/go.sum b/docs/debugging/inspect/go.sum
index cdd3093a7..eaeac19c8 100644
--- a/docs/debugging/inspect/go.sum
+++ b/docs/debugging/inspect/go.sum
@@ -25,14 +25,14 @@ github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU=
github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/docs/orchestration/docker-compose/docker-compose.yaml b/docs/orchestration/docker-compose/docker-compose.yaml
index a8ba2d0e6..864914f2f 100644
--- a/docs/orchestration/docker-compose/docker-compose.yaml
+++ b/docs/orchestration/docker-compose/docker-compose.yaml
@@ -2,7 +2,7 @@ version: '3.7'
# Settings and configurations that are common for all containers
x-minio-common: &minio-common
- image: quay.io/minio/minio:RELEASE.2024-11-07T00-52-20Z
+ image: quay.io/minio/minio:RELEASE.2024-12-13T22-19-12Z
command: server --console-address ":9001" http://minio{1...4}/data{1...2}
expose:
- "9000"
diff --git a/go.mod b/go.mod
index ed9bba196..c00713d11 100644
--- a/go.mod
+++ b/go.mod
@@ -49,10 +49,10 @@ require (
github.com/minio/highwayhash v1.0.3
github.com/minio/kms-go/kes v0.3.0
github.com/minio/kms-go/kms v0.4.0
- github.com/minio/madmin-go/v3 v3.0.77
- github.com/minio/minio-go/v7 v7.0.81-0.20241125171916-a563333c01ef
+ github.com/minio/madmin-go/v3 v3.0.78
+ github.com/minio/minio-go/v7 v7.0.82
github.com/minio/mux v1.9.0
- github.com/minio/pkg/v3 v3.0.22
+ github.com/minio/pkg/v3 v3.0.23
github.com/minio/selfupdate v0.6.0
github.com/minio/simdjson-go v0.4.5
github.com/minio/sio v0.4.1
@@ -71,7 +71,7 @@ require (
github.com/pkg/xattr v0.4.10
github.com/prometheus/client_golang v1.20.5
github.com/prometheus/client_model v0.6.1
- github.com/prometheus/common v0.60.1
+ github.com/prometheus/common v0.61.0
github.com/prometheus/procfs v0.15.1
github.com/puzpuzpuz/xsync/v3 v3.4.0
github.com/rabbitmq/amqp091-go v1.10.0
@@ -79,7 +79,7 @@ require (
github.com/rs/cors v1.11.1
github.com/secure-io/sio-go v0.3.1
github.com/shirou/gopsutil/v3 v3.24.5
- github.com/tinylib/msgp v1.2.4
+ github.com/tinylib/msgp v1.2.5
github.com/valyala/bytebufferpool v1.0.0
github.com/xdg/scram v1.0.5
github.com/zeebo/xxh3 v1.0.2
@@ -88,11 +88,11 @@ require (
go.uber.org/atomic v1.11.0
go.uber.org/zap v1.27.0
goftp.io/server/v2 v2.0.1
- golang.org/x/crypto v0.29.0
+ golang.org/x/crypto v0.31.0
golang.org/x/oauth2 v0.24.0
- golang.org/x/sync v0.9.0
- golang.org/x/sys v0.27.0
- golang.org/x/term v0.26.0
+ golang.org/x/sync v0.10.0
+ golang.org/x/sys v0.28.0
+ golang.org/x/term v0.27.0
golang.org/x/time v0.8.0
google.golang.org/api v0.205.0
gopkg.in/yaml.v2 v2.4.0
@@ -158,7 +158,7 @@ require (
github.com/go-openapi/validate v0.24.0 // indirect
github.com/gobwas/httphead v0.1.0 // indirect
github.com/gobwas/pool v0.2.1 // indirect
- github.com/goccy/go-json v0.10.3 // indirect
+ github.com/goccy/go-json v0.10.4 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
@@ -185,11 +185,11 @@ require (
github.com/juju/ratelimit v1.0.2 // indirect
github.com/kr/fs v0.1.0 // indirect
github.com/kylelemons/godebug v1.1.0 // indirect
- github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
github.com/lestrrat-go/blackmagic v1.0.2 // indirect
github.com/lestrrat-go/httpcc v1.0.1 // indirect
+ github.com/lestrrat-go/httprc v1.0.6 // indirect
github.com/lestrrat-go/iter v1.0.2 // indirect
- github.com/lestrrat-go/jwx v1.2.30 // indirect
+ github.com/lestrrat-go/jwx/v2 v2.1.3 // indirect
github.com/lestrrat-go/option v1.0.1 // indirect
github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect
@@ -225,11 +225,12 @@ require (
github.com/posener/complete v1.2.3 // indirect
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
github.com/prometheus/prom2json v1.4.1 // indirect
- github.com/prometheus/prometheus v0.55.1 // indirect
+ github.com/prometheus/prometheus v0.300.1 // indirect
github.com/rivo/uniseg v0.4.7 // indirect
github.com/rjeczalik/notify v0.9.3 // indirect
github.com/rs/xid v1.6.0 // indirect
- github.com/safchain/ethtool v0.4.1 // indirect
+ github.com/safchain/ethtool v0.5.9 // indirect
+ github.com/segmentio/asm v1.2.0 // indirect
github.com/shoenig/go-m1cpu v0.1.6 // indirect
github.com/tidwall/gjson v1.18.0 // indirect
github.com/tidwall/match v1.1.1 // indirect
@@ -253,14 +254,12 @@ require (
go.opentelemetry.io/otel/trace v1.32.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
golang.org/x/mod v0.22.0 // indirect
- golang.org/x/net v0.31.0 // indirect
- golang.org/x/text v0.20.0 // indirect
+ golang.org/x/net v0.32.0 // indirect
+ golang.org/x/text v0.21.0 // indirect
golang.org/x/tools v0.27.0 // indirect
google.golang.org/genproto v0.0.0-20241113202542-65e8d215514f // indirect
- google.golang.org/genproto/googleapis/api v0.0.0-20241113202542-65e8d215514f // indirect
- google.golang.org/genproto/googleapis/rpc v0.0.0-20241113202542-65e8d215514f // indirect
- google.golang.org/grpc v1.68.0 // indirect
- google.golang.org/grpc/stats/opentelemetry v0.0.0-20241028142157-ada6787961b3 // indirect
- google.golang.org/protobuf v1.35.1 // indirect
-
+ google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 // indirect
+ google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 // indirect
+ google.golang.org/grpc v1.69.0 // indirect
+ google.golang.org/protobuf v1.35.2 // indirect
)
diff --git a/go.sum b/go.sum
index 263829887..51eb90c08 100644
--- a/go.sum
+++ b/go.sum
@@ -228,8 +228,8 @@ github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6Wezm
github.com/gobwas/ws v1.2.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
-github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
-github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
+github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
@@ -379,17 +379,16 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
-github.com/lestrrat-go/backoff/v2 v2.0.8 h1:oNb5E5isby2kiro9AgdHLv5N5tint1AnDVVf2E2un5A=
-github.com/lestrrat-go/backoff/v2 v2.0.8/go.mod h1:rHP/q/r9aT27n24JQLa7JhSQZCKBBOiM/uP402WwN8Y=
github.com/lestrrat-go/blackmagic v1.0.2 h1:Cg2gVSc9h7sz9NOByczrbUvLopQmXrfFx//N+AkAr5k=
github.com/lestrrat-go/blackmagic v1.0.2/go.mod h1:UrEqBzIR2U6CnzVyUtfM6oZNMt/7O7Vohk2J0OGSAtU=
github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=
github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E=
+github.com/lestrrat-go/httprc v1.0.6 h1:qgmgIRhpvBqexMJjA/PmwSvhNk679oqD1RbovdCGW8k=
+github.com/lestrrat-go/httprc v1.0.6/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo=
github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI=
github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4=
-github.com/lestrrat-go/jwx v1.2.30 h1:VKIFrmjYn0z2J51iLPadqoHIVLzvWNa1kCsTqNDHYPA=
-github.com/lestrrat-go/jwx v1.2.30/go.mod h1:vMxrwFhunGZ3qddmfmEm2+uced8MSI6QFWGTKygjSzQ=
-github.com/lestrrat-go/option v1.0.0/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
+github.com/lestrrat-go/jwx/v2 v2.1.3 h1:Ud4lb2QuxRClYAmRleF50KrbKIoM1TddXgBrneT5/Jo=
+github.com/lestrrat-go/jwx/v2 v2.1.3/go.mod h1:q6uFgbgZfEmQrfJfrCo90QcQOcXFMfbI/fO0NqRtvZo=
github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
@@ -449,19 +448,19 @@ github.com/minio/kms-go/kes v0.3.0 h1:SU8VGVM/Hk9w1OiSby3OatkcojooUqIdDHl6dtM6Nk
github.com/minio/kms-go/kes v0.3.0/go.mod h1:w6DeVT878qEOU3nUrYVy1WOT5H1Ig9hbDIh698NYJKY=
github.com/minio/kms-go/kms v0.4.0 h1:cLPZceEp+05xHotVBaeFJrgL7JcXM4lBy6PU0idkE7I=
github.com/minio/kms-go/kms v0.4.0/go.mod h1:q12CehiIy2qgBnDKq6Q7wmPi2PHSyRVug5DKp0HAVeE=
-github.com/minio/madmin-go/v3 v3.0.77 h1:cqp5kVeT5anDyocvoN81puwpy+GN7t+Xdj6xCLpnONE=
-github.com/minio/madmin-go/v3 v3.0.77/go.mod h1:ku/RUc2xeo4Uui/GHUURMoNEVXk4Ih40xA3KHLyMF1o=
+github.com/minio/madmin-go/v3 v3.0.78 h1:JHUZU8akWSu8UF+mIBpsOSLtOG9b4ZTZVz3TShLbYn4=
+github.com/minio/madmin-go/v3 v3.0.78/go.mod h1:IZOL4lEMiJ4QN2iWQjkOIIthcVuNYU7ENF7RkyxlzKY=
github.com/minio/mc v0.0.0-20241113163349-308a8ea9d072 h1:XkmrGflHybEIUx66+5H8Q3qJNqeHA/Z/0oGxb0eGyEE=
github.com/minio/mc v0.0.0-20241113163349-308a8ea9d072/go.mod h1:Ige8iv/XoT2Qooopu4Ki8WWsspFZMD4crNEOwmMys3c=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v6 v6.0.46/go.mod h1:qD0lajrGW49lKZLtXKtCB4X/qkMf0a5tBvN2PaZg7Gg=
-github.com/minio/minio-go/v7 v7.0.81-0.20241125171916-a563333c01ef h1:DB3ArSCJHnKOXzcqVTRoPOpehiDGFO/HcEoynvBa+B0=
-github.com/minio/minio-go/v7 v7.0.81-0.20241125171916-a563333c01ef/go.mod h1:84gmIilaX4zcvAWWzJ5Z1WI5axN+hAbM5w25xf8xvC0=
+github.com/minio/minio-go/v7 v7.0.82 h1:tWfICLhmp2aFPXL8Tli0XDTHj2VB/fNf0PC1f/i1gRo=
+github.com/minio/minio-go/v7 v7.0.82/go.mod h1:84gmIilaX4zcvAWWzJ5Z1WI5axN+hAbM5w25xf8xvC0=
github.com/minio/mux v1.9.0 h1:dWafQFyEfGhJvK6AwLOt83bIG5bxKxKJnKMCi0XAaoA=
github.com/minio/mux v1.9.0/go.mod h1:1pAare17ZRL5GpmNL+9YmqHoWnLmMZF9C/ioUCfy0BQ=
-github.com/minio/pkg/v3 v3.0.22 h1:KkwmMtKoVJRLnDmf7KLa3E0NV6C8LHtq//ZFWeajJfg=
-github.com/minio/pkg/v3 v3.0.22/go.mod h1:LwYm9J2+ZMgnrVvnxxFKss1QCuY86X85ec6CQNv2a4k=
+github.com/minio/pkg/v3 v3.0.23 h1:KgGWTk6JEtAJC3PhEowqe61R29h63kwxiHwy5RF12yI=
+github.com/minio/pkg/v3 v3.0.23/go.mod h1:mIaN552nu0D2jiSk5BQC8LB25f44ytbOBJCuLtksX7Q=
github.com/minio/selfupdate v0.6.0 h1:i76PgT0K5xO9+hjzKcacQtO7+MjJ4JKA8Ak8XQ9DDwU=
github.com/minio/selfupdate v0.6.0/go.mod h1:bO02GTIPCMQFTEvE5h4DjYB58bCoZ35XLeBf0buTDdM=
github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
@@ -560,16 +559,16 @@ github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:
github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/common v0.60.1 h1:FUas6GcOw66yB/73KC+BOZoFJmbo/1pojoILArPAaSc=
-github.com/prometheus/common v0.60.1/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw=
+github.com/prometheus/common v0.61.0 h1:3gv/GThfX0cV2lpO7gkTUwZru38mxevy90Bj8YFSRQQ=
+github.com/prometheus/common v0.61.0/go.mod h1:zr29OCN/2BsJRaFwG8QOBr41D6kkchKbpeNH7pAjb/s=
github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
github.com/prometheus/prom2json v1.4.1 h1:7McxdrHgPEOtMwWjkKtd0v5AhpR2Q6QAnlHKVxq0+tQ=
github.com/prometheus/prom2json v1.4.1/go.mod h1:CzOQykSKFxXuC7ELUZHOHQvwKesQ3eN0p2PWLhFitQM=
-github.com/prometheus/prometheus v0.55.1 h1:+NM9V/h4A+wRkOyQzGewzgPPgq/iX2LUQoISNvmjZmI=
-github.com/prometheus/prometheus v0.55.1/go.mod h1:GGS7QlWKCqCbcEzWsVahYIfQwiGhcExkarHyLJTsv6I=
+github.com/prometheus/prometheus v0.300.1 h1:9KKcTTq80gkzmXW0Et/QCFSrBPgmwiS3Hlcxc6o8KlM=
+github.com/prometheus/prometheus v0.300.1/go.mod h1:gtTPY/XVyCdqqnjA3NzDMb0/nc5H9hOu1RMame+gHyM=
github.com/puzpuzpuz/xsync/v3 v3.4.0 h1:DuVBAdXuGFHv8adVXjWWZ63pJq+NRXOWVXlKDBZ+mJ4=
github.com/puzpuzpuz/xsync/v3 v3.4.0/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
@@ -591,11 +590,13 @@ github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
-github.com/safchain/ethtool v0.4.1 h1:S6mEleTADqgynileXoiapt/nKnatyR6bmIHoF+h2ADo=
-github.com/safchain/ethtool v0.4.1/go.mod h1:XLLnZmy4OCRTkksP/UiMjij96YmIsBfmBQcs7H6tA48=
+github.com/safchain/ethtool v0.5.9 h1://6RvaOKFf3nQ0rl5+8zBbE4/72455VC9Jq61pfq67E=
+github.com/safchain/ethtool v0.5.9/go.mod h1:w8oSsZeowyRaM7xJJBAbubzzrOkwO8TBgPSEqPP/5mg=
github.com/scylladb/termtables v0.0.0-20191203121021-c4c0b6d42ff4/go.mod h1:C1a7PQSMz9NShzorzCiG2fk9+xuCgLkPeCvMHYR2OWg=
github.com/secure-io/sio-go v0.3.1 h1:dNvY9awjabXTYGsTF1PiCySl9Ltofk9GA3VdWlo7rRc=
github.com/secure-io/sio-go v0.3.1/go.mod h1:+xbkjDzPjwh4Axd07pRKSNriS9SCiYksWnZqdnfpQxs=
+github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
+github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
@@ -624,8 +625,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
@@ -633,8 +634,8 @@ github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JT
github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
-github.com/tinylib/msgp v1.2.4 h1:yLFeUGostXXSGW5vxfT5dXG/qzkn4schv2I7at5+hVU=
-github.com/tinylib/msgp v1.2.4/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
+github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po=
+github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo=
@@ -716,8 +717,8 @@ golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58
golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
@@ -750,8 +751,8 @@ golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
-golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
+golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE=
golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
@@ -764,8 +765,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
-golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -804,8 +805,9 @@ golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -815,8 +817,8 @@ golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
-golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
-golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -826,8 +828,8 @@ golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
@@ -858,19 +860,17 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20241113202542-65e8d215514f h1:zDoHYmMzMacIdjNe+P2XiTmPsLawi/pCbSPfxt6lTfw=
google.golang.org/genproto v0.0.0-20241113202542-65e8d215514f/go.mod h1:Q5m6g8b5KaFFzsQFIGdJkSJDGeJiybVenoYFMMa3ohI=
-google.golang.org/genproto/googleapis/api v0.0.0-20241113202542-65e8d215514f h1:M65LEviCfuZTfrfzwwEoxVtgvfkFkBUbFnRbxCXuXhU=
-google.golang.org/genproto/googleapis/api v0.0.0-20241113202542-65e8d215514f/go.mod h1:Yo94eF2nj7igQt+TiJ49KxjIH8ndLYPZMIRSiRcEbg0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241113202542-65e8d215514f h1:C1QccEa9kUwvMgEUORqQD9S17QesQijxjZ84sO82mfo=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241113202542-65e8d215514f/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
+google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 h1:CkkIfIt50+lT6NHAVoRYEyAvQGFM7xEwXUUywFvEb3Q=
+google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576/go.mod h1:1R3kvZ1dtP3+4p4d3G8uJ8rFk/fWlScl38vanWACI08=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576 h1:8ZmaLZE4XWrtU3MyClkYqqtl6Oegr3235h7jxsDyqCY=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0=
-google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA=
-google.golang.org/grpc/stats/opentelemetry v0.0.0-20241028142157-ada6787961b3 h1:hUfOButuEtpc0UvYiaYRbNwxVYr0mQQOWq6X8beJ9Gc=
-google.golang.org/grpc/stats/opentelemetry v0.0.0-20241028142157-ada6787961b3/go.mod h1:jzYlkSMbKypzuu6xoAEijsNVo9ZeDF1u/zCfFgsx7jg=
+google.golang.org/grpc v1.69.0 h1:quSiOM1GJPmPH5XtU+BCoVXcDVJJAzNcoyfC2cCjGkI=
+google.golang.org/grpc v1.69.0/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -880,8 +880,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io=
+google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=