pax_global_header00006660000000000000000000000064143704166300014516gustar00rootroot0000000000000052 comment=0ca04abb61d85983b2ac1e1b2f20a934435e1ab5 ripe-atlas-tools-3.1.0/000077500000000000000000000000001437041663000147165ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/.github/000077500000000000000000000000001437041663000162565ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/.github/workflows/000077500000000000000000000000001437041663000203135ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/.github/workflows/python-package.yml000066400000000000000000000015251437041663000237530ustar00rootroot00000000000000# This workflow will install Python dependencies, run tests and lint with a variety of Python versions # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions name: Python package on: push: branches: [ master, 'release-*' ] pull_request: branches: [ $default-branch ] jobs: build: runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.7", "3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip python -m pip install tox - name: tox run: tox ripe-atlas-tools-3.1.0/.gitignore000066400000000000000000000013271437041663000167110ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *.swp # C extensions *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover # Translations *.mo *.pot # Django stuff: *.log # Sphinx documentation docs/_build/ # PyBuilder target/ # PyCharm .idea/ ripe-atlas-tools-3.1.0/CHANGES.rst000066400000000000000000000125251437041663000165250ustar00rootroot00000000000000Release History =============== 3.1.0 (release 2023-02-07) -------------------------- - Improved probe-search and measurement-search, including "csv" and "tab" output - --stream-timeout and --stream-limit added to measure command - Use the latest stream API (cousteau update) and add --timeout to stream command 3.0.3 (release 2022-11-18) -------------------------- - Fix issue where the measure command would continue to stream results after all probes have responded 3.0.2 (release 2022-05-23) -------------------------- - Fix "measure spec" command which was broken due to cousteau issue 3.0.1 (release 2022-02-24) -------------------------- - Updated cousteau dependency to the non-alpha release 3.0.0 (release 2022-02-23) -------------------------- - API keys can now be passed in environment variables - probe-search by --location now works, as long as the user specifies their own Google Geocoding API key - Modernized tests and switched to GitHub actions - The default renderer for ping measurements is now more consistent and more similar to other ping tools, including having a statistical summary at the end - measure, report and stream commands now all use the same set of renderers - "measure spec" command which takes a JSON blob to create measurements - Allow measure --target to be specified as a positional arg (or --query-argument for DNS) - Move to latest cousteau version (python-socketio) - Various other fixes to code and documentation - Official supported Python versions changed to 3.6, 3.7, 3.8, 3.9 and 3.10 2.3.0 (released 2018-11-23) --------------------------- Features and changes ~~~~~~~~~~~~~~~~~~~~ - Add result date and time to traceroute, NTP and SSL renderers - Add support for specifying measurement tags on measurement creation - Add option (--go-web) to open measurement URL in browser - Nicer presentation of 403 errors from the API - Official supported Python versions changed to 2.7, 3.4, 3.5, 3.6 and 3.7 Bug Fixes ~~~~~~~~~ - Fix cousteau/sagan dependencies 2.2.3 (released 2017-01-17) --------------------------- Bug Fixes ~~~~~~~~~ - Fix for distribution issues that prevented the command-line scripts from working 2.2.2 (released 2017-10-12) --------------------------- Features and changes ~~~~~~~~~~~~~~~~~~~~ - Align various option defaults, minimums and maximums with API reality, including... - ... allow the set of options necessary for "TCP ping" measurements https://labs.ripe.net/Members/wilhelm/measuring-your-web-server-reachability-with-tcp-ping - Add compact DNS results renderer - Fix some unicode output issues 2.1 (released 2016-04-21) --------------------------- New Features ~~~~~~~~~~~~ - Add a simple NTP renderer Changes ~~~~~~~ - Use new cousteau (1.4) & sagan(1.2) versions. Bug Fixes ~~~~~~~~~ - Fix for some unicode problems when using colors - Fix issue #177, with `gdbm` problem. 2.0.2 (released 2016-10-21) --------------------------- New Features ~~~~~~~~~~~~ - Add aliases to measurements IDs - Add --traceroute-show-asns to traceroute renderer Bug Fixes ~~~~~~~~~ - Stream command was not passing the correct API key. After API became stricter this command started failing. - Handle missing geometry for probes. - Fix issues for AS-paths with only 1 probe - Various fixes for tests 2.0.1 (released 2016-04-20) --------------------------- Changes ~~~~~~~ - Corrected references in the docs to obsolete command names. - Fixed broken 2.0.0 egg. 2.0.0 (released 2016-04-20) --------------------------- Changes ~~~~~~~ - Renamed and merged some commands for clarity, preserving the old names as deprecated aliases. - Improved help text and usage output. - Support for bash auto-completion. 1.2.3 (released 2016-03-08) --------------------------- Changes ~~~~~~~ - Usage of newest Cousteau/Sagan library. - Support of API keys for fetching results on report command. - Default radius for probes filtering is changed to 15. - Several changes for supporting Windows. 1.2.2 (released 2016-01-13) --------------------------- New Features ~~~~~~~~~~~~ - Cleaner and more consistent implementation of the renderer plugable architecture. - Usage of newest Cousteau library. 1.2.1 (released 2015-12-15) --------------------------- Bug Fixes ~~~~~~~~~ - Restored some required template files. 1.2.0 (released 2015-12-15) --------------------------- Output Changes ~~~~~~~~~~~~~~ - `#119`_: Support HTTP results. - `#122`_: Allow packagers to set the user agent. 1.1.1 (released 2015-11-25) --------------------------- Output Changes ~~~~~~~~~~~~~~ - `#103`_: Removed header from the ``report`` command. Bug Fixes ~~~~~~~~~ - `#105`_: Measurement report and stream broken on Python3.4. 1.1.0 (released 2015-11-12) --------------------------- New features ~~~~~~~~~~~~ - Support for the creation of NTP, SSLCert, and HTTP measurements. - Additional argument in report command to filter results by probe ASN. - Additional renderer that shows the different destination ASNs and some additional stats about them. Bug Fixes ~~~~~~~~~ - Various fixes. Changes ~~~~~~~ - Better testing. - Additional documentation. 1.0.0 (released 2015-11-02) --------------------------- - Initial release. .. _#103: https://github.com/RIPE-NCC/ripe-atlas-tools/issues/103 .. _#105: https://github.com/RIPE-NCC/ripe-atlas-tools/issues/105 .. _#119: https://github.com/RIPE-NCC/ripe-atlas-tools/issues/119 .. _#122: https://github.com/RIPE-NCC/ripe-atlas-tools/issues/122 ripe-atlas-tools-3.1.0/CONTRIBUTING.rst000066400000000000000000000047231437041663000173650ustar00rootroot00000000000000How To Contribute ================= We would love to have contributions from everyone and no contribution is too small. Please submit as many fixes for typos and grammar bloopers as you can! To make participation in this project as pleasant as possible for everyone, we adhere to the `Code of Conduct`_ by the Python Software Foundation. The following steps will help you get started: Fork, then clone the repo: .. code:: bash $ git clone git@github.com:your-username/ripe-atlas-tools.git Make sure the tests pass beforehand: .. code:: bash $ tox or .. code:: bash $ nosetests tests/ Make your changes. Include tests for your change. Make the tests pass: .. code:: bash $ tox or .. code:: bash $ nosetests tests/ Push to your fork and `submit a pull request`_. Here are a few guidelines that will increase the chances of a quick merge of your pull request: - *Always* try to add tests and docs for your code. If a feature is tested and documented, it's easier for us to merge it. - Follow `PEP 8`_. - Write `good commit messages`_. - If you change something that is noteworthy, don't forget to add an entry to the `changes`_. .. note:: - If you think you have a great contribution but aren’t sure whether it adheres -- or even can adhere -- to the rules: **please submit a pull request anyway**! In the best case, we can transform it into something usable, in the worst case the pull request gets politely closed. There’s absolutely nothing to fear. - If you have a great idea but you don't know how or don't have the time to implement it, please consider opening an issue and someone will pick it up as soon as possible. Thank you for considering a contribution to this project! If you have any questions or concerns, feel free to reach out the RIPE Atlas team via the `mailing list`_, `GitHub Issue Queue`_, or `messenger pigeon`_ -- if you must. .. _submit a pull request: https://github.com/RIPE-NCC/ripe-atlas-tools/compare/ .. _PEP 8: https://www.python.org/dev/peps/pep-0008/ .. _good commit messages: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html .. _Code of Conduct: https://www.python.org/psf/codeofconduct/ .. _changes: https://github.com/RIPE-NCC/ripe-atlas-tools/blob/master/CHANGES.rst .. _mailing list: https://www.ripe.net/mailman/listinfo/ripe-atlas .. _GitHub Issue Queue: https://github.com/RIPE-NCC/ripe-atlas-tools/issues .. _messenger pigeon: https://tools.ietf.org/html/rfc1149 ripe-atlas-tools-3.1.0/LICENSE000066400000000000000000001044601437041663000157300ustar00rootroot00000000000000GNU GENERAL PUBLIC LICENSE Version 3, 29 June 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 General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is 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. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. 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. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. 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 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. Use with the GNU Affero General Public License. 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 Affero 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 special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 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 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 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. {one line to give the program's name and a brief idea of what it does.} Copyright (C) {year} {name of author} This program is free software: you can redistribute it and/or modify it under the terms of the GNU 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: {project} Copyright (C) {year} {fullname} This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". 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 GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read .ripe-atlas-tools-3.1.0/MANIFEST.in000066400000000000000000000003431437041663000164540ustar00rootroot00000000000000include LICENSE include README.rst include CHANGES.rst include MANIFEST.in include ripe/atlas/tools/user-agent recursive-include ripe *.py recursive-include ripe *.yaml recursive-include ripe *.txt recursive-include tests *.py ripe-atlas-tools-3.1.0/PACKAGING.md000066400000000000000000000055101437041663000165250ustar00rootroot00000000000000We're working with the community to get this project packaged for as many platforms as possible. To that end, We've created this file to help organise resources. If you'd like to package the toolkit for your favourite distro, or if you've already started, please add your name/GitHub below with a pull request so we don't have people wasting time doubling up on work rather than collaborating. ## OpenBSD * [Florian Obser](https://github.com/fobser) ### Status During the Bucharest hackathon, Florian hacked out a package it's already [in the ports tree](http://cvsweb.openbsd.org/cgi-bin/cvsweb/ports/net/py-ripe.atlas.tools/). ## FreeBSD * [Max Stucchi](https://github.com/stucchimax) ### Status Max has submitted the new ports and [they have been accepted](https://svnweb.freebsd.org/ports?view=revision&revision=403526). ## Gentoo * [Daniel Quinn](https://github.com/danielquinn) ### Status After a great deal of help from #gentoo-proxy-maint, Daniel's pull requests were accepted into the Gentoo portage tree. You can now install it with `emerge ripe-atlas-tools`. ## Debian * Apollon Oikonomopoulos ### Status Apollon has imported the project to [debian tree](https://tracker.debian.org/pkg/ripe-atlas-tools). ## Ubuntu ### Status Apollon's work in debian has made it also to Ubuntu. ## Arch * [Wouter de Vries](https://github.com/woutifier) ### Status Wouter has added this project to [Arch's AUR repository](https://aur.archlinux.org/packages/ripe-atlas-tools). ## Fedora * [Jan Včelák](https://github.com/vcelda) ### Status In progress: https://github.com/fcelda/fedora-ripe-atlas-tools Jan is currently building the binary packages in COPR (which will take some time as there is a lot of other packages in the queue): https://copr.fedoraproject.org/coprs/jvcelak/ripe-atlas-tools/ ## Voidlinux * [jnbr](https://github.com/jnbr) ### Status With a lot of help from the Voidlinux maintainers, it got merged into the [XBPS source packages collection](https://github.com/voidlinux/void-packages/srcpkgs/ripe-atlas-tools). You can install it with `xbps-install ripe-atlas-tools`. ## Windows * [Chris Amin](https://github.com/chrisamin) ### Status A highly experimental self-contained installer is available at https://github.com/chrisamin/ripe-atlas-tools-win32/. This installer doesn't require the presence of a system Python installation. ## Other Platforms We've been talking with members of the community about expanding the package support for Magellan, but so far no one has officially volunteered. The RIPE Atlas team is happy to assist anyone interested in porting this toolkit to any platform, but we're especially keen on at least getting into: * Red Hat * CentOS If you'd like to try your hand, or would simply like to offer some advice, feel free to add your name here or contact us directly via *atlas at ripe dot net*. ripe-atlas-tools-3.1.0/README.rst000066400000000000000000000047421437041663000164140ustar00rootroot00000000000000RIPE Atlas Tools (Magellan) =========================== |Documentation| |Build Status| |PYPI Version| |Python Versions| |Python Implementations| |Python Format| |Requirements| The official command-line client for RIPE Atlas. Full Documentation ------------------ Everything is up on `ReadTheDocs`_ Examples -------- Configure API key for creating measurements:: $ ripe-atlas configure --set authorisation.create=MY_API_KEY Ping an IP address from five probes:: $ ripe-atlas measure ping ping.ripe.net --probes 5 .. image:: screenshots/ripe-atlas-measure-ping.png Search for connected probes in Germany, grouping by ASN:: $ ripe-atlas probe-search --country de --aggregate-by asn_v4 --limit 10 .. image:: screenshots/ripe-atlas-probe-search.png Search for NTP measurement metadata and process the results with awk:: $ ripe-atlas measurement-search --type ntp --format tab --no-header --limit 5 \ | awk -Ft '{printf "#%s (%s)\n", $1, $3}' .. image:: screenshots/ripe-atlas-measurement-search.png Can I Contribute? ----------------- Absolutely. Please read our `guide`_ on how to contribute. Colophon -------- This project was code-named by means of a `poll`_. In order to conform to the RIPE Atlas theme, it had to be named for an explorer, and so the winning suggestion was for Magellan, *"in memory of those times when RTT was ~3 years"*. .. |Documentation| image:: https://readthedocs.org/projects/ripe-atlas-tools/badge/?version=latest :target: http://ripe-atlas-tools.readthedocs.org/en/latest/?badge=latest :alt: Documentation Status .. _ReadTheDocs: https://ripe-atlas-tools.readthedocs.org/ .. _guide: https://github.com/RIPE-NCC/ripe-atlas-tools/blob/master/CONTRIBUTING.rst .. _poll: https://github.com/RIPE-NCC/ripe-atlas-tools/issues/13 .. |Build Status| image:: https://travis-ci.org/RIPE-NCC/ripe-atlas-tools.png?branch=master :target: https://travis-ci.org/RIPE-NCC/ripe-atlas-tools .. |PYPI Version| image:: https://img.shields.io/pypi/v/ripe.atlas.tools.svg .. |Python Versions| image:: https://img.shields.io/pypi/pyversions/ripe.atlas.tools.svg .. |Python Implementations| image:: https://img.shields.io/pypi/implementation/ripe.atlas.tools.svg .. |Python Format| image:: https://img.shields.io/pypi/format/ripe.atlas.tools.svg .. |Requirements| image:: https://requires.io/github/RIPE-NCC/ripe-atlas-tools/requirements.svg?branch=master :target: https://requires.io/github/RIPE-NCC/ripe-atlas-tools/requirements/?branch=master :alt: Requirements Status ripe-atlas-tools-3.1.0/dev-scripts/000077500000000000000000000000001437041663000171615ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/dev-scripts/compare-openapi-spec.py000066400000000000000000000115701437041663000235460ustar00rootroot00000000000000#!/usr/bin/env python """ Compare the CLI measure command options with the fields, limits and defaults from the API via a call to the OpenAPI (swagger) URL. """ from __future__ import print_function import requests from ripe.atlas.tools.commands.base import Command openapi_url = "https://atlas.ripe.net/docs/api/v2/reference/api-docs/api/v2/measurements" types = [ ("ping", "Writeping measurement"), ("traceroute", "Writetraceroute measurement"), ("dns", "WriteDNS measurement"), ("sslcert", "SSL cert measurement"), ("http", "HTTP measurement"), ("ntp", "NTP measurement"), ] # These are the expected differences from the OpenAPI spec. # If somethign is defined here it means that an option deliberately has a # different default, valid range or is not included in the CLI tools. # e.g. if we want the tools to behave more like their common unix counterparts # or it makes sense to express things differently on a command-line common_differences = { "is_oneoff": None, # implied by lack of --interval "type": None, # set as the subcommand "start_time": None, # deliberately unsupported "stop_time": None, # deliberately unsupported "is_public": None, # deliberately unsupported "description": { "default": "", }, "interval": { "default": None, }, "resolve_on_probe": None, # Not sent explicitly to preserve behaviour } type_expected_differences = { "ping": dict(common_differences, **{ "packet_interval": { "default": 1000, }, "size": { "default": 48, }, "skip_dns_check": None, }), "traceroute": dict(common_differences, **{ "max_hops": { "default": 255, }, "protocol": { "default": "ICMP", }, "skip_dns_check": None, "paris": { "default": 0, }, "dont_fragment": { "default": False, }, "response_timeout": { "default": None, } }), "dns": dict(common_differences, **{ "protocol": { "default": "UDP", }, "query_class": { "default": "IN", }, "query_type": { "default": "A", }, "skip_dns_check": None, "set_rd_bit": { "default": True, }, "use_probe_resolver": None, # Implied by missing target "include_abuf": None, "include_qbuf": None, "prepend_probe_id": None, "use_macros": None, }), "sslcert": common_differences.copy(), "http": dict(common_differences, **{ "extended_timing": None, # "timing_verbosity" "more_extended_timing": None, # "timing_verbosity" "max_bytes_read": { "alias": "body_bytes", }, "path": { "default": "/", } }), "ntp": common_differences.copy(), } def compare_type(cmd_name, api_model, expected_differences): print(cmd_name) cmd = Command.load_command_class("measure")(["measure", cmd_name]).create() cmd.add_arguments() args = {} for arg in cmd.parser._actions: args[arg.dest] = arg seen_diffs = False for field_name, model_field in sorted(api_model["properties"].items()): if field_name in expected_differences and expected_differences[field_name] is None: continue if model_field["readOnly"]: continue explicit_values = expected_differences.get(field_name, {}) opt_name = explicit_values.get("alias", field_name) if opt_name in args: cmd_field = args.get(opt_name) expected_default = explicit_values.get("default", model_field.get("defaultValue")) if cmd_field.default != expected_default: print("\t", field_name, "DEFAULT", repr(cmd_field.default), repr(expected_default)) seen_diffs |= True expected_min = explicit_values.get("minimum", model_field.get("minimum")) cmd_min = getattr(cmd_field.type, "minimum", None) if cmd_min != expected_min: print("\t", field_name, "MINIMUM", cmd_min, expected_min) seen_diffs |= True expected_max = explicit_values.get("maximum", model_field.get("maximum")) cmd_max = getattr(cmd_field.type, "maximum", None) if cmd_max != expected_max: print("\t", field_name, "MAXIMUM", cmd_max, expected_max) seen_diffs |= True else: print("\t", field_name, "\t", "MISSING") seen_diffs |= True if not seen_diffs: print("\t", "OK") if __name__ == "__main__": api_spec = requests.get(openapi_url).json() for cmd_name, api_name in types: compare_type( cmd_name, api_spec["models"][api_name], type_expected_differences[cmd_name] ) ripe-atlas-tools-3.1.0/docs/000077500000000000000000000000001437041663000156465ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/docs/Makefile000066400000000000000000000152521437041663000173130ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/RIPEAtlasToolsMagellan.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/RIPEAtlasToolsMagellan.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/RIPEAtlasToolsMagellan" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/RIPEAtlasToolsMagellan" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." ripe-atlas-tools-3.1.0/docs/_static/000077500000000000000000000000001437041663000172745ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/docs/_static/.keep000066400000000000000000000000001437041663000202070ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/docs/_static/custom.css000066400000000000000000000005421437041663000213210ustar00rootroot00000000000000/* override table width restrictions */ @media screen and (min-width: 767px) { .wy-table-responsive table td { /* !important prevents the common CSS stylesheets from overriding this as on RTD they are loaded after this stylesheet */ white-space: normal !important; } .wy-table-responsive { overflow: visible !important; } } ripe-atlas-tools-3.1.0/docs/changelog.rst000066400000000000000000000000341437041663000203240ustar00rootroot00000000000000.. include:: ../CHANGES.rst ripe-atlas-tools-3.1.0/docs/conf.py000066400000000000000000000262221437041663000171510ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # RIPE Atlas Tools (Magellan) documentation build configuration file, created by # sphinx-quickstart on Mon Oct 26 18:36:52 2015. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os __version__ = None exec(open("../ripe/atlas/tools/version.py").read()) # Believe it or not, this is the officially sanctioned way to add custom CSS. def setup(app): app.add_css_file("custom.css") # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.imgmath', 'sphinx.ext.viewcode', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'RIPE Atlas Tools (Magellan)' copyright = u'2015, The RIPE Atlas Team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # # If the build process ever explodes here, it's because you've set the version # number in ripe.atlas.tools.version to a string in a format other than x.y.z # # The short X.Y version. version = ".".join(__version__.split(".")[:2]) # The full version, including alpha/beta/rc tags. release = ".".join(__version__.split(".")[:3]) # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'RIPEAtlasToolsMagellandoc' # # Attempt to use the ReadTheDocs theme. If it's not installed, fallback to # the default. # try: import sphinx_rtd_theme html_theme = "sphinx_rtd_theme" html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] except ImportError: pass # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'RIPEAtlasToolsMagellan.tex', u'RIPE Atlas Tools (Magellan) Documentation', u'The RIPE Atlas Team', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'ripeatlastoolsmagellan', u'RIPE Atlas Tools (Magellan) Documentation', [u'The RIPE Atlas Team'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'RIPEAtlasToolsMagellan', u'RIPE Atlas Tools (Magellan) Documentation', u'The RIPE Atlas Team', 'RIPEAtlasToolsMagellan', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # -- Options for Epub output ---------------------------------------------- # Bibliographic Dublin Core info. epub_title = u'RIPE Atlas Tools (Magellan)' epub_author = u'The RIPE Atlas Team' epub_publisher = u'The RIPE Atlas Team' epub_copyright = u'2015, The RIPE Atlas Team' # The basename for the epub file. It defaults to the project name. #epub_basename = u'RIPE Atlas Tools (Magellan)' # The HTML theme for the epub output. Since the default themes are not optimized # for small screen space, using the same theme for HTML and epub output is # usually not wise. This defaults to 'epub', a theme designed to save visual # space. #epub_theme = 'epub' # The language of the text. It defaults to the language option # or en if the language is not set. #epub_language = '' # The scheme of the identifier. Typical schemes are ISBN or URL. #epub_scheme = '' # The unique identifier of the text. This can be a ISBN number # or the project homepage. #epub_identifier = '' # A unique identification for the text. #epub_uid = '' # A tuple containing the cover image and cover page html template filenames. #epub_cover = () # A sequence of (type, uri, title) tuples for the guide element of content.opf. #epub_guide = () # HTML files that should be inserted before the pages created by sphinx. # The format is a list of tuples containing the path and title. #epub_pre_files = [] # HTML files shat should be inserted after the pages created by sphinx. # The format is a list of tuples containing the path and title. #epub_post_files = [] # A list of files that should not be packed into the epub file. epub_exclude_files = ['search.html'] # The depth of the table of contents in toc.ncx. #epub_tocdepth = 3 # Allow duplicate toc entries. #epub_tocdup = True # Choose between 'default' and 'includehidden'. #epub_tocscope = 'default' # Fix unsupported image types using the PIL. #epub_fix_images = False # Scale large images. #epub_max_image_width = 0 # How to display URL addresses: 'footnote', 'no', or 'inline'. #epub_show_urls = 'inline' # If false, no index is generated. #epub_use_index = True # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = {'http://docs.python.org/': None} ripe-atlas-tools-3.1.0/docs/contributing.rst000066400000000000000000000000411437041663000211020ustar00rootroot00000000000000.. include:: ../CONTRIBUTING.rst ripe-atlas-tools-3.1.0/docs/index.rst000066400000000000000000000012241437041663000175060ustar00rootroot00000000000000RIPE Atlas Tools (Magellan) =========================== The official command-line client for RIPE Atlas. .. _index-why-this-exists: Why This Exists =============== `RIPE Atlas`_ is a powerful Internet measurements platform that until recently was only accessible via the website and the RESTful API. The reality however is that a great many people using RIPE Atlas are most comfortable on the command-line, so this project is an attempt to fill that gap. .. _RIPE Atlas: https://atlas.ripe.net Contents ======== .. toctree:: :maxdepth: 2 quickstart installation use plugins contributing packaging troubleshooting changelog ripe-atlas-tools-3.1.0/docs/installation.rst000066400000000000000000000160751437041663000211120ustar00rootroot00000000000000.. _requirements-and-installation: Requirements & Installation *************************** This is a Linux-based tool, though it should work just fine in a BSD variant. Windows is experimentally supported. In terms of the actual installation, only Python's package manager (``pip``) is currently supported, and the installation process may require some system packages to be installed in order for everything to work. .. _requirements-and-installation-system-requirements: System Requirements =================== Some of the dependencies need to be compiled, so you'll need a compiler on your system, as well as the development libraries for Python. In the Linux world, this typically means a few packages need to be installed from your standard package manager, but in true Linux fashion, each distribution does things slightly differently. The most important thing to know is that you need Python 2.7 or 3. Python 2.6 will never be supported because it's old, ugly, and needs to die. .. _requirements-and-installation-distribution-specific-requirements: Distribution Specific Requirements ---------------------------------- .. note:: If you're running OpenBSD, you can skip this whole section. You can even skip the next one too. Just skip down to :ref:`Installation:OpenBSD ` and follow the instructions. Everything else is taken care of for you. .. _requirements-and-installation-distribution-specific-requirements-debian: Debian/Ubuntu ............. The following has been tested on Debian Jessie. Debian-based distributions require three system packages to be installed first: .. code:: bash sudo apt-get install python-dev libffi-dev libssl-dev You'll also need either ``virtualenv`` (recommended), or if you're not comfortable with that, at the very least, you'll need ``pip``: .. code:: bash sudo apt-get install python-virtualenv python-pip .. _requirements-and-installation-distribution-specific-requirements-centos: CentOS ...... This following has been tested on CentOS 7. Since we require Python's ``pip``, we first need to install the ``epel-release`` repository: .. code:: bash sudo yum install epel-release You'll also need the following system libraries: .. code:: bash sudo yum install gcc libffi-devel openssl-devel Once that's finished, you'll need access to ``virtualenv`` (recommended), or if you're not comfortable with that, at the very least, you'll need ``pip``: .. code:: bash sudo yum install python-virtualenv python-pip .. _requirements-and-installation-distribution-specific-requirements-gentoo: Gentoo ...... If you're a Gentoo user, you never have to worry about development libraries, but if you intend to use the bleeding-edge version of this package (and what self-respecting Gentoo user wouldn't?) then you'll probably want to make sure that git is built with curl support: .. code:: bash sudo USE="curl" emerge git If you're not going bleeding edge, or if you're just going to use SSH to get the code from GitHub, then Gentoo will have everything ready for you. .. _requirements-and-installation-distribution-specific-requirements-apple: Apple OSX ......... These instructions expect that you've got Python's ``pip`` installed, so if you have no idea what that is, or simply don't have it yet, you should be able to install pip with one easy command: .. code:: bash sudo easy_install pip Outside of that, a few of the Python dependencies require that you have a compiler on your system. For this, you need only get a free copy of `Xcode`_ from the app store, and from there you should be good to go. .. _Xcode: https://itunes.apple.com/us/app/xcode/id497799835 .. _installation-python-requirements: Python Requirements =================== Importantly, Magellan requires Python 2.7 or higher. For most desktop users, this shouldn't be a problem, but for some older servers like CentOS 6 and lower, this may cause some pain. Thankfully, for most such systems, there are usually work-arounds that allow you to install a more modern version of Python in parallel. Magellan depends on two other RIPE Atlas libraries, Cousteau and Sagan, which in turn depend on a reasonable number of Python libraries. Thankfully, Python's package manager, ``pip`` should handle all of these for you: * ripe.atlas.cousteau * ripe.atlas.sagan * tzlocal * pyyaml .. _installation: Installation ============ .. _installation-from-openbsd: OpenBSD ------- OpenBSD was the first platform to have a port for Magellan, so installation is easy: .. code:: bash sudo pkg_add ripe.atlas.tools .. _installation-from-freebsd: FreeBSD ------- FreeBSD has a port ready for you: .. code:: bash cd /usr/ports/net/py-ripe.atlas.tools make install .. _installation-from-gentoo: Gentoo ------ There's an ebuild for Magellan in Portage, so installation is as any other package: .. code:: bash sudo emerge ripe-atlas-tools .. _installation-from-pypi: From PyPi --------- Python's ``pip`` program can be used to install packages globally (not a good idea since it conflicts with your system package manager) or on a per-user basis. Typically, this is done with `virtualenv`_, but if you don't want to use that, you can always pass ``--user`` to the ``pip`` program and it'll install a user-based copy in ``${HOME}/.local/``. .. _virtualenv: https://pypi.python.org/pypi/virtualenv .. code:: bash # From within a virtualenv pip install ripe.atlas.tools # In your user's local environment pip install --user ripe.atlas.tools Or if you want to live on the edge and perhaps try submitting a pull request of your own: One day, we want this process to be as easy as installing any other command-line program, that is, with ``apt``, ``dfn``, or ``emerge``, but until that day, Python's standard package manager, ``pip`` does the job nicely. .. _installation-from-github: From GitHub ----------- If you're feeling a little more daring and want to go bleeding-edge and use our ``master`` branch on GitHub, you can have pip install right from there: .. code:: bash pip install git+https://github.com/RIPE-NCC/ripe-atlas-tools.git If you think you'd like to contribute back to the project, we recommend the use of pip's ``-e`` flag, which will place the Magellan code in a directory where you can edit it, and see the results without having to go through a new install procedure every time. Simply clone the repo on GitHub and install it like so: .. code:: bash pip install -e git+https://github.com/your-username/ripe-atlas-tools.git .. _installation-from-tarball: From a Tarball -------------- If for some reason you want to just download the source and install it manually, you can always do that too. Simply un-tar the file and run the following in the same directory as ``setup.py``: .. code:: bash python setup.py install Using Docker -------------- You can find an unofficial Alpine-based docker image on Dockerhub `here `__, or simply build your own image based on the Dockerfile available `here `__. ripe-atlas-tools-3.1.0/docs/packaging.rst000066400000000000000000000026351437041663000203320ustar00rootroot00000000000000Packaging ========= For those interested in packaging RIPE Atlas Tools for their favourite distro, this section is for you. Currently Supported ------------------- * OpenBSD * FreeBSD * Gentoo * Debian * Ubuntu In Progress ----------- * Fedora: Jan Včelák is currently building the binary packages in `COPR`_ (which will take some time as there is a lot of other packages in the queue) .. _`COPR`: https://copr.fedoraproject.org/coprs/jvcelak/ripe-atlas-tools/ Additional Distributions ------------------------ Is your distribution not listed? If you'd like to build a package for another distro or even if you're just someone who knows someone who can help us package and distribute this, please get in touch. Further Information ------------------- User Agent ~~~~~~~~~~ When packaging, it's good practise to manually set the user agent used within the toolkit so that we can get a rough idea of which distros are using this software. This is easily done by writing an arbitrary string to ``/ripe/atlas/tools/user-agent``. Something like this is recommended::: RIPE Atlas Tools [FreeBSD 10.2] 1.2 The only limitations to this file are that it should: * Only have one line in it (all other will be ignored) * That line should have a maximum of 128 characters in it If no ``user-agent`` file is included then a platform-specific string will be automatically generated based on Python's ``platform`` module. ripe-atlas-tools-3.1.0/docs/plugins.rst000066400000000000000000000164661437041663000200760ustar00rootroot00000000000000.. _plugins: How to Create Your Own Plugins ============================== We built this toolkit for the community, and we knew going in that we couldn't possibly build every feature that every user could want, so we built this thing to be pluggable. You can write your own renderer(s) and use them seamlessly within your own environment, and if you think that others might benefit from your work, you can share your renderer as easy as posting a file online. Ready? So you have an idea now. You want to create a renderer called "awesomerenderer" and you want it to do some fancy things with traceroute measurement results. What do you have to do? .. _plugins-create: Create Your Renderer File ------------------------- As we've already covered, Magellan will look for renderers in very specific places, so you need to put your file(s) there. Additionally however, you have to make sure that you conform to Python norms, or stuff just won't work. Here's the basic commands to get you started: .. code:: bash $ mkdir -p ${HOME}/.config/ripe-atlas-tools/renderers $ touch ${HOME}/.config/ripe-atlas-tools/renderers/__init__.py $ touch ${HOME}/.config/ripe-atlas-tools/renderers/my_renderer.py The ``mkdir`` step there will create the renderers directory (if it doesn't exist already), and the ``touch`` commands will create the mandatory init file (for Python) and your renderer. Note that you can use whatever name you like for your renderer, so long as it consists only of letters, numbers, and the underscore and that it starts with a letter. Also, to be compliant with the rest of the project, it should be entirely lowercase. For our purposes though, ``my_renderer.py`` will suffice. .. _plugins-try-to-run: (Try to) Run It! ---------------- If you run this right now: .. code:: bash $ ripe-atlas report --help You should see ``my_renderer`` int he list of options for ``--renderer``. Pretty cool eh? However, if you try to run that, this'll happen: .. code:: bash $ ripe-atlas report 1000192 --renderer my_renderer The renderer you selected, "my_renderer" could not be found. Which kind of makes sense really. You've created a file called ``my_renderer``, but it's totally empty. Magellan found the file alright, but when it tried to import ``Renderer`` from it, everything exploded. .. _plugins-write: Actually Write a Renderer ------------------------- So now you know that we can see your renderer file, but you need to know what kind of code to put in there. Don't worry, we've got you covered: .. _plugins-write-anatomy: Anatomy of a Renderer ~~~~~~~~~~~~~~~~~~~~~ A "renderer" is simply a file located in a special place that contains some Python code defining a class called ``Renderer`` that subclasses ``ripe.atlas.tools.renderers.base.BaseRenderer``. Your class need only define one method: ``on_result()``, which is called every time a new result comes down the pipe. Let's look at a really simple example: .. code:: python from ripe.atlas.tools.renderers.base import Renderer as BaseRenderer class Renderer(BaseRenderer): # This renderer is capable of handling ping results only. RENDERS = [BaseRenderer.TYPE_PING] def on_result(self, result): """ on_result() only gets one argument, a result object, which is actually an instance of a RIPE Atlas result parsed with Sagan: https://ripe-atlas-sagan.readthedocs.org/ """ return "Packets received: {}".format(result.packets_received) As you can see, this renderer isn't very useful, but we're providing it here to give you a rough idea of what you get to play with when defining your own renderer. In the case of our PingPacketRenderer, we're doing the simplest of tasks: we're returning the number of packets in each result. The job of ``on_result()`` is to take a Sagan result object as input and return a string. **It should not print anything to standard out**, rather it should simply return a string that will get printed to standard out by the surrounding framework. .. _plugins-write-anatomy-additional: Additional Options :::::::::::::::::: It's likely that you will only ever need to work with ``on_result()``, but in the event that you'd like to get more complicated, there are options: ``header()``, ``additional()``, and ``footer()``. Note however that these other methods are currently only available to the ``report`` command. Streaming only makes use of ``on_result()``. .. _plugins-write-anatomy-additional-header: header() ........ The value returned from this method is printed to standard out before any results are captured. By default it returns an empty string. .. _plugins-write-anatomy-additional-additional: additional() ............ Typically used for summary logic, this is executed after the last result is rendered. A common pattern is to override ``__init__()`` to set some collector properties, update them via ``on_result()``, and then print out said properties in a summary via this method. For an example, let's update our ``Renderer`` class: .. code:: python from ripe.atlas.tools.renderers.base import Renderer as BaseRenderer class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_PING] def __init__(self, *args, **kwargs): self.packet_total = 0 BaseRenderer.__init__(self, *args, **kwargs) def on_result(self, result): self.packet_total += result.packets_received return "Packets received: {}\n".format(result.packets_received) def additional(self, results): return "\nTotal packets received: {}\n".format(self.packet_total) Note that the passed-in value of ``results`` is the list of Sagan Result objects that were previously looped over for on_result(). You can do some interesting things with that. .. _plugins-write-anatomy-additional-footer: footer() ........ Much the same as ``header()``, this should return a string, but unlike ``header()``, the output of this method is rendered after everything else. .. _plugins-run: Run It! ------- Now that you've written your renderer and the file is stored where it's supposed to be, it should be ready to go: .. code:: bash $ ripe-atlas report --help You should see ``my_renderer`` in the list of options for ``--renderer`` just as before, but now when you actually try to execute it... .. code:: bash $ ripe-atlas report 1000192 --renderer my_renderer Packets received: 3 Packets received: 3 Packets received: 3 Packets received: 3 Packets received: 3 Packets received: 3 Total packets received: 18 It's not very interesting, but it's a start! .. _plugins-contributing: Contributing ------------ We love it when people write stuff that talks to our stuff. If you think your stuff is useful, it'd be awesome if you could do any of these: * Post to the [ripe-atlas mailing list](https://www.ripe.net/mailman/listinfo/ripe-atlas) about it. You can also solicit feedback from the RIPE Atlas developers or the wider community on this list. * Write a blog post about your plugin, what makes it useful, etc. * Tweet about it. Feel free to mention [@RIPE_Atlas](https://twitter.com/ripe_atlas) and we might even retweet it. * Create a [pull request](https://github.com/RIPE-NCC/ripe-atlas-tools/pulls) for this project to get your plugin added to core. ripe-atlas-tools-3.1.0/docs/quickstart.rst000066400000000000000000000027601437041663000205770ustar00rootroot00000000000000Quickstart ========== This is a very fast break down of everything you need to start using Ripe Atlas on the command line. Viewing public data is quick & easy, while creation is a little more complicated, since you need to setup your authorisation key. Viewing Public Data ------------------- 1. :ref:`Install ` the toolkit. 2. View help with: ``ripe-atlas --help`` 3. View a basic report for a public measurement: ``ripe-atlas report `` 4. View the live stream for a measurement: ``ripe-atlas stream `` 5. Get a list of probes in ASN 3333: ``ripe-atlas probe-search --asn 3333`` 6. Get a list of measurements with the word "wikipedia" in them: ``ripe-atlas measurement-search --search wikipedia`` Creating a Measurement ---------------------- 1. Log into `RIPE Atlas`_. If you don't have an account, you can create one there for free. 2. Visit the `API Keys`_ page and create a new key with the permission ``Create a new user defined measurement`` 3. Install the toolkit as below. 4. Configure the toolkit to use your key with ``ripe-atlas configure --set authorisation.create=MY_API_KEY`` 5. View the help for measurement creation with ``ripe-atlas measure --help`` 6. Create a measurement with ``ripe-atlas measure ping --target example.com`` .. _`RIPE Atlas`: https://atlas.ripe.net/ .. _`API Keys`: https://atlas.ripe.net/keys/ Advanced Use ------------ Refer to the :ref:`complete usage documentation ` for more advanced options. ripe-atlas-tools-3.1.0/docs/troubleshooting.rst000066400000000000000000000057651437041663000216440ustar00rootroot00000000000000.. _troubleshooting: Troubleshooting =============== Sometimes things don't go as planned. In these cases, this page is here to help. .. _troubleshooting-insecureplatformwarning: InsecurePlatformWarning ----------------------- On older systems (running Python versions <2.7.10), you may be presented with a warning message that looks like this:: /path/to/lib/python2.7/site-packages/requests/packages/urllib3/util/ssl_.py:100: InsecurePlatformWarning: A true SSLContext object is not available. This prevents urllib3 from configuring SSL appropriately and may cause certain SSL connections to fail. For more information, see https://urllib3.readthedocs.org/en/latest/security.html#insecureplatformwarning. InsecurePlatformWarning This is due to the insecure way older versions of Python handle secure connections and a visit to the above URL will tell you that the fix is one of three options: * Upgrade to a modern version of Python * Install three Python packages: ``pyopenssl``, ``ndg-httpsclient``, and ``pyasn1`` * `Suppress the warnings`_. Don't do that though. .. _Suppress the warnings: https://urllib3.readthedocs.org/en/latest/security.html#disabling-warnings .. _troubleshooting-saganopensslosx: Sagan, OpenSSL, and OSX ----------------------- If you're using Mac OSX, the installation of Sagan, (one of Magellan's dependencies) may give you trouble, especially in how Apple handles PyOpenSSL on their machines. Workarounds and proper fixes for this issue can be found in the `Sagan installation documentation`_. .. _Sagan installation documentation: https://ripe-atlas-sagan.readthedocs.org/en/latest/installation.html#troubleshooting .. _troubleshooting-libyaml: Complaints from libyaml ----------------------- During the installation, you may see something like this scroll by: .. code::none Running setup.py install for pyyaml checking if libyaml is compilable x86_64-linux-gnu-gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -fPIC -I/usr/include/python2.7 -c build/temp.linux-x86_64-2.7/check_libyaml.c -o build/temp.linux-x86_64-2.7/check_libyaml.o build/temp.linux-x86_64-2.7/check_libyaml.c:2:18: fatal error: yaml.h: No such file or directory #include ^ compilation terminated. libyaml is not found or a compiler error: forcing --without-libyaml (if libyaml is installed correctly, you may need to specify the option --include-dirs or uncomment and modify the parameter include_dirs in setup.cfg) Don't worry. This is just the installation script noticing that you don't have libyaml installed and it's complaining because it's good to have around for performance reasons. However, since we're only using YAML for configuration, performance isn't an issue, and the fallback option will be sufficient. If however, you don't like these sorts of errors, make sure that libyaml is installed for your distribution before attempting to install this toolkit. ripe-atlas-tools-3.1.0/docs/use.rst000066400000000000000000000732641437041663000172100ustar00rootroot00000000000000.. _use: How to Use the RIPE Atlas Toolkit ********************************* .. _use-configure: Configuration ============= For most features, Magellan will work out-of-the-box, but if you'd like to customise the experience, or if you want to use this tool to create a measurement of your own, then you'll need to configure it. Thankfully, configuration is easy by way of the ``configure`` command::: $ ripe-atlas configure --help .. _use-configure-options: Options ------- ================== ================= ======================================== Option Arguments Explanation ================== ================= ======================================== ``--editor`` Invoke ${EDITOR} to edit the configuration directly ``--set`` path=value Permanently set a configuration value so it can be used in the future. ``--init`` Create a configuration file and save it into your home directory at: ``${HOME}/.config/ripe-atlas-tools/rc`` ================== ================= ======================================== .. _use-configure-examples: Examples -------- Create a standard configuration file. Note that this typically isn't necessary:: $ ripe-atlas configure --init Invoke your editor of choice to manually fiddle with the configuration file:: $ ripe-atlas configure --editor Set an arbitrary value within the configuration file. You can use dot-separated notation to dictation the value you wish to change:: $ ripe-atlas configure --set authorisation.create=YOUR_API_KEY .. _use-go: Quick Measurement Information ============================= For the impatient, and for those looking to see how they might write their own plugins, we have a simple ``go`` command::: $ ripe-atlas go This will open a web browser and take you to the detail page for the measurement id provided. .. _use-measurements: Measurement Querying ==================== A querying tool for finding existing measurements in the RIPE Atlas database. You can request a table-formatted list of measurements based on search-string lookups, type, start time, etc. .. _use-measurements-options: Options ------- ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--search`` A free-form string This could match the target or description. ``--status`` One of: scheduled, The measurement status. stopped, ongoing ``--af`` One of: 4, 6 The address family. ``--type`` One of: ping, The measurement type. traceroute, dns, sslcert, ntp, http ``--field`` One of: status, The field(s) to display. target, url, type, Invoke multiple times for id, description multiple fields. The default is id, type, description, and status. ``--ids-only`` Display a list of measurement ids matching your filter criteria. ``--limit`` An integer The number of measurements to return. The number must be between 1 and 1000 ``--started-before`` An ISO timestamp Filter for measurements that started before a specific date. The format required is YYYY-MM-DDTHH:MM:SS ``--started-after`` An ISO timestamp Filter for measurements that started after a specific date. The format required is YYYY-MM-DDTHH:MM:SS ``--stopped-before`` An ISO timestamp Filter for measurements that stopped before a specific date. The format required is YYYY-MM-DDTHH:MM:SS ``--stopped-after`` An ISO timestamp Filter for measurements that stopped after a specific date. The format required is YYYY-MM-DDTHH:MM:SS ============================ ================== ============================== .. _use-measurements-examples: Examples -------- Get a list of measurements:: $ ripe-atlas measurement-search Filter that list by ``status=ongoing``:: $ ripe-atlas measurement-search --status ongoing Further filter it by getting measurements that conform to IPv6:: $ ripe-atlas measurement-search --status ongoing --af 6 Get that same list, but strip out everything but the measurement ids:: $ ripe-atlas measurement-search --status ongoing --af 6 --ids-only Limit that list to 200 entries:: $ ripe-atlas measurement-search --status ongoing --af 6 --limit 200 Get that list, but show only the id, url and target fields: $ ripe-atlas measurement-search --status ongoing --af 6 \ --field id --field url --field target Filter for measurements of type ``dns`` that started after January 1, 2015:: $ ripe-atlas measurement-search --type dns --started-after 2015-01-01 .. _use-probes: Probe Querying ============== Just like the ``measurement-search`` command, but for probes, and a lot more powerful. You can use this command to find probes within an ASN, prefix, or geographical region, and then aggregate by country, ASN, and/or prefix. .. _use-probes-options: Options ------- ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--limit`` An integer Return limited number of probes. ``--field`` One of: status, The field(s) to display. description, Invoke multiple times for address_v6, multiple fields. The default address_v4, is id, asn_v4, asn_v6, asn_v4, is_public, country, and status. asn_v6, id, prefix_v4, prefix_v6, is_anchor, country, coordinates ``--aggregate-by`` country, asn_v4, Aggregate list of probes based asn_v6, on all specified aggregations. prefix_v4, Multiple aggregations prefix_v6 supported. ``--all`` Fetch *ALL* probes. That will give you a loooong list. ``--max-per-aggregation`` An integer Maximum number of probes per aggregated bucket. ``--ids-only`` Print only IDs of probes. Useful to pipe it to another command. ``--asn`` An integer Filter the list by an ASN ``--asnv4`` An integer Filter the list by an ASN ``--asnv6`` An integer Filter the list by an ASN ``--prefix`` A prefix string Filter the list by a prefix ``--prefixv4`` A prefix string Filter the list by a prefix ``--prefixv6`` A prefix string Filter the list by a prefix ``--location`` A free-form string The location of probes as a string i.e. 'Amsterdam' ``--center`` A pair of Location as geographic ,-string, i.e. coordinates "48.45,9.16" ``--radius`` An integer Radius in km from specified center/point. ``--country`` A two-letter The country in which the ISO country code probes are located. ============================ ================== ============================== .. _use-probes-examples: Examples -------- Get a list of probes within ASN 3333:: $ ripe-atlas probe-search --asn 3333 Further filter that list to show only probes in ASN 3333 from the Netherlands:: $ ripe-atlas probe-search --asn 3333 --country nl Change the limit from the default of 25 to 200:: $ ripe-atlas probe-search --asn 3333 --limit 200 Aggregate the probes by country, and then by ASN:: $ ripe-atlas probe-search --asn 3333 --aggregate-by country --aggregate-by asn_v4 Show the id, url, target, description, and whether the probe is public or not:: $ ripe-atlas probe-search --asn 3333 --field id --field url --field description \ --field is_public .. _use-report: Result Reporting ================ A means to generate a simple text-based report based on the results from a measurement. Typically, this is used to get the latest results of a measurement in a human-readable format, but with the ``--start-time`` and ``--stop-time`` options, you can get results from any time range you like. It's possible to generate the report by automatically fetching the results from the API, by reading a local file, or by reading standard input. .. _use-report-options: Options ------- ================== ================== ======================================== Option Arguments Explanation ================== ================== ======================================== ``--auth`` RIPE Atlas key One of the RIPE Atlas key alias alias configured for results fetching. ``--probes`` A comma-separated Limit the report to only results list of probe ids obtained from specific probes. ``--probe-asns`` A comma-separated Limit the report to only results list of ASNs obtained from probes belonging to specific ASNs. ``--renderer`` One of: dns, http, The renderer you want to use. If this ntp, ping, raw, isn't defined, an appropriate renderer ssl_consistency, will be selected. sslcert, traceroute, traceroute_aspath, aggregate_ping ``--from-file`` A file path The source of the data to be rendered. Conflicts with specifying a measurement_id to fetch from the API. ``--aggregate-by`` One of: status, Tell the rendering engine to aggregate prefix_v4, the results by the selected option. Note prefix_v6, that if you opt for aggregation, no country, output will be generated until all rtt-median, results are received. asn_v4, asn_v6 ``--start-time`` An ISO timestamp The start time of the report. The format should conform to YYYY-MM-DDTHH:MM:SS ``--stop-time`` An ISO timestamp The stop time of the report. The format should conform to YYYY-MM-DDTHH:MM:SS ================== ================== ======================================== .. _use-report-examples: Examples -------- Get the latest results of measurement 1001:: $ ripe-atlas report 1001 The same, but specifically request the ping renderer:: $ ripe-atlas report 1001 --renderer ping Aggregate those results by country:: $ ripe-atlas report 1001 --aggregate-by country Get results from the same measurement, but show all results from the first week of 2015:: $ ripe-atlas report 1001 --start-time 2015-01-01 --stop-time 2015-01-07 Get results from the first day of 2015 until right now:: $ ripe-atlas report 1001 --start-time 2015-01-01 Pipe the contents of an arbitrary file into the renderer. The rendering engine will be guessed from the first line of input:: $ cat /path/to/file/full/of/results | ripe-atlas report The same, but point Magellan to a file deliberately rather than using a pipe:: $ ripe-atlas report --from-file /path/to/file/full/of/results .. _use-stream: Result Streaming ================ Connect to the streaming API and render the results in real-time as they come in. .. _use-stream-options: Options ------- ================== ================== ======================================== Option Arguments Explanation ================== ================== ======================================== ``--auth`` RIPE Atlas key One of the RIPE Atlas key alias alias configured for results fetching. ``--limit`` A number < 1000 The maximum number of results you want to stream. The default is to stream forever until you hit ``Ctrl+C``. ``--renderer`` One of: dns, http, The renderer you want to use. If this ntp, ping, raw, isn't defined, an appropriate renderer ssl_consistency, will be selected. sslcert, traceroute, traceroute_aspath, aggregate_ping ================== ================== ======================================== .. _use-stream-examples: Examples -------- Stream the results from measurement #1001:: $ ripe-atlas stream 1001 Limit those results to 500:: $ ripe-atlas stream 1001 --limit 500 Specify a renderer:: $ ripe-atlas stream 1001 --renderer ping Combine for fun and profit:: $ ripe-atlas stream 1001 --renderer ping --limit 500 .. _use-measure: Measurement Creation ==================== The most complicated command we have, this will create a measurement (given a plethora of options) and begin streaming the results back to you in a standardised rendered form. It's invoked by using a special positional argument that dictates the type of measurement you want to create. This also unlocks special options, specific to that type. See the :ref:`examples ` for more information. .. _use-measure-options: Options ------- All measurements share a base set of options. ====================== ================== ==================================== Option Arguments Explanation ====================== ================== ==================================== ``--renderer`` One of: dns, http, The renderer you want to use. If ntp, ping, raw, this isn't defined, an appropriate ssl_consistency, renderer will be selected. sslcert, traceroute, traceroute_aspath, aggregate_ping ``--dry-run`` Do not create the measurement, only show its definition. ``--auth`` An API key The API key you want to use to create the measurement. ``--af`` One of: 4, 6 The address family, either 4 or 6. The default is a guess based on the target, favouring 6. ``--description`` A free-form string The description/name of your new measurement. ``--target`` A domain or IP The target, either a domain name or IP address. If creating a DNS measurement, the absence of this option will imply that you wish to use the probe's resolver. ``--no-report`` Don't wait for a response from the measurement, just return the URL at which you can later get information about the measurement. ``--go-web`` Don't wait for a response from the measurement, just immediately open the measurement URL in the default web browser. ``--resolve-on-probe`` Flag that indicates that a name should be resolved (using DNS) on the probe. Otherwise it will be resolved on the RIPE Atlas servers. ``--interval`` An integer Rather than run this measurement as a one-off (the default), create this measurement as a recurring one, with an interval of n seconds between attempted measurements. This option implies ``--no-report``. ``--from-area`` One of: WW, West, The area from which you'd like to North-Central, select your probes. South-Central, North-East, South-East ``--from-country`` A two-letter ISO The country from which you'd like to country code select your probes. ``--from-prefix`` A prefix string The prefix from which you'd like to select your probes. ``--from-asn`` An ASN number The ASN from which you'd like to select your probes. ``--from-probes`` A comma-separated Probes you want to use in your list of probe ids measurement. ``--from-measurement`` A measurement id A measurement id which you want to use as the basis for probe selection in your new measurement. This is a handy way to re-create a measurement under conditions similar to another measurement. ``--probes`` An integer The number of probes you want to use. ``--include-tag`` A tag name Include only probes that are marked with this tag. Note that this option may be repeated. ``--exclude-tag`` A tag name Exclude probes that are marked with this tag. Note that this option may be repeated. ``--measurement-tags`` A comma-separated Measurement tags to be applied to list of the newly created measurement. measurement tags ====================== ================== ==================================== .. _use-measure-options-ping: Ping-Specific Options ::::::::::::::::::::: ====================== ================== ==================================== Option Arguments Explanation ====================== ================== ==================================== ``--packets`` An integer The number of packets sent ``--size`` An integer The size of packets sent ``--packet-interval`` An integer ====================== ================== ==================================== .. _use-measure-options-traceroute: Traceroute-Specific Options ::::::::::::::::::::::::::: ============================= ================== ==================================== Option Arguments Explanation ============================= ================== ==================================== ``--packets`` An integer The number of packets sent ``--size`` An integer The size of packets sent ``--protocol`` One of: ICMP, UDP, The protocol used. For DNS TCP measurements, this is limited to UDP and TCP, but traceroutes may use ICMP as well. ``--timeout`` An integer The timeout per-packet ``--dont-fragment`` Don't Fragment the packet ``--paris`` An integer Use Paris. Value must be between 0 and 64.If 0, a standard traceroute will be performed. ``--first-hop`` An integer Value must be between 1 and 255. ``--max-hops`` An integer Value must be between 1 and 255. ``--port`` An integer Destination port, valid for TCP only. ``--destination-option-size`` An integer IPv6 destination option header. ``--hop-by-hop-option-size`` An integer IPv6 hop by hop option header. ============================= ================== ==================================== .. _use-measure-options-dns: DNS-Specific Options :::::::::::::::::::: ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--query-class`` One of: IN, CHAOS The query class. The default is "IN" ``--query-type`` One of: A, SOA, The query type. The default TXT, SRV, SSHFP, is "A" TLSA, NSEC, DS, AAAA, CNAME, DNSKEY, NSEC3, PTR, HINFO, NSEC3PARAM, NS, MX, RRSIG, ANY ``--query-argument`` A string The DNS label to query. ``--set-cd-bit`` Set the DNSSEC Checking Disabled flag (RFC4035) ``--set-do-bit`` Set the DNSSEC OK flag (RFC3225) ``--set-nsid-bit`` Include an EDNS name server. ID request with the query. ``--udp-payload-size`` An integer May be any integer between 512 and 4096 inclusive. ``--set-rd-bit`` Set the Recursion Desired flag. ``--retry`` An integer Number of times to retry. ============================ ================== ============================== .. _use-measure-options-sslcert: SSL Certificate-Specific Options :::::::::::::::::::::::::::::::: ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--port`` An integer The port to query ============================ ================== ============================== .. _use-measure-options-http: HTTP-Specific Options ::::::::::::::::::::: ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--header-bytes`` An integer The maximum number of bytes to retrieve from the header ``--version`` A string The HTTP version to use ``--method`` A string The HTTP method to use ``--path`` A string The path on the webserver ``--query-string`` A string An arbitrary query string ``--user-agent`` A string An arbitrary user agent ``--body-bytes`` An integer The maximum number of bytes to retrieve from the body ``--timing-verbosity`` One of: 0, 1, 2 The amount of timing information you want returned. 1 returns the time to read, to connect, and to first byte, 2 returns timing information per read system call. 0 (default) returns no additional timing information. ============================ ================== ============================== .. _use-measure-options-ntp: NTP-Specific Options :::::::::::::::::::: ============================ ================== ============================== Option Arguments Explanation ============================ ================== ============================== ``--packets`` An integer The number of packets sent ``--timeout`` An integer The timeout per-packet ============================ ================== ============================== .. _use-measure-examples: Examples -------- The simplest of measurements. Create a ping with 50 probes to example.com:: $ ripe-atlas measure ping --target example.com The same, but don't actually create it, just show what would be done:: $ ripe-atlas measure ping --target example.com --dry-run Be more specific about which address family you want to target:: $ ripe-atlas measure ping --target example.com --af 6 Ask for 20 probes from Canada:: $ ripe-atlas measure ping --target example.com --probes 20 --from-country ca Or ask for 20 Canadian probes that definitely support IPv6:: $ ripe-atlas measure ping --target example.com --probes 20 \ --from-country ca --include-tag system-ipv6-works Rather than creating a one-off create a recurring measurement:: $ ripe-atlas measure ping --target example.com --interval 3600 Moving onto DNS measurements, do a lookup for example.com. Since we're not specifying ``--target`` here, this implies that we want to use the probe's resolver:: $ ripe-atlas measure dns --query-argument example.com Getting a little more complicated, let's set a few special bits and make a more complex query:: $ ripe-atlas measure dns --query-type AAAA --query-argument example.com \ --set-nsid-bit --set-rd-bit --set-do-bit --set-cd-bit .. _use-shortcuts: Shortcuts --------- If you're creating a lot of measurements in a short time, typing out ``ripe-atlas measure traceroute`` a whole bunch of times can be tiresome, so we've added a few shortcut scripts for you: ================================= ========================== Where you'd typically write You could use this instead ================================= ========================== ``ripe-atlas measure ping`` ``aping`` ``ripe-atlas measure traceroute`` ``atraceroute`` ``ripe-atlas measure dns`` ``adig`` ``ripe-atlas measure sslcert`` ``asslcert`` ``ripe-atlas measure http`` ``ahttp`` ``ripe-atlas measure ntp`` ``antp`` ================================= ========================== So for example, these two commands are the same:: $ ripe-atlas measure ping --target example.com $ aping --target example.com If you want to streamline your typing process even more than this, we recommend the use of your shell's ``alias`` feature, which is both powerful and customisable for your needs. ripe-atlas-tools-3.1.0/ripe-atlas-bash-completion.sh000066400000000000000000000007671437041663000224070ustar00rootroot00000000000000## This is highly inspired from Django's manage.py autocompletion ## https://github.com/django/django/blob/1.9.4/extras/django_bash_completion#L42-L57 ## To install this, add the following line to your .bash_profile: ## ## . ~/path/to/django_bash_completion _ripe_atlas_bash_completion() { COMPREPLY=( $( COMP_WORDS="${COMP_WORDS[*]}" \ COMP_CWORD=$COMP_CWORD \ RIPE_ATLAS_AUTO_COMPLETE=1 $1 ) ) } complete -F _ripe_atlas_bash_completion -o default ripe-atlas ripe-atlas-tools-3.1.0/ripe/000077500000000000000000000000001437041663000156555ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/__init__.py000066400000000000000000000015031437041663000177650ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: from pkgutil import extend_path __path__ = extend_path(__path__, __name__) ripe-atlas-tools-3.1.0/ripe/atlas/000077500000000000000000000000001437041663000167615ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/__init__.py000066400000000000000000000015031437041663000210710ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: from pkgutil import extend_path __path__ = extend_path(__path__, __name__) ripe-atlas-tools-3.1.0/ripe/atlas/tools/000077500000000000000000000000001437041663000201215ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/__init__.py000066400000000000000000000000001437041663000222200ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/aggregators/000077500000000000000000000000001437041663000224265ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/aggregators/__init__.py000066400000000000000000000014631437041663000245430ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from .base import RangeKeyAggregator, ValueKeyAggregator, aggregate __all__ = [ "aggregate", "RangeKeyAggregator", "ValueKeyAggregator", ] ripe-atlas-tools-3.1.0/ripe/atlas/tools/aggregators/base.py000066400000000000000000000064371437041663000237240ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import itertools class ValueKeyAggregator(object): """Aggregator based on tha actual value of the key/attribute""" def __init__(self, key, prefix=None): self.aggregation_keys = key.split(".") self.key_prefix = prefix or self.aggregation_keys[-1].upper() def get_key_value(self, entity): """ Returns the value of the key/attribute the aggregation will use to bucketize probes/results """ attribute = entity for key in self.aggregation_keys: attribute = getattr(attribute, key) return attribute def get_bucket(self, entity): """ Returns the bucket the specific entity belongs to based on the give key/attribute """ return "{0}: {1}".format(self.key_prefix, self.get_key_value(entity)) class RangeKeyAggregator(ValueKeyAggregator): """ Aggregator based on where the position of the value of the key/attribute is in the given range """ def __init__(self, key, ranges): ValueKeyAggregator.__init__(self, key) self.aggregation_ranges = sorted(ranges, reverse=True) def get_bucket(self, entity): """ Returns the bucket the specific entity belongs to based on the give key/attribute """ bucket = "{0}: < {1}".format( self.key_prefix, self.aggregation_ranges[-1] ) key_value = self.get_key_value(entity) for index, krange in enumerate(self.aggregation_ranges): if key_value > krange: if index == 0: bucket = "{0}: > {1}".format(self.key_prefix, krange) else: bucket = "{0}: {1}-{2}".format( self.key_prefix, krange, self.aggregation_ranges[index - 1], ) break return bucket def _get_sort_key(kv): key = [] for is_digit, part in itertools.groupby(kv[0], key=str.isdigit): part = "".join(part) if is_digit: part = int(part) key.append(part) return key def aggregate(entities, aggregators): """ Aggregate the given entities using the given aggregators. Returns a dict of {combined_aggregation_key_tuple: entity_list}, where the keys are in ascending numeric >> lexical order. """ if not aggregators: return entities buckets = {} for e in entities: key = " | ".join(a.get_bucket(e) for a in aggregators) bucket = buckets.setdefault(key, []) bucket.append(e) return dict(sorted(buckets.items(), key=_get_sort_key)) ripe-atlas-tools-3.1.0/ripe/atlas/tools/cache.py000066400000000000000000000110561437041663000215410ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import datetime import functools import os import sys try: import cPickle as pickle except ImportError: import pickle try: import anydbm as dbm # anydbm py2.7 will use the best available dbm except ImportError: import dbm # ... and on Python3 dbm does the same from .helpers import xdg class LocalCache(object): """ Simple caching engine, making use of the built-in dbm support. This will create a file called cache.db in ripe-atlas-tools config directory and dump stuff in there for use later. """ def __init__(self): self._now = datetime.datetime.now() self._db_file = None @property def _db(self): if self._db_file is None: self._db_file = dbm.open(self._get_or_create_db_path(), "c") return self._db_file def __contains__(self, key): return key in self._db def __getitem__(self, key): return self.get(key) def __setitem__(self, key, value, expires=None): self._db[key] = pickle.dumps((expires, value)) def __delitem__(self, key): if key not in self._db: raise KeyError del self._db[key] def keys(self): return self._db.keys() def items(self): for key in self.keys(): yield key, self._db[key] def get(self, key, default=None): if key in self._db: expires, value = pickle.loads(self._db[key]) if not expires or expires > self._now: return value else: del self._db[key] return default def set(self, key, value, expires=None): return self.__setitem__( key, value, self._now + datetime.timedelta(seconds=expires) ) def clear(self, key=None): """ Removes a specific key from the cache manually, or will wipe the entire cache if you don't specify `key`. Note that this shouldn't be necessary unless you've cached something with an inappropriately long expire time. """ if key: if key in self._db: del self._db[key] else: for key in self.keys(): del self._db[key] def expire(self): """ Clears out should-be-expired values from the cache. Note that this happens automatically whenever you call `.get()` so you should never really need to run this. """ for key in self.keys(): self.get(key) @staticmethod def _get_or_create_db_path(): v = sys.version_info file_name = "cache-{}.{}.{}.db".format(v.major, v.minor, v.micro) db_path = os.path.join("/", "tmp", file_name) if "HOME" in os.environ: db_path = os.path.join(xdg.get_config_home(), file_name) try: os.makedirs(os.path.dirname(db_path)) except OSError: pass # Better to ask forgiveness than permission return db_path cache = LocalCache() class Memoiser(object): """ Enabling class for the @memoised decorator """ def __init__(self, function, cache_time): self._function = function self._cache_time = cache_time def __call__(self, *args, **kwargs): key = pickle.dumps([args, kwargs]) value = cache[key] if value: return value value = self._function(*args, **kwargs) cache.set(key, value, self._cache_time) return value def __get__(self, obj, objtype): """Support instance methods.""" return functools.partial(self.__call__, obj) def memoised(cache_time): """ Decorate a method or function with this to cache the result of said method for n seconds: @memoised(60 * 60) # Cache for one hour my_function(some_arguments): ... return whatever """ def _wrap(function): return Memoiser(function, cache_time=cache_time) return _wrap ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/000077500000000000000000000000001437041663000217225ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/__init__.py000066400000000000000000000000001437041663000240210ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/alias.py000066400000000000000000000120771437041663000233740ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import os from ..exceptions import RipeAtlasToolsException from ..helpers.validators import ArgumentType from ..settings import AliasesDB, aliases from .base import Command as BaseCommand class Command(BaseCommand): NAME = "alias" EDITOR = os.environ.get("EDITOR", "/usr/bin/vim") DESCRIPTION = "Manage measurements' and probes' aliases" EXTRA_DESCRIPTION = ( "As an alternative to this command, you can just create/edit {}".format( AliasesDB.USER_RC ) ) def add_arguments(self): subparsers = self.parser.add_subparsers( title="action", dest="action", help="Action to be performed on aliases. " "Run 'ripe-atlas alias --help' for more details.", ) add_parser = subparsers.add_parser("add", help="Add/modify an alias.") add_parser.add_argument( "type", action="store", choices=["measurement", "probe"], help="Type of target object.", ) add_parser.add_argument( "target", action="store", type=int, help="Target's ID.", ) add_parser.add_argument( "alias", action="store", type=ArgumentType.alias_is_valid, help="Alias name.", ) del_parser = subparsers.add_parser("del", help="Remove an alias.") del_parser.add_argument( "type", action="store", choices=["measurement", "probe"], help="Type of target object.", ) del_parser.add_argument( "alias", action="store", type=ArgumentType.alias_is_valid, help="Alias name.", ) show_parser = subparsers.add_parser("show", help="Show target's ID.") show_parser.add_argument( "type", action="store", choices=["measurement", "probe"], help="Type of target object.", ) show_parser.add_argument( "alias", action="store", type=ArgumentType.alias_is_valid, help="Alias name.", ) list_parser = subparsers.add_parser("list", help="List configured aliases.") list_parser.add_argument( "type", action="store", choices=["measurement", "probe"], help="Type of target object.", ) subparsers.add_parser( "editor", help="Invoke {0} to edit the configuration directly".format(self.EDITOR), ) def run(self): if not self.arguments.action: raise RipeAtlasToolsException( "Action not given. Use --help for more information." ) if self.arguments.action == "editor": os.system("{0} {1}".format(self.EDITOR, AliasesDB.USER_RC)) return self.ok("Aliases file writen to {}".format(AliasesDB.USER_RC)) else: alias_type = self.arguments.type if self.arguments.action == "add": alias_name = self.arguments.alias target_id = self.arguments.target try: ArgumentType.alias_is_valid(alias_name) except Exception as e: raise RipeAtlasToolsException(str(e)) aliases[alias_type][alias_name] = target_id AliasesDB.write(aliases) elif self.arguments.action == "del": alias_name = self.arguments.alias del aliases[alias_type][alias_name] AliasesDB.write(aliases) elif self.arguments.action == "show": alias_name = self.arguments.alias if alias_name in aliases[alias_type]: self.ok( "'{}' is an alias for {}".format( alias_name, aliases[alias_type][alias_name] ) ) else: self.not_ok("'{}' alias does not exist".format(alias_name)) elif self.arguments.action == "list": res = "{} aliases:\n\n".format(alias_type.capitalize()) for alias_name in sorted(aliases[alias_type]): res += "- {}: {}\n".format( alias_name, aliases[alias_type][alias_name] ) self.ok(res) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/base.py000066400000000000000000000241611437041663000232120ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from typing import Optional from datetime import datetime import argparse import importlib import os import pkgutil import sys import platform from ..helpers.actions import StoreIfNotEmpty from ..helpers import xdg from ..helpers.colours import colourise from ..version import __version__ class RipeHelpFormatter(argparse.RawTextHelpFormatter): def _format_usage(self, *args): r = argparse.RawTextHelpFormatter._format_usage(self, *args).capitalize() return "\n\n{}\n".format(r) def _get_command_name(cmd_or_factory): return ( cmd_or_factory.NAME if cmd_or_factory.NAME else cmd_or_factory.__module__.rsplit(".", 1)[-1] ) class Command(object): # If NAME isn't defined then the module name is used # It exists basically to allow hyphens in the command names NAME: Optional[str] = None DESCRIPTION = "" # Define this in the subclass _commands = None DEPRECATED_ALIASES = { "measurement": "measurement-info", "measurements": "measurement-search", "probe": "probe-info", "probes": "probe-search", "render": "report", } def __init__(self, *args, **kwargs): self.arguments = None self.parser = argparse.ArgumentParser( formatter_class=RipeHelpFormatter, description="\n\n".join( [ self.DESCRIPTION + ".", getattr(self, "EXTRA_DESCRIPTION", ""), ] ), prog="ripe-atlas {}".format(self.get_name()), ) self.user_agent = self._get_user_agent() @classmethod def get_name(cls): return _get_command_name(cls) @staticmethod def _get_packages_for_paths(paths): """ Yield path, package_name for all of the packages found in `paths`. """ for loader, package_name, _ in pkgutil.iter_modules(paths): yield loader.path, package_name @classmethod def _get_user_command_path(cls): return os.path.join(xdg.get_config_home(), "commands") @classmethod def _load_commands(cls): """ Scan for available commands and store a map of command names to module paths. """ builtin_path = os.path.dirname(__file__) user_command_path = cls._get_user_command_path() cls._commands = {} paths = [builtin_path, user_command_path] for path, package_name in cls._get_packages_for_paths(paths): if package_name == "base": continue if path == builtin_path: module = "ripe.atlas.tools.commands.{}".format(package_name) else: module = package_name if user_command_path not in sys.path: sys.path.append(user_command_path) cls._commands[package_name] = module @classmethod def load_command_class(cls, command_name): """ Get the Command or Factory with the given command name. """ if command_name in cls.DEPRECATED_ALIASES: alias = command_name command_name = cls.DEPRECATED_ALIASES[alias] sys.stderr.write( colourise( "Warning: {} is a deprecated alias for {}\n\n".format( alias, command_name, ), "yellow", ) ) if cls._commands is None: cls._load_commands() try: module_name = cls._commands[command_name.replace("-", "_")] except KeyError: return module = importlib.import_module(module_name) if hasattr(module, "Factory"): cmd = module.Factory else: cmd = module.Command return cmd @classmethod def get_available_commands(cls): """ Get a list of commands that we can execute. By default, we have a fixed list that we make available in this directory, but the user can create her own plugins and store them at ~/.config/ripe-atlas-tools/commands/. If we find any files there, we add them to the list here. """ if not cls._commands: cls._load_commands() return sorted(cls._commands.keys()) def init_args(self, args=None): """ Initialises all parse arguments and makes them available to the class. """ if args is None: args = sys.argv[1:] self.arguments = self.parser.parse_args(self._modify_parser_args(args)) def run(self): raise NotImplementedError() def add_arguments(self): """ A hook that's executed in the __init__, you can make use of `self.parser` here to add arguments to the command: self.parser.add_argument( "measurement_id", type=int, help="The measurement id you want to use" ) """ pass def _modify_parser_args(self, args): """ A modifier hook that can be overridden in the child class to allow that class to manipulate the arguments before being parsed. The common use-case we're trying to solve here is popping a secondary argument off of the list and/or appending `--help` in some circumstances. """ self.add_arguments() return args def print(self, message): """ Write to stdout regardless of whether it is a tty or not. """ sys.stdout.write(message + "\n") def ok(self, message): """ Write a successful message to the tty if present. """ if sys.stdout.isatty(): sys.stdout.write("\n{}\n\n".format(colourise(message, "green"))) def not_ok(self, message): """ Writer an unsuccessful message to the tty if present. """ if sys.stdout.isatty(): sys.stdout.write("\n{}\n\n".format(colourise(message, "red"))) @staticmethod def _get_os_string(): """ Return a string identifying the system OS suitable for use in the User-Agent header. """ os = platform.system() if os == 'Darwin': release = platform.mac_ver()[0] return f'macOS {release}' elif os == 'Windows': release = platform.win32_ver()[0] return f"Windows {release}" pass else: try: # Use a shim for Python < 3.10 info = xdg.freedesktop_os_release() except OSError: pass else: name = info.get("NAME") if name: version = info.get("VERSION_ID", "") return f"{name} {version}" return platform.platform() @classmethod def _get_user_agent(cls): """ Allow packagers to change the user-agent to whatever they like by placing a file called `user-agent` into the `tools` directory. If no file is found, we go with a sensible platform-specific default + the version. """ try: custom = os.path.join(os.path.dirname(__file__), "..", "user-agent") with open(custom) as f: return f.readline().strip()[:128] except IOError: pass # We go with the default os_str = cls._get_os_string() return f"RIPE Atlas Tools [{os_str}] {__version__}" def add_flag(self, parser, name, default, help, no_help=None): """ Convenience method to create a store_true --foo option along with a --no-foo store_false counterpart, including proper indication of which is the default. This should be used when it's possible for a flag to have a True default, either in the defaults or the custom user YAML. """ dest = name.replace("-", "_") if no_help is None: no_help = f"Do not {help[0].lower()}{help[1:]}" parser.set_defaults(**{dest: default}) default_true = " (default)" if default else "" default_false = " (default)" if not default else "" parser.add_argument( f"--{name}", action="store_true", help=f"{help}{default_true}", ) parser.add_argument( f"--no-{name}", action="store_false", dest=dest, help=f"{no_help}{default_false}", ) def add_primary_argument(self, name, parser): """ Create a positional argument which acts as an alias for --`name`. """ parser.add_argument( name, help=f"If present, sets the --{name} argument", nargs="?", action=StoreIfNotEmpty, ) class MetaDataMixin(object): @staticmethod def _prettify_boolean(boolean): checkmark = "\u2714" x = "\u2718" if boolean: return colourise(checkmark, "green") return colourise(x, "red") @staticmethod def _prettify_time(dtime): if isinstance(dtime, datetime): return "{} UTC".format(dtime.isoformat().replace("T", " ")) return str(dtime) @staticmethod def _render_line(header, value): print("{} {}".format(colourise("{:25}".format(header), "bold"), value)) class Factory(object): NAME = None @classmethod def build(cls, *args, **kwargs): return object() @classmethod def get_name(cls): return _get_command_name(cls) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/configure.py000066400000000000000000000126771437041663000242720ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import functools import os from ..exceptions import RipeAtlasToolsException from ..settings import Configuration, conf from .base import Command as BaseCommand class Command(BaseCommand): NAME = "configure" EDITOR = os.environ.get("EDITOR", "/usr/bin/vim") DESCRIPTION = "Adjust or initialize configuration options" EXTRA_DESCRIPTION = ( "As an alternative to this command, you can just create/edit {}".format( Configuration.USER_RC ) ) def add_arguments(self): self.parser.add_argument( "--editor", action="store_true", help="Invoke {0} to edit the configuration directly".format(self.EDITOR), ) self.parser.add_argument( "--set", action="store", help="Permanently set a configuration value so it can be used in " "the future. Example: --set authorisation.create=MY_API_KEY", ) self.parser.add_argument( "--init", action="store_true", help="Create a configuration file and save it into your home " "directory at: {}".format(Configuration.USER_RC), ) def run(self): if not self.arguments.init: if not self.arguments.editor: if not self.arguments.set: self.ok("Effective configuration options:") self.print(self.get_existing_config()) return self.ok("Call configure --help for more information") self._create_if_necessary() if self.arguments.editor: os.system("{0} {1}".format(self.EDITOR, Configuration.USER_RC)) if self.arguments.init or self.arguments.editor: return self.ok( "Configuration file writen to {}".format(Configuration.USER_RC) ) if self.arguments.set: if "=" not in self.arguments.set: raise RipeAtlasToolsException( "Invalid format. Execute with --help for more information." ) path, value = self.arguments.set.split("=") self.set(path.split("."), value) def get_existing_config(self, c=conf, parts=[]): s = "" for key in c: full_key = parts + [key] val = c[key] if isinstance(val, dict): s += self.get_existing_config(val, full_key) else: s += f'{".".join(full_key)} = {val!r}\n' return s def set(self, path, value): if path[:2] == ["authorisation", "fetch_aliases"]: if len(path) > 3: raise RipeAtlasToolsException( "Invalid alias for a fetch API key: it must be in the " "format authorisation.fetch.some-alias=MY_API_KEY" ) if "fetch_aliases" not in conf["authorisation"]: conf["authorisation"]["fetch_aliases"] = {} if conf["authorisation"]["fetch_aliases"] is None: conf["authorisation"]["fetch_aliases"] = {} alias = path[2] if alias not in conf["authorisation"]["fetch_aliases"]: conf["authorisation"]["fetch_aliases"][alias] = None required_type = str else: try: required_type = type(self._get_from_dict(conf, path)) except KeyError: raise RipeAtlasToolsException( 'Invalid configuration key: "{}"'.format(".".join(path)) ) if value.isdigit(): value = int(value) if not isinstance(value, required_type): raise RipeAtlasToolsException( 'Invalid configuration value: "{}". You must supply a {} for ' "this key".format(value, required_type.__name__) ) self._set_in_dict(conf, path, value) Configuration.write(conf) @staticmethod def _create_if_necessary(): if os.path.exists(Configuration.USER_RC): return if not os.path.exists(Configuration.USER_CONFIG_DIR): os.makedirs(Configuration.USER_CONFIG_DIR) Configuration.write(conf) @staticmethod def _get_from_dict(data, path): return functools.reduce(lambda d, k: d[k], path, data) @classmethod def _set_in_dict(cls, data, path, value): cls._get_from_dict(data, path[:-1])[path[-1]] = value @staticmethod def cast_value(value): # Booleans are a pain in the ass to cast if value.lower() == "true": return True if value.lower() == "false": return False try: return int(value) except ValueError: try: return float(value) except ValueError: return str(value) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/go.py000066400000000000000000000026661437041663000227130ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import webbrowser from .base import Command as BaseCommand from ..helpers.validators import ArgumentType class Command(BaseCommand): NAME = "go" DESCRIPTION = "Visit the web page for a specific measurement" URL = "https://atlas.ripe.net/measurements/{0}/" def add_arguments(self): self.parser.add_argument( "measurement_id", type=ArgumentType.msm_id_or_name(), help="The measurement id or alias you want reported", ) def run(self): url = self.URL.format(self.arguments.measurement_id) if not webbrowser.open(url): self.ok( "It looks like your system doesn't have a web browser " "available. You'll have to go there manually: {0}".format(url) ) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/000077500000000000000000000000001437041663000233635ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/__init__.py000066400000000000000000000052461437041663000255030ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...exceptions import RipeAtlasToolsException from ..base import Factory as BaseFactory from .ping import PingMeasureCommand from .traceroute import TracerouteMeasureCommand from .dns import DnsMeasureCommand from .sslcert import SslcertMeasureCommand from .http import HttpMeasureCommand from .ntp import NtpMeasureCommand from .spec import SpecMeasureCommand class Factory(BaseFactory): TYPES = { "ping": PingMeasureCommand, "traceroute": TracerouteMeasureCommand, "dns": DnsMeasureCommand, "sslcert": SslcertMeasureCommand, "http": HttpMeasureCommand, "ntp": NtpMeasureCommand, "spec": SpecMeasureCommand, } DESCRIPTION = "Create a measurement and wait for the results" def __init__(self, sys_args): self.build_class = None self.sys_args = sys_args if len(self.sys_args) >= 2: self.build_class = self.TYPES.get(self.sys_args[1].lower()) if not self.build_class: self.raise_log() def raise_log(self): """Depending on the input raise with different log message.""" # cases: 1) ripe-atlas measure 2) ripe-atlas measure --help/-h if len(self.sys_args) == 1 or ( len(self.sys_args) == 2 and self.sys_args[1] in ("--help", "-h") ): log = "Usage: ripe-atlas measure [arguments]\n\n" "Types:\n" for type_name, type_ in sorted(self.TYPES.items()): log += f"\t{type_name:<12} {type_.DESCRIPTION}\n" log += ( "\nFor extended options for a specific measurement type, " "try ripe-atlas measure --help." ) # cases: ripe-atlas measure bla else: log = ( "The measurement type you requested is invalid. " "Please choose one of {}." ).format(", ".join(self.TYPES.keys())) raise RipeAtlasToolsException(log) def create(self, *args, **kwargs): return self.build_class(*args, **kwargs) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/base.py000066400000000000000000000432051437041663000246530ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import json import os import re import webbrowser from collections import OrderedDict from ripe.atlas.cousteau import ( Ping, Traceroute, Dns, Sslcert, Http, Ntp, AtlasSource, AtlasCreateRequest, ) from ripe.atlas.cousteau.measurement import AtlasMeasurement from ...exceptions import RipeAtlasToolsException from ...helpers.colours import colourise from ...helpers.validators import ArgumentType from ...renderers import Renderer from ...settings import conf, aliases, AliasesDB from ...streaming import Stream from ..base import Command as BaseCommand class Command(BaseCommand): NAME = "measure" DESCRIPTION = "Create a measurement and optionally wait for the results" CREATION_CLASSES = OrderedDict( ( ("ping", Ping), ("traceroute", Traceroute), ("dns", Dns), ("sslcert", Sslcert), ("http", Http), ("ntp", Ntp), ("spec", AtlasMeasurement), ) ) def __init__(self, *args, **kwargs): self._type = None self._is_oneoff = True BaseCommand.__init__(self, *args, **kwargs) def _modify_parser_args(self, args): kinds = self.CREATION_CLASSES.keys() error = ( "Usage: ripe-atlas measure <{}> [options]\n" "\n" " Example: ripe-atlas measure ping --target example.com" "".format("|".join(kinds)) ) if not args: raise RipeAtlasToolsException(error) if args[0] not in self.CREATION_CLASSES.keys(): raise RipeAtlasToolsException(error) self._type = args.pop(0) if not args: args.append("--help") return BaseCommand._modify_parser_args(self, args) def add_arguments(self): self.parser.add_argument( "--renderer", choices=Renderer.get_available(), help="The renderer you want to use. If this isn't defined, an " "appropriate renderer will be selected.", ) self.parser.add_argument( "--dry-run", action="store_true", help="Do not create the measurement, only show its definition.", ) # Standard for all types self.parser.add_argument( "--auth", type=str, default=os.getenv("ATLAS_CREATE_KEY", conf["authorisation"]["create"]), help="The API key you want to use to create the measurement. " "(Can be defined with `ripe-atlas configure --set authorisation.create` " "or the ATLAS_CREATE_KEY environment variable)", ) self.parser.add_argument( "--af", type=int, choices=(4, 6), help="The address family, either 4 or 6", ) self.parser.add_argument( "--description", type=str, default=conf["specification"]["description"], help="A free-form description", ) self.parser.add_argument( # Most types "--target", type=ArgumentType.ip_or_domain, help="The target, either a domain name or IP address. If creating " "a DNS measurement, the absence of this option will imply " "that you wish to use the probe's resolver.", ) self.parser.add_argument( "--no-report", action="store_true", help="Don't wait for a response from the measurement, just return " "the URL at which you can later get information about the " "measurement.", ) self.parser.add_argument( "--go-web", action="store_true", help="Open the measurement in a webbrowser immediately.", ) self.parser.add_argument( "--set-alias", help="After creating the measurement, register an alias for it.", type=ArgumentType.alias_is_valid, metavar="ALIAS", ) self.parser.add_argument( "--interval", type=int, help="Rather than run this measurement as a one-off (the default), " "create this measurement as a recurring one, with an interval " "of n seconds between attempted measurements. This option " "implies --no-report.", ) origins = self.parser.add_mutually_exclusive_group() origins.add_argument( "--from-area", type=str, choices=( "WW", "West", "North-Central", "South-Central", "North-East", "South-East", ), help="The area from which you'd like to select your probes.", ) origins.add_argument( "--from-country", type=ArgumentType.country_code, metavar="COUNTRY", help="The two-letter ISO code for the country from which you'd " "like to select your probes. Example: --from-country=GR", ) origins.add_argument( "--from-prefix", type=str, metavar="PREFIX", help="The prefix from which you'd like to select your probes. " "Example: --from-prefix=82.92.0.0/14", ) origins.add_argument( "--from-asn", # http://www.iana.org/assignments/as-numbers/as-numbers.xhtml type=ArgumentType.integer_range(1, 2**32 - 2), metavar="ASN", help="The ASN from which you'd like to select your probes. " "Example: --from-asn=3333", ) origins.add_argument( "--from-probes", type=ArgumentType.comma_separated_integers(minimum=1), metavar="PROBES", help="A comma-separated list of probe-ids you want to use in your " "measurement. Example: --from-probes=1,2,34,157,10006", ) origins.add_argument( "--from-measurement", type=ArgumentType.integer_range(minimum=1), metavar="MEASUREMENT_ID", help="A measurement id which you want to use as the basis for " "probe selection in your new measurement. This is a handy " "way to re-create a measurement under conditions similar to " "another measurement. Example: --from-measurement=1000192", ) self.parser.add_argument( "--probes", type=ArgumentType.integer_range(minimum=1), default=None, help="The number of probes you want to use. Defaults to {}," "unless --from-probes is invoked, in which case the number of " "probes selected is used.".format( conf["specification"]["source"]["requested"] ), ) self.parser.add_argument( "--include-tag", type=ArgumentType.tag, action="append", metavar="TAG", help="Include only probes that are marked with these tags. " "Example: --include-tag=system-ipv6-works", ) self.parser.add_argument( "--exclude-tag", type=ArgumentType.tag, action="append", metavar="TAG", help="Exclude probes that are marked with these tags. " "Example: --exclude-tag=system-ipv6-works", ) self.parser.add_argument( "--group-id", type=int, help="Add newly created measurement to a group that you own", ) # Validation is too complex because it's based on the interval, so # we just accept the round-trip for server-side validation self.parser.add_argument( "--spread", type=int, default=conf["specification"]["spread"], help="Specify the spread of probes within a single measurement interval", ) self.add_flag( parser=self.parser, name="resolve-on-probe", default=conf["specification"]["resolve_on_probe"], help="Resolve the target on each probe instead of once by the server", no_help="Resolve the target once on the server instead of on each probe", ) self.parser.add_argument( "--measurement-tags", help="Comma-separated list of tags to apply to the new measurement", ) self.parser.add_argument( "--stream-limit", type=int, help="The maximum number of results you want to stream, " "defaults to number of requested probes", ) self.parser.add_argument( "--stream-timeout", type=float, default=300, help="Stop streaming new measurements after this number of seconds", ) Renderer.add_arguments_for_available_renderers(self.parser) def run(self): self._account_for_selected_probes() if self.arguments.dry_run: return self.dry_run() is_success, response = self.create() if not is_success: self._handle_api_error(response) # Raises an exception pk = response["measurements"][0] url = "{0}/measurements/{1}/".format(conf["website-url"], pk) self.ok( f"Looking good! Measurement {pk} was created and details about " f"it can be found here:\n\n {url}" ) if self.arguments.go_web: self.ok("Opening the url in the browser\n\n ") if not webbrowser.open(url): self.ok( "It looks like your system doesn't have a web browser " "available. You'll have to go there manually: {0}".format(url) ) if self.arguments.set_alias: alias = self.arguments.set_alias aliases["measurement"][alias] = pk AliasesDB.write(aliases) if not self.arguments.no_report: self.stream(pk, url) def dry_run(self): print(colourise("\nDefinitions:\n{}".format("=" * 80), "bold")) for param, val in self._get_measurement_kwargs().items(): print(colourise("{:<25} {}".format(param, val), "cyan")) print(colourise("\nSources:\n{}".format("=" * 80), "bold")) for param, val in self._get_source_kwargs().items(): if param == "tags": print( colourise( "tags\n include{}{}\n exclude{}{}\n".format( " " * 17, ", ".join(val["include"]), " " * 17, ", ".join(val["exclude"]), ), "cyan", ) ) continue print(colourise("{:<25} {}".format(param, val), "cyan")) def create(self): creation_class = self.CREATION_CLASSES[self._type] return AtlasCreateRequest( server=conf["api-server"], key=self.arguments.auth, user_agent=self.user_agent, measurements=[creation_class(**self._get_measurement_kwargs())], sources=[AtlasSource(**self._get_source_kwargs())], is_oneoff=self._is_oneoff, ).create() def stream(self, pk, url): self.ok("Connecting to stream...") capture_limit = self.arguments.stream_limit or self.arguments.probes stream = Stream( pk, capture_limit=capture_limit, timeout=self.arguments.stream_timeout ) renderer = Renderer.get_renderer(name=self.arguments.renderer, kind=self._type)( arguments=self.arguments ) renderer.render(stream) self.ok("Disconnected from stream") def clean_target(self): if not self.arguments.target: raise RipeAtlasToolsException( "You must specify a target for that kind of measurement" ) return self.arguments.target def clean_description(self): if self.arguments.description: return self.arguments.description if conf["specification"]["description"]: return conf["specification"]["description"] return "{} measurement to {}".format( self._type.capitalize(), self.arguments.target ) def _get_measurement_kwargs(self): # This is kept apart from the r = {} because dns measurements don't # require a target attribute target = self.clean_target() r = { "af": self._get_af(), "description": self.clean_description(), } spec = conf["specification"] # Shorter names are easier to read if self.arguments.interval or spec["times"]["interval"]: r["interval"] = self.arguments.interval self._is_oneoff = False self.arguments.no_report = True elif not spec["times"]["one-off"]: raise RipeAtlasToolsException( "Your configuration file appears to be setup to not create " "one-offs, but also offers no interval value. Without one of " "these, a measurement cannot be created." ) if self.arguments.measurement_tags: tags = self.arguments.measurement_tags.split(",") r["tags"] = tags if target: r["target"] = target if self.arguments.group_id: r["group_id"] = self.arguments.group_id if self.arguments.spread is not None: r["spread"] = self.arguments.spread if self.arguments.resolve_on_probe is not None: r["resolve_on_probe"] = self.arguments.resolve_on_probe return r def _get_source_kwargs(self): r = conf["specification"]["source"] r["requested"] = self.arguments.probes if self.arguments.from_country: r["type"] = "country" r["value"] = self.arguments.from_country elif self.arguments.from_area: r["type"] = "area" r["value"] = self.arguments.from_area elif self.arguments.from_prefix: r["type"] = "prefix" r["value"] = self.arguments.from_prefix elif self.arguments.from_asn: r["type"] = "asn" r["value"] = self.arguments.from_asn elif self.arguments.from_probes: r["type"] = "probes" r["value"] = ",".join([str(_) for _ in self.arguments.from_probes]) elif self.arguments.from_measurement: r["type"] = "msm" r["value"] = self.arguments.from_measurement r["tags"] = { "include": self.arguments.include_tag or [], "exclude": self.arguments.exclude_tag or [], } af = "ipv{}".format(self._get_af()) kind = self._type spec = conf["specification"] for clude in ("in", "ex"): clude += "clude" if not r["tags"][clude]: r["tags"][clude] += spec["tags"][af][kind][clude] r["tags"][clude] += spec["tags"][af]["all"][clude] return r def _get_af(self): """ Returns the specified af, or a guessed one, or the configured one. In that order. """ if self.arguments.af: return self.arguments.af if self.arguments.target: if ":" in self.arguments.target: return 6 if re.match(r"^\d+\.\d+\.\d+\.\d+$", self.arguments.target): return 4 return conf["specification"]["af"] def _account_for_selected_probes(self): """ If the user has used --from-probes, there's a little extra magic we need to do. """ # We can't use argparse's mutually_exclusive_group() method here because # that library doesn't allow partial overlap. if self.arguments.from_probes and self.arguments.probes: raise RipeAtlasToolsException( "Explicit probe selection (--from-probes) in incompatible with " "a --probes argument." ) configured = conf["specification"]["source"]["requested"] if not self.arguments.probes: self.arguments.probes = configured if self.arguments.from_probes: self.arguments.probes = len(self.arguments.from_probes) @staticmethod def _handle_api_error(response): message = "There was a problem communicating with the RIPE Atlas API." if isinstance(response, dict): if response.get("error", {}).get("status") == 403: message += ( "\n\nThe status is 403 so you probably need an API key.\n\n" "Go to https://atlas.ripe.net/keys/ and create a key with the " "permission 'Create a new user defined measurement' and install " "using:\n\n" " ripe-atlas configure --set authorisation.create=MY_API_KEY\n" ) message += f"\n\n{json.dumps(response, indent=2)}" raise RipeAtlasToolsException(message) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/dns.py000066400000000000000000000136351437041663000245310ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.sagan.dns import Message from ...exceptions import RipeAtlasToolsException from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class DnsMeasureCommand(Command): DESCRIPTION = "Create a DNS measurement and wait for the results" def _upper_str(self, s): """ Private method to validate specific command line arguments that should be provided in upper or lower case :param s: string :return: string in upper case """ return s.upper() def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="query_argument", parser=self.parser) specific = self.parser.add_argument_group("DNS-specific Options") specific.add_argument( "--protocol", type=self._upper_str, choices=("UDP", "TCP"), default=conf["specification"]["types"]["dns"]["protocol"], help="The protocol used.", ) specific.add_argument( "--query-class", type=self._upper_str, choices=("IN", "CHAOS"), default=conf["specification"]["types"]["dns"]["query-class"], help='The query class. The default is "{}"'.format( conf["specification"]["types"]["dns"]["query-class"] ), ) specific.add_argument( "--query-type", type=self._upper_str, choices=list(Message.ANSWER_CLASSES.keys()) + ["ANY"], # The only ones we can parse default=conf["specification"]["types"]["dns"]["query-type"], help='The query type. The default is "{}"'.format( conf["specification"]["types"]["dns"]["query-type"] ), ) specific.add_argument( "--query-argument", type=str, default=conf["specification"]["types"]["dns"]["query-argument"], help="The DNS label to query", ) self.add_flag( parser=specific, name="set-cd-bit", help="Set DNSSEC Checking Disabled flag (RFC4035)", default=conf["specification"]["types"]["dns"]["set-cd-bit"], ) self.add_flag( parser=specific, name="set-do-bit", help="Set DNSSEC OK flag (RFC3225)", default=conf["specification"]["types"]["dns"]["set-do-bit"], ) self.add_flag( parser=specific, name="set-nsid-bit", help="Set Name Server Identifier flag (RFC5001)", default=conf["specification"]["types"]["dns"]["set-nsid-bit"], ) self.add_flag( parser=specific, name="set-rd-bit", help="Set Recursion Desired flag (RFC1035)", default=conf["specification"]["types"]["dns"]["set-rd-bit"], ) specific.add_argument( "--retry", type=ArgumentType.integer_range(minimum=0, maximum=10), default=conf["specification"]["types"]["dns"]["retry"], help="Number of times to retry", ) specific.add_argument( "--udp-payload-size", type=ArgumentType.integer_range(minimum=512, maximum=4096), default=conf["specification"]["types"]["dns"]["udp-payload-size"], help="May be any integer between 512 and 4096 inclusive", ) specific.add_argument( "--timeout", default=conf["specification"]["types"]["dns"]["timeout"], type=ArgumentType.integer_range(minimum=100, maximum=30000), help="Per packet timeout in milliseconds", ) self.add_flag( parser=specific, name="tls", help="Send query using DNS-over-TLS", default=conf["specification"]["types"]["dns"]["tls"], ) def clean_target(self): """ Targets aren't required for this type """ return self.arguments.target def clean_description(self): if self.arguments.target: return Command.clean_description(self) return "DNS measurement for {}".format(self.arguments.query_argument) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) for opt in ("class", "type", "argument"): if not getattr(self.arguments, "query_{0}".format(opt)): raise RipeAtlasToolsException( "At a minimum, DNS measurements require a query argument." ) r["query_class"] = self.arguments.query_class r["query_type"] = self.arguments.query_type r["query_argument"] = self.arguments.query_argument r["set_cd_bit"] = self.arguments.set_cd_bit r["set_do_bit"] = self.arguments.set_do_bit r["set_rd_bit"] = self.arguments.set_rd_bit r["set_nsid_bit"] = self.arguments.set_nsid_bit r["protocol"] = self.arguments.protocol r["retry"] = self.arguments.retry r["udp_payload_size"] = self.arguments.udp_payload_size r["use_probe_resolver"] = "target" not in r r["tls"] = self.arguments.tls if self.arguments.timeout is not None: r["timeout"] = self.arguments.timeout return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/http.py000066400000000000000000000070761437041663000247260ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class HttpMeasureCommand(Command): DESCRIPTION = "Create an HTTP measurement and wait for the results" def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="target", parser=self.parser) spec = conf["specification"]["types"]["http"] specific = self.parser.add_argument_group("HTTP-specific Options") specific.add_argument( "--header-bytes", type=ArgumentType.integer_range(minimum=0, maximum=2048), default=spec["header-bytes"], help="The maximum number of bytes to retrieve from the header", ) specific.add_argument( "--version", type=str, default=spec["version"], help="The HTTP version to use", ) specific.add_argument( "--method", type=str, default=spec["method"], help="The HTTP method to use" ) specific.add_argument( "--port", type=ArgumentType.integer_range(minimum=1, maximum=65535), default=spec["port"], help="Destination port", ) specific.add_argument("--path", type=str, default=spec["path"], help="") specific.add_argument( "--query-string", type=str, default=spec["query-string"], help="" ) specific.add_argument( "--user-agent", type=str, default=spec["user-agent"], help="The user agent used when performing the request", ) specific.add_argument( "--body-bytes", type=ArgumentType.integer_range(minimum=1, maximum=1020048), default=spec["body-bytes"], help="The maximum number of bytes to retrieve from the body", ) specific.add_argument( "--timing-verbosity", type=int, choices=(0, 1, 2), default=spec["timing-verbosity"], help="The amount of timing information you want returned. 1 " "returns the time to read, to connect, and to first byte, 2 " "returns timing information per read system call. 0 " "(default) returns no additional timing information.", ) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) keys = ( "header_bytes", "version", "method", "port", "path", "query_string", "user_agent", ) for key in keys: r[key] = getattr(self.arguments, key) if self.arguments.timing_verbosity > 0: r["extended_timing"] = True if self.arguments.timing_verbosity > 1: r["more_extended_timing"] = True r["max_bytes_read"] = self.arguments.body_bytes return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/ntp.py000066400000000000000000000033641437041663000245440ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class NtpMeasureCommand(Command): DESCRIPTION = "Create an NTP measurement and wait for the results" def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="target", parser=self.parser) spec = conf["specification"]["types"]["ntp"] specific = self.parser.add_argument_group("NTP-specific Options") specific.add_argument( "--packets", type=ArgumentType.integer_range(minimum=1, maximum=16), default=spec["packets"], help="The number of packets sent", ) specific.add_argument( "--timeout", type=ArgumentType.integer_range(minimum=1, maximum=60000), default=spec["timeout"], help="The timeout per-packet", ) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) r["packets"] = self.arguments.packets r["timeout"] = self.arguments.timeout return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/ping.py000066400000000000000000000044301437041663000246730ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class PingMeasureCommand(Command): DESCRIPTION = "Create a ping measurement and wait for the results" def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="target", parser=self.parser) spec = conf["specification"]["types"]["ping"] specific = self.parser.add_argument_group("Ping-specific Options") specific.add_argument( "--packets", type=ArgumentType.integer_range(minimum=1, maximum=16), default=spec["packets"], help="The number of packets sent", ) specific.add_argument( "--size", type=ArgumentType.integer_range(minimum=1, maximum=2048), default=spec["size"], help="The size of packets sent", ) specific.add_argument( "--packet-interval", type=ArgumentType.integer_range(minimum=2, maximum=30000), default=spec["packet-interval"], ) self.add_flag( parser=specific, name="include-probe-id", default=spec["include_probe_id"], help="Include the ASCII-encoded probe ID in the ping packets", ) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) r["packets"] = self.arguments.packets r["packet_interval"] = self.arguments.packet_interval r["size"] = self.arguments.size if self.arguments.include_probe_id: r["include_probe_id"] = True return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/spec.py000066400000000000000000000064041437041663000246730ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import sys import json from .base import Command from ...settings import conf from ...exceptions import RipeAtlasToolsException class SpecMeasureCommand(Command): DESCRIPTION = "Create a measurement from a JSON spec and wait for the results" def clean_target(self): return self.arguments.target def add_arguments(self): Command.add_arguments(self) self.parser.add_argument( "json_spec", help="JSON object containing the RIPE Atlas measurement spec. " "Use @some-file.json to load the spec from a given file, or @- to load the " "spec from standard input. " "Any optional command-line arguments you specify will be merged into this " "spec.", ) self.parser.add_argument( "--type", help="The 'type' of the measurement to be added to the spec JSON", ) def _read_file(self, filename): if filename == "-": return sys.stdin.read() try: with open(filename) as f: return f.read() except FileNotFoundError: raise RipeAtlasToolsException(f"No such file: {filename}") def _clean_json_spec(self): arg = self.arguments.json_spec if arg.startswith("@"): arg = self._read_file(arg[1:]) try: spec = json.loads(arg) except ValueError: raise RipeAtlasToolsException("Spec is invalid JSON") if not isinstance(spec, dict): raise RipeAtlasToolsException("Spec should be a JSON object") return spec def _get_measurement_kwargs(self): spec = self._clean_json_spec() if self.arguments.type: self._type = spec["type"] = self.arguments.type else: self._type = spec.get("type") if not self._type: raise RipeAtlasToolsException('Spec should contain a "type"') if self._type not in conf["specification"]["types"]: raise RipeAtlasToolsException(f"Unknown measurement type: {self._type}") from_args = super()._get_measurement_kwargs() # Allow override of description or use a different default that doesn't # bother about the target if not self.arguments.description: del from_args["description"] if "description" not in spec: spec["description"] = f"{self._type.title()} measurement" # Allow override of "af" otherwise use the default if not self.arguments.af and "af" in spec: del from_args["af"] spec.update(from_args) return spec ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/sslcert.py000066400000000000000000000033571437041663000254240ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class SslcertMeasureCommand(Command): DESCRIPTION = "Create a TLS (SSL) cert measurement and wait for the results" def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="target", parser=self.parser) spec = conf["specification"]["types"]["sslcert"] specific = self.parser.add_argument_group("SSL Certificate-specific Options") specific.add_argument( "--port", type=ArgumentType.integer_range(minimum=1, maximum=65535), default=spec["port"], help="Destination port", ) specific.add_argument( "--hostname", default=spec["hostname"], type=str, help="SNI Hostname", ) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) r["port"] = self.arguments.port if self.arguments.hostname: r["hostname"] = self.arguments.hostname return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measure/traceroute.py000066400000000000000000000121051437041663000261110ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ...helpers.validators import ArgumentType from ...settings import conf from .base import Command class TracerouteMeasureCommand(Command): DESCRIPTION = "Create a traceroute measurement and wait for the results" def _upper_str(self, s): """ Private method to validate specific command line arguments that should be provided in upper or lower case :param s: string :return: string in upper case """ return s.upper() def add_arguments(self): Command.add_arguments(self) self.add_primary_argument(name="target", parser=self.parser) spec = conf["specification"]["types"]["traceroute"] specific = self.parser.add_argument_group("Traceroute-specific Options") specific.add_argument( "--packets", type=ArgumentType.integer_range(minimum=1, maximum=16), default=spec["packets"], help="The number of packets sent", ) specific.add_argument( "--size", type=ArgumentType.integer_range(minimum=0, maximum=2048), default=spec["size"], help="The size of packets sent", ) specific.add_argument( "--protocol", type=self._upper_str, choices=("ICMP", "UDP", "TCP"), default=spec["protocol"], help="The protocol used.", ) specific.add_argument( "--timeout", type=ArgumentType.integer_range(minimum=1), default=spec["timeout"], help="The timeout per-packet", ) self.add_flag( parser=specific, name="dont-fragment", default=spec["dont-fragment"], help="Disable fragmentation of outgoing packets", ) specific.add_argument( "--paris", type=ArgumentType.integer_range(minimum=0, maximum=64), default=spec["paris"], help="Use Paris. Value must be between 0 and 64." "If 0, a standard traceroute will be performed", ) specific.add_argument( "--first-hop", type=ArgumentType.integer_range(minimum=1, maximum=255), default=spec["first-hop"], help="Value must be between 1 and 255", ) specific.add_argument( "--max-hops", type=ArgumentType.integer_range(minimum=1, maximum=255), default=spec["max-hops"], help="Value must be between 1 and 255", ) specific.add_argument( "--port", type=ArgumentType.integer_range(minimum=1, maximum=65535), default=spec["port"], help="Destination port, valid for TCP only", ) specific.add_argument( "--destination-option-size", type=ArgumentType.integer_range(minimum=0, maximum=1024), default=spec["destination-option-size"], help="IPv6 destination option header", ) specific.add_argument( "--hop-by-hop-option-size", type=ArgumentType.integer_range(minimum=0, maximum=2048), default=spec["hop-by-hop-option-size"], help=" IPv6 hop by hop option header", ) specific.add_argument( "--duplicate-timeout", default=spec["duplicate-timeout"], type=int, help="Time to wait (in milliseconds) for a duplicate response " "after receiving the first response", ) specific.add_argument( "--response-timeout", default=spec["response-timeout"], type=ArgumentType.integer_range(minimum=1, maximum=60000), help="Response timeout for one packet", ) def _get_measurement_kwargs(self): r = Command._get_measurement_kwargs(self) keys = ( "destination_option_size", "dont_fragment", "first_hop", "hop_by_hop_option_size", "max_hops", "packets", "paris", "port", "protocol", "size", "timeout", ) for key in keys: r[key] = getattr(self.arguments, key) optional_keys = ["duplicate_timeout", "response_timeout"] for key in optional_keys: val = getattr(self.arguments, key) if val is not None: r[key] = val return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measurement_info.py000066400000000000000000000172321437041663000256410ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.cousteau import Measurement from ripe.atlas.cousteau.exceptions import APIResponseError from .base import Command as BaseCommand, MetaDataMixin from ..exceptions import RipeAtlasToolsException from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from ..helpers.validators import ArgumentType from ..settings import conf class Command(MetaDataMixin, BaseCommand): NAME = "measurement-info" DESCRIPTION = "Return the meta data for one measurement" def add_arguments(self): self.parser.add_argument( "id", type=ArgumentType.msm_id_or_name(), help="The measurement id or alias" ) def run(self): try: measurement = Measurement( server=conf["api-server"], id=self.arguments.id, user_agent=self.user_agent, ) except APIResponseError: raise RipeAtlasToolsException("That measurement does not appear to exist") self.render_basic(measurement) getattr(self, "render_{}".format(measurement.type.lower()))(measurement) @classmethod def render_basic(cls, measurement): cls._render( measurement, ( ("id", "ID"), ( "id", "URL", lambda id: colourise( f"{conf['website-url']}/measurements/id/", "cyan" ), ), ("type", "Type", cls._prettify_type), ("status", "Status"), ("description", "Description", sanitise), ("af", "Address Family"), ("is_public", "Public?", cls._prettify_boolean), ("is_oneoff", "One-off?", cls._prettify_boolean), ("target", "Target Name", sanitise), ("target_address", "Target Address", sanitise), ("target_asn", "Target ASN"), ("interval", "Interval"), ("spread", "Spread"), ("creation_time", "Created", cls._prettify_time), ("start_time", "Started", cls._prettify_time), ("stop_time", "Stopped", cls._prettify_time), ("probes_requested", "Probes Requested"), ("probes_scheduled", "Probes Scheduled"), ("probes_currently_involved", "Probes Involved"), ("participant_count", "Participant Count"), ("is_all_scheduled", "Fully Scheduled?", cls._prettify_boolean), ("resolved_ips", "Resolved IPs", lambda _: ", ".join(_)), ("resolve_on_probe", "Resolve on the Probe", cls._prettify_boolean), ), ) @classmethod def render_ping(cls, measurement): cls._render( measurement, ( ("packets", "Packets"), ("size", "Size"), ), ) @classmethod def render_traceroute(cls, measurement): cls._render( measurement, ( ("packets", "Packets"), ("protocol", "Protocol"), ("dont_fragment", "Don't Fragment", cls._prettify_boolean), ("paris", "Paris"), ("first_hop", "First Hop"), ("max_hops", "Maximum Hops"), ("timeout", "Timeout"), ("size", "Size"), ("destination_option_size", "Destination Option Size"), ("hop_by_hop_option_size", "Hop-by-hop Option Size"), ("gap_limit", "Gap Limit"), ), ) @classmethod def render_dns(cls, measurement): cls._render( measurement, ( ("query", "Query", cls._prettify_query), ("retry", "Retry Times"), ("include_qbuf", "Include the Qbuf?", cls._prettify_boolean), ("include_abuf", "Include the Abuf?", cls._prettify_boolean), ("protocol", "Protocol"), ("prepend_probe_id", "Prepend the Probe ID?"), ("udp_payload_size", "UDP Payload Size"), ( "use_probe_resolver", "Use the Probe's Resolver?", cls._prettify_boolean, ), ("set_do_bit", "Set the DO Bit?", cls._prettify_boolean), ("set_nsid_bit", "Set the NSID Bit?", cls._prettify_boolean), ("set_rd_bit", "Set the RD Bit?", cls._prettify_boolean), ("set_cd_bit", "Set the CD Bit?", cls._prettify_boolean), ), ) @classmethod def render_sslcert(cls, measurement): cls._render(measurement, (("port", "Port"),)) @classmethod def render_http(cls, measurement): cls._render( measurement, ( ("header_bytes", "Header Bytes"), ("version", "Version"), ("method", "Method"), ("port", "Port"), ("path", "Path", sanitise), ("query_string", "Query String", sanitise), ("user_agent", "User-Agent"), ("max_bytes_read", "Body Bytes"), ), ) timing_verbosity = 0 if "extended_timing" in measurement.meta_data: if measurement.meta_data["extended_timing"]: timing_verbosity = 1 if "more_extended_timing" in measurement.meta_data: if measurement.meta_data["more_extended_timing"]: timing_verbosity = 2 cls._render_line("Timing Verbosity", timing_verbosity) @classmethod def render_ntp(cls, measurement): cls._render( measurement, ( ("packets", "Packets"), ("timeout", "Timeout"), ), ) @staticmethod def _prettify_type(kind): types = { "ping": "Ping", "traceroute": "Traceroute", "dns": "DNS", "sslcert": "SSL Certificate", "http": "HTTP", "ntp": "NTP", } if kind in types: return colourise(colourise(types[kind], "bold"), "blue") return colourise("Unknown", "red") @staticmethod def _prettify_query(query): return sanitise( "{} {} {}".format(query["class"], query["type"], query["value"]) ) @classmethod def _render(cls, measurement, keys): for prop in keys: value = cls._get_measurement_property(measurement, prop[0]) if value != "-" and len(prop) == 3: value = prop[2](value) cls._render_line(prop[1], value) @classmethod def _get_measurement_property(cls, measurement, property_name): value = getattr(measurement, property_name, None) if value is None and property_name in measurement.meta_data: value = measurement.meta_data[property_name] if value is None: value = "-" return value ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/measurement_search.py000066400000000000000000000153711437041663000261550ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import itertools from typing import Dict from ripe.atlas.cousteau import MeasurementRequest from ..helpers import tabular from ..helpers.sanitisers import sanitise from ..helpers.validators import ArgumentType from ..settings import conf from .base import Command as BaseCommand class Command(BaseCommand): NAME = "measurement-search" LIMITS = (1, 10000) MAX_PAGE_SIZE = 500 # Request chunks of this size or smaller STATUS_SPECIFIED = 0 STATUS_SCHEDULED = 1 STATUS_ONGOING = 2 STATUS_STOPPED = 4 STATUS_FORCED_STOP = 5 STATUS_NO_SUITABLE_PROBES = 6 STATUS_FAILED = 7 STATUSES = { "scheduled": ( STATUS_SPECIFIED, STATUS_SCHEDULED, ), "ongoing": (STATUS_ONGOING,), "stopped": ( STATUS_STOPPED, STATUS_FORCED_STOP, STATUS_NO_SUITABLE_PROBES, STATUS_FAILED, ), } COLUMNS: Dict[str, tabular.ColumnDef] = { "id": {"align": ">", "width": 7}, "type": {"align": "^", "width": 10}, "description": {"align": "^", "width": 42}, "status": {"align": "^", "width": 18}, "target": {"align": ">", "width": 45}, "url": {"align": "^", "width": 45}, } DESCRIPTION = ( "Fetch and print measurements fulfilling specified criteria based " "on given filters" ) def add_arguments(self) -> None: self.parser.add_argument( "--search", type=str, help="A search string. This could match the target or description.", ) self.parser.add_argument( "--status", type=str, choices=self.STATUSES.keys(), help="The measurement status.", ) self.parser.add_argument( "--af", type=int, choices=(4, 6), help="The address family." ) self.parser.add_argument( "--type", type=str, choices=("ping", "traceroute", "dns", "sslcert", "ntp", "http"), help="The measurement type.", ) timing = self.parser.add_argument_group("Timing") for position in ("started", "stopped"): for chrono in ("before", "after"): timing.add_argument( "--{}-{}".format(position, chrono), type=ArgumentType.datetime, help="Filter for measurements that {} {} a specific date. " "The format required is YYYY-MM-DDTHH:MM:SS".format( position, chrono ), ) self.parser.add_argument( "--limit", type=ArgumentType.integer_range(self.LIMITS[0], self.LIMITS[1]), default=50, help="The number of measurements to return. The number must be " "between {} and {}".format(self.LIMITS[0], self.LIMITS[1]), ) tabular.add_argument_group(self.parser, self.COLUMNS.keys()) def run(self) -> None: if not self.arguments.field: self.arguments.field = ["id", "type", "description", "status"] request_fields = list( set(self.arguments.field) | set(self.arguments.aggregate_by) ) if "status" not in request_fields: request_fields.append("status") filters = self._get_filters() measurements = MeasurementRequest( server=conf["api-server"], return_objects=True, user_agent=self.user_agent, fields=",".join(request_fields), page_size=min(self.MAX_PAGE_SIZE, self.arguments.limit), **filters, ) truncated_measurements = itertools.islice(measurements, self.arguments.limit) renderer = tabular.renderers[self.arguments.format] rows = [self._get_row(m) for m in truncated_measurements] for line in renderer( rows=rows, total_count=measurements.total_count, columns=dict((c, self.COLUMNS[c]) for c in self.arguments.field), filters=filters, arguments=self.arguments, ): print(line) def _get_row(self, measurement) -> tabular.RowDef: r = {} for field in self.arguments.field + self.arguments.aggregate_by: if field == "url": r["url"] = f"https://atlas.ripe.net/measurements/{measurement.id}/" elif field == "type": r["type"] = measurement.type.lower() elif field == "target": r["target"] = sanitise( measurement.target or measurement.target_ip or "-" ) elif field == "description": r["description"] = sanitise(measurement.description) or "" else: r[field] = sanitise(getattr(measurement, field)) return { "values": r, "colour": self._get_colour_from_status(measurement.status_id), } def _get_filters(self) -> Dict[str, str]: r = {} if self.arguments.search: r["search"] = self.arguments.search if self.arguments.status: r["status__in"] = self.STATUSES[self.arguments.status] if self.arguments.af: r["af"] = self.arguments.af if self.arguments.type: r["type"] = self.arguments.type if self.arguments.started_before: r["start_time__lt"] = self.arguments.started_before if self.arguments.started_after: r["start_time__gt"] = self.arguments.started_after if self.arguments.stopped_before: r["stop_time__lt"] = self.arguments.stopped_before if self.arguments.stopped_after: r["stop_time__gt"] = self.arguments.stopped_after return r def _get_colour_from_status(self, status: int) -> str: if status in self.STATUSES["ongoing"]: return "green" if status == self.STATUS_STOPPED: return "yellow" if status in self.STATUSES["stopped"]: return "red" if status in self.STATUSES["scheduled"]: return "blue" return "white" ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/probe_info.py000066400000000000000000000057361437041663000244310ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.cousteau import Probe from ripe.atlas.cousteau.exceptions import APIResponseError from .base import Command as BaseCommand, MetaDataMixin from ..exceptions import RipeAtlasToolsException from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from ..helpers.validators import ArgumentType from ..settings import conf class Command(MetaDataMixin, BaseCommand): NAME = "probe-info" DESCRIPTION = "Return the meta data for one probe" def add_arguments(self): self.parser.add_argument( "id", type=ArgumentType.probe_id_or_name(), help="The probe id or alias" ) def run(self): try: probe = Probe( server=conf["api-server"], id=self.arguments.id, user_agent=self.user_agent, ) except APIResponseError: raise RipeAtlasToolsException("That probe does not appear to exist") keys = ( ("id", "ID"), ( "id", "URL", lambda id: colourise(f"{conf['website-url']}/probes/{id}/", "cyan"), ), ("is_public", "Public?", self._prettify_boolean), ("is_anchor", "Anchor?", self._prettify_boolean), ("country_code", "Country"), ("description", "Description", sanitise), ("asn_v4", "ASN (IPv4)"), ("asn_v6", "ASN (IPv6)"), ("address_v4", "Address (IPv4)"), ("address_v6", "Address (IPv6)"), ("prefix_v4", "Prefix (IPv4)"), ("prefix_v6", "Prefix (IPv6)"), ("geometry", "Coordinates", self._prettify_coordinates), ("status", "Status"), ) for key in keys: value = getattr(probe, key[0]) if value is None: value = "-" elif len(key) == 3: value = key[2](value) self._render_line(key[1], value) print(colourise("Tags", "bold")) for tag in probe.tags: print(" {}".format(tag["slug"])) @staticmethod def _prettify_coordinates(geometry): if geometry and "coordinates" in geometry and geometry["coordinates"]: return "{},{}".format( geometry["coordinates"][1], geometry["coordinates"][0] ) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/probe_search.py000066400000000000000000000326051437041663000247360ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import itertools import sys from typing import Any, Dict, List, Mapping, Tuple import requests from ripe.atlas.cousteau import ProbeRequest from ..exceptions import RipeAtlasToolsException from ..helpers import tabular from ..helpers.sanitisers import sanitise from ..helpers.validators import ArgumentType from ..settings import conf from .base import Command as BaseCommand class Command(BaseCommand): NAME = "probe-search" MAX_PAGE_SIZE = 500 # Request chunks of this size or smaller DESCRIPTION = ( "Fetch and print probes fulfilling specified criteria based on " "given filters" ) COLUMNS: Dict[str, tabular.ColumnDef] = { "id": {"align": ">", "width": 5}, "asn_v4": {"align": ">", "width": 6}, "asn_v6": {"align": ">", "width": 6}, "country": {"align": "^", "width": 7}, "status": {"align": "^", "width": 15}, "prefix_v4": {"align": ">", "width": 18}, "prefix_v6": {"align": ">", "width": 18}, "coordinates": {"align": "^", "width": 19}, "is_public": {"align": "^", "width": 9}, "description": {"align": "^", "width": 30}, "address_v4": {"align": ">", "width": 15}, "address_v6": {"align": ">", "width": 39}, "is_anchor": {"align": "^", "width": 9}, } def add_arguments(self) -> None: """Adds all commands line arguments for this command.""" asn = self.parser.add_argument_group("ASN") asn.add_argument( "--asn", type=int, help="Probes in IPv4 or IPv6 prefixes announced by this ASN", ) asn.add_argument( "--asnv4", type=int, help="Probes in IPv4 prexfixes announced by this ASN" ) asn.add_argument( "--asnv6", type=int, help="Probes in IPv6 prefixes announced by this ASN" ) prefix = self.parser.add_argument_group("Prefix") prefix.add_argument( "--prefix", type=str, help="Probes with addresses in this IPv4 or IPv6 CIDR prefix", ) prefix.add_argument( "--prefixv4", type=str, help="Probes with addresses in this IPv4 prefix" ) prefix.add_argument( "--prefixv6", type=str, help="Probes with addresses in this IPv6 prefix" ) area = self.parser.add_argument_group("Area") geo_location = area.add_mutually_exclusive_group() geo_location.add_argument( "--location", type=str, help="The location of probes as a string i.e. 'Amsterdam'", ) geo_location.add_argument( "--center", type=str, help="Location as ,-string, i.e. '48.45,9.16'. " "Note: use --center=-5,10 (no space) to allow for negative latitudes", ) geo_location.add_argument( "--country", type=str, help="The country code of probes." ) area.add_argument( "--radius", type=int, default=15, help="Radius in km from specified center/point. Default: 15", ) self.parser.add_argument( "--tag", type=ArgumentType.tag, action="append", metavar="TAG", help="Include only probes that are marked with these tags. " "Use --tag multiple times to filter on the basis of more " "than one tag. " "Example: --tag system-ipv6-works --tag system-ipv4-works", dest="tags", ) self.parser.add_argument( "--limit", type=int, default=25, help="Return at most this number of probes. Default: 25", ) self.parser.add_argument( "--all", action="store_true", help="Fetch all probes; takes a long time!", ) self.parser.add_argument( "--status", type=int, choices=[0, 1, 2, 3], help=( "Probe's connection status [0 - Never Connected, " "1 - Connected, 2 - Disconnected, 3 - Abandoned]" ), ) self.parser.add_argument( "--auth", type=str, default=conf["authorisation"]["google_geocoding"], help=( "Google Geocoding API key to be " "used to perform --location search." ), ) tabular.add_argument_group(self.parser, self.COLUMNS.keys()) def run(self) -> None: if not self.arguments.field: self.arguments.field = [ "id", "asn_v4", "asn_v6", "country", "status", ] if self.arguments.all: self.arguments.limit = sys.maxsize filters = self._get_filters() request_fields = self._get_request_fields() probes = ProbeRequest( server=conf["api-server"], return_objects=True, user_agent=self.user_agent, fields=",".join(request_fields), page_size=min(self.MAX_PAGE_SIZE, self.arguments.limit), **filters ) truncated_probes = itertools.islice(probes, self.arguments.limit) renderer = tabular.renderers[self.arguments.format] rows = [self._get_row(m) for m in truncated_probes] for line in renderer( rows=rows, total_count=probes.total_count, columns=dict((c, self.COLUMNS[c]) for c in self.arguments.field), filters=filters, arguments=self.arguments, ): print(line) def _get_filters(self) -> Dict[str, str]: """ Get the request filters for sending to the API. """ if self.arguments.all: return {} args: Dict[str, Any] = {} if any([self.arguments.asn, self.arguments.asnv4, self.arguments.asnv6]): args.update(self._clean_asn()) if any( [ self.arguments.prefix, self.arguments.prefixv4, self.arguments.prefixv6, ] ): args.update(self._clean_prefix()) if self.arguments.location: args.update(self._clean_location()) if self.arguments.center: args.update(self._clean_center()) if self.arguments.country: args.update(self._clean_country_code()) if self.arguments.status is not None: args.update({"status": self.arguments.status}) if self.arguments.tags: args.update({"tags": ",".join(self.arguments.tags)}) return args def _clean_asn(self) -> Mapping[str, int]: """Make sure ASN arguments don't conflict and make sense.""" asn = self.arguments.asn asnv4 = self.arguments.asnv4 asnv6 = self.arguments.asnv6 if asn and (asnv4 or asnv6): exc_log = ( "Specifying argument --asn together with --asnv4/--asnv6 " "doesn't make sense" ) raise RipeAtlasToolsException(exc_log) if asn: return {"asn": asn} asn_args = {} if asnv4: asn_args["asn_v4"] = asnv4 if asnv6: asn_args["asn_v6"] = asnv6 return asn_args def _clean_prefix(self) -> Dict[str, str]: """Make sure ASN arguments don't conflict and make sense.""" prefix = self.arguments.prefix prefixv4 = self.arguments.prefixv4 prefixv6 = self.arguments.prefixv6 if prefix and (prefixv4 or prefixv6): exc_log = ( "Specifying argument --prefix together with " "--prefixv4/--prefixv6 doesn't make sense" ) raise RipeAtlasToolsException(exc_log) if prefix: return {"prefix": prefix} prefix_args = {} if prefixv4: prefix_args["prefix_v4"] = prefixv4 if prefixv6: prefix_args["prefix_v6"] = prefixv6 return prefix_args def _clean_location(self) -> Dict[str, Any]: """Make sure location argument are sane.""" if not self.arguments.auth: raise RipeAtlasToolsException( "--location requires a Google Geocoding API key specified with " "--auth or configure command (authorisation.google_geocoding)" ) lat, lng = self.location2degrees() if self.arguments.radius: location_args = { "radius": "{0},{1}:{2}".format(lat, lng, self.arguments.radius) } else: location_args = {"latitude": lat, "longitude": lng} return location_args def location2degrees(self) -> Tuple[str, str]: """Fetches degrees based on the given location.""" error_log = ( "The following error occured while trying to fetch lat/lon " "for location <{}>:\n\n{}" ) google_api_url = "https://maps.googleapis.com/maps/api/geocode/json" try: result = requests.get( google_api_url, params={ "key": self.arguments.auth, "address": self.arguments.location, }, ) except ( requests.ConnectionError, requests.HTTPError, requests.Timeout, ) as e: error_log = error_log.format(self.arguments.location, e) raise RipeAtlasToolsException(error_log) data = result.json() if "error_message" in data: error = error_log.format(self.arguments.location, data["error_message"]) raise RipeAtlasToolsException(error) try: lat = data["results"][0]["geometry"]["location"]["lat"] lng = data["results"][0]["geometry"]["location"]["lng"] except (KeyError, IndexError) as e: error = error_log.format(self.arguments.location, e) raise RipeAtlasToolsException(error) return str(lat), str(lng) def _clean_center(self) -> Dict[str, Any]: """Make sure center argument are sane.""" try: lat, lng = self.arguments.center.split(",") except ValueError: raise RipeAtlasToolsException( "Point argument should be in format." ) if self.arguments.radius: center_args = { "radius": "{0},{1}:{2}".format(lat, lng, self.arguments.radius) } else: center_args = {"latitude": lat, "longitude": lng} return center_args def _clean_country_code(self) -> Dict[str, str]: """Make sure country_code argument are sane.""" return {"country_code": self.arguments.country} def _get_row(self, probe) -> tabular.RowDef: r = {} for field in self.arguments.field + self.arguments.aggregate_by: if field == "country": r[field] = (probe.country_code or "").lower() elif field in ("asn_v4", "asn_v6"): r[field] = getattr(probe, field) or None elif field == "description": description = sanitise(probe.description) or None r[field] = description elif field == "coordinates": if probe.geometry and probe.geometry["coordinates"]: lng, lat = probe.geometry["coordinates"] r[field] = "{:7.4f} {:8.4f}".format(lat, lng) else: r[field] = None elif field in ("is_public", "is_anchor"): if getattr(probe, field): r[field] = "\u2714" # Check mark else: r[field] = "\u2718" # X else: r[field] = sanitise(getattr(probe, field)) return {"values": r, "colour": self._get_colour_from_status(probe.status)} @staticmethod def _get_colour_from_status(status: str) -> str: if status == "Connected": return "green" if status == "Disconnected": return "yellow" if status == "Abandoned": return "red" return "white" def _get_request_fields(self) -> List[str]: request_fields = list(self.arguments.field) for field in self.arguments.aggregate_by: if field not in request_fields: request_fields.append(field) if "country" in request_fields: request_fields.remove("country") request_fields.append("country_code") if "status" not in request_fields: request_fields.append("status") if "coordinates" in request_fields: request_fields.remove("coordinates") request_fields.append("geometry") return request_fields ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/report.py000066400000000000000000000235521437041663000236160ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import os import sys try: import ujson as json except ImportError: import json import itertools from ripe.atlas.sagan import Result from ripe.atlas.cousteau import AtlasLatestRequest, AtlasResultsRequest from ..aggregators import RangeKeyAggregator, ValueKeyAggregator, aggregate from ..exceptions import RipeAtlasToolsException from ..helpers.validators import ArgumentType from ..renderers import Renderer from .base import Command as BaseCommand from ..filters import SaganSet, FilterFactory, filter_results from ..settings import conf class Command(BaseCommand): NAME = "report" DESCRIPTION = ( "Report the results of an existing measurement from the API, " "a file or standard input" ) EXTRA_DESCRIPTION = ( "Examples:\n" " ripe-atlas report 1001 --probes 157,10006\n" " ripe-atlas report --from-file results.json\n" " cat results.json | ripe-atlas report --aggregate-by prefix_v4\n" ) AGGREGATORS = { "country": ["probe.country_code", ValueKeyAggregator], "rtt-median": [ "rtt_median", RangeKeyAggregator, [10, 20, 30, 40, 50, 100, 200, 300], ], "status": ["probe.status", ValueKeyAggregator], "asn_v4": ["probe.asn_v4", ValueKeyAggregator], "asn_v6": ["probe.asn_v6", ValueKeyAggregator], "prefix_v4": ["probe.prefix_v4", ValueKeyAggregator], "prefix_v6": ["probe.prefix_v6", ValueKeyAggregator], } def add_arguments(self): self.parser.add_argument( "measurement_id", type=ArgumentType.msm_id_or_name(), help="The measurement ID or alias to fetch from the results API. " "(Conflicts with the --from-file option)", nargs="?", ) self.parser.add_argument( "--auth", type=str, choices=conf["authorisation"]["fetch_aliases"].keys(), help="The API key alias you want to use to fetch the measurement. " "To configure an API key alias, use " "`ripe-atlas configure --set " "authorisation.fetch_aliases.ALIAS_NAME=YOUR_KEY`. " "(Can also be passed using the ATLAS_FETCH_KEY environment variable)", ) self.parser.add_argument( "--probes", type=ArgumentType.comma_separated_integers_or_file, help="Either a comma-separated list of probe ids you want to see " "exclusively, a path to a file containing probe ids (one on " 'each line), or "-" for standard input in the same format.', ) self.parser.add_argument( "--renderer", choices=Renderer.get_available(), help="The renderer you want to use. If this isn't defined, an " "appropriate renderer will be selected.", ) self.parser.add_argument( "--aggregate-by", type=str, choices=self.AGGREGATORS.keys(), action="append", help="Tell the rendering engine to aggregate the results by the " "selected option. Note that if you opt for aggregation, no " "output will be generated until all results are received.", ) self.parser.add_argument( "--probe-asns", type=ArgumentType.comma_separated_integers( minimum=1, # http://www.iana.org/assignments/as-numbers/as-numbers.xhtml maximum=2 ** 32 - 2, ), help="A comma-separated list of probe ASNs you want to see " "exclusively.", ) self.parser.add_argument( "--start-time", type=ArgumentType.datetime, help="The start time of the report.", ) self.parser.add_argument( "--stop-time", type=ArgumentType.datetime, help="The stop time of the report.", ) self.parser.add_argument( "--from-file", type=ArgumentType.path, help="The source of the data to be rendered. " "(Conflicts with specifying measurement_id)", ) Renderer.add_arguments_for_available_renderers(self.parser) def _get_request_auth(self): if os.getenv("ATLAS_FETCH_KEY"): return os.getenv("ATLAS_FETCH_KEY") if self.arguments.auth: return conf["authorisation"]["fetch_aliases"][self.arguments.auth] else: return conf["authorisation"]["fetch"] def _get_request(self): kwargs = { "server": conf["api-server"], "msm_id": self.arguments.measurement_id, "user_agent": self.user_agent, } kwargs["key"] = self._get_request_auth() if self.arguments.probes: kwargs["probe_ids"] = self.arguments.probes if self.arguments.start_time: kwargs["start"] = self.arguments.start_time if self.arguments.stop_time: kwargs["stop"] = self.arguments.stop_time if "start" in kwargs or "stop" in kwargs: return AtlasResultsRequest(**kwargs) return AtlasLatestRequest(**kwargs) def run(self): if self.arguments.measurement_id and self.arguments.from_file: raise RipeAtlasToolsException( "You can only specify one of --from-file or " "measurement_id, not both." ) if self.arguments.measurement_id: results, sample = self._get_results_from_api(self.arguments.measurement_id) use_regular_file = False else: if self.arguments.from_file: use_regular_file = self.arguments.from_file != "-" elif sys.stdin.isatty(): self.parser.print_help() sys.exit(1) else: use_regular_file = False results, sample = self._get_results_from_file(use_regular_file) # Sagan calls measurements "ssl" when they are actually "sslcert" # so we use .raw_data once we have verified and parsed the sample. measurement_type = Result.get(sample).raw_data["type"].lower() renderer = Renderer.get_renderer(self.arguments.renderer, measurement_type)( arguments=self.arguments ) results = SaganSet( iterable=results, probes=self.arguments.probes, ) if self.arguments.probe_asns: asn_filters = set([]) for asn in self.arguments.probe_asns: asn_filters.add(FilterFactory.create("asn", asn)) results = filter_results(asn_filters, list(results)) if self.arguments.aggregate_by: results = aggregate(results, self.get_aggregators()) renderer.render(results) if use_regular_file: self.file.close() def _get_results_from_api(self, measurement_id): results = self._get_request().get()[1] if isinstance(results, list): if not results: raise RipeAtlasToolsException( "There aren't any results for your request." ) else: error = results.get("error") msg = "Error fetching measurement results" if error: msg += ": [{status} {title}] {detail}".format(**error) else: msg = "{} Error fetching measurement results".format(error) raise RipeAtlasToolsException(msg) sample = results[0] return results, sample def _get_results_from_file(self, using_regular_file): """ We need to get the first result from the source in order to detect the type. Additionally, if the source is actually one great big JSON list, then we need to parse it so we iterate over the results since there's no newline characters. """ self.file = sys.stdin if using_regular_file: self.file = open(self.arguments.from_file) # Pop the first line off the source stack. This may very well be a Very # Large String and cause a memory explosion, but we like to let our # users shoot themselves in the foot. sample = next(self.file) # Re-attach the line back onto the iterable so we don't lose anything results = itertools.chain([sample], self.file) # In the case of the Very Large String, we parse out the JSON here if sample.startswith("["): results = json.loads("".join(results)) sample = results[0] # Reassign sample to an actual result return results, sample def get_aggregators(self): """Return aggregators list based on user input""" aggregation_keys = [] for aggr_key in self.arguments.aggregate_by: # Get class and aggregator key aggregation_class = self.AGGREGATORS[aggr_key][1] key = self.AGGREGATORS[aggr_key][0] if aggr_key == "rtt-median": # Get range for the aggregation key_range = self.AGGREGATORS[aggr_key][2] aggregation_keys.append(aggregation_class(key=key, ranges=key_range)) else: aggregation_keys.append(aggregation_class(key=key)) return aggregation_keys ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/shibboleet.py000066400000000000000000000117231437041663000244200ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import random import requests from ..cache import cache from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from .base import Command as BaseCommand class Command(BaseCommand): DESCRIPTION = "https://xkcd.com/806/" HEADERS = { "Accept": "application/vnd.github.v3+json", "User-Agent": "RIPE Atlas Tools (Magellan)", } URLS = { "root": "https://api.github.com", "statistics": [ "/repos/RIPE-NCC/ripe.atlas.sagan/stats/contributors", "/repos/RIPE-NCC/ripe-atlas-cousteau/stats/contributors", "/repos/RIPE-NCC/ripe-atlas-tools/stats/contributors", ], "users": "/users", } SPACING = ( 61, 61, 61, 53, 7, 53, 6, 52, 5, 52, 49, 48, 47, 46, 47, 47, 43, 41, 38, 39, 42, 46, ) BOAT = ( "\n{}|\n{}|\n{}|\n{}|{}|\n{}|{}---\n{}---{}'-'\n{}'-' ____|_____\n{}__" "__|__/ | /\n{}/ | / | /\n{}/ |( | (\n{}( " " | \\ | \\\n{}\\ | \\____|____\\ /|\n{}/\\____|___`---.----` ." "' |\n{}.-'/ | \\ |__.--' \\\n{}.'/ ( | \\ |. " " \\\n{}_ /_/ \\ | \\ | `. \\\n{}`-.' \\.--._|.--" "-` | `-._______\\\n{}``-.-------'-------'------------/\n{}`'.______" "_________________.'\n" ).format(*[" " * _ for _ in SPACING]) WATER = "~" * 80 def __init__(self, *args, **kwargs): BaseCommand.__init__(self, *args, **kwargs) self.statistics = {} def run(self): r = ( "\nThanks for using RIPE Atlas!\n\nThis toolkit " "(Magellan) is a group effort, spearheaded by the team at the " "RIPE\nNCC, but supported by members of the community from all " "over. If you're\ncurious about who we are and what sorts of " "stuff we work on, here's a break\ndown of our contributions to " "date.\n\nName Changes URL\n{}\n" ).format("-" * 79) for contributor in self.get_contributors(): r += "{name:20} {changes:10} {url}\n".format(**contributor) print( "{}{}{}\n".format( r, colourise(self.BOAT, "bold"), colourise(self.WATER, "blue"), ) ) def get_contributors(self): cache_key = "github:statistics" self.statistics = cache.get(cache_key, {}) if not self.statistics: for url in self.URLS["statistics"]: self._update_statistics_from_url(url) cache.set(cache_key, self.statistics, 60 * 10) r = [] for k, v in self.statistics.items(): r.append( {"name": sanitise(k), "changes": v["changes"], "url": v["url"]} ) random.shuffle(r) return r def _update_statistics_from_url(self, url): response = requests.get( "{}{}".format(self.URLS["root"], url), headers=self.HEADERS ) contributors = response.json() # Sometimes, GitHub just returns nothing if not contributors: return self._update_statistics_from_url(url) for contributor in response.json(): user = self.get_user(contributor["author"]["login"]) name = user["name"] or contributor["author"]["login"] if name not in self.statistics: self.statistics[name] = { "changes": 0, "url": contributor["author"]["html_url"], } for week in contributor["weeks"]: self.statistics[name]["changes"] += week["a"] + week["d"] def get_user(self, username): cache_key = "github-user:{}".format(username) user = cache.get(cache_key) if user: return user cache.set( cache_key, requests.get( "{}{}/{}".format( self.URLS["root"], self.URLS["users"], username ), headers=self.HEADERS, ).json(), 60 * 60 * 24 * 365, ) return self.get_user(username) ripe-atlas-tools-3.1.0/ripe/atlas/tools/commands/stream.py000066400000000000000000000054071437041663000235750ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.cousteau import Measurement from ripe.atlas.cousteau.exceptions import APIResponseError from ..exceptions import RipeAtlasToolsException from ..renderers import Renderer from ..streaming import Stream from .base import Command as BaseCommand from ..helpers.validators import ArgumentType class Command(BaseCommand): NAME = "stream" DESCRIPTION = "Output the results of a public measurement as they become available" EXTRA_DESCRIPTION = "Streaming of non-public measurements is not supported." URLS = { "detail": "/api/v2/measurements/{0}.json", } def add_arguments(self): self.parser.add_argument( "measurement_id", type=ArgumentType.msm_id_or_name(), help="The measurement id or alias you want streamed", ) self.parser.add_argument( "--limit", type=int, help="The maximum number of results you want to stream", ) self.parser.add_argument( "--renderer", choices=Renderer.get_available(), help="The renderer you want to use. If this isn't defined, an " "appropriate renderer will be selected.", ) self.parser.add_argument( "--timeout", type=float, help="Stop streaming after this number of seconds", ) Renderer.add_arguments_for_available_renderers(self.parser) def run(self): try: measurement = Measurement( id=self.arguments.measurement_id, user_agent=self.user_agent, ) except APIResponseError as e: raise RipeAtlasToolsException(e.args[0]) self.ok("Connecting to stream...") stream = Stream( self.arguments.measurement_id, capture_limit=self.arguments.limit, timeout=self.arguments.timeout, ) renderer = Renderer.get_renderer( name=self.arguments.renderer, kind=measurement.type.lower() )(arguments=self.arguments) renderer.render(stream) self.ok("Disconnected from stream") ripe-atlas-tools-3.1.0/ripe/atlas/tools/exceptions.py000066400000000000000000000016131437041663000226550ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.tools.helpers.colours import colourise import sys class RipeAtlasToolsException(Exception): def write(self): r = str(self) sys.stderr.write("\n{0}\n\n".format(colourise(r, "red", fileobj=sys.stderr))) ripe-atlas-tools-3.1.0/ripe/atlas/tools/filters.py000066400000000000000000000134331437041663000221470ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ripe.atlas.sagan import Result from ripe.atlas.sagan import ResultParseError from ripe.atlas.cousteau import ProbeRequest from ripe.atlas.cousteau import Probe as CProbe from .exceptions import RipeAtlasToolsException from .cache import cache from .settings import conf class FilterFactory(object): @staticmethod def create(key, value): """Create new filter class based on the key""" if key == "asn": return ASNFilter(value) else: return Filter(key, value) class Filter(object): """ Class that represents filter for results. For now supports only attributes of probes property of Result property. It could be extended for any property of Result easily. """ def __init__(self, key, value): self.key = key self.value = value def filter(self, result): """ Decide if given result should be filtered (False) or remain on the pile of results. """ try: attr_value = getattr(result.probe, self.key) except AttributeError: log = ( "Cousteau's Probe class does not have an attribute " "called: <{}>" ).format(self.key) raise RipeAtlasToolsException(log) if attr_value == self.value: return True return False class ASNFilter(Filter): """Class thar represents filter by probes that belong to given ASN.""" def __init__(self, value): key = "asn" super(ASNFilter, self).__init__(key, value) def filter(self, result): asn_v4 = getattr(result.probe, "asn_v4") asn_v6 = getattr(result.probe, "asn_v6") if self.value in (asn_v4, asn_v6): return True return False def filter_results(filters, results): """docstring for filter""" new_results = [] for result in results: for rfilter in filters: if rfilter.filter(result): new_results.append(result) break return new_results class SaganSet(object): """ An iterable of sagan results with attached probe information that allows for filtering by the filters module. """ def __init__(self, iterable=None, probes=()): self._probes = probes self._iterable = iterable def __iter__(self): sagans = [] for line in self._iterable: # line may be a dictionary (parsed JSON) if hasattr(line, "strip"): line = line.strip() # Break out when there's nothing left if not line: break try: sagan = Result.get( line, on_error=Result.ACTION_IGNORE, on_warning=Result.ACTION_IGNORE, ) if not self._probes or sagan.probe_id in self._probes: sagans.append(sagan) if len(sagans) > 100: for sagan in self._attach_probes(sagans): yield sagan sagans = [] except ResultParseError: pass # Probably garbage in the file for sagan in self._attach_probes(sagans): yield sagan def __next__(self): return iter(self).next() def next(self): return self.__next__() def _attach_probes(self, sagans): probes = dict( [ (p.id, p) for p in Probe.get_many( (s.probe_id for s in sagans) ) ] ) for sagan in sagans: sagan.probe = probes[sagan.probe_id] yield sagan class Probe(object): """ A crude representation of the data we get from the API via Cousteau """ EXPIRE_TIME = 60 * 60 * 24 * 30 @classmethod def get(cls, pk): """ Given a single id, attempt to fetch a probe object from the cache. If that fails, do an API call to get it. Don't use this for multiple probes unless you know they're all in the cache, or you'll be in for a long wait. """ r = cache.get("probe:{}".format(pk)) if not r: kwargs = {"id": pk, "server": conf["api-server"]} probe = CProbe(**kwargs) cache.set("probe:{}".format(probe.id), probe, cls.EXPIRE_TIME) return probe @classmethod def get_many(cls, ids): """ Given a list of ids, attempt to get probe objects out of the local cache. Probes that cannot be found will be fetched from the API and cached for future use. """ r = [] fetch_ids = [] for pk in ids: probe = cache.get("probe:{}".format(pk)) if probe: r.append(probe) else: fetch_ids.append(str(pk)) if fetch_ids: kwargs = {"id__in": fetch_ids, "server": conf["api-server"]} for probe in [p for p in ProbeRequest(return_objects=True, **kwargs)]: cache.set("probe:{}".format(probe.id), probe, cls.EXPIRE_TIME) r.append(probe) return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/000077500000000000000000000000001437041663000215635ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/__init__.py000066400000000000000000000000001437041663000236620ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/actions.py000066400000000000000000000004761437041663000236040ustar00rootroot00000000000000from argparse import Action class StoreIfNotEmpty(Action): """ Like 'store' but don't overwrite an existing/conflicting option if the given value is empty. """ def __call__(self, parser, namespace, values, option_string=None): if values: setattr(namespace, self.dest, values) ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/colours.py000066400000000000000000000046331437041663000236310ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import sys COLOURS_AVAILABLE = False try: # We use curses to detect ANSI colour support import curses except ImportError: # Curses isn't available on all platforms try: import colorama # Colorama wraps stdout/stderr on Windows except ImportError: pass else: colorama.init() COLOURS_AVAILABLE = True else: if sys.stdout.isatty(): curses.setupterm() COLOURS_AVAILABLE = curses.tigetnum("colors") >= 8 class Colour(object): @classmethod def _colourise(cls, text, colour): return "{}[{}m{}{}[0m".format(chr(0x1B), colour, text, chr(0x1B)) @classmethod def black(cls, text): return cls._colourise(text, 30) @classmethod def red(cls, text): return cls._colourise(text, 31) @classmethod def green(cls, text): return cls._colourise(text, 32) @classmethod def yellow(cls, text): return cls._colourise(text, 33) @classmethod def blue(cls, text): return cls._colourise(text, 34) @classmethod def mangenta(cls, text): return cls._colourise(text, 35) @classmethod def cyan(cls, text): return cls._colourise(text, 36) @classmethod def white(cls, text): return cls._colourise(text, 37) @classmethod def bold(cls, text): return cls._colourise(text, 1) def colourise(text, colour, fileobj=sys.stdout): """ Return an ANSI escaped string of the specified content and colour, or the input text if colour support is not available or not appropriate. `fileobj` is used to determine whether the output is a terminal. """ if COLOURS_AVAILABLE and fileobj.isatty(): return getattr(Colour, colour)(text) else: return text ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/sanitisers.py000066400000000000000000000021441437041663000243220ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . FORBIDDEN = dict((i, None) for i in list(range(0, 32)) + [127]) def sanitise(s, strip_newlines=True): """ Strip out control characters to prevent people from screwing with the output """ if isinstance(s, bytes): s = s.decode("utf-8") if not isinstance(s, str): return s if not strip_newlines: return s.translate(dict((k, v) for k, v in FORBIDDEN.items() if not k == 10)) return s.translate(FORBIDDEN) ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/tabular.py000066400000000000000000000231041437041663000235670ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import argparse import csv import re from io import StringIO from typing import (Any, Dict, Iterable, Iterator, List, Mapping, Optional, Tuple) from typing_extensions import Literal, NotRequired, TypedDict from .colours import colourise Alignment = Literal["<", "^", ">"] LEFT: Alignment = "<" CENTRE: Alignment = "^" RIGHT: Alignment = ">" class ColumnDef(TypedDict): align: Alignment width: int class RowDef(TypedDict): obj: NotRequired[Any] values: Dict[str, Any] colour: NotRequired[str] # ((1, "Value1"), (3, True), (4, 5342),) AggregationKey = Tuple[Any, ...] class SortableNull: def __str__(self): return "null" def __hash__(self): return 0 def __eq__(self, other): return isinstance(other, type(self)) def __lt__(self, other): if isinstance(other, type(self)): return False return True def __gt__(self, other): return False class Renderer: """ Abstract base class for tabular renderers. """ def __init__( self, rows: List[RowDef], total_count: int, columns: Dict[str, ColumnDef], filters: Mapping[str, str], arguments: argparse.Namespace, ): self.rows = rows self.total_count = total_count self.columns = columns self.filters = filters self.aggregate_by: List[str] = arguments.aggregate_by self.max_per_aggregation: Optional[int] = arguments.max_per_aggregation self.no_header: bool = arguments.no_header def __iter__(self) -> Iterator[str]: if not self.no_header: for line in self.get_header(): yield line if self.aggregate_by: for composite, rows in self._aggregate(): aggr_header = self.get_aggregation_header(composite) if aggr_header is not None: yield aggr_header for row in rows: yield self.get_line(row) else: for row in self.rows: yield self.get_line(row) if not self.no_header: for line in self.get_footer(): yield line def get_header(self) -> Iterable[str]: """ Return an iterable of lines to output before the table. """ return [] def get_aggregation_header(self, composite: AggregationKey) -> Optional[str]: """ Return a line to output before each aggregation bucket. """ return None def get_line(self, row: RowDef) -> str: """ Return a single line rendering the given row. """ raise NotImplementedError def get_footer(self) -> Iterable[str]: """ Return an iterable of lines to output after the table. """ return [] def _aggregate(self) -> Iterable[Tuple[AggregationKey, List[RowDef]]]: buckets: Dict[AggregationKey, List[RowDef]] = {} for row in self.rows: values = [row["values"][k] for k in self.aggregate_by] composite = tuple(SortableNull() if v is None else v for v in values) bucket = buckets.setdefault(composite, []) if ( self.max_per_aggregation is None or len(bucket) < self.max_per_aggregation ): bucket.append(row) return sorted(buckets.items()) class PrettyRenderer(Renderer): """ Renderer which outputs colourised, human-readable tables """ _fmt = None @property def fmt(self) -> str: if not self._fmt: self._fmt = " ".join( f"{{!s:{c['align']}{c['width']}}}" for c in self.columns.values() ) return self._fmt def get_header(self) -> Iterable[str]: if self.filters: yield "" yield colourise("Filters:", "white") for k, v in self.filters.items(): if k not in ("search",): v = str(v) yield colourise(f" {k}: {v}", "cyan") yield "" yield colourise(self.fmt.format(*self.columns.keys()), "white") yield colourise(self._get_horizontal_rule(), "white") def get_aggregation_header(self, composite: AggregationKey) -> str: header = dict(zip(self.aggregate_by, composite)) values = [] for name in self.columns: if name in self.aggregate_by: values.append(header[name]) else: values.append(" ") line = self.fmt.format(*values) result = re.sub( r" ( *)( [^ ]|$)", lambda s: " " + len(s.group(1)) * "-" + s.group(2), line, ) for name in self.aggregate_by: if name not in self.columns: result += f" ({name}:{header[name]})" return result def get_line(self, row: RowDef) -> str: values = [ "-" if val is None else str(val)[: col["width"]] for (col, val) in zip(self.columns.values(), row["values"].values()) ] line = self.fmt.format(*values) if row.get("colour"): line = colourise(line, row["colour"]) return line def get_footer(self) -> Iterable[str]: hr = self._get_horizontal_rule() yield colourise(hr, "white") yield colourise( ("{:>" + str(len(hr)) + "}").format( "Showing {} of {}".format( min(len(self.rows), self.total_count) or "all", self.total_count, ) ), "white", ) def _get_horizontal_rule(self, char="=") -> str: """ A bit of a hack: We get a formatted line for no other reason than to determine the width of that line. Then we use a regex to overwrite that line with "=". """ return re.sub(r".", char, self.fmt.format(*["" for c in self.columns])) class CSVRenderer(Renderer): """ Renderer which outputs comma-separated values, where strings are always enclosed in double quotes, and literal double quotes are written as "". """ dialect = "excel" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.data = StringIO() self.writer = csv.writer(self.data, dialect=self.dialect) def get_header(self) -> Iterable[str]: yield self.get_line({"values": dict((k, k) for k in self.columns.keys())}) def get_line(self, row: RowDef) -> str: self.data.seek(self.data.truncate(0)) self.writer.writerow( [ "" if v is None else str(v) for (k, v) in row["values"].items() if k in self.columns ] ) return self.data.getvalue()[:-1] class TabRenderer(Renderer): """ Renderer which outputs tab-separated values, where literal tabs are replaced with spaces. """ def get_header(self) -> Iterable[str]: yield self.get_line({"values": dict((k, k) for k in self.columns.keys())}) def get_line(self, row: RowDef) -> str: return "\t".join( "" if v is None else str(v).replace("\t", " ") for (k, v) in row["values"].items() if k in self.columns ) class IDAction(argparse.Action): def __call__(self, parser, namespace, *args, **kwargs): namespace.format = "tab" namespace.field = ["id"] namespace.no_header = True def add_argument_group(parser: argparse.ArgumentParser, fields: Iterable[str]): """ Add an argument group to the given parser with all of the parameters for controlling the tabular renderers. """ fields = list(fields) group = parser.add_argument_group("Output") group.add_argument( "--field", type=str, action="append", choices=fields, default=[], help="The field(s) to display. Invoke multiple times for multiple fields.", ) group.add_argument( "--format", default="pretty", choices=renderers.keys(), help="Output format. Default: pretty", ) group.add_argument( "--no-header", action="store_true", default=False, help="Omit header line(s)", ) group.add_argument( "--ids-only", nargs=0, action=IDAction, help="Print only IDs, equivalent to --format=tab --field=id --no-header. " "Useful for piping to another command.", ) group.add_argument( "--aggregate-by", action="append", default=[], choices=fields, help="Aggregate results based on all specified aggregations." " Use this option multiple times for more specific aggregations.", ) group.add_argument( "--max-per-aggregation", type=int, help="Maximum number of rows per aggregated bucket.", ) renderers = { "pretty": PrettyRenderer, "csv": CSVRenderer, "tab": TabRenderer, } ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/validators.py000066400000000000000000000152051437041663000243100ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import argparse import os import re import sys from dateutil import parser from ..settings import aliases class ArgumentType(object): @staticmethod def path(string): if not os.path.exists(string) and not string == "-": raise argparse.ArgumentTypeError( 'The file name specified, "{}" does not appear to exist'.format(string) ) return string @staticmethod def country_code(string): if not re.match(r"^[a-zA-Z][a-zA-Z]$", string): raise argparse.ArgumentTypeError( "Countries must be defined with a two-letter ISO code" ) return string.upper() @staticmethod def datetime(string): try: return parser.parse(string) except parser.ParserError: raise argparse.ArgumentTypeError( "Times must be specified in ISO 8601 format. For example: " "2010-10-01T00:00:00 or a portion thereof. All times are in " "UTC." ) @staticmethod def ip_or_domain(string): message = '"{}" does not appear to be an IP address or host ' "name".format( string ) if " " in string: raise argparse.ArgumentTypeError(message) if "." not in string and ":" not in string: if not re.match(r"^\w+$", string): raise argparse.ArgumentTypeError(message) return string @classmethod def comma_separated_integers_or_file(cls, string): """ Allow a list of comma-separated integers, or a file containing a newline-separated list of integers, OR "-" which implies standard out. """ if re.match(r"^((\d+,?)+)$", string): return cls.comma_separated_integers()(string) f = sys.stdin if not string == "-": if not os.path.exists(string): raise argparse.ArgumentTypeError("Cannot find file: {}".format(string)) f = open(string) try: return [int(_) for _ in f.readlines()] except ValueError: raise argparse.ArgumentTypeError( "The contents of the file presented does not conform to input " "standards. Please ensure that every line in the file " "consists of a single integer." ) @staticmethod def tag(string): pattern = re.compile(r"^[a-z_\-0-9]+$") if not pattern.match(string): raise argparse.ArgumentTypeError( '"{}" does not appear to be a valid tag.'.format(string) ) return string class integer_range(object): def __init__(self, minimum=float("-inf"), maximum=float("inf")): self.minimum = minimum self.maximum = maximum def __call__(self, string): message = "The integer must be between {} and {}.".format( self.minimum, self.maximum ) if self.maximum == float("inf"): message = "The integer must be greater than {}.".format(self.minimum) try: integer = int(string) if integer < self.minimum or integer > self.maximum: raise argparse.ArgumentTypeError(message) except ValueError: raise argparse.ArgumentTypeError("An integer must be specified.") return integer class comma_separated_integers(object): def __init__(self, minimum=float("-inf"), maximum=float("inf")): self.minimum = minimum self.maximum = maximum def __call__(self, string): r = [] for i in string.split(","): try: i = int(i) except ValueError: raise argparse.ArgumentTypeError( "The ids supplied were not in the correct format. Note " "that you must specify them as a list of " "comma-separated integers without spaces. Example: " "1,2,34,157,10006" ) if i < self.minimum: raise argparse.ArgumentTypeError( "{} is lower than the minimum permitted value of " "{}.".format(i, self.minimum) ) if i > self.maximum: raise argparse.ArgumentTypeError( "{} exceeds the maximum permitted value of {}.".format( i, self.maximum ) ) r.append(i) return r class regex(object): def __init__(self, regex): self.regex = re.compile(regex) def __call__(self, string): if not self.regex.match(string): raise argparse.ArgumentTypeError( '"{}" does not appear to be valid.'.format(string) ) return string @staticmethod def alias_is_valid(string): ret = None if string and not string.isdigit(): pattern = re.compile(r"^[a-zA-Z\._\-0-9]+$") if pattern.match(string): ret = string if not ret: raise argparse.ArgumentTypeError( '"{}" does not appear to be a valid ' "alias.".format(string) ) return ret class id_or_alias(object): TYPE = None def __call__(self, string): if string.isdigit(): return int(string) if string in aliases[self.TYPE]: return int(aliases[self.TYPE][string]) else: raise argparse.ArgumentTypeError( '"{}" does not appear to be an existent ' "{} alias.".format(string, self.TYPE) ) class msm_id_or_name(id_or_alias): TYPE = "measurement" class probe_id_or_name(id_or_alias): TYPE = "probe" ripe-atlas-tools-3.1.0/ripe/atlas/tools/helpers/xdg.py000066400000000000000000000070101437041663000227150ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import platform import re import os import os.path def get_config_home(): """ """ config_home = os.environ.get("XDG_CONFIG_HOME") if config_home is None: config_home = os.path.expanduser("~/.config") return os.path.join(config_home, "ripe-atlas-tools") if hasattr(platform, "freedesktop_os_release"): freedesktop_os_release = platform.freedesktop_os_release else: # Shim for Python versions < 3.10, taken from CPython # freedesktop.org os-release standard # https://www.freedesktop.org/software/systemd/man/os-release.html # NAME=value with optional quotes (' or "). The regular expression is less # strict than shell lexer, but that's ok. _os_release_line = re.compile( "^(?P[a-zA-Z0-9_]+)=(?P[\"']?)(?P.*)(?P=quote)$" ) # unescape five special characters mentioned in the standard _os_release_unescape = re.compile(r"\\([\\\$\"\'`])") # /etc takes precedence over /usr/lib _os_release_candidates = ("/etc/os-release", "/usr/lib/os-release") _os_release_cache = None def _parse_os_release(lines): # These fields are mandatory fields with well-known defaults # in practice all Linux distributions override NAME, ID, and PRETTY_NAME. info = { "NAME": "Linux", "ID": "linux", "PRETTY_NAME": "Linux", } for line in lines: mo = _os_release_line.match(line) if mo is not None: info[mo.group("name")] = _os_release_unescape.sub( r"\1", mo.group("value") ) return info def freedesktop_os_release(): """Return operation system identification from freedesktop.org os-release""" global _os_release_cache if _os_release_cache is None: errno = None for candidate in _os_release_candidates: try: with open(candidate, encoding="utf-8") as f: _os_release_cache = _parse_os_release(f) break except OSError as e: errno = e.errno else: raise OSError( errno, f"Unable to read files {', '.join(_os_release_candidates)}" ) return _os_release_cache.copy() def get_os_string(): os = platform.system() if os == 'Darwin': release = platform.mac_ver()[0] return f'macOS {release}' elif os == 'Windows': release = platform.win32_ver()[0] return f"Windows {release}" pass else: try: info = freedesktop_os_release() except OSError: pass else: name = info.get("NAME") if name: version = info.get("VERSION_ID", "") return f"{name} {version}" return platform.platform() ripe-atlas-tools-3.1.0/ripe/atlas/tools/ipdetails.py000066400000000000000000000103251437041663000224520ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import requests import IPy from .cache import cache class IP(object): RIPESTAT_URL = "https://stat.ripe.net/data/prefix-overview/data.json?resource={ip}" CACHE_EXPIRATION_TIME = 60 * 60 * 24 * 7 def __init__(self, address): self.cached_prefix_found = False self.ip_object = IPy.IP(address) self.address = self.ip_object.strFullsize() self.asn = None self.holder = None self.prefix = None self.not_querable_types = [ "RESERVED", "UNSPECIFIED", "LOOPBACK", "UNASSIGNED", "DOCUMENTATION", "ULA", "LINKLOCAL", "PRIVATE", ] details = self._get_details() if details: self.asn = details["ASN"] self.holder = details["Holder"] self.prefix = details["Prefix"] def _get_details(self): details = None if not self.is_querable(): return details details = cache.get("IPDetails:{}".format(self.address)) if details: return details details = self.get_from_cached_prefix() if not details: details = self.query_stat() if details: self.update_cache(details) return details def is_querable(self): """Determines if address is worth querable.""" return self.ip_object.iptype() not in self.not_querable_types def get_from_cached_prefix(self): """Search cache for existing cached Prefix""" details = None for cache_entry in cache.keys(): if not cache_entry.decode().startswith("IPDetailsPrefix:"): continue prefix_details = cache.get(cache_entry) # data could exist but expired if not prefix_details: continue prefix = IPy.IP(prefix_details["Prefix"]) if self.ip_object in prefix: details = prefix_details self.cached_prefix_found = True break return details def query_stat(self): """Query RIPE Stat to get address details.""" URL = self.RIPESTAT_URL.format(ip=self.address) details = {} try: response = requests.get(URL) if not response.ok: return details res = response.json() except (requests.exceptions.RequestException, ValueError): # Catch all requests exception + not valid json ones. return details if res.get("status") == "ok": try: details = { "ASN": str(res["data"]["asns"][0]["asn"]), "Holder": res["data"]["asns"][0]["holder"], "Prefix": res["data"]["resource"], } except ( # Protect from any kind of malformed json response AttributeError, ValueError, KeyError, IndexError, TypeError, ): pass return details def update_cache(self, details): """Update cache for the address and prefix if needed.""" if not self.cached_prefix_found: key = "IPDetailsPrefix:{}".format(details["Prefix"]) cache.set(key, details, self.CACHE_EXPIRATION_TIME) key = "IPDetails:{}".format(self.address) cache.set(key, details, self.CACHE_EXPIRATION_TIME) def __str__(self): return "IP {}, ASN {}, Holder {}".format(self.address, self.asn, self.holder) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/000077500000000000000000000000001437041663000221125ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/__init__.py000066400000000000000000000013161437041663000242240ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from .base import Renderer __all__ = ["Renderer"] ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/base.py000066400000000000000000000174211437041663000234030ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import importlib import os import pkgutil import sys from ..exceptions import RipeAtlasToolsException from ..helpers import xdg class Renderer(object): TYPE_PING = "ping" TYPE_TRACEROUTE = "traceroute" TYPE_DNS = "dns" TYPE_SSLCERT = "sslcert" TYPE_HTTP = "http" TYPE_NTP = "ntp" RENDERS = () def __init__(self, *args, **kwargs): """ If "arguments" is in kwargs it can be used to gather renderer's optional arguments which have been passed via CLI. See also add_arguments(). """ self.show_header = True self.show_footer = True if "arguments" in kwargs: self.show_header = kwargs["arguments"].show_header self.show_footer = kwargs["arguments"].show_footer @classmethod def get_available(cls): """ Return a list of renderers available to be used. """ paths = [os.path.dirname(__file__)] if "HOME" in os.environ: path = xdg.get_config_home() sys.path.append(path) paths += [os.path.join(path, "renderers")] names = [] for _, module_name, _ in pkgutil.iter_modules(paths): if module_name == "base": continue # Check that we can actually use this renderer, otherwise drop it try: cls.get_renderer_by_name(module_name) except Exception: continue names.append(module_name) return names @staticmethod def add_common_arguments(parser): group = parser.add_argument_group(title="Optional arguments for all renderers") group.add_argument( "--no-header", dest="show_header", action="store_false", help="Don't show a header/title before rendering results", ) group.add_argument( "--no-footer", dest="show_footer", action="store_false", help="Don't show a footer/summary after rendering results", ) @staticmethod def add_arguments_for_available_renderers(parser): Renderer.add_common_arguments(parser) for renderer_name in Renderer.get_available(): renderer_cls = Renderer.get_renderer_by_name(renderer_name) renderer_cls.add_arguments(parser) @staticmethod def render_template(template, **kwargs): """ A crude templating engine. """ template = os.path.join(os.path.dirname(__file__), "templates", template) with open(template) as f: return str(f.read()).format(**kwargs) @classmethod def get_renderer(cls, name=None, kind=None): """ Using the name if you've asked for it specifically, or attempting to guess the appropriate renderer based on the kind of measurement, this will return a Renderer subclass or None if nothing can be found. """ renderer = None if name: renderer = cls.get_renderer_by_name(name) if not renderer and kind: renderer = cls.get_renderer_by_kind(kind) if kind: cls._test_renderer_accepts_kind(renderer, kind) return renderer @classmethod def get_renderer_by_name(cls, name): error_message = f'The renderer you selected, "{name}" could not be found.' # User-defined, user-supplied r = cls.import_renderer("renderers", name) if not r: r = cls.import_renderer("ripe.atlas.tools.renderers", name) if not r: raise RipeAtlasToolsException(error_message) return r @classmethod def get_renderer_by_kind(cls, kind): error_message = ( f'A default renderer for "{kind}" measurements could not be found.' ) r = cls.import_renderer("ripe.atlas.tools.renderers", kind) if not r: raise RipeAtlasToolsException(error_message) return r @staticmethod def import_renderer(package, name): """ Return the Renderer class from package.name, or None if either package or package.name don't exist. """ full_name = f"{package}.{name}" try: spec = importlib.util.find_spec(full_name) except ModuleNotFoundError: return if not spec: return return getattr(importlib.import_module(full_name), "Renderer") @staticmethod def add_arguments(parser): """ Add renderer's optional arguments here. Suggested format: group = parser.add_argument_group( title="Optional arguments for XXX renderer" ) group.add_argument( ... ) """ pass def render(self, results, sample=None): """ Render the given iterable of RIPE Atlas JSON results. """ # Put aggregated and unaggregated results in the same format normalized = dict(results) if isinstance(results, dict) else {"": results} header_shown = False last_key = None for key, results in normalized.items(): for sagan in results: # Possibly show render header if self.show_header and not header_shown: print(self.header(sagan), end="") header_shown = True if key: indent = " " if key != last_key: # Show aggregation group header print("\n" + key) last_key = key else: indent = "" line = Result(self.on_result(sagan), sagan.probe_id) print(indent + line, end="") if self.show_footer: print(self.footer(), end="") def header(self, sample): """ Override this to add a header. `sample` is a single parsed result from the result set (probably the first one). It can be used to infer metadata about the measurement without having to do an extra API call. """ return "" def footer(self): """ Override this to add a footer. To provide a summary here, statistics should be gathered in the `on_result` callback, ideally without storing all results in memory. """ return "" @staticmethod def _test_renderer_accepts_kind(renderer, kind): if kind not in renderer.RENDERS: raise RipeAtlasToolsException( "The renderer selected does not appear to support measurements " 'of type "{}"'.format(kind) ) def on_result(self, result): """ This must be defined in the subclass, and must return a string, even if that string is "". """ raise NotImplementedError() class Result(str): """ A string-like object that we can use to render results, but that contains enough information to be used by the aggregators if need be. """ def __new__(cls, value, probe_id): obj = str.__new__(cls, value) obj.probe_id = probe_id return obj ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/dns.py000066400000000000000000000105561437041663000232570ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from tzlocal import get_localzone from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_DNS] TIME_FORMAT = "%a %b %d %H:%M:%S %Z %Y" def on_result(self, result): created = result.created.astimezone(get_localzone()) probe_id = result.probe_id r = "\n\nProbe #{0}\n{1}\n".format(probe_id, "=" * 79) if result.responses: for response in result.responses: r += self.get_formatted_response(probe_id, created, response) else: r += "\n {}\n".format(colourise("No response found", "red")) return r @classmethod def get_formatted_response(cls, probe_id, created, response): if not response.abuf: return "\n- {0} -\n\n No abuf found.\n".format(response.response_id) header_flags = [] for flag in ( "aa", "ad", "cd", "qr", "ra", "rd", ): if getattr(response.abuf.header, flag): header_flags.append(flag) edns = "" if response.abuf.edns0: edns = ( "\n ;; OPT PSEUDOSECTION:\n ; EDNS: version: {0}, " "flags:; udp: {1}\n".format( response.abuf.edns0.version, response.abuf.edns0.udp_size ) ) question = "" if response.abuf.questions: question = response.abuf.questions[0].name return cls._colourise_by_response( response, cls.render_template( "reports/dns.txt", # Older measurements don't have a response_id response_id=response.response_id or 1, probe=probe_id, question_name=sanitise(question), header_opcode=response.abuf.header.opcode, header_return_code=response.abuf.header.return_code, header_id=response.abuf.header.id, header_flags=" ".join(header_flags), edns=edns, question_count=len(response.abuf.questions), answer_count=len(response.abuf.answers), authority_count=len(response.abuf.authorities), additional_count=len(response.abuf.additionals), question=sanitise( cls.get_section("question", response.abuf.questions), strip_newlines=False, ), answers=sanitise( cls.get_section("answer", response.abuf.answers), strip_newlines=False, ), authorities=sanitise( cls.get_section("authority", response.abuf.authorities), strip_newlines=False, ), additionals=sanitise( cls.get_section("additional", response.abuf.additionals), strip_newlines=False, ), response_time=response.response_time, response_size=response.response_size, created=created.strftime(cls.TIME_FORMAT), destination_address=sanitise(response.destination_address), ), ) @staticmethod def get_section(header, data): if not data: return "" return "\n ;; {0} SECTION:\n{1}\n".format( header.upper(), "\n".join([" {0}".format(_) for _ in data]) ) @staticmethod def _colourise_by_response(response, output): colour = "red" if response.is_error else "green" return colourise(output, colour) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/dns_compact.py000066400000000000000000000067631437041663000247720ustar00rootroot00000000000000# Copyright (c) 2017 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from tzlocal import get_localzone from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_DNS] TIME_FORMAT = "%Y-%m-%d %H:%M:%S" ANSWER_COLORS = ["cyan", "blue"] def on_result(self, result): created = result.created.astimezone(get_localzone()) probe_id = result.probe_id r = [] if result.responses: for response in result.responses: r.append(self.get_formatted_response(probe_id, created, response)) else: r.append( "{}{}\n".format( self.get_header(probe_id, created), colourise("No response found", "red"), ) ) return "".join(r) @classmethod def get_header(cls, probe_id, created): return "Probe {0:>6}: {1} ".format( "#{}".format(probe_id), created.strftime(cls.TIME_FORMAT), ) @classmethod def get_formatted_response(cls, probe_id, created, response): s = [] answers = "" if response.abuf: header_flags = [] for flag in ( "aa", "ad", "cd", "qr", "ra", "rd", ): if getattr(response.abuf.header, flag): header_flags.append(flag) s.append(response.abuf.header.return_code) s.append(" ".join(header_flags)) answers = cls.print_answers(response.abuf.answers) else: s.append("No abuf found") if response.is_error or not response.abuf: color = "red" elif len(response.abuf.answers) == 0: color = "yellow" else: color = "green" status = colourise(" ".join(s), color) return "".join( [ cls.get_header(probe_id, created), status, " " if answers else "", answers, "\n", ] ) @staticmethod def get_rrdata(data): """ Return RRdata in condensed text form. """ if not data: return "" # It's too complicated to override __str__ method of all Answer # classes of Sagan so let's compress it text-wise instead r = str(data).split() r.pop(2) # get rid of the class return sanitise(" ".join(r)) @classmethod def print_answers(cls, data): """ Return list of colourised condensed textual RRdata. """ r = [] for record, color in zip(data, cls.ANSWER_COLORS * len(data)): r.append(colourise(cls.get_rrdata(record), color)) return "; ".join(r) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/dst_asn.py000066400000000000000000000035301437041663000241200ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from .base import Renderer as BaseRenderer from collections import Counter from ..helpers.sanitisers import sanitise from ..ipdetails import IP class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_PING] SHOW_DEFAULT_HEADER = False SHOW_DEFAULT_FOOTER = False def __init__(self, *args, **kwargs): BaseRenderer.__init__(self, *args, **kwargs) # Keys are timestamps, data struct captures ASN membership self.asns = Counter() self.asn2name = {} def on_result(self, result): dst = result.destination_address if dst is not None: ip = IP(dst) if ip.asn: self.asns[ip.asn] += 1 self.asn2name[ip.asn] = sanitise(ip.holder) else: self.asns[""] += 1 self.asn2name[""] = "unknown" return "" return "" def additional(self): total = sum(self.asns.values()) r = "" for asn, count in self.asns.most_common(): r += "AS%s %.2f%% (%s)" % ( asn, 100.0 * count / total, self.asn2name[asn], ) return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/http.py000066400000000000000000000043341437041663000234470ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ..helpers.colours import colourise from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): """ We're abusing the Extended Log File Format here to render the result, amending it to include a few things not originally specified in the W3C Working Draft: http://www.w3.org/TR/WD-logfile.html Namely: http-version, header-bytes, and body-bytes """ RENDERS = [BaseRenderer.TYPE_HTTP] COLOURS = {"2": "green", "3": "blue", "4": "yellow", "5": "red"} def on_result(self, result, probes=None): r = "#Version: 1.0\n#Date: {}\n#Fields: {}\n".format( result.created.strftime("%Y-%m-%d %H:%M:%S"), "cs-method cs-uri c-ip s-ip sc-status time-taken http-version " "header-bytes body-bytes", ) for response in result.responses: r += self._colourise_by_status( "{} {} {} {} {} {} {} {} {}\n".format( result.method, result.uri, response.source_address, response.destination_address, response.code, response.response_time, response.version, response.head_size, response.body_size, ), response.code, ) return r + "\n" def _colourise_by_status(self, output, status): try: return colourise(output, self.COLOURS[str(status)[0]]) except (IndexError, KeyError): return colourise(output, "red") ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/ntp.py000066400000000000000000000063251437041663000232730ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from tzlocal import get_localzone from datetime import datetime from .base import Renderer as BaseRenderer from ..helpers.colours import colourise class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_NTP] TIME_FORMAT = "%a %b %d %H:%M:%S %Z %Y" def on_result(self, result): created = result.created.astimezone(get_localzone()) r = self.get_formatted_response(result) if not r: r = colourise("No results\n", "red") return "\n{}\n{}\n\n{}".format( colourise("Probe #{}".format(result.probe_id), "bold"), colourise(created.strftime(self.TIME_FORMAT), "bold"), r, ) @staticmethod def get_formatted_response(result): leap = result.leap_second_indicator stratum = result.stratum v = result.version mode = result.mode # just here for completeness, flake8 doesn't like when it's not used # end_time = result.end_time poll = result.poll precision = result.precision refid = result.reference_id ref_time = result.reference_time root_delay = result.root_delay root_disp = result.root_dispersion if not leap and not stratum and not v and not mode: return if mode != "server": print("invalid mode: %s" % mode) r = "[NTP] %s -> %s (%s)\n" % ( result.source_address, result.destination_name, result.destination_address, ) r += "\tversion: %s, stratum: %s/16\n" % ( colourise(v, "bold"), colourise(stratum, "bold"), ) r += "\trefid: %s\n" % colourise(refid, "bold") r += "\tleap: %s, poll: %s, precision: %s\n" % (leap, poll, precision) r += "\troot_delay: %s, root_disp: %s\n" % (root_delay, root_disp) r += "\tref-time: %s\n\n" % datetime.fromtimestamp(ref_time) try: for idx, pkt in enumerate(result.packets): if not pkt.rtt: r += f"\t[{idx}] *\n]" continue r += "\t[%s] %s\n" % (idx, str(pkt)) r += "\t\ttrans: %s -> recv: %s\n" % ( pkt.transmitted_time, pkt.received_time, ) r += "\t\torigin: %s -> final: %s\n\n" % ( pkt.origin_time, pkt.final_time, ) except Exception as ex: print("Got exception when reading packet: %s" % ex) print("Raw: %s" % pkt.raw_data) return r ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/ping.py000066400000000000000000000107621437041663000234270ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ..helpers.sanitisers import sanitise from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): """ This is meant to be a stub example for what an aggregate renderer might look like. If you have ideas as to how to make this better, feel free to send along a pull request. """ RENDERS = [BaseRenderer.TYPE_PING] def __init__(self, **kwargs): BaseRenderer.__init__(self, **kwargs) self.target = "" self.packet_loss = 0 self.sent_packets = 0 self.received_packets = 0 self.rtts = [] self.rtts_min = [] self.rtts_max = [] self.rtt_types_map = {"min": self.rtts_min, "max": self.rtts_max} def collect_stats(self, result): """ Calculates, stores and collects all stats we want from the given result. """ if not self.target: self.target = result.destination_name self.sent_packets += result.packets_sent self.received_packets += result.packets_received self.collect_min_max_rtts("min", result.rtt_min) self.collect_min_max_rtts("max", result.rtt_max) self.collect_packets_rtt(result.packets) def collect_min_max_rtts(self, rtt_type, rtt): """ Stores the given rtt in the corresponding list (min/max) if rtt is set. """ rtt = rtt if not rtt: rtt = 0 self.rtt_types_map[rtt_type].append(rtt) def collect_packets_rtt(self, packets): """ Collects all the rrts of given packets and stores them in our rtts list. """ for packet in packets: rtt = packet.rtt if not packet.rtt: rtt = 0 self.rtts.append(rtt) def calculate_loss(self): """Calculates the total loss between received and sent packets.""" if not self.sent_packets: return 0 return (1 - float(self.received_packets) / self.sent_packets) * 100 def mean(self): """Calculates the mean of the collected rtts""" return round(float(sum(self.rtts)) / max(len(self.rtts), 1), 3) def median(self): """Calculates the median of the collected rtts""" sorted_rtts = sorted(self.rtts) index = (len(self.rtts) - 1) // 2 if len(self.rtts) % 2: return sorted_rtts[index] else: return (sorted_rtts[index] + sorted_rtts[index + 1]) / 2.0 def on_result(self, result): packets = result.packets if not packets: return "No packets found\n" self.collect_stats(result) # Because the origin value is more reliable as "from" in v4 and as # "packet.source_address" in v6. origin = result.origin if ":" in origin: origin = packets[0].source_address times = ", ".join([str(_.rtt) + " ms" for _ in packets]) return ( f"{result.packet_size} bytes from {result.destination_address} via " f"probe #{result.probe_id} ({origin})" f": ttl={packets[0].ttl} times={times}\n" ) def header(self, sample): resolved_on = ( "server" if sample.destination_address == sample.destination_name else "probe" ) return f"PING {sample.destination_name} (resolved on {resolved_on})\n" def footer(self): if not self.sent_packets: return "" self.packet_loss = self.calculate_loss() return self.render_template( "reports/aggregate_ping.txt", target=sanitise(self.target), sent=self.sent_packets, received=self.received_packets, packet_loss=self.packet_loss, min=min(self.rtts_min), median=self.median(), mean=self.mean(), max=max(self.rtts_max), ) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/raw.py000066400000000000000000000022761437041663000232640ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import json from .base import Renderer as BaseRenderer from ..helpers.sanitisers import sanitise class Renderer(BaseRenderer): RENDERS = [ BaseRenderer.TYPE_PING, BaseRenderer.TYPE_TRACEROUTE, BaseRenderer.TYPE_DNS, BaseRenderer.TYPE_SSLCERT, BaseRenderer.TYPE_HTTP, BaseRenderer.TYPE_NTP, ] SHOW_DEFAULT_HEADER = False SHOW_DEFAULT_FOOTER = False def on_result(self, result, probes=None): return sanitise(json.dumps(result.raw_data, separators=(",", ":"))) + "\n" ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/ssl_consistency.py000066400000000000000000000071511437041663000257120ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ..helpers.sanitisers import sanitise from .base import Renderer as BaseRenderer THRESHOLD = 80 # % class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_SSLCERT] def __init__(self, *args, **kwargs): BaseRenderer.__init__(self, *args, **kwargs) self.uniqcerts = {} self.blob_list = [] def footer(self): most_seen_cert = self.get_nprobes_ofpopular_cert() for cert_id in sorted( self.uniqcerts, key=lambda pk: self.uniqcerts[pk]["cnt"], reverse=True ): self.blob_list.append(self.render_certificate(cert_id)) if self.uniqcerts[cert_id]["cnt"] < most_seen_cert * THRESHOLD / 100: self.blob_list.extend(self.render_below_threshold(cert_id)) return "\n".join(self.blob_list) def bucketize_result_cert(self, result): for certificate in result.certificates: cert_id = certificate.checksum_sha256 if cert_id not in self.uniqcerts: self.uniqcerts[cert_id] = {"cert": None, "cnt": 0, "probes": []} self.uniqcerts[cert_id]["cert"] = certificate self.uniqcerts[cert_id]["cnt"] += 1 self.uniqcerts[cert_id]["probes"].append(result.probe) def get_nprobes_ofpopular_cert(self): """ Gets the number of probes that have seen the most popular (in terms of probes) cert. """ if not self.uniqcerts: return 0 return max([self.uniqcerts[cert_id]["cnt"] for cert_id in self.uniqcerts]) def render_certificate(self, cert_id): """Renders the specific certificate""" certificate = self.uniqcerts[cert_id]["cert"] return self.render_template( "reports/ssl_consistency.txt", issuer_c=sanitise(certificate.issuer_c), issuer_o=sanitise(certificate.issuer_o), issuer_cn=sanitise(certificate.issuer_cn), subject_c=sanitise(certificate.subject_c), subject_o=sanitise(certificate.subject_o), subject_cn=sanitise(certificate.subject_cn), sha256fp=certificate.checksum_sha256, seenby=self.uniqcerts[cert_id]["cnt"], s="s" if self.uniqcerts[cert_id]["cnt"] > 1 else "", ) def render_below_threshold(self, cert_id): """ Print information about the given cert that is below our threshold of visibility. """ blob_list = [ " Below the threshold ({0}%)".format(THRESHOLD), " Probes that saw it: ", ] for probe in self.uniqcerts[cert_id]["probes"]: log = ( " ID: {id}, country code: {cc}, ASN (v4/v6): {asn4}/{asn6}" ).format( id=probe.id, cc=probe.country_code, asn4=probe.asn_v4, asn6=probe.asn_v6 ) blob_list.append(log) return blob_list def on_result(self, result): self.bucketize_result_cert(result) return "" ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/sslcert.py000066400000000000000000000051541437041663000241500ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from tzlocal import get_localzone import OpenSSL from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_SSLCERT] TIME_FORMAT = "%a %b %d %H:%M:%S %Z %Y" def on_result(self, result): r = "" for certificate in result.certificates: r += self.get_formatted_response(certificate) created = result.created.astimezone(get_localzone()) return "\n{}\n{}\n{}\n".format( colourise("Probe #{}".format(result.probe_id), "bold"), colourise(created.strftime(self.TIME_FORMAT), "bold"), r, ) @classmethod def get_formatted_response(cls, certificate): x509 = OpenSSL.crypto.load_certificate( OpenSSL.crypto.FILETYPE_PEM, certificate.raw_data.replace("\\/", "/").replace("\n\n", "\n"), ) pkey_type = x509.get_pubkey().type() # TODO: to be improved if pkey_type == 6: pkey_type_descr = "rsaEncryption" else: pkey_type_descr = pkey_type return cls.render_template( "reports/sslcert.txt", issuer_c=sanitise(certificate.issuer_c), issuer_o=sanitise(certificate.issuer_o), issuer_cn=sanitise(certificate.issuer_cn), not_before=certificate.valid_from, not_after=certificate.valid_until, subject_c=sanitise(certificate.subject_c), subject_o=sanitise(certificate.subject_o), subject_cn=sanitise(certificate.subject_cn), version=x509.get_version(), serial_number=x509.get_serial_number(), signature_algorithm=x509.get_signature_algorithm(), pkey_type=pkey_type_descr, pkey_bits=x509.get_pubkey().bits(), sha1fp=certificate.checksum_sha1, sha256fp=certificate.checksum_sha256, ) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/000077500000000000000000000000001437041663000241105ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/reports/000077500000000000000000000000001437041663000256065ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/reports/aggregate_ping.txt000066400000000000000000000002571437041663000313160ustar00rootroot00000000000000 --- {target} ping statistics --- {sent} packets transmitted, {received} received, {packet_loss:.3}% loss rtt min/med/avg/max = {min:.3f}/{median:.3f}/{mean:.3f}/{max:.3f} ms ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/reports/dns.txt000066400000000000000000000010231437041663000271270ustar00rootroot00000000000000 - {response_id} - ; <<>> RIPE Atlas Tools <<>> {question_name} ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: {header_opcode}, status: {header_return_code}, id: {header_id} ;; flags: {header_flags}; QUERY: 1, ANSWER: {answer_count}, AUTHORITY: {authority_count}, ADDITIONAL: {additional_count} {edns}{question}{answers}{authorities}{additionals} ;; Query time: {response_time} msec ;; SERVER: {destination_address}#53({destination_address}) ;; WHEN: {created} ;; MSG SIZE rcvd: {response_size} ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/reports/ssl_consistency.txt000066400000000000000000000002701437041663000315700ustar00rootroot00000000000000Certificate: Issuer: C={issuer_c}, O={issuer_o}, CN={issuer_cn} Subject: C={subject_c}, O={subject_o}, CN={subject_cn} SHA256 Fingerprint={sha256fp} Seen by {seenby} probe{s} ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/templates/reports/sslcert.txt000066400000000000000000000007771437041663000300410ustar00rootroot00000000000000 Certificate: Data: Version: {version} Serial Number: {serial_number} Signature Algorithm: {signature_algorithm} Issuer: C={issuer_c}, O={issuer_o}, CN={issuer_cn} Validity Not Before: {not_before} Not After : {not_after} Subject: C={subject_c}, O={subject_o}, CN={subject_cn} Subject Public Key Info: Public Key Algorithm: {pkey_type} Public-Key: ({pkey_bits} bit) SHA1 Fingerprint={sha1fp} SHA256 Fingerprint={sha256fp} ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/traceroute.py000066400000000000000000000056341437041663000246510ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from tzlocal import get_localzone from .base import Renderer as BaseRenderer from ..helpers.colours import colourise from ..helpers.sanitisers import sanitise from ..ipdetails import IP class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_TRACEROUTE] TIME_FORMAT = "%a %b %d %H:%M:%S %Z %Y" DEFAULT_SHOW_ASNS = False @staticmethod def add_arguments(parser): group = parser.add_argument_group( title="Optional arguments for traceroute renderer" ) group.add_argument( "--traceroute-show-asns", help="Show Autonomous System Numbers (ASNs) in the traceroute " "results.", action="store_true", default=Renderer.DEFAULT_SHOW_ASNS, ) def __init__(self, **kwargs): BaseRenderer.__init__(self, **kwargs) if "arguments" in kwargs: self.show_asns = kwargs["arguments"].traceroute_show_asns else: self.show_asns = Renderer.DEFAULT_SHOW_ASNS def on_result(self, result): r = "" for hop in result.hops: if hop.is_error: r += "{}\n".format(colourise(sanitise(hop.error_message), "red")) continue name = "" asn = "" rtts = [] for packet in hop.packets: name = name or packet.origin or "*" if self.show_asns: if packet.origin and not asn: asn = IP(packet.origin).asn if packet.rtt: rtts.append("{:8} ms".format(packet.rtt)) else: rtts.append(" *") if not asn: tpl = "{hop:>3} {name:37} {rtts}\n" else: tpl = "{hop:>3} {name:28} {asn:>8} {rtts}\n" r += tpl.format( hop=hop.index, name=sanitise(name), asn="AS{}".format(asn) if asn else "", rtts=" ".join(rtts), ) created = result.created.astimezone(get_localzone()) return "\n{}\n{}\n\n{}".format( colourise("Probe #{}".format(result.probe_id), "bold"), colourise(created.strftime(self.TIME_FORMAT), "bold"), r, ) ripe-atlas-tools-3.1.0/ripe/atlas/tools/renderers/traceroute_aspath.py000066400000000000000000000072431437041663000262070ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from ..ipdetails import IP from .base import Renderer as BaseRenderer class Renderer(BaseRenderer): RENDERS = [BaseRenderer.TYPE_TRACEROUTE] DEFAULT_RADIUS = 2 @staticmethod def add_arguments(parser): group = parser.add_argument_group( title="Optional arguments for traceroute_aspath renderer" ) group.add_argument( "--traceroute-aspath-radius", type=int, help="Number of different ASs starting from the end of the " "traceroute path. " "Default: {}.".format(Renderer.DEFAULT_RADIUS), metavar="RADIUS", default=Renderer.DEFAULT_RADIUS, ) def __init__(self, *args, **kwargs): BaseRenderer.__init__(self, *args, **kwargs) self.paths = {} # Number of different ASs starting from the end of the traceroute path. if "arguments" in kwargs: self.RADIUS = kwargs["arguments"].traceroute_aspath_radius else: self.RADIUS = Renderer.DEFAULT_RADIUS @staticmethod def _get_asns_for_output(asns, radius): asns_with_padding = [""] * radius + asns asns_with_padding = asns_with_padding[-radius:] return " ".join( [ "{:>8}".format("AS{}".format(asn) if asn else "") for asn in asns_with_padding ] ) def header(self, sample): return ( "For each traceroute path toward the target, the " "last {} ASNs will be shown\n\n".format(self.RADIUS) ) def on_result(self, result): ip_hops = [] for hop in result.hops: for packet in hop.packets: if packet.origin: ip_hops.append(packet.origin) break asns = [] # starting from the last hop's IP, get up to ASNs for address in reversed(ip_hops): ip = IP(address) if ip.asn and ip.asn not in asns: asns.append(ip.asn) if len(asns) == self.RADIUS: break as_path = self._get_asns_for_output(list(reversed(asns)), self.RADIUS) if as_path not in self.paths: self.paths[as_path] = {} self.paths[as_path]["cnt"] = 0 self.paths[as_path]["responded"] = 0 self.paths[as_path]["cnt"] += 1 if result.destination_ip_responded: self.paths[as_path]["responded"] += 1 return "Probe #{:<5}: {}, {}completed\n".format( result.probe_id, as_path, "NOT " if not result.destination_ip_responded else "", ) def footer(self): s = "\nNumber of probes for each AS path:\n\n" for as_path in self.paths: s += " {}: {} probe{}, {} completed\n".format( as_path, self.paths[as_path]["cnt"], "s" if self.paths[as_path]["cnt"] > 1 else "", self.paths[as_path]["responded"], ) return s ripe-atlas-tools-3.1.0/ripe/atlas/tools/settings/000077500000000000000000000000001437041663000217615ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/settings/__init__.py000066400000000000000000000173341437041663000241020ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from collections.abc import Mapping import copy import os import re import yaml from ..helpers import xdg class UserSettingsParser(object): USER_CONFIG_DIR = xdg.get_config_home() USER_RC = None def get(self): r = copy.deepcopy(self.DEFAULT) if os.path.exists(self.USER_RC): with open(self.USER_RC) as y: custom = yaml.load(y, Loader=yaml.FullLoader) if custom: r = self.deep_update(r, custom) return r @classmethod def deep_update(cls, d, u): """ Updates a dictionary with another dictionary, only it goes deep. Stolen from http://stackoverflow.com/questions/3232943/ """ for k, v in u.items(): if isinstance(v, Mapping): r = cls.deep_update(d.get(k, {}), v) d[k] = r else: d[k] = u[k] return d @staticmethod def write(data): raise NotImplementedError() class Configuration(UserSettingsParser): """ A singleton configuration class that's smart enough to create a config out of defaults + yaml """ USER_RC = os.path.join(UserSettingsParser.USER_CONFIG_DIR, "rc") DEFAULT = { "authorisation": { "fetch": "", "fetch_aliases": {}, "create": "", "google_geocoding": "", }, "specification": { "af": 4, "description": "", "source": { "type": "area", "value": "WW", "requested": 50, }, "spread": None, "resolve_on_probe": None, "times": { "one-off": True, "interval": None, "start": None, "stop": None, }, "types": { "ping": { "packets": 3, "packet-interval": 1000, "size": 48, "include_probe_id": None, }, "traceroute": { "packets": 3, "size": 48, "protocol": "ICMP", "dont-fragment": False, "paris": 0, "first-hop": 1, "max-hops": 255, "port": 80, "destination-option-size": None, "hop-by-hop-option-size": None, "timeout": 4000, "response-timeout": None, "duplicate-timeout": None, }, "sslcert": { "port": 443, "hostname": None, }, "ntp": {"packets": 3, "timeout": 4000}, "dns": { "set-cd-bit": False, "set-do-bit": False, "protocol": "UDP", "query-class": "IN", "query-type": "A", "query-argument": None, "set-nsid-bit": False, "udp-payload-size": 512, "set-rd-bit": True, "retry": 0, "timeout": None, "tls": False, }, "http": { "header-bytes": 0, "version": "1.1", "method": "GET", "port": 80, "path": "/", "query-string": None, "user-agent": "RIPE Atlas: https://atlas.ripe.net/", "body-bytes": None, "timing-verbosity": 0, }, }, "tags": { "ipv4": { "ping": {"include": [], "exclude": []}, "traceroute": {"include": [], "exclude": []}, "dns": {"include": [], "exclude": []}, "sslcert": {"include": [], "exclude": []}, "http": {"include": [], "exclude": []}, "ntp": {"include": [], "exclude": []}, "all": {"include": ["system-ipv4-works"], "exclude": []}, }, "ipv6": { "ping": {"include": [], "exclude": []}, "traceroute": {"include": [], "exclude": []}, "dns": {"include": [], "exclude": []}, "sslcert": {"include": [], "exclude": []}, "http": {"include": [], "exclude": []}, "ntp": {"include": [], "exclude": []}, "all": {"include": ["system-ipv6-works"], "exclude": []}, }, }, }, "ripe-ncc": { "endpoint": "https://atlas.ripe.net", "stream-base-url": "https://atlas-stream.ripe.net", "version": 0, }, } @staticmethod def write(config): """ PyYaml is incapable of preserving comments, or even specifying them as an argument to `.dump()` (http://pyyaml.org/ticket/114), so we have to do some regex gymnastics here to make sure that the config file remains easy for n00bs to read. """ template = os.path.join(os.path.dirname(__file__), "templates", "base.yaml") authorisation = re.compile("^authorisation:$", re.MULTILINE) tags = re.compile("^ tags:$", re.MULTILINE) specification = re.compile("^specification:$", re.MULTILINE) ripe = re.compile("^ripe-ncc:$", re.MULTILINE) with open(template) as t: payload = str(t.read()).format( payload=yaml.dump(config, default_flow_style=False) ) payload = ripe.sub( "\n# Don't mess with these, or Bad Things may happen\n" "ripe-ncc:", payload, ) payload = authorisation.sub("# Authorisation\n" "authorisation:", payload) payload = specification.sub( "\n# Measurement Creation\n" "specification:", payload ) payload = tags.sub( " # Tags added to probes selection\n" " tags:", payload ) with open(Configuration.USER_RC, "w") as rc: rc.write(payload) def get(self): d = super().get() d["website-url"] = d["ripe-ncc"]["endpoint"] d["api-server"] = d["ripe-ncc"]["endpoint"].replace("https://", "") d["stream-base-url"] = d["ripe-ncc"]["stream-base-url"] return d class AliasesDB(UserSettingsParser): """ A singleton class to manage user aliases """ USER_RC = os.path.join(UserSettingsParser.USER_CONFIG_DIR, "aliases") DEFAULT = {"measurement": {}, "probe": {}} @staticmethod def write(aliases): if not os.path.exists(AliasesDB.USER_CONFIG_DIR): os.makedirs(AliasesDB.USER_CONFIG_DIR) payload = yaml.dump(aliases, default_flow_style=False) with open(AliasesDB.USER_RC, "w") as rc: rc.write(payload) conf = Configuration().get() aliases = AliasesDB().get() ripe-atlas-tools-3.1.0/ripe/atlas/tools/settings/templates/000077500000000000000000000000001437041663000237575ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/ripe/atlas/tools/settings/templates/base.yaml000066400000000000000000000025611437041663000255610ustar00rootroot00000000000000# # This is the config file for the ripe-atlas command. It follows the YAML # formatting standard found here: http://yaml.org/ -- but the layout should be # rather intuitive. # # Lines that start with "#" (like this one) are considered comments and # are ignored by the parser. Beyond that, the configuration data is laid out # in a hierarchical fashion # # section_name: # variable_name: "some-value" # some_other_variable_name: 123 # a_subsection: # something: "something else" # # Where possible, we've commented this file to help you out, but you can also # use the ripe-atlas script to modify it for you. Simply type: # # $ ripe-atlas configure --help # # And the help text that appears will walk you through it. # # One good thing to put in here is your API key. This makes it easy to # generate measurements quickly. Defining your API key looks like this: # # authorisation: # create: "YOUR-API-KEY" # # Leaving this file empty won't hurt, but it will mean that you'll have to # use the --auth=YOUR-API-KEY flag every time you try to create a # measurement. # # What follows is a complete break down of all possible options, set initially # to their defaults. If you wish to change a default, simply change the value # to whatever you like and save this file. # ############################################################################ {payload} ripe-atlas-tools-3.1.0/ripe/atlas/tools/streaming.py000066400000000000000000000035531437041663000224720ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from typing import Iterator, Optional from ripe.atlas.cousteau import AtlasStream from ripe.atlas.sagan import Result from .settings import conf class Stream: """ Iterable wrapper for AtlasStream that yields sagan Results up to a specified capture limit and/or timeout """ def __init__( self, pk: int, capture_limit: Optional[int] = None, timeout: Optional[float] = None, ): self.pk = pk self.capture_limit = capture_limit self.timeout = timeout self.num_received = 0 def __iter__(self) -> Iterator[Result]: stream = AtlasStream(base_url=conf["stream-base-url"]) stream.connect() stream.subscribe("result", msm=self.pk) for event_name, payload in stream.iter(seconds=self.timeout): if event_name == "atlas_result": parsed = Result.get( payload, on_error=Result.ACTION_IGNORE, on_malformation=Result.ACTION_IGNORE, ) yield parsed self.num_received += 1 if self.num_received == self.capture_limit: break stream.disconnect() ripe-atlas-tools-3.1.0/ripe/atlas/tools/version.py000066400000000000000000000012611437041663000221600ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . __version__ = "3.1.0" ripe-atlas-tools-3.1.0/screenshots/000077500000000000000000000000001437041663000172565ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/screenshots/ripe-atlas-measure-ping.png000066400000000000000000005743241437041663000244360ustar00rootroot00000000000000PNG  IHDR(3'^ iCCPiccHPSǿ{oz%"%&H'ZW! JbGX *"@WE\ kE"}Ae],Pyy;3g/'ss*$4X tq4ϋ gJ!!Awxr\,fBPNdQ>KD,ɒs3t) 9i9a1`&"2Ǔ&@ayf6? աxl-(KPvOO|eSQY If\KY&-ʔ[zljc)R04~jF sX$d39qS,yצ D/WōbaOK3{%J9)IFB\?'9"zEQs835([P8Nzp\-:#+0 >QA.dY@ r| ( $H ɠ:*ʠ : ]n@B_`tX6g, 8 ^ y&ue  d! HHUHRT"5H#҂Ez!3aK+ccVa0e#:L3.3bX,M.cKgW~pX\ n9WkFxY|.1E|@&l 8K(!%\ tD%хL7wQ2ɄF ֒JI5Ǥwd2YL%kȥ^g Ŝ¡̧(()((T1ՓG͢nVQPR?)  u  FlŅ9%()8JhF&&צ歭-߶n]{ {^499:9Jk v;uV3y9..Y.']ttMu=bl샳xnn=Lx=z 25΁6\ -II_Bq!lV 9Qi,)J1j~TUh螘Y1+cnjƊbqQqF1] L,]pc´).-:?̫$pv' 9WOvMX,HtK,N|䖴-i0#$yHޤKz8u,-:6~V"N7gd,hXH%=]X<, ʄ2d6dT^֛]iIԒSK^fl㲁ߜc7[vEJʊUЪUM V_ZԵZ_1O;oM^z ACF6~/,.,)Z/͏?mJԺq---][=)V.)6g[vw,qľdNNΞҠ҆]Z\YU^[kt[O{_/EWUUW>`X?U%蒯̾5~x,}lL“&Fu81@kCyAO@ "%Nn`|$ܧf߉9}p~qT =g  6o cHRMz&u0`:pQ<bKGD (2: pHYs%%IR$tIME 8>T& PzTXtRaw profile type iccXi*^r@83P"^D-69,[Q/RoUD%bҭtsreڠjY^U.?YEuc崾,J-k~\BsGǐqw|iuRVspGj?ue=]!jz_Ҋe ujѡM V|ajρBEwKKݡkw!վ;ek?d֦IZy=>q:()udݷ_QiD K~}QDƇ'j5byOl6hv󾴊ķ T( -ڀJv?3A~Ki)w_}H/_K3nI~L>Z?YONqi-%}Xk)"0A%Ⱦk|x)P츢wb_)IxwOUӯ 3hډJ[<ӌ栣g17fb:T:1;6h<3Agqp89#mNL;MhJT߶+Av >4<)/}%Ab: ^fƄ?H'Hs/ȽFD]I(:U#W:J֍&ڸfܹ\0!sARUH|-, (m#TЇooB4 jJiWa0Rt aR .Dc5XR_:޼v;C:@B\`g+3щuбe̪COz5|ImZk[皼k l 3itjq969gYVDz^Nt ЉP}ͫ 4%^r$ώq#'8SGXk,¾fk4AKNk_aMV ^IK;(wA+ Io!l$f$Q]1c[B8ULRbɝzivVZ1 u0= DPy(4}eIa"E[#5YɶٜXuX:r{TA%F^fQ;̼RT&0 }غǶ8Òh V$bO=v\UF#9pX=q:?s8qYpEBmƺKIDm rn}xͥKApkf&[)%MSZ)-U)^OͰ"c[ɭf}$S6XCw U2+xfyT`{"I'K;Eɖ N3 w:;\ &ɞbvdFLJ(S@(P=G1t|f;/| ~8#PОrYM=*"QGj(H qiG;gLBer8x`6'UdXN l :X`vB,$%!uhFj/8 :QfkP!.Z;;%GP2*^P b6G1HMhzZ4/ea4v 3`jYX5L-hc C 0-F(%\lVdL5SZZ($><{TJ]jJymO6Zj~u::'tGgCd槦lv{<Qcyd&4=Z F sd'I ✳.{lY[[j ٰ-Jd9bh[! (Qߨ,QD;QZ abCmd)s5dSt6^yc2 m3lHgoqa>۬-kron)nF!אg(v7JIKQc;yR[v!5$M0@3 =e&LWcFMF7pY,t;"oeUZawUv/4ZpH=iN^:U@4lwBҦt' 13{SQFI}"E(ڱ)Xtc c dȈz%T g|w`䩑1: N~/3UeXzQisr`Ø6 i q8*AT"%rSI^mE8ɎC  y6~0!PcHuL քNXYu d[,}[ZFH* oja)U 6+}{/: l >g9;;6Ǹ~go el ڔ->BxZ|ԅ.6l+6KGcu!վaMeou#|Lh{N.'v\PRpPw`kwmuy=ACi6j6a(ꄓDi8||&G .hrf??i_7?u}86?MEG\w>Η|} OGϯg_n>9zTz߳}y|9uۮ^FE75XzTXtRaw profile type xmp(S[r0 )z9 _gwehH !ծ|}G^3-,Q}[O\oB2'+Oޝd̅6~&ĪVxs2nV. e1V%L 5(6(L2NR`[<%f쨼&A-gEnjIQ2Cq4X#caNvDXx!iIDATxw$G}OMؙ 9lnv/P#@amc~66lD@!$]9m9=ӳ;w}^hgzU*`B!B!B,BB!B!KB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!Ă52M.I!.ɱл"B!Ļlp!ew`!؜Ò η7m斏,fdx -a `}fŲ#4u/!K+%-;OkwgmhvޞKRZ$Q1P_?\wwo^m>9;)JQ|Wfן9i }S#HJdov13Bp uHˋ!a|(,^Fg߼<K$p@])0 B6gK8Yo2)rJHˉ%Agk?W;9֯z,dbCB;Gߩftĸ.59ʼnLW_u~3V ^nIi/N&15D}UZe;p RpfG=DvNele[r o PSg_JU\V&a#-'PmwuHϋan#=?}s>{:f'GD44O s~G0Y$c2 lvKWhhGt5av:h"a|]u[ha6淽Mˍ!-'e!u Pܖnߝf|;} J;ø\/gcX{s>U[KCYڛ=R#@i 2Rf|-Md,SÙ7$͒TˤkhbGV$Q*gŖ-Oghp_+M5CZN ri]#%348Fwǀ\JW͘@l;>84 PZlUrр^!V 'Yߝa>,?[CPR#)_IT;7]KV>vWCͽrKؘwoX=1B]kg]>hהd:-Mdن,qW1k?ߜߜxk錄 ЭBCN,~_iV](aɿ,ѷ>h{u|[=n> b1֍N/`ʿ7>Bt(`+ڸWtQ̊Cl؂//Jҩ-94=XW8/eOri&neRP9[ <A6 i\>c|];ywǖtm,V3o+`(C|Jf-N*^}Cc()1r|>N6":}q h} TMwBn!~/oLS묫ɏj2 ⨾0HWRj$|iAk7_b/I׮ɚ~qVh&xR#)X|c!xyY{(n2) ~3893<ЫNދ6ȏ-0k [`qS#Iύe d_; .8^5SXf!֫+q}PVIQsHSHˊAi+Q\`댿eb6fnP-5LxT_b8~idR~_sɇ~#kӣ8{ޮYA^i"u]Q.v(}#I',mbje+өγ?=4ىҩ&4+yh <`(K֤˝_ʆ uA680<# ip~u%n[:?5( JzUn MG2 x]7g5/0JR1~UYK76ףK^R zz@Zs?56ZZ#nd%iY~ҜK:P#{RDM;vFgӔ0y-@X[7:Z#=j.l>zWڱ[Y%DRsb]47ts=Z?v% erhnag8{xhO>\3?>т1 a<ݧ>vp.>p~S:sHJl6t oS#zO ΌhA{k|qNp1ONMÊ7 c.Fj7LleՖ\rHɎFwˮg9{ğKę悖nv0vq%dϮ}@ǯ<7` (:B^i"RsbhbwX=U 5˛ϝ+Oˎa<2 qj.oN|e997QH^i2\^jg׎s6xmsIϋgijt"9y^ll(pT_h[Jzn,=C~yc\\mM˧*϶p l+-S’ulz twg>'xUؒCbZ$fJ?GBb}_vxC*o+o\i9(mL'8{2ȏedM&ʤK~w(rb1)EVճtm&<ޞsL3,N6͌=h@nҵYT_j##7|ӿ<\-}_Y{s>+6g3'FL/"%#}5ScXsSZѴ@"%`Z4Aj.GrS#|w%&\.ښzE]TPPsջ^R;7g&q^vT_İj{YqCl؈KmS'֢[рMw|Wi장X=U[saܥ˛Oho,025'5*F\T_l ̦Y80)Z!y]Bz~JAW?wNg^%8#؟Av+4|7w?UnEOȯ0zvb> .J9i:΍wW%Ȍr\M̂8yyjYwk2 yxleVș+=3g럕,si4@c%)1\UGLDd }0hluk`^Ubj$[>TLvQf1mͽ{G߮jW&x4M16:N6^>ޏ\%(L&-]<4MZi DƆY'^G e0hf׎s.'#'~:z`N~>g}9$EL&tqȋG)l` z{ՠtɲTܜORj&34vOy0yږCDT(q׬7o:{4_k>y0[Ro_*|²/ u(YGW>ۯ\2 $Su7;MƢN>VoN+罷>囲Rq#8 02[A/eLߚϡݕty|(c;ΡAz/]("cop|o 9%&<FP3++4tw #2r'W:2泣1B#*6본$cpn'{u#c41N}Dxqcwf޹̏GUZ>[ c)ehMy4tՋƒWZW@tJ3b2@LVa7q}~?rۉ?  r>#)-Ԭ t!U͓q}M( 2"IɌJ-S_ەqx#M]E.NO3rq|ZLM+/Y |&k#[갓7,srjﭽZc\] \峽r'kn#:>' '̭? ƅBI 㯿!&ڿ+<; >e.M|+o7[|W1=d]vWyl|o6i}[>eRc7ͽ]s bB0CZN4?ѡ7+7n! 2Jb 7vNFOB @-_nuTo?^ ӏn-.Iʇw^羾wߺ[ (Xa.6ο,#:>=/gzE>14}|܅(mv+.] ꞇ2&!0;Hˉ6&.n=9k_nbӝE[CRs^#+)pj[/?uUxs(P:j'rb_-iQ$Gq''EO _C&4-rtO~W7by^P+NkHN"4 ď#\|$G2ϝ^8w(JOOT:5'7+oLf~1 (pfEq`-v^ߕmdVxH3y_덵]( 6@fyLb=(⮇+M",Ngk?7oNxMX vicSsd8(r;{_aM15fc~{V G/.ۘjb.[ FLcoENnb+5dsgB/x'\^~eҰXys_Ǿ{_`D$÷2NZS#IɘɿIO 8Oyrj}9tGa=1S}]Rbx>zBouݭfEq@_Dni">T^ wq`?o{p qayG{Ϋ_W}?1P"=7Л|o&3?ְuۃKwx'q'=󭗼b= *uw /'K>Yќ>P~?KͅVz|v yd9 a%e xirn#tE7$e^odUs82h# &G#z\퇤fGq\M$2xS[ pfFs`=v\ZCX.-'Ƹ>q8W:l6S$ɰ|εc{X1[̬ޖP(TM~k[)rT03lq k(7:zpZϿW߸̂xK1}Ջ< ]ךq)|ʾ/oFLBIZW&՝^_;8NWL&ErjLHɈuxA)bC&.KehϱYX1{Y\nwj,A&o)v_)R_Ͽe4?]Iϳ?=l|ESmfz;IHR9‰&FG5%avSl0Lolloxi=UX_,0~]j? ә}.q]9(-i5`$US5[GNrK.LxÃ~, 3Kf/vUP$D~nr1qxcU9}7V"8~J1} ؚRwVnAa녳YڕvtdG{̍J@OX^jfѪ4FGt9dz>SM>sN!kͯC*0ͺgʁeHgЀ!>C/3|Ow>o q(e^UlB4v>w}e9JSpNN"TߨG'-׸^x*p+I]J ב~d!~dmf@(OOMnf)x4^{?G߮6nنl>(^vAAm0!?s}4gzh28 /zȈw{;,Mrio )"+Rx}ꎳXLG3S\^8MW86}k1, A[ pmI[ x mxwgAnKJ{ɩOihCFeU&I)|Nv w57ym@w ُ799ɕlbdXD+ϵ_BBjY1t5ͤ 5EJz$}] c4tHYpDڱ[-hX}t9{stg!1![C6EKSû<}EɩQ T?/^iLY4=n::EoװB1bd{~6qx+YJ#_->ߝb|+y ]Ui Dw+Kh^>̿ Z^~J $S4SLK$)gozQrX*]O/;=#[eVN#1bk4Bmʅy]oijMɈ&&ɉDo  qD+(ߋM9RϪylN쭥bu{3P(rơm\/G3쳾D'gH>^e!?늤(z|'D{[_4ShGltzw z7.ɁI)|~4_&k2LO_32XX;qDc6 hܜ#)Mwʱ5^LnqPh<ԎFtw>G_'8#S\:~wkJ̮i(u$GмFj} בBӔa}}5qw v bHo=z{Z}]G[YsS> eס=OӦ1Kr`6AmUa"?}dTF#QwhEW/p:5qN{}i=¼S=vQ1+NkJ# 7riGOg)Pʸz!z~=DkCqz8 ̕y{u{b}g䝞k@_0JA9&h5mp&z|._GNj]!yηFzni91vxpMi+KGD1<4^j LfDdwXL,ߜC,=9Q,gyhPw-DKftm_ݕL?>94{|<!_^Dq&9zfLswngza6M2듉J)nĘ[sДƁ7=_ [gLcY%x%bg:N4"cC>w{Ygk^zd|7.8gVW`i"s0;˿>N4}Ƕ`a^|_w벸ce| x3iXuMtr>"=JzwKkѢ@5_!9=;c#D'KD'MC^lm&:ށR{8J|V1uwpCͤ|m&}Ü_]U9JɌğ+*T>%qA@H)0Q_/ۘEt|ؔ˟Lh)>lBisƧD=G|4َm"&!镽{1rbx@}'&S<^o羖kgt<GLpPܯ>r;z%k3Y6aNЮy_<[gf )O0JC84ES| 1Yt, )z)Qhht0tf;=Qj~<ޟa4Q۟wu44;]_ʸ1qXifx^ i{}Bh>uZwY/!z P8YU[MsW.vhڌ|GC?^}w`a~|=~>؟+\8LVQ<Nឳn9\œd%P,8/>᝞nAijM\vjYkSxZ'I>D̋2R p~RM0yK`zah` 5Zl1Gi5@[3ט3MLݤ➇S\l /=q>F|/wKqeNVnaن,~C+!O$g"<?炙Цܐ\\>BM,Ujklܗ1O7{qi3Ľg4)&άhRңik!&>q a2+J iy3z 5ZzZiOg1C@AJ+KWӋd|u5-EsaT繝rk|27e]@H)uR؂-|Sɼꝥ.J >5GGӕ.4-8} Fcm'qILW]hN)J)}x9ENδhoR|}یJN7r>g<~ael4g3q Y/iJ2{D .nB)T$Sy|׷_B+N41RC$O ƍOլO\*c/2'gZxW|mэ1UoW\>!hjbƎya 2i|Ckgt7?Qyz[;'Y8w"9T8)*wrKxg~6{__ۊVͽ6EϳsW׮CcRLPsIjWR,wr٣!"&m,cXg:I aQjxa|MJ3(pZ-h~;9i3>7Jl1GhJyؘ~_~#{u\$G| l }E`#avT(5E4h<B6 ʒW! ְTG~G?jY1$Πsg[xwhk_Mu]Wò&Q:.iߞ2|M)"Lh9󽽹FZl¿1ȷcE݂RL4FFwzp?UK 4byk=2irЭZG/>8=eN3ߪZӠmg}=w <=.{k=]$AՔ {qMp<=&̏G4tt\=4쿹܋u4ES]7 n)DŇ蔹63(p]`ȣ~yJ_x9wPE}u'aD_ ү??JD42[zyo{_<6xg"hJySSU;(?FM}@85PtXEr'Fב&F#q湃89:"h N5othAzM{.i93ޟ52>UWω5GO7]=j`lEL <'wfFM&j`tt0R2Q&%r=<&OU)#_fG_+? )gv#oU-3]ڛx8گm!4kh4^ .tjYܫedLj OܰLS}eMCchp|[tOdLߣR#рNkqxw+6 9#Kmzs>ٱiXIf^\@Ũ>&'EMQ,<5DYGh'f+N4ouM3wvty*w}Q;;c>'uÕ44.;rFFi?_G 傦.5oxxmHAY2J)q$XEkO_tsBŇF{K/#c4_FC#)=P4 >Χd<5ʜۿi_ +&ޟte =7;)KJļ/Ih苷mЂqs\$:|}և='2W(Լ-OEcM'Uw暩zDY1q#P'@i_mʿg6ؘ0C x Bt93j+_筽FBj~NoZ4M2ѠS:M?V,ޮ9*>^eltû+Y5㳐 e22<ƅ Ua[ȐvL}۴6xe7ݿϽw?!c`47B ahh8bb 5MppfD>LI7=*g222Yb}&#ã^5DK}7a6Jz|G2'0yx>{P ^}ľZOawr"9H=īsh7Xuȏ+6dqu!rK 36A\q+]<yq_DT?|W1ϋNt}Gy~b-ZgD::.A0W*;O4\qTvP9R]8!Iv>knl"$ͥ>:{zsuL(_4f&:xs+X"pT{(y Mi {"bIˋ窭)~}FO>fo adF^ᶥ49qG\]o hx% :RK|y'FFY1HSg^jٿNE`{ŒXb>9E ~5h(nh`튯63?e)EA4El>^Ԁ]Jav)vlw"gvnU-h(ʋf\>+F;!PJ 6Y;S`||ޮ!Pzǰ|* k+ 6[rA3qq꫟.q!@##ߨX;Z.~_׿-}QcvS+݃4h>zkѸ{/|nMyO[7_LsO1g0[ͬܚ/bd^v )]aN*L~iZZC4_!4F2kt}*gنxyb_- \y#+^ϗy+Qż~x?u8~ݷ24Fc]߸lޞS\¦BNņ,!{AtgTm&4N,#}3s?UNlֆ^)*Op6VHtL&lEix6<4F}UFPsP]E3sxk[8bX2kW'}!"C+8y 'qu -'c$#2|a%&GP_Iά(J0[L_;TO7S:7c 29@^iyh$G $p""CPTldTyd,>[M0,^J+ Q;x[9N|XNgzIҟ pi2ɻ9N6i/I!$hD)ȋtE]p|o5W YOjV4AMwZ/G Y/EbzpJWd3_ꉪst]_d9U;.N#_X,&ryU$8#Xy~:(]͠mqI4t]HQy2m}$D[Uo}(b"Xw;/7}DL&{>UN|^)ZOig~|fTCvQ)|ΥL =d'L+f\v\+DXz7OV'GūHuj3'OqDKfVq@-c.3xc+:"#X^}UäfF( y_η6@dLشg ˧uܱ6 gƁ7.r|{^WztGD0Yq8=ە8zIH1y{dR5g#A633Mts.|wN]3LoVm3qD>&NgMyXmf_LDkg m -My^]iLKaԑpq2EN ik9_$),wYO{sߌ OdL%+()OorArJ8V߫:+I{]/ `ŧDxUU[lРORBF9fGO7"*>.I"='>^|ܜ.εKVqFrZ44Ƴgx7'fM/%3;>ZFjN,1ѱD (.]\8Hrz4y.q_LXgy{g|̑z-MtE*YqtwPuvyI.Ia|C3E( ~mVaS7~ڣ쎏:BZN4Y ,Z_GwvSu¥)/ DŅU@d$6?sj}h飥а My2yX,fv8Ñ=^u^/o 鹱d%27WD:%)z-ĒU8Q_07yKzS:JjvY/N&$`z£]YNR'it'mGkQ1Hh`$8~_.ϷCvQ<%(t_[TkhQxU:ѱayٻ5C;џ dE*N#'%I[3/ǧ74)]FQH;!z:) 3./dQ(EIټDtfǒU@r'EK PuraLɌ*ȏ%3/` 15x2w>JlD%_HT\N4z;24ƹ DDžYOd ʓIɈfgN\KLˎ\FdFrzlUQ!:6eS.EɄ9}8f'%SINQ<[ "0SS?Ko 8u;Q^ٱdR8D,4t[?$%3Zʏ##?{݁gyd3669e̊! %INOp+Wzu[HAY ј-vp֫]zeS2Q^Gŷ%Xa}V}\-^AxT0eXIn^>Oe l1BY?qA~YKd'7uCpXم dS$WQYa}]*wMH"9-ڣC4+RqDO$xlq5fL)NIZ^,3?>ojV4ü )Ļ +Xz>j&.Ag[@O={Ujv FF/Tɝ>ӻal5\g6Qqv KHȘښz W@J) !,Fk-V3 JY)!,NgkO̗`"bBc`^"89760z!0FG LpAfR7ldaoB\ZLoȼC7j.Ǚ\K{:/Q7]K7tu xu6a|0a \:a'26gųStD؉ ~\?{C3*zI_ ^GvZ{nu4;!t{f@-u]sm+dЕ,KeMy1j},xq{%F8K.15\:vU7jߞ5 _9{מ l;%\&= i/Nrts\ۿ|S6>0d\.vW?dv8ߟ0M%,]ɶJyq=|E[ <A6 鹱\>c|xd%KYvgzv_ ?~k; X{K> hi!>ŁRb1S]U P R2cr|>N6":l ?Jtg,-ٟ'&dS'.B9{מ>!B!~Y$GyAfl_'s`MvWY=A]v9ѷkfn!,>tڜ~Nuذ-̪ 3QҟKX\[Ou?"q-o0zd2)s.0v‚^V{5M·9]K{d 2z{=~ң8{Abs8+]~ya ,mbj$WS{gzhrݑ1.j2 %\ϞNoՙ۽Kp{!W.{{k5syu4RKOE $n[&K?3YPH]324N\?)[ΊM9$GL+=hy?M=>sPJH)`JXwK>@/v}+inz`1ToP>/ߞq|ږKDT.?!5'5!88Mب >۩gE/Nl5jr쾇ϾkA_D2'O?zڋmm˜h@6~/=g|^jyqO}e#-Tma L -SBLlޚ1X-P\.퍽|w>L\?Y*[INB- sItFrg[#[CɲTޜGxd0O?kDF{^A&QPLZnfџ&#/gEϯbb qxyl=ޙ3YQ?DGK!V2 .N3Y߾JwǀA>4L3;+]47cXD!amʬpfEsx#-~ƑSH_{D}+Z-[CKc`+I ʒHˎݨ5ua)*O&)- [B6.l"5'1EFǩ<ۊXðXgn'!-{>Di;5He<v~kog=5jL&Kys+x=.=/sɝXJqE*G߮ؾrK[ȶ{Kx;oWBkC{vԠLxd=[/D=QdEr}y +wEJd™Mni"64vpk3YK!vUYNݒ{KimesU8yI|0&)ma~=|5 و6>Nsba'"&{fFDtH.VK$gDc[& HˎalxRZ{YR;#x5DDى,C+qfƐ[v+.|`ݭ]EW[ ~o - =N"Yk~ŧ]-ޮZrJ-1.smu2XMtPXDFn,ߙ=,7=3;iEʹ0{t) ,.sGk8ALwG?h^kCG@WQwoLO SޚhmW/Gbj_i:l,^AKsWߧ=]!B|/#U;׿~/}6bBMr^>Ժ[ pfFs@v^1ۥdp@gj$G7.mer'Gު N'8ۯ\էOz|<͠ɤS/]dD\6Gמ>sR2qDy3nWs^Uj[./?ug>(NGLːɀlj.ϭx~J#8$^9?j9ĴH3K'|A73<ٟ?YAt\_+6\#E+R9VW+Md=\:̓{{rDgyxg1ީ{h΍2i{m2xvJ̏fL29u?~˧x޹/nbc?=g>άhN7-] P4vEni"&`.R#<yIlP~|ߛ~|xga>Txd%˜Zyg>+QPq ZN%1-Hd~=t oȐw)4*i=ǧF6YiEV睓(c#h.?$Gr]:G>|twzLJ#-'Σ;f%_*.smVcx7G <2W>ʲY͊o\ hyHQCzYlAIq']#Ng[?7oN0>JOi& R8?N)A6 eIl`ư; @75Bl,ߔͯgGlc6V_Yv^_ B!>xsPx'oM"02B {#|̏z;hJW赝>? kaקs4v=ё1z83fn)d~uuG8sn$R1y?[:}}kZa 8MS$O ( FsDvq"O`707:f04M*GߪLzχbs'y8<8ʮXM,]9ocOywXׅjƙ㽟[rQJ <%̒ h?=Odo Ɋ-(bǓ}䃅%á]( }\f00õM~> LvQ~=Lc18}=,ߒɤx ׏G9WT(<MS8 bX=,&p)FKgfu7?YY x^ONq6 ՝h.(X5gbjn/b*LDT#|RTBVledל ՝42"xG?Tyfl1_nryo?j6|F98~B!xz_6364R6F"WBi0jhrЈ ̑zVoc]%DƄr|o XW/pXX2`vaԗE+ӈ f糁mdcb[ l 0h&l Gd0`+6>Ǡ~滋bu_TCЮ)ٿb܏U8}W?#>ʵiDz? HΈ{^j:A]}Us>L\FGXl#2\ЈMppv@5Ř4 MiY瞫wn$G5C>hul%Ȯ/at=b"cC8abc{ v==cԔU>iRMӮ\>OHʈ{xrf"6(|ChqzVkg<6UHdl0R`}he!vxY*a6~㻶`ݗ1^I[ʧyÃd'xUC#Y: WN&/?u|aEK(\̩)sNR>Lcxh lv  &0wӏgdسZ(`=AHX+6ec;Yg*]Fhxr6~4"cBC!BP*ksp)~/];P;{r` {9yC*isA@&bm /WSM& o;9,ېk[n.+Ĉe=){_Uwǿw=T5,Yo:wfgxpO~i`2+=mPfοOVtm&Ke3̩5U5k}f2)Z_ ެܚ^w+>^:jfŖ(g:΢iDdž=-@9? zw/N™Ho@/8+R у27Ž'MY%| n_0wܔOGK?9ZAGzޞҧGa !BPjfeZܬh3|ꋤRTx[r(ߐs?;} 'qa~>V Ň{)WRyu>F摯muHO\ޠՋ_s,*rJ9|"cBlae .n_AjN,N+ؒCņ,!N\xUZAtiqfŌ4piDM5NfycxfYTG@M|M4^z"@4i3v(WV-&(Hq.`| *ϴ2Rr*Tm'ncfn=J*X9Q˥9:gqCC##:4}tE2>Ǘra8+?(e@Yӹ|2+6g]HHMWrSAVB‚X99)!VvQ )9RW"B!dFβ (_7[QJFӠb5x,][ʝ(+]2:2f8 ]JF%Nښzw2lgX\So(9im}k~Zϲ^lb/JϿ;?V]sfyJg_|nWlcdpѡq~='0Ogwud>L 9ӡi Ԍ{yR>Gp%gDMûhmd&9#j攕"(Gd__PB3*=F`̺ݒR"8eKLҸRaokǁ4C(R#Q@Ce~3S}>./15\² YX6q2t1ʹ0w *ך u8DƄ3\²5J ȹ˝ _znE]Ӡ;KLeNJHE4L5M2^JD1Acm7Q P~勦3 S9[oo׍uh}\_8cxGNoodhh1NW})]ݟ`tlϝ6N[Sa`½>*H@j/Tzqv>wƿsI`x Ҽ,r4olf\|GQP9)IJ5|q!B Pr>P[℀hMo R.ͥqD6'{,&:Kt0>:_Zϗy0 062ۯ6a테m=dz *6d`<з"'}$LHmmoj_FA~*^̐Iግf?Y?_DzToEe21煀 9{@GX"o!AľZPpۃKVŵXL㼘|Sw|Ym^u|_gGK?X=g4X5mCm4n{p>5FVSdܼ|=s|O #/(]:k8tEf?j|WHfzfʌkQh>rv#ۿ/6)1>.Uvp+UOט1W*iwlv n)྇W0:ٟ˓ϟYssf AV??^kvgz^YYV-MtVz z"6A}U;#{4}Ü9|udz^ѴwS_3U[sQެp{'B!)yc*3-tS?KX'O{Bn@ +tDNq,o'%= 'XM,]IDL({vrD#+9s{qfŐWɬ8uʌs:L$=`ay3&ž7.+iە$7.]V Ϯ:6 %N2b$>9j/Z[M0IVcBH;a6&ƯNmb4+ž;u?+It|s|m ;L\E+Ұ,3t S?~]O3X*׷qjzItxUkȉ`AA+d=D|J`ϯj5s,̉3͔NgMXmf[D$j;I͌1<59%$iGA/z} ޹+ ΋Ҵ &bo摯o;WtAٍi| +X̜9]Y̊ /$Hخ6ugV4(Yf3S_ӏ7\)}BCu'vV|S6`+6`([N|r{Uu.wd;0ܓI͜,!)Yр,`@\ͱwj&Iˍ`I _GCu'J)bY"~a.n+-urgsXaږ8>5alu}Ü<߼ɹ%$GqB!}| JC|?]Aqy N4M{(wS-uR @_נ o~tqe҃&'5ď7_Jni˜y}ü Ms4d\F8}~o1o; wfdx'|.O6DņG_XEdJ=|(,O\Mk/?u $`;/{,12<Ɠ{{>,OC\]ubCZCG7ݷ$J1qS7K:Ɓ395,^`0wU 'Kf{ux勳(Ctg LxE44w _?pG˘ľޜƗ~u%RL<kó}:NcoCg>/ןEVfү380FD߿kx#3(oOUP\T ho&!%gqdk'Va|%oq"_kxS^E_dhZ{/(c [ȶsK4:,g7G[ng}#l텸Ƶ_*K f_˹ |y-JhI 4y>][b&N/Pޔ&42P.3G=GTPm]Bɷ {9{.5M?eNJhkyY9]F^ެ{ wyw!B ^,u?DĄ=Dw.ǟz _Gd0t5/RBXζ"FB" b=GTc !,Fkc kQxT0с#Ndl(}t ̿;'C_ZOvQB!&ߵ^|߸pgۉmb.8}:GR?^| .B!Y=AiS̴N\EXL#~$I]!BKFP@5v r-B!B9ErB!B! F^B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#J!B!B!ĂB!B!bHR!B!B`$@)B!B!X0B!B!B, P !B!B!(B!B! FB!B!B#D +B!B!BL,cln o_z᱅%!B!B!2)-$8PJKS]7'06ZDs@0c ;B!B!B j㇭V3w}i(`ܥ1;DXD0 EGkãf}n~?>!B!B|]J)2 iPs1lv KfR<ޅ>H ʒtyNt.!`}lRj$e\:ݲЇw]$MB!B!Ļu PؒCV~m}<ݷlxh_dgبZ 3JZv+c.FG{uZ)uo eC-$K'7oRs;1R"acdx,iJ/0d&84Yw.f` 2;@v؂ NɤX2WB!B0x+_FKCO@ۂڒKNI<ά4Es}?٣ƯrS߿N٪tVl!15DK]7 M]^r?ۜCbz$fh羮ޞ˪mGq4ښzx󹳜>tecLJd'`2whke9v ڔN3l hzlep`q)g9+0>hZAϷܿ{^NBJ8?<$Fa6+y'}HSBJf!a6 \jէOrT\y؟AS ݌=$}w3gkP@P{~|#cTqw(^BO?vpnRscQJgo~y}]=rpD\53>ujv kn# {HcT_hߜJ6FZ껩<Lչ6~XmVz<ԼB!B!=AI7?m4vsm+Y)]CKc/iٱ,]Ș᜕7fMxToN sc ľZm&5[n͹;ȩu{Xݒ5ȑU\ 15ٌS{xn0>IN&NdWgOӔb&,N{K/f Gt՝]l>.h{+-DT\(tLTl(3m&5;`| 5/Ș]ǿiୗ1?BTL(7oɾ?\GOZ,fB#l7a1 Kt4˅ME/g+X1~]M[c/9,]鳜Ul|u# )[}Wv06梠,켌6ey"ߛ{ K7ynctxB‚8OeaTk!4({_ZwDvFlCc>ut\pt g| BZN,Wqb_H Ini"GT36:NvqNKDƄQX̱wjE!B!OwBJhp3mR@$_|EtkK8> &EZN ?ЮJ,f0<4uQ P&rb߾~u7+?LfAvylKy{oOΩ{9ˍlcxClg6_5Jc~yD??ͩux糷k bn(q>ϬxRl6 ?Ժ|^\ n%JS<˅`dEq@v~^R@'wWW;]sw.gsP* ~>}P` HɊ+xҬߧAӢHNO3Ou=]|732v^i)f)s|xgaʿ^#+)pj[./?u|ڧ+NkHN"$ ƛ ribt !B!4?a#o[>83usjŲY^iAd0 `|ES]gVw v]-&Y^ؒR<|e׎sX,Y]2' !:|5qg2o5|zd@:/u]X&a'15*=G]88ye^&_2\o>]ΎUjfA9+E?aQ4L?q|;j]S$ y_˷d0izp;a(rˡ]( )#>?4꫻G4!B!B!xh5Ȍsl%26>@ʄh&E33h. 􏠩A"4gv yCM'aE0qy(v (L/xF(ES|*AB]S& j=8:GqWpPڛ{ W5ЊS"m 6Yݟ #?D*cٿ6ɚMo ڤ TA6}A(lv j7yC BLXJ!B!7̼3 C.h ~=Q1ƣ|\ #Xx|܅2EDbdpO~y= M DgJf梻}PGOa$zjiFtW=DKCIRsmIfT{<_oq3ly_:owQW~jW u BH u D cw;qI^c'qO؎kp\ދ(jPH~JvJyaܙg{朢|:1!$fP-EDRԺ=vG' -mX<ҧ6*E(yZEj^$)9xz;u&eR76wX .]X"H$D"H$V7PT5cgFAAkRPZ#9aQ1sPZAwYShj)?WTm6 ] |Cvs"WIfbޥ14iinr&RQVLJ]G y"J7?H$D"H$D M 9 _1\uE# uіI<Buj6P !;!ƌm<*y:RmqUL ""ƛcZܷ}*uC~2+FN#c}Ȝ`纓We@1_/4֎yg35Y=IZ0| u j.&CC-n~E[6PP(>YejR@-} dH Wdžs]O7ȍa/e׆S |q56_D"H$D"H$X?2g{hNf0szgCS3.ũlkmgړ6Ov-)9ᴴrtOY #( JGÍۻ4 :ktj o)bK)" q}P'8_@DO?FK9qaoE(턽{GXRqA'hTYRv[8bha#} Ή wMCYyEo4y\}" Sg%=kk衽&33x+B?y#Jp/H gڜDǚa\Wn "vhݟEjN8g_N"H$D"H$iA PY5HgIErj t#tPأa}}w@rm#bGpTPʐu$1tTMcI|HOL`S4]׉lԼ4uOrlYer#ytE58M`_Oyj wfpYj"c}Xeg]D|zp_+ExgTshWi^1i5/{6&oHrI36)pl]}ۊ9SxʏkGu~^v%_e|džLb.9IC] +oҀGl`Ƽdb菢(4@5qWt8n;*=hvo<@(ε{~ddJ (*Zg 4*O֤k&@7 K]uo= R1!h gb&\ǰ~&ubS}+}-OuWK"&)j+ @FgE6pԤOJH? P(;S{-m|fO!.5 VpDo=C1Df]rޟUMt14Եmm!Y.3Ɔ[Pn$dK~I$D"H$D"StuN(ՙMQBՅe8:ȅu\l;cr*ou5U7YT4SSوV;xYExq4\,1;y9i~56x9,LQ'W{y%ZQ'{j]֨تijWkuUMY6~rD"H$D"H (%L bL0}"#^yo_W72I$D"H$D"H$9=/4Ih4ݾSklHˋׅs8)H$D"H$D"DzPJJpd2ChkRWDCEllp 묖F"H$D"H$D4PJJLbFֆU7q9-C.D"H$D"H$@)H$D"H$D"H R"H$D"H$D" @)H$D"H$D"H iH$D"H$D"H$4PJ$D"H$D"H$AC(%D"H$D"H$ɠ! D"H$D"H$dАJD"H$D"H$D2hHD"H$D"H$D"4R"H$D"H$D" @)H$D"H$D"H iH$D"H$D"H$4PJ$D"H$D"H$AC(%D"H$D"H$ɠ! D"H$D"H$dАJD"H$D"H$D2hHD"H$D"H$D"4R"H$D"H$D" @)H$D"H$D"H iH$D"H$D"H$4PJ$D"H$D"H$AC(%D"H$D"H$ɠ! D"H$D"H$dАJD"H$D"H$D2hHD"H$D"H$D"4R"H$D"H$D" @)H$D"H$D"H iH$D"H$D"H$4PJ$D"H$D"H$AC(%D"H$D"H$ɠ! D"H$D"H$dАJD"H$D"H$D2hHD"1=n|)߈kA1 D"H$D_4PJ$ ȣ}1 vs$ɿ mnD"H$D"/@= H$~899o+>|t4(L,#*j nExDFF>̙n?!o 7w6666|`7K"H$D"3 PR tLUu5=zzƌI'8(@ Bߎ\qN:æۺ])>]M[ ֫ѨIKK&<,@/P\\ʖ۩L#8(;ws ڨT5ap'Nd-! &11 T*S8xc}w9j8r87nm@ ))aTWpq6mBAff!l߱LJJ )1//Ojjj9|kmŋ&ijn&V^Ka/{^zU:2AppB~~TVW{2pqq!:z.΃ Z7nnn2FJJ8p`7K"H$D"2  N3.*(@@kk+k~ǟ-ݍ2IIMIK$P: [ftpp`(@]}=w좵aɉS'qʀ? Č3Yz/LLLUUU& xP^AlL4kMccS2v\{L4E(2ё¿ŋZ}ccy{@fKy^m(.-%88ܜ,22>Ѝ߂=@Q/"!!vJKIFF*ZUך,¸l@9z(Ff:v3uɧEh(BfHVo{߿ 7ϾG{V;͒H$D"H$ R/_Ç ?CQ<< fȟn^{Ta<=z~R5 kɉdoێVu'ߏ}[; pyllILYףX4 W^1&(*JK }NbR<_/V b\n7\u#Q#Yz|fE!""[u\ŹsrEx9~g^̙ә7w}+C{z7,f:(h,u #Yn#[#z0?gާ!raMć ?к#hӻK$VB_|Y7]Ǹq٬\`7I"H$D"2pIrλ6Ο/g-g>=EF"7' ??_6o9o.[[ y#pqvW9{{{Փہ?hzKE{{m_..Z\}hZJ߰e31"  |xɀN:83ib@+%l߾`\@@?=YFEљb>mD>AA̼j: Ӡ *+*9z_/^BIIѲS&3iR>q(+=_}˖yHFGa,GE<LǴihx̗&OpiK3y з3: PS[ǝw?gձA\%D"H$\ЃҸ_QQ ppt0Q^[e PPUB=魞na2Ɍ5)))4nuQe|}]|MC\jv;bFDZ1^ޞT^BSP\Rw~BCV7U=Hqq)˾[ X>2ـ_[ر))s1݋18qeN9Î{QU`OSs#-cN>Y7]KSsYƒe?b{ngI?Lxo?˯pD!I PR;o5\joYr L2U<(С1(8STl4}$ft,fKF}i_xWE?xY7]CZJ(Ep5WҦW߰r<}w1uJrq9̙sGÏ?cru3N??_x$&Ƴa&~9_w̗x~qGԶF3عچyW޽hjjbax ''oFKQq2Yŋthl5۹k7ja%4$={Dk]]9QxE|:~D"H$]k02 Œxojسg?**JOŋVu“ ,,SxN (BgUvvv$%sMr JKTgg'&ߢ\F-Cח?W^}z租/U(!>!ww7Ν+g׮=|" 0> ˗+oc󡹹Ϭ]ٰa 6l!4$Pn]p3<?޿udﾃ:= 3gNgMTWt+!,]wI`3O6ѬZww߯g嚫`ÆT` Eh;vr+$"2@w>--u78n&{/O?k2wMz/;?_l9<ՏP_1mI ^K.gkb-OE5,i**X' Dcooo/NCXn |IHgw~^zNŋa-lظ BBBmjy?RUU͟;ZZZ9wcN0lX9} ͗8n{蟣K'~>BXX0.C]m-?*GKs R]]P2nD"H$T009qaqJZmk1̌ζ2']<j53fLci̘1WMgUqQhCw`hx1c:zVy덗;r XG^KVp@S (;[ƮhinzC777to"e޽V3/o:[[ 464_OrJ"W zӨՌKcc#6^:rͨQV77W/(h4jFWޢJgx@yT |Ip MMM|R4[r(Sՠ@Vmm]Q'ѶkoyM_`Oa0q݆M(%cd*Dٳg~CQ W%Fa̘ ZZt~]))-cVKyv ֮݀F&_4N.dũSgШ Z;j5*! .Y7?mmz<h[; #cyotENv~fT#󥶞݆KA*>G;Xogvl5}ʎv hk\jjjH$D"H$3`1( ~dtf "33V}o!&) >NwT Q1˃`@;0z?l߾)S zxyyn> @xXU'^% 687ogHKOe0\]\YbRU]c*|0 Eznci5̀\D"H$D&K\|Έ@}]=>tch՗ EUU' IGTTV3eeg;?of{whFO}KG0qb}P[[G}NFF*^^CM(`ccøl͝ůeFMM JrʔΞ;]{2TZZ現 8w[}A3Ν;˯(i{{;?ѣ eX0+Wwa@\PAkkC=(Yo=NgEEeK===pqrG~@瓮6*@ˣW٣N+:1䌡jZ $ 55 ^^^}ܣ0;w}}={ it<:KK%2t\g'x N{6*W@Mz-k%(0Au竺@A{{;Bk]N?malN9ceƭZgggx:*([Qy?TTVZ7_3:!NAu|ٙ&|ڽ Bv bsk o/ݜ캞J$D"H$ R;k?WNm];JKfjZW_/za'pe#mmV:2O;[z AASRRne5=cvV\C~8bqvv2y<\jjj(888Dq:\CP[m= xwV & -]FccAoՊ (BXxX## lY>>\rqqBecCB|:#eeg ݭ۳`h6#nZtaUA[`CooIZZiL,]wpyZm{c`$'=-SΠRHMI9HDVQt%$]{-h,So|@x`MBߺtΗHRHMMb|QպG@^'[tVv?DQQJyCo&)qɜ:uZ?_8klht̕qҙdN(*2U[Q@bУ:@)H$D"H&y9z?"G)P OEE%i|2EUa!lݺc <aT3ENKKVfO{%@ ȁ/6jkkiooϗS (/`{վ>> Yǭ@mm-y3uj/O1d-:+<$1 j{xz CEowТG}}KOYY@c}q|9MM44_W[9z#Gy7`l-~cyy91P]\nϗ:Xb۹kMd%gŅ6x46lY=hqu1U/g̡E( Hbu5+zv#8rD7_rsX0o6=_Ο/~O]7z:عk ͤ%ɧ_拫3?._eijjֵly.\DPJJR"H$D"X΀%DY>;:UG;;;Fi=c &(i+'UPP 32Rł9Bk& 88sob|^.F۵ع{{;L端t;" l۾w,&﻾;`Ig}[]ܹ?c3vgϞݕmccF 0޽yQyxxD}CO="NFF%!OPdͬWV^GQq  aaݾ//__o}DJl=Qa񬵵[w2{(al̈^{ nٳBTźHewslmh S׃FPC(**Ec{!8uwơo@X ueC=% !LϗSa|EԞFKE;D"H$1PZFEHVeܸl[i //V˴{oCB|,B蒊t iooG<5Yb uLߙH",Zq ~45Ǐ4/~+Pk4L8wNNCMsKv5:\\\pww3K:3H#99#GwzpR\\HO݈IKKѯUk֡U3W:MKK 1a"Fy4Q/C;rqP 4ܜSGW}ؾu'))ׇ'· ?>W8!ߗܜncArR“Xb qptdǎ]ؐI`` ?3+Y3FνiS'g_Y&~Hqws!K}C=z^zZ){u7SWWc2ӰᇟݍFm;),JEEѨY%C~Y<~۰z}7|}_:_KʈCjJ"gd݄_~i)̜1?pW]zW>),:k/ht)jk'!> 7m18_t3y<_:}m ]wwl),ڦjZ/7Q[W/i/v) vφ پcɄk֬4nٙAAe]Ϗ[YYY CC}=VdzȅƼ[fJFz* eg{ uYYY[ΠΛMfF ( -;ǻY߆MdgePUkLS\r'MLmiޞtRRFP8[V>W?}OX''RP-:O#--1v'b2%K Oill`tB<7x5OSgxw^FjznjHOKm]m=,F;VUWrHclVZ-Ǐdl1#?ɑ > +W<1^6m铹zWvMNɍ_rtﾷ`±3gy1`/g#/GMgI$rԃ݀k"11gϞIM]-'O㏫(+;;͓H$V"B.sfHsK3w ---ݤ8*GW(NNCx &I$?;B^"?o6666|`7kИXGTT$ P@}o`7 =ZϒH$ RV3g΍^SfAvv:ptnΪm '88t$6<=R~3E883>w,+W4T23 dǎ=v66*F2<* Ο/ĉlظ!r!$&ɓ8p0r 9)a"ȑclڴֶ/TBؾc@Rb^CRS[Xn/,7zZ`PUUVh0BQ vS"6vboh 9y4__ޮ5Y>33@v!HJJ`ذk~/ɉj8r6/'23 1O^wyc]/]èX" (<>և垻n#$$?5:DGGZűwSϘ]RP0O7BuNN8i!..QQ~fCdd8#G gas<<=u{1ԟ^C=0!`\_~c6, ||ԙ"֭Hmm]LJN.bzV7̹28dOà !@UZgy&PPs {Ii)AfK&9akkKii!A"#-^6-'|Y06#FD fNiiQ#y/Qs=w@cS.Ă<YѣeOٹskEk+U5ۑ43xoq=ͱYGgx@t1)py45{ɉ455Q^^Ï1(µ\ɕ~A/]M[נ>IXX$tQ@( eÝS'E֮oԩ3V7P޺`r OH4L7 !/7&((̌4&whZŧy]']dR` jI3yIXh H ={l}n]WLA( U8ّY~bx6d;0Оxy Ko򽽆rɠ@qyrӃ <䋧=tѻLr(oV,X0x w]}S>m"J;i0p0hhhÅy}zz W]1{ ֖,3wޱs  ;iQ().%0@Q yG'sGK8̟;qY!==+ʮ]{y_4~]wzƑ>>GŰ_>lȋVA(OvƘ0>q?[x{_p&!/w,OEE\,>puwwWpM1n\I`ޱ2#48 ~'¸ӭ-?,_m<{>Ĉhʉ.W,rv꺮hHNJdĺr:׋X7M&&&N9O=?=7ˮ{y[̝w}AbR<^Ƣ/_gCO=@?zbi͛/f@6AXX۷GBlُTTT7veøn PmKZX\[[=F- =imm5xxccG{{{늃CQaoogu̸jǎGcMg#GsL1bqg?Q_W \]]khh' $?^ ?I Vc3/\Dts-##GGG՗E_,Qn23ҬZ߂73ct/GaMf@9z8}u!?)?n\9?rIQeG],k(z#rވrAApttdtB!;;pׇvt/شi+=G;/qmۉ3 헫q ~3߸ {}b+--- ٽj1u(8Bk`6msK+7ne(*5wE=y_$83ѣAe-K}8pgW ~fDk-Ŀ^pXzŸwK 1.'<͞&7er7fiV}M[ض}'*bp]qtt$1~gNhuְOOF=ر/ bRϱb ےy6lܴg#/{uTbpvtt$atEg_wg}D]m=c;.zo6ÆEj|16N,Z(gN1rX h.bdfMiYve{ŭWLaOo{J=G{;8(=Ċ"ګ6mbѾoYU-S&3yR>hZJKW߲eve9c: q"T\|x%%.XzӍג 9oC`?&z0P5y:83iF%2"R\T׋m^?!nZrakg0nXlY>חVo|٠?8z2HGzs&&&M=T&*رc@m;:?sqvfq>|HGرc8bc"#=S߷Kc G=LosfPa~ X>A'cI|K{EQxwOcvãǟ.̙b]wJ`?=W]9 |}(-;Νv*wӍג riÇCAEm]-weH.90ixbyI.}x %@+h e5gٹsK`2L<OwOڵ픖/eVCxQxx3ɑ'观-#x߰obv#1 [v/.:rq ˗cǀ\rqfq9zF7Kg_v&ƛ;EyV__2)_"QÎf3b8-5lB ?~|:۷"++0}$I(|JHP6<;cm.2 Ú3ƤIT `?EwvgaP8}#cpr?"0muq# 3Dm]$~H||}(..1y驜9S̱֏S]2'"|]/ȃ݋"kbIoY2WIy.G>HYw9tp'{R?Ĭ{(믛,v|Wc&Ova~Sߌ\GL+YXWGE(>rİ޹ܜ1Čf $'M@(y66' 0Wr1HaRKx9S\ʁ:}ۓ{뮛,Y{>30.}pcGO7K>a nfgQT*26vw+ϾY];C~5Ă<@50)9S\lt#֓}BrhwGS_}30[n"(8w &3uJ>޼{qdg4PFGGϖm;ŇhhldNQq E60'Omi)--ceT*RSˋo|׫/OFt"y*w45)Iރ3{cذa('))ÇWDzz '|~VoXz-a$$D_˸lbVD^V+T&ņ7A:PO3b8(p`I o//*+*)/bJJJEhH-Z)ݲDG #4:QRRfӂ9ߗ6m;̊;)2_~{3wM1h"((m[J:}G 7鷠*"#"صkgϝibb˓摧;=` yGm.֭DFf*SNݍxWLxX(:޽ŖIOE瑜#:RFz*.>dKkqrl۾/)ᥗ_CIi_[J"-5O?5>f89RjkhjlBhooV4сC4lrG/:9i\qq)˖`(rW;a_۰?ڴ^Z@k2"7`|}PQ B0Q5_X%.** ?E\.dI̬덂B}m+*+QP:qyMk =pqv&{L:%%&SnFQ_oXػA$'(0&' 5j$~}(u2!xzrFvއ@BddEE%-BSDFt몯|^-B7[y]ZZbU9q9_KEw 7q_oYra$D|2rs)^]S'{١ojX~3%8::GbbãC7 +: j 5_..de֣}晣C _PR\کѫcxӧ#"tLOkWLaUy/ckk))9=~~$%3|x2_>Du|{}yv ,Eo=U}FZ7_8STd ەb 碶Q|Ϯb ;ˬ]L,@/_MMm\ݜyX =N}n+xGIJL ==[9~ȈpBC9u{ԔD@aSJ{#>Ȉ06o鋄8~&{ॗ^[Rz7̜9u7R]]ӭ\vV,]CՠVu7Zf 47jKK ۰q 6n!44Pn]0:}TUUҟ~GؕӧM"))UkvZn=^s7lR`<N>CXX qبlxo@<:b4D_0:vvv$%3k8z}j . *gg' Z>E./է3{GEEJŭ!aTn;]'zq:0>g8wc NpP g{/% XaSUUb[Çr}{o'-5ɓ&ϭv| !A,'ׇ˯3bpAzǏ4V>S6ftuuEAt y[zWr u=Ą xQ_W"\͑f<쀟w:Qr\9ey^!tat}hllDA1}٬l}1,24b|Y?aB.Xi7ax544"u_E(e.#D* B3W]5aaYrc秵ŨvNuYBwz .ezGuu-~&STwBnuq:})DFW'fu3BRJ%Glz-..\uT @QSTT-g&hUVUUUw5nLNCx/9#Qlx:o͞[IgOnwz2l5r]Q(jk:`oϾ`_Rg_tYnت/}[ yy9ht.Ohl0!{ a8ydBrTJaiڅ )ytglqt@1x4Z͛o?~;Xey/Y5uolJKϲk^]R$EX-ֆ+G})-է3Y>j~RFsa~\!L8`lBF͸qci)?clذ AZzrU*))ճ{>rT\A``uoP୿Ͱ]Ok70xo\z7KaemE/Tue„Lk=Zr Y PP=ׇ&/^rΝ/(x捋s!_S&˾Nkrβ[_NX I/[[ C=ihl7Orr"bU8q`RA{1r2i:9ib}77W-ۋ9cPQy؜~mjj shhh.Ѝ@&36Jf<h&(tMzF 9ٙja|^x)F5R3(+;#?KɓLKzW^=bMeegyg8q$SK/`T|O>mQSSB!d VW_/bEΜ)V.{ ~}ʩgر};vf]l߹;wc.vĽ 2RF&O9Ѩ0!F֭T3p}@]]}=GS7ts{u+ -O|R47Q0o7O:Î;پs7'1tL*.'O# )ɐ^Ply45Q`T~"zNYNin\ k{LPXx>xЧj>aMtl UFYV`` 9W7_ihj4o֋L?ɀxPw߭薵ѾPN g4Փ=w17e Z,@QT`;J|z}evnu|Kq"#qwwg Ffݡa!TU~>۶}'S's+9r؀4F63B$bժ'ioyPJK zQMHpc"WJ.9h袖p<,]#MMMŐ=&Ʀ&`-A̜9а^meSjܪqvv"??-6vIdk[77Rv J!j/// <4=r׽w \g;IIMJh6!3C~:H@MqHK_(\]\XbY_Jsdscgg+8ۣ E18珟(/ShbD.u JIIAtQNh0KNjѣ'@|{3<,P5>\>>CMkkUzj_SSC^8;;Q0ayRB/*'Z"0ss#P ,,{s=uy?IRRɉlW!c>WY%;+&Lҙ2p-7Q_YL[(dʲ?Zm@7_s3uG%kL:MMM89950QٿDcǧ4ܜYyLO?%˼Y0fVxټe;HޡO!qtlټ]={;}>oeѱ :~dCYA_?^b +Vgyo60,Ͽ͘gidV]T뉢յ]w/JBEkBÂ1o 7ؾ}'SpW5u7oX+\v*-sgaVgKK }ЫF2fL:Mn$3# gW-3jP yRA7tlH*s9ǿ;t_!t =ؾ}SLW5t(67_gKnjx,]},K?sv2 Kdpzz .|nhuc{aM@9`wtzt~;}$0Nh}FKċ?YaWc3ul02yr>my}Btq0QK7t蛍MM<G;~KAeAb=v?en[0Y䌡~}=:bqjSnjةW jj-e|К^jjt.sʻ9jIkzh{ME|CNjkٴq V|/g]ϨQX71l5L㞻n?#<ʅ4PbĂ<xI`ooorkh9k/|(## lY|}}(g'llT$mInNu%bkk+_/^BMM :Y7^ÓOhPF@1ng۸q+#ccHKMbL]z0O-v!ؿ EE}r/KTT$i)I'1`Yr,Hc_'!LQJ1DӘ55d-iq+<4瑑ᄇPZzN'?}}:')ylذx2ғ9u.(zjΙC}V;︕$???g؈{ ?wB1W@رƛsRhK%6y :pj(,@+rEgUv;DQd !464/*+Is#Apɉx:w'!(Bt3 p .'@/,55]l^Y " d|ҙٵ/IIY ª'N+;K`P nTVVY4q<;wgEh-#GȶTos[ϝ]8t{燖e`a1mS7ulxT$r/):a)55ܺ`n;R[Sc@T婧_0-^z2+~RkA9r>^A'GɝSR/^!CC?P\}JBH8pEE_a%ܩo? 9}{A~'N`}|}%y@{SZ06BXw승^*[Uk,zI' Vx{Ηd&M'1QǤٵ{Y/ꭿ/7V;k)## _Ky]19_z? vVqI(?}s, 8s5f~̟7llT[ ؄wssE(-2e̟7DBB+vQ=36 ϗDf^KM!Gȑc|gd`ln[0[<~9]ki|#Z(rlj$+B^I? Můj3g:5k[\yeHZZeꔉK[__X-#imM-mm;wtO%WQ:^#.c5Wʇn=| ~/v;;wd> pvv-: xMxx(iIJ7Oੌ] BAYB*/J`4>K繓3xpss.jΟ/^W)nBB:=|șnwrqǗ_-aїU[[[{|6{?;kkhmՕ:||@l<xՁС==@!=-[?ZbJJ nF9k_G> Sn N'ck:}Z2[n'#:=ŋ@U?( ? m\XX06*Yчw1rgxy`UT1Uߗû:}N{.^lE>BL\7p'taE{466ry9z~Fnn ̂7evZ[D& q`Μ8t7N^_RШլi&Ogô)[}}&z8} ;ơ|ży7s9l50_ ̾^tu5-B؅;~~<}; ϗ;~eaXV7P޵'1 VQYb#N 'u1I?,2A7&v9@rR~~$'Z6nwz#9:UĈ yo^ $,<=Xg}E~4Xyy[fG.DtY0N23RŭshmȢ/Z3qHp yrTSHv-;w!%%ɓ'v%&ƣR`& "oXYvZvCZJ'^xeSTTb>c'ٳG%=7ǎu?{i)?}n-vEDDiɀ,pd[BS3)?fJI {P&ݝBV|}}ȥ0@1P{#!trttUևx嵿S5k7Π믗i6jk6ݧرd&Mͷ?Im;{۹k)L27.݋FYF'8;;fZ|Sz-\l~}qLiɌfǁ_^gp}3gT\,Eg,j+CNŖ|qC18x?dy\ZNKfY@?Fi'1x1; **mX2(p+ICW,㤽\lmԌ#ފm4f5׫VG9`ca9}=?tm-P)p?Ft?DD3b"dͥJW )ұaE}s: @XXo}r=K/??KyN^v-\lmc yAHp )OXN!?uz.RSR4ؾ_ %{BV^GA~AFKW|XGqIW5+V~/~1R/}[{0:;߽{/O/eKzں:/4]F[{;ǏR#5Z-I8 wN=V-tn)> _lFwHKM"5e4.T.sQ#Ȼaf@0oM5ZM`r# &cߏֶ^9VH7ڙw5k~B0in9991nXZص|1=ԭWYFޞ+O;,~~{ceflj ']Qÿd„q̟7&۶5uۥ%::(**~}ew}U_aYo~}?y?ovBh5_~-ZSN^ G"CtδlGަ-ns_茑 i$'rNOe:E9F zDD fdfv|Grsj6Ռ8.z:4jriinn%4Ă<mmظyX4ׇpyZZ."NS\\Bqq m((8qjk͌g[{ȗ(.6,_(KgLˉ! <#+?և[immKy|j4)'!f;;nϮ{K{s{bߤR{˼'-]boonq;;oϮӟ,~ǂuO{23RIMMyTT$qq1TWPZj܈gc_s?wq B@Jjy[z Z!HMI4wL`nqvr{o<+/P3G;w@H28삻ۀWfF*iFHg&M^tVL^B=}߀aVP '7 YW߼~_%y?|Q`c[:咙rwE1KwO@sFqIK/Eif<3er?aodS:{؟yZ?>0kFm|ikSg77Bw}۶"9%ﺍ;väpg}̒a($%% <ё;vaalV&|纬"pOL>ʅ OF_6y7YcuMBBӧ=t.\s'wu6oΎdbF ?"-b*aa޽FCnNC==X2QF菇~޸l),3\1}"ع{;[ˏ?4և@ g݆KVfvdw@##@$%%(&ևpƍ&=={;{Nfpnm.v-M̛;NQV:^)2tZ{JY~cz]A]M6}+aKFZ2v71N1_t闹f C~l @(lcY[[ǦM}'qpWî{9t(5}M=IDAT?!&k7WNm78'u5'U={'''0bEp㵼'ajΝ=F'91]ڷ)ְ}^R5EQPT6c]A8DUeqq1w@wIJhbj8Deeq#c}wg~4j qb€ҕݻŽwΦ[hkk',,~U+!{>>9&Lȥ4<:8YxڤK?_Jt/3ao~wV@NKHEE%ӦMkgֿfMOhjjfhko'ǽNjr" .7nO,}b+;v"kL:dF6g撚:DP)TUUcpp466Ǎ7\JZ"}^gUU5O>"7x #IOKk?W`bddu#_1} (d& UU<ijy|d8%wqϛv>b)E!hbbVaێ]Z>Fcٰi ۷2[z Of9 ul߾qq/*+X~3Y7rO&BkcYd"Y^ywa.++ذac2hgʵ}ko1YddPΕ{UΠbރ[mg ؘ@wTtٿގ1$egϱ,~ce`3b !شq ӧOWvx{q * 2Ǥ ֭mŸ:w>22p }y_ErR +s˜t=)Yq3_|i(lzZ29cOJ(\qTвtfȥNvvZBrIJm[? E~\lܴ?h.FF's gӧ{ f yz{y(Z+L:ҹ E&fD41#@mK3o,ӓHOAQ,7ϻ\\ =ww3.tS]b ;(( ޞc2HIэ_YY~QO>o//ץ1É(>Zc=ٰa3wcN\ (c:e@FPw]:ƿ"oO0ebgwؘhFbơ2zD]&_KcXYj}Al6ڳ }uMUY*+;k;7lDVVu Zd;O3b755qWDBB#/|995j}~i&q53tj֯|LSSDg:&q3t^c TWz2{u8 qoogVe՚uL.@Cc[ğ*6ԔdwƨYWmHNMJJ"(4 XW|ģ_g *p#f̳Q V75>^̘qENyn}}P;Ѝ8bM$$SNh^'$yk5j$i)]W[~bU} B֘.O|>\l|Ыl֨;;uW*+ذ^/wFBʕϳKHOK###!+;ϻWA`H=~D'znQ#IKO\jWԽDCV7_P@QِyS.|[ZxL-g^^L2swGm. B:z?8@F& Пҁ+C==8w Ǯ./"~n Iuu f^uvvbPOJKEQՅ/XUYwA :pi,.kcϏ9^TUVYqSTS]Sc1OWkAܻ_񦮶W`EEWJJʺ1Fm!9_IJJpwwÃ[%)4 ~?o\zIT*yTr{݀>qq,HJL **9Ʀ[immHJJ`Xd559z60uFpp;ws:HJJ )1/rQ֮ŋMhrM@~UUhzZ[[9G?`ClFS@rhE]kN}.R>CgӦ-ܳ-f%Ky{(^Cwl۶'Nv+WP :е{ 'z0"Pp ?ȩg.op~Ahh0/5:bڂ<<=/uI_(~%5@vZPZf-7j:拇Go5_,a7~^C=0!Kkŋog6,1zS[[gXv#uVoWw7nFJJ8pЀ׿;! Џ@{nbj=<IeU5B~'i/{Gi>O̹3KV "#É"", ٷo X\OkpIOÇv.^4-4j5rg i)˦ڬ^`s S $+#Iyw8pǏd|^.od붝?{?3 6lB??_̛͈Q*NQs=wOcs3.T0"&U73̹<oǂhvo_WF.D+Jw>{B9(sfMNV""gΜ%ߏԔD AP_֛/s״;xWw,*jsj`Lÿ[:Ɣө1N1nɶm;ٽgQmwÏa#cIggl$'%NDuq# #ecoG\lqWIgؑ@mm60 |:zbJfpNJ{[ %%9;5%쬴=eAA.mz0<7t9gMUU52<<=3a7v3`@:p–;?r zҦhgFuuo EQUUvFVVV7 AOח'DMz8aN"G@T|i|{#p0?1cOhi7=9%J1%9GAj5X[[w|4έΰ`I445 jEGߘ+*9fP^v___G[cPVVq9 ri5P5l^NfIT6lڬ̺I+Ԧ ֬77O#oxnY:tUU5*'k?T^b/K:Yu?qC9x8!00i75A7@bc8tH f}I hJ'|b\ DYYY2th$7n qw1i8:99cG_~R/">>ٳzSV7ٳ&:j[N͡W  !((jjj>3+PUU H'Kqq\ 6 Jj)Qvc#`oo{XXYYakeCScMZ[[ѷ+\g٪ma!Ƥ1{]L?Sg_czޞHJKX`j7>L8AccϿ_~---_3|(622RfϋULhYHIIdbme͂K4hfϺ GKܫl۶K~ݯa@?iiɜ8y>95<6Ȟ=5x~OIp|Wr:$M:_˗|9ϞuǏɈ:z3V'EO[SN !(?Ŧ ܫ DXm`ig'MRD^c ƌ$3; /ww.V\f-_27'q ٴq -ILƛoL3Ͻ F|xFË,S>0EŊ .\Ʈ:2ab#%!#ժ<+ >?INJ@DN?G??fΘFPDrqvv(BCQ(_de)ޯ =EYygꝓpp2yrұaU/&VrQ) =fd2ǎ8ooog2 %Qn1[4_/1>r9#zhwɉ^(6gO'Q0q]`Ch?x!$ *ۍ!e`EޢCĂ\A4LE! 'xD[;Ɏt8ƌZ˓g~\c?XsPz#G1udq1޳W-@ccJ"LiY9e|gϞcF;nŋW"HLч㇟YtFoo/^xn.666lVDy%".6axLVT}7MEӃ/2Hii9/FK"1!@xOG zf1Ap GGRy,_FM߾.xzÆ[ "&*7xQer3;f6ljMKyy D74jjU5nnnA8zty\p𠪪ʫGʧ"+Va`?;;<ݹڥ# (+ʕk 8@UTmR_T7mmw!eoo7T\]]H|i'8x03BffVexxڽOϵk9z8剕U2 BCٷ˗+cop" fOg^L@?q6QCg~nAjJ"Fʇ XYZKpp_z''G:BXX(ׯkNA}Kɉ<|?_/AG~"6_JRbeL6-cy}M--tpL{{Z;M:O`uԠw{{;ݨndŗLENP~ *jHڰdu]wx{! 1'Gi|+tOcr 9-o3.$&ꚗaɔ_6z{QG8TR|=Ç~JccA:g~x㭷M^\?`/RZZU{9JJ)DYEJ;猖v0ij-]puu!)> /EG?}hllb~i>d@HtpV|^vGo싁ѭꊇqqQlظ`bbn+ +;1cFa*+1G?FyyP<|u466lݶE\LBMj7j djג^A+2P|OB΃ބ!O [NۜT՘N/ꊧ'qq1lܸА`:Ӌ/#++cFj^SX[e.WH o/bc^/z=~/!񦵭{{h&s޳s3T;7v^|ZlRDzZ sfߍm^νɉ>UGgGxy(UMrrZ+W*9u sUc]WUURcG̎{XNi_tT$wLȡGx_r~-^^|Əa"jkڥǡ˗ ԾsrrIsciiAaaM lt#"KZm/] p sfMW_+557:1Eq[rZ^{y&6wQ[wc^DDW¹s $*: /& ( MITpvqq}Sc ꬷ7bc:e2'Ofuz gggQSLGGyϐ Jϙ?gD7DũEj)֜w5׾\\|58kH|}}c%|%,TT=z19)DvhUwxzz<\y>1b8dcMhP:׮o@ʰD6m٦aTK0g]ߩAcFƍ[us~xגCDO}VV՗%^<I>L4"%4Mm;4!~C =/"SSx9||Õ=|D.>|x|)r9(jv@^~6 [`*׬7ʊUkRc<{ o/[4+E,Xe/&hX]%Kk+VY`ʔI>++W1.NN?XZZQVVuMv ]m>{@6,ٳχukoNN|qCmm}RLF?<8(ʪjƌ$$Di?hĎ]u b0͞}7)(" 3/SQif"`8Ǝׇ#Sџ10nHBCصc7k jjjrstLi8h;faaieT/mD'Oʕk j^ptzc{^z/94* /rZgٲUE;'C{? 'Uյ9svNNR&(^qPZYZIcSn0uijϽʓ?ȑ92ƆFd16c JLOT9'ZZn&fLB|lAXc7BILUsP @|B MPZjWHg d|j Yx?x/YiU,-gZ{כt:(8mmmYG}?l`mixo888 ",_Ƥ]\N;0jd/ ~~>a4vFpBٟ膋ڡ? \9wO}??_JJLJr"#sqۏ>D[YZNSSSN@GS}'aBINWsPd2c7Pr2ZNwذq II2DOT9ټoCttNRDښ5@NNVt͛3zTs2YpZ;A]߳k(.NS 7?wr!n \R! H=*z$ilPow%vѧҒY466mN ϦIuȘuFjꃋ3vv\|SceiI^n KFq5+KKrr35ˠaPHMSb$,--]I/Xh  @JVVdgw? >**.3J {`?IW) -^ҥ&:ŭ聘]`2eIʢꖀVfgXwtd*3zNDi2{$F^.=sN#444 зL&7?9zYh9?ԝ(j]s/(JKs [o8u%*@Y454허~c䟥%w "¥,[aNF/.SSDÞtwlaY;w5k7QdH7-qCI_3gYʼu ^+~!hllBʥ+ZkMhh ?Q5Ȕ0244T\d89: :*v5f`2Өz mmmee1gLs2/^X/%ihC"¥k9zT_QbP%ED%MGRVCGxOOJRbI琛_׮H'Ԥ=+l~"*]OcNz5zRap/Ke2hoo"̜y E◗͐!8::t{=P*[{(ǟ~2^8AuE]]= bggCӯT98j{A'v.U]B> P .]S::9`! ::v۶"66Ν %SOҥKD?OMRb!KKKHD] 6>JYyE EXX(vHtTj<&:*K/M'O(XWW- viW'|'QO" &ϏjD!eQK|\e%\B@.=*9d0>)onD `Rq^jNN,dZ]#f 6Z/8wxzsȀ, S80T4_/9bʝ <KN-uRD@Oa*_ː!׹;ߩU\CnT3(+G4@OHv dJqCQÇ)hС<؟ BRRBgO6 $?KnN&?lt71l=ozZۺS R 0Ax{y1GsGSsA.oS0 Q޳Y"8(  wqvFʵ+'{1k4yRqtgAye_RIss3׮_z&"'NĉS|;GҘ5.fϾ]~k.$֪5℈ j hw>vfaA(\4xشyх/*+CG:^N[[;^^ϕwHUTe///F,ʕ*; ZLWE*V{ww7DA"B; Aɹ*ER*Qdc'yطM$'% 8Gg'D;'9)/vbgkkJoRZNEz~Bʊ}. J24B[/.. _TOI>riM u'Tds|ձR#,\^ ikkۓQ ޡF'<5*+]''LEyH.C10AXvi)}ם?q?WH]?9(GG  x{yGs>By)C<*T#jTxOo@h~a4wd:;VFgWOޅNNj;OmBǓsUGtXvAd=H5@ZKTʕJ[hii^ "'N|;Gҙ=sgߥnb΅DnA{IzA;^ތO*ME{#>^̝*~ ~;Q z4o \r?'yO{E/Юj|)N"Ӧcҩ6d!^z-=c ?ӬAD#W牔 WL I6LL)+~LɁCEb|,(BzWEΝ/%<< 7~7}."6neܟ'Mwe^(Aj$zu<ӧZ @"hm°)zEjJ"ΞNku+ƺOnN:.ekμ%_BRB#/ hv붿3(+-cs)طIIq㏿T/. Ʌ2l)2./+**.3_o RD Q%x@!T}ՊGu'KK5 :gBCA<H>{|/46ogʵH{~-Y{ KЍ@{}G\>+4齽]}%$'Q8"?\]llС?O<> ?aXawL9?k$%3$"ܨu/rHgϗV5c{+=zin}wcꌨśC8y #7' M}Dl]t@9ٙuO%A&[[z:^t1rM Q!P Ddmδ|wJ׆/DDLA=(*QUX qp?hKcj@E6nBlt؍=YwKޮ`$%10>Enau`?9걏: xyPiÒ?EOET,/@ oo/ s(/Ȇ[ ʕ0-O جGTqؘ(vA uktmڼxr9wU}Fx8s\="l#11y#t/, z鹏)ҢA[2嗥D2jT}ZQQC9EQ?E0۶$3+Ԕ$c8q2"9D餼`0dePSRrIxSkk+6n ?õtZZQ_{ AJ>ݹ-9+$<| 3O}.,-0| vvsUSww7D~=}VечM[ ]xxQV7oFrR zvVo7hJ4ۙ rj~ٮnpDØ3gw?75֮Ĉy(ΪU54} zqrREgcFF~Q(_ LSsQ=>oo/&>?.Ԣ$ɓDd;H"FP[WnA[X$y e7S;| QAb~hb?,; ?,]iPʡXm"/gΞ3j-˕V`?t@;oR.տS\,2ԎӀصǧiRhyr{N c)m^5Քkڍ~>z~@Co޼x zAXFwE;_wG.\2L#tX||8uV~1{LgA{^@д]?Ek~!88Qhlj6}M]6OI>*[t7s/KnFG A1N5%zH.H'ڿ~y;o"klҥ+88!6&hJYl _Hg̨Bط66d9xKL,\\\XtA9JUM C#ࡣXYZ04r .VM[ '??7_{-vP/oۋdlmxrjՅ KK׳ ":: K vԤ}{:(Ok%99444rY %KWmF֏GDNN.'\U͂5H0cEVf)A\\ JKغmFА 3HNJΆgG֙{rP⢉:;s0RSzU i3..R 0пVҊ{9s, *FK@Ѯbڍ~;44A؍^P|`{z^0[;8;6W?mШ!&QyOA2(4553c4);ߚR/BdLKoՅG#VVVٳ_ϜE.o $$XZXQs}fmmuCoBt\홳Yn#y9۱wo g˼y?eA)=+V1G0i,,,PS_m;7l@y7xY6~={KH l7rfSS3w HLC@//O %+ ;o".W455қLv$9)#mry|3]DRWiIIdePj"˖PSSs/fذdӇ9} ˗fWН3Cg&Rn<=2_5'BgO~ giiɳ~K+KJb]߭Bi6Μ9SIKK!''Qy?[Y]]ö;HKKIȆ }^ESfΘFJr \tNoNmɰ 7Ϙ9} )$' +. o)4ٰa5*_vJp Wj߅ڐBBB y~4]pQپ}r;}Ý  (!zvZj{lݶSMni?IJJ) S=H|\ISOD>G3;%EM!}NhHJ'+}2y옑,[a _,%_JSaH7Zx7xOL"E;ww+#MMDG2|P r\)_~5dI͆Zt;"Uݶ5R "D Ȑ().ާAG7TRIJID@WtE?ӧ@JJZ?z/|PBpjx Aa"_oX;WW)@ڰQhvhosWV}Ec|a[ pwguDDtcrLڟcRN+۳gJ[l/|P`-FGv/=-nM[9s,3O%#= )ާS/hnn^wFRbCr'O1DžzoAZz r CW1 | 2 9wms3hjjoϽ !1ĄXA/oO93IL%11DVw7}#}쉏a@7iͧlR0-!w3I R[}>==ݙ8aG'7,5I*ȶmEj 5Nnl;o#rBYp (wUzi$ȥ|]aXq }X Foآo歜9{wO!#=LH=ź8WW,Br+\vT/P4Y"55[ۉBrRj|5k70k4A0IMm[蟠wLcC ؟?w66'\ļodeo<[^XYZC]]}t逋3nrJ xp|)/N nnڠDKZ+/u g'T^5{>\ڋQ=sΨt5 wjjj2e2~~><<ܩ1J5ύ[OOw-?Agg'+6='"b0O=+puu__W|Oq3|IG|Q[~\0L>/E&Cm|XX[[# FG(o?_y d2^;Y[[!nz"Wn%nv^2|vWo_W(++7BOB|3~:e#Ges?݈R-g=ϭ/FsqqݍyW*ޚopuuͭp+qSv㕫JgOq3vGOa,[dxsv73WT&O\'1_JJ=Gvvxzzn߭ﾓoX~30 3n 2zQ# f33OP(xL[` 8a 6 7~Ʈfa Oʼzp#͌=a.5rٻw?%%&,cfaГ]faN_F[[aF!Y4 3ڊ ZZZشyo:fnm#3zc" w~}SBcf񻄈 30%*.]ɧ^%0 "ce30Ìcei L[Č _xA 0 3mp|)55u4(fqf`vNafo̺!Z֯bF/ 30 30 30 30 3`Aifafafafaff0;(0 30 30 30 30Ì ffafafafaf4 30 30(~3¤Ǔ1~ 30 34 30`aaAB| >>޿a}Đ!qvv_ 3g s rs218,,,׬a#_Ż}¥K?WW  ݽ/u ={k6PQq~=30D@˵k\v~9L4fyd}xϏǏ_ 3g "}3gNBƚ͐CxN546W~W?Yܥ0gfazAieiwOa-9sΠ6BCHOOӃ:9/\`˖"r[HHX́Fppxa\\GG2X~oz)RS x~Ng-,dDFF6 ?._ʯgRT Qu@llٳ8rn~E6 :N8Ŏimk|&l@(58yE_xoM\l4nnq)lݶdwaVoZimm!! G9V@|| B_hW(mH``{tK\\4B(ڥ;ĀtRɗZ߀RsK٪G &<|A3:ts/ԧ%ӧɆO<;p؉nϡ_߾~EA@]_=c>IKKۃZ9.uv]DEL89^޺clE@_oKzo|9-6iAm]=Ηd( > \\>} /qȱ^3틟/>o$~FHP <+9FuM-""r~_rG]]A|i|򠾶 ~vSN|.??~Jz}Iޣ]ކ>0XX8u ?/eI(y( -"Z[Y^K f0ca)w>2299tjkk sfEVV=Æ%10?7G7 dxN[`}[GG;U{zŬ<(ngKKKy>bhnnU  ?a)|455fm(Hyy$E?/b&[p|aml(//'04RRyME 'ƚFJR"oATU5|,-yB`-ݶONN ''ںߵrLƀ0g=sZD@_2HIN薿t%k+'+3d7gdg(p9HM/ 0q? DZllmHa/(ڱ[o dePS|"&z(شy{|FZ*A*..]`=.rs2E_Ϝ?ҏDF壏0>jTL}#F G%mFD Hוѣ " Q8{|8(o%ݬ <QjtN{%;;QgϰD GB}_zϿQQ d"앨! 4a~@~( )A1~H@[kQOhǮ^yߨ!dmqf+,yMɗ %{$tE~={H?R%RC^̞5Aagi)W9c_.o%=d<ƍDj백!..Q1O>E/'o߾5vB.""Ν7o߾=Q!N;AAG"Zۘ|zAYK{{A,28|}5UUd2“O<̃Ã?mq-~Fs[-k0tNZYY1nHƎ)dÍc x?/( ,,,5s*ٙ16z^,5  hiiABB3.&>˗s_<#P+orn82sT>k7GP(D^z-&L̙S3ױ~cF"P^~?__Ξ}7ёlٺ--װ!|@?kTW֯ A?{xQ}V-ӝW*>Q"~>zׯ/O> +ou/ctv""/jkg0fG5'U_7n$䫯Q]]5̙u7?W*uFv~϶^L:fAm^}o*%+Ӄ 1-Wćf.KϏ~>JNWK†[=k:n%]V5k7ͷ{aVܼ3z|r(-( aM{eOݟW%L2 bc8x鑝# "Bo _JrƏb|Ưc3s?0W=A`@qQ:l:tYw=[ KsNx{x7(+0_u'9v\CDs_ϞyqCD3tGO8vݭ @D7n߬W Lpp |lP`5TUU cIA>#&~KufbogכSQ!fprtMVVXXpӧuV늅gmmm z3lɰ5IYw1ahN:3Ͻm;з …2H5|w7ԓQ/GKK ;:} |+qq&_Fz*VV,XTeX#")Iۛ?+k+~^K6HjrI\SOϐ?Ӓ9y4}5--sڵk8xX/m BP?akkN`os|7N.{=Í˗֏˗h}~_a۶"3Sbϋ5 'm?D&wϗ -#prv&4D]ٱc7wyCyuvg>_=)[|"+3 /oOv.V}~:׮]ͭ)9xXk՘e>8X3.&ͩgx$9-t!o"o= *bV?c1g]L7SNsm{ |3 4kWqrv0xn۾B㰲ed;7 Ihn^yowx?27aYnNu];5 aɜ̜9C˹52`8C##]ŋx/=VxxxЧ=/\ɰepD8/4 .Q˩IG+@BNJraaZ=3c/ G&XztVΧ1ؤe4!-GVz9g,,[Gi|p㚣> kHΈZ ds"HINBiY'Fm@ɷg̨H ,Y.kO> 0Iٮ#b-4 5θ߉nu*z1n8q&6ѣFHIEafįJ?\^x~.e9|SLݍG%LֆWO Fg;U4S Yʮ٩~L?HzNvjf0K.R C#m1Cޮ.=x?)ll}vS;Gϔv嫴3?&N(PYUɓx^k?[ni|j)]|Д5 1?_f@>JPPbشyw11Q8tȄBIΘ>?g"52//O~Cw5sô:(cb5$H'+P 'VVݟf,d+`o߇!DFF0`@O% )D@q6C#ٳw/[Ȩy:;hw,IL%8ėx'GG<,k5 $..cN/%''#|M$5s(޻-WINgԨ<4Qƌ)'P~K@HLcKThnjO d2ਹYώIIln@D)N7W{aKzݍWۍT =|'w_(o4Jc@W\]]HH|iNÔ^N KKCп=FS4w0x@D=r"[Vܜ3EHDžr#O|B,6mU.&&#3爎~=ĠAațyuدWBiy9%pFā%;'8rJ;Ǡ^^i)رnOYEJ.gϞVM?խ~/bcظi+!!ADE/!*,ZtƏ Z~y_Sx?_ŋ? [bE">6Py٩>>^8t޵( &M[t:996,K6[<U5KꊧqqQ߰DEG/`Ѣde3nL>bmcmE_o/&k=j&17 n%zA9<7 K֮ۨlؑz_hmeKR3n|}Xn#urg:N|&t(O>OC Zj-,q1$''rӿ!444%$Ģ@d{DUU|wy f=j ёL}<o:_d/4MmE֩KOKV}NNuu5|n۶{{;,--),̣qvwvۋvhrϜyS]S|fdcƌ >.Wߪ" W\k=g]uA_ _ ((訡d2^y-Q 2_o8(5!轮q\]~Ɔ(LSXj6A]e!.Wo?7v/z".ODA7U52sfK9o:qUh8q:0<7 %kתO__>L)._3  &O#z19)Qmۊ4Ԫw <=y)zIy>)Ǽ og$+?0>kn_$55M[ky۷b]@=:97kjyomtƘхǰqV_Z_}Ig]֩kDI1qrv≹u3Fk#HoC =/,gN).5%` F";+./ѻ\ހ KzwVF;gK܈芞ߖE0{yn&G|ah{Z,7гn>޴hV3b:svmRDڰ̹ __o֭1N.|qi4zXƆ(NӿrZ 3Ǎb@hVv&Mޢ?9g!xSNwk;E!; __/t${*sfޅdց(s2~ʰ8A&wPvWƎ-$8$;+UU|̋>vHBBٱk2̺^Fr_ <+Th?LIH:SHhU?x{{q*؇_dEG"^~o446P(6m2~>jH&OC%yŧ8qV=$=-{>,_;J9"=mDuEuu5L=&*z(.\|}%|IO2g]|_:9Ι#<zoxn&V֬^ Κ88Qã`!x长IvBdT}&5X| ?`~$KB{C/E)?+KKJYnF:[^qPZYZASSZ;>*O<0# QGsc2 u榠i|hi>} aQnBCILSsP @b| M8pnE\d2D,Z4̖@#^u`R)ֆ#h72ǟ AJ <$b0O?ҍ<@@ccY(5[y-5jÇgsW"Ν֭9sCҩz@9{vE;q1|Պ 3qh5á+,--yD-a5&p"0 7g|*/QRrPJR/pq1\J(e4;WŋدO\u8LA~ښ~}ry~1|WrRR[~BҒ =;0 x5L!3a-$%?1ܓohldm6a,ёy ~E/54j<خ`¥|*61ztYpqn'h̘q'qZQ~~ -a<}de&xz(p (6BG,b zIv4vrPOY=K<ܫ C *{C  ၇P)mc4r$'UO^ ߱xEpvrdM F cgkTTƤEDZc>%}ps릹6l5|7ww*/RJ'=*.y2(((ZADäS*ȕ+W;}V#"5o+k+.%?/?]=tw_օ/}$%(U'nbcgb Sǟtp%'%.z ͩj ޜ#W+bce׮b䍍&'bgg;`W(Dٲc\98SޞP˯\ޠɬS5.}]?ATKNJё+}ѧDî$bcgGF/E kX~c&0J obMFa*ӧ`a!c~7ft( 譳EQtuL]?v꙳o-vjq>F3񶱸uԞ; CGx'hSp?=z?q1$ǰS _J;wӠw[[or+-05% 'gXkױe2h}e#jgޭi'-Ǩ8.>m4U􊃲 ?"֫뫐}ϜdeUjGDSIDATQ8~ o";8yt/c> JFWWq *JBB ;va 4ف7n.H@]>uWwgt23H^Nlذ^L$ۓm1E'5 N{y2Z [Y`S+.]%9<н"$ޭR.o?HUѲ29c*z~ Ȱ*KWط}#\'C@|._ޟ(RWoCwW:"N._¿XDիŀ` 5"?Q!u*;[^M@ɁFHJCo7zޘ^$ox6Yxyz ELؚ(vKnnzƗ|DZ=|C Q=E/uyԯ__ijngz'=2A IxxxҢ)#Õ uuYϥ˕/ѻC{dv957ȑND^ )3g:Yi|m'廟5G/'~;ڵ" D]z뭸)ep8 BoQ{L'++oJ?oޏτ c C ;+Y3/}GN: HFhh4Y݌3% aDnvz3g:ٙi|3 gw7DaX9):de$D.0MvC#Y~E~=[r _~}qvvgJXpw̙ԯ9w1aرs6ntvjǍ˗w?V9'AK֬'6: %;}tPvl+XWWO[[MZO-A@c?YXI{{I w;ΝGEeNZCP p琔t MMMח_(an#IQڕD9/) RhBE:w݀d)*Jm :FiyE EXX(vvDtT;o//+A>DH]mf;uC@#ڳ70,4ZeqLr;/eSP||υŋA'DQҕ+m]2?Z|Yݩrkk+,^Nm]=sܭw>o~=󯴷md` ӣ*DzpYhh0\xY#/Մ89:"deQ[^Yz̞Δ)y@{ QK⪨(ꏼRE+~jD~.Ci#˯3_Jy粯fct>{=meuoiiR W"v֭:tDSBHJ'))\r3h^\PːALW_S[zZ[uWT|`X(ٙi5ѢE˨c컙r#P[?_w/o"?/)oza_k #[/O+$%QKr_@;wtw!>^<#RTMڹOYi̞ysf\G7m$ DA熨"".w xaY3hTE.\09)+K6njt+W!G~֎GSyNU˼<=P2d652+W@@Di,0(Ry:򘺻u'>^x{{2w# ShSO>d#ڷ-$'3τhܩ:8?IqT\ɢ2X rvvB\\Dy0d㴲*[98Ηj|'*X+:Qרpuۦ7-?O>Lǁ JW@>(,Z‚NC);P_/)z^^^OeeW⁈fzZZdHmRA oO>jŎyD|Y7+ýGʑy @хB@=e̩BF{{]nTYyA׋TbjSO>q1IJDG]=D{u+3gN#8( E#(oDG2ֲEpe+)ʡc ;~Ȕ?Пį1Ip-]hJrZXE'Nsi#YYi̞1ٳfb'>^ 4Iu(r:r{I7ܬPɣbhiAF7G!_vFzZ w}'N?}-(34f͜&5vc-wUqv_*\(; .i L,9p^~CEwQtaUU/"2WM@"BCrkSS3% @юzqhaiaгΟ'<| nn:{7m ??sҔWUzDTYYv=^NHpctԦ"@Y3|CMhCjJ"sLZk+ ~^jt{OwBXɠ-[thoWw I qǟ|&cc={/;Ҳlٲ )1B-E#GNv4EF/K7Ȑ!B}:8ċ:"c ]&VZ[[ٵ{/Y鄄(bTblм{ Μ=Ҟݓ?u(9^t6UE$GeemxzxKhTKSAH*4ڜ;Aa&ċ/>;Xr "CGgђܱ Nہv 1!#cuzFDR8FF(vUkS>rVYȨ]6,{#yV.9p^B|O:Ο/%))p?iT[__"RmjYRy[cP˺caLpw]_v/ 轾OrZ;zg+I…imnVNz?(׿KޫkYBƕW rVDkk[e (/5)!QB>2NUTGőG;jomj I!ާ4/k@4(Q9{ 0q+y9it/]LlL$>>z_ĐA":~#OלWɨ+ΠkQg҅;_v mX2;Ç Cz -vd AXE6lJ^^w ?lܸWM!G*JwD멲/̾U :rog5A}ӧhvN>Ù>r QIL v BCAOgRȞbݎ] Bbb q\Zgu˕(DC## zmESJĬ.,Z5DkE\oo/}iko| Mndgq,Q0\;>dggp%5]>4B Qfckk˘1<ZQ+oo/~^<<4i&gVE>B^nfL#';wۼy va>9sNw2eó5cA7pʺBSs#//YO7 .ADFѥ "##9Eq?IMI"!!'OIB&cjjkA snN& .,:t$'++vrE`8)[[[Yq3V(U ZA((DحEm/څS5僥n\|kJsSVVR=}Ҳr*)ʦٽ /7o_.,,rv=G"" q8ѢR/4Yf0o&%%?3(=[iSh׳nkmB^@<Xjg9PU=[ O?ó5'|M*tD|W65%8B:t05FYd<5Qr=.rr_/_Os2(9=_?=N\7ަwڟ:]䀁JA~.\,y>yOy1.UuQcpe!9QW_#:"LҟįgQRr[✄O+5}\]?!۩=S}}ikUN]p) =@s F(r 9B!])ց:ѣ Ōk%?3n,  Ɂ@=uD t;+xX oZZC^^63gL%))WS/d2k4rnLM\'}()9?~^)1/`ʝxYv.]QESzKW`o_ 666dgŪ8My%hni&x6.N,]ʠDƇC"x9x0VV 5N7nB/y9 l^D}}>^  szA(tuu᱇ʒ={q95K vMSS #cG /@vNMMnإV cpwpvv"';}]xO|rϱtJiEVvH|\ IIKKغMIhH$''`kcÙϩОm`X(1DE aG~={ >(D*+}_ggg\TW D}#.KB|,>0{Aᴵͼs88џ`P{#!>Fᴷ<θ:;!"+3 /44Dƭ__@к~gΞgڍbgo޽%XXXB/F8TWtz ǏL,>Aڰ$:PR+1HW;vWƃÎ!)1A¨χPEvwLٸȁ"+3 ~XdVė|W^ACCgΞر*mX8r8Ύdg»+:Z U@/`kcMNv>!lݶ\IX0 sOwQs^{( U^"++MwhHfO>%I\ZV'v{Ɉ\m|qr?~X;o7^dMg%&xˠA+hjjfiR)ͼ9.@r C.f]ɑ$0\?,`y.E\l4e,]Ro8;;Z2c|HH v"js`X(qqDEEhTVcXjWTǎ><ݾ3..NHD):bY'! X?$y(JQ~AC Do^r.o1jdu,^B2t,rhDXvȑT)+ҊC`J9x0VVV ̂tU\Rřa<нرv7?$ک'+D9c"ͼ ׆cTW0tNv%Cj7JYYNL[X-a}_`*;ښ'zzcee={9sr9BBFю=&SϜ=Ǻu)Nŗ2Sgw?j%/`&/fF.]?%nCuyǯH_gN K4h 3QzȍM(·F!X$m =G,-ٽX_ ":*K kX[YRܪ'Ζ˓}rI%_ `, \]PЍܴAIA?IMmA+ktDB3?&[ꠔ>ݎ+P]U͘хL}V@mM-۶@ssIߩ_|GfJBd{n~۶ׯR$Dn`f{ bHLEEj*#MMDGGrnG@(*8/0>kjjy7rmDG !9)#o.UJM #|)IIdePF; De+Vw렬^?&5%TDӧΰl*vޫF@XTc$pgTaߡ g`)lϞ}Ғgy+ K<Ķ]VA۴ygϞc)@}]={כvJcC#6lyQyO1s) $'Pq2_}5Ooo/bXz*r96l2s4R{߶;IKOA.o;>wwFCDv4(1xR6E-i$ǂ PQQ~dDŴ(RccƌV*] PwTغmr?7AS'OƟ{hӥP~΄c1} Ўȶ;y\II dfQD@dlgtL_z5l K"##Eӧϰlj_G_z^]ˣoHcS31ёLm Hܹ,"n(PYj;FP?Qp"D!k@JJ.Wwv \{ݴkfL4 K@Amm=[?h/ܢҒo\*Vk--|7F€,= [><\v˹sY@ذqV\Cr><"uulݦ}>;C;HOOAޠWH3_m"3$b "2٫?7mƙ1N҇)喪x?_;򶹹g_x;&FrR<1CP[qizU;IOKAzwnNu_cWn@`O~zٗXCUU .P+OզM>v| 2 6npp݋UAi}g& $&Ƃ(PSS^hOCrkkj~O>00l "ohfݺMZӣҟ 2iR\#}㵖k|i u:>;Ą8bZ gIU UQ[8(uG7 j|rDtPve6.jIt_~)!>F#kךN鿋%mX2 ]~2󾛯/u'F)dҤXZZnikqvvׇz]gF$wÝr-9T*qttjGo2I/eqpP"ɬځT* {=f r .ZowՕ'K-N%3Ǜ.VX'Na\?ܬXZr]_AuMJ[=={R__ϙ]viTgՠ'=+IԳWDO;;;M]]}[IsPjjj-WJ988 I6G|̙5?slErW.P׍'20 xK^1;vرsxүoz)dvر{t&BxW-cNG7kͲe+Icǎ;SW \1/_˓&@aA.Mnǎ;vBj;iǎPZZ*^cǎHDDx/'رc $""Ybn#\KrK5r(7p-Peocǎ?(2|c攟:ͬjv7!eGرcǎ.(r~mY9\=J+())eOٴyY رcTUWS`vع=8iǎ؃vرse9p ӦC;&破cǎ;vرcǎ;vرcUÞҎ;vرcǎ;vرcǎ;W {Ҏ;vرcǎ;vرcǎ;W {Ҏ;vرcǎ;vرcǎ;W {Ҏ;vرcǎE8;;_j7ŎǑ=xn;vر_=@iǎ;v:\.'9yW)vعtc<@\xx_رső$ onu2yyvscرj7jr ?|S\aУgj8z8.^Fy<;v؈\&M .p3pnҟ׍%q@<|ˮquuG ߗWM;pdG} `-P,^j7QTGhD%O?j7!92^_g $1)Hٿmҥ./((#a]Z4B(޲ϤIuM-`5\lR`7l*ܹ*$uu477wS飾}{?/?AhޣEޛ/Y.7_NXBHOhH$ѣٳߨ(*̣{w/e^ @6n#Gur+: N5O?t{NXX0{7R'{08(wm09E=?ټyACz`DnN驼;67e8:(9YvА`rruY}iS&ۧsUU& BEB|.\(22RPT,[hyLUu:@qff0uT$$q5TU&?-;k 1F ?ND^:m*^dY!d"#-xz GNDn 22Ryurk0th\HJJ@ 2we2  E= L"HN>T*{$& JȈ~'./+VfmMOK!?'j3}b9)+-'4$Ad5~֠{BHp9S$n,cG''GPo?c zjrXRwO:cR`=@ToX10#|FuvD ͸Ĥxzy٬^6[TnH^6(7mˏBKOO!7/jсð!Hrus&))fg.?ם3ƍͯ+$In cGGH2qrt$)i-vB^ sFZi>fr*c  &c8$I\wƎ5z,)y-O;j4s AuU N$%%pqO  "''4ݽ5hiiğ/@YTO˥8rsٵ{7~/*+!߿w̲@ijs+^@.ѷoojjYngIRɘ5j(%eyθ4osCR!˙rDrskÛiRA~,_3#ILv37\?gβ~&=_ݙ5kxٗ8t^3kƍb-mZ߃E%O=v}ؾWZRFPpYin&!!U 8::+,_TOKK ˖Ws窮vԨwɮFoTz3ۓ_^GÐғeG̚y/B\~ErSo&䄹OT?V=rc9}^"IG}_OXgs|A?dJ\ ȗ_}gqE\j1ѣ;Μ =z? I?=Ӌ}ߝj{﹃x~mOLe"9Kg0f8GdiAzu NCQT-̚9[Q1?I̲;:K0p%_lZ(  71z^gC;YCg?)=-[w_]0mMu4N6r}&GEZR`]5í@Gb箽|mq5qƍ-ݼ&#=1cFu>:?O{*=mS_~%إDGEJqVM~?q@_~YBe9@fr۶޳Ow"#l> AGܕ]FZ눺࠴]xJ'G;AI^妏=:998;;i[.h6&7ϱz:L]\\HHDIfϞ֏---|֑s9ACC#O<<~ϟy:_~@}ؖ A9ڄ"zebJsts!jOqFr}YVYB\!!A ΁9^pw26# o6{?NNNxx t]!ڨZ`)>ޜ:ͩZxXf2qpT2g\.apkrI"3#Ũd544+I ܽx".\OϞ=ۧ7;SW9zCgH/7=DGGʦ-fكgtp0 EcGr{YV0f[*n[f֮M[$qz^lx{bێ]6EB€?kO|18kbiSobܘ8|Gxի׃x}... HωCY&փz~xYSk֬E?X֓xS$A+Roii ߁Ĥih'?k茟',\n#۫;E֮-dBdf|bԛ7v$O8Hb8m;ص{DEiQ4zL?zx$ :SfTϳw-aGZ%Κ{ȥ1ё ^H>tCĉ6}ƻNPP?:Ŗ-;yBuiɥ}yO )DmmwNY\߿/dI~@\eIbdǛSlٺ ~5?h+Gw/T-*5<,r9=qqq'A2889зo,O?0 u9nq8w77Ab{] ]9Heo+k3,wpPT^1H>x6sѧw/F%IYEy `ɒf}?;k ;~CrؿzERZ30az^\ "",jǰ!dfV{B2lOl}zn|VY>{ԡ($} #$$Y'g'CA`_LX++*CX0~dIwWɝ|xH`Xka;defnsѨ7wE%8U~9f׌EB|JGscrwi[T3狎$&!G9q~}{G1ԟ0pP1c޽O=?Ǐ#77 G#388qFTBPYY;JKl>& 75?-?"$c'o!z/FҼ|:eJ//ORS9qȮ{ %9i+~_YRbRݮ=ݎ>cؽv\\Nee%gV}Ĉ"JKebz&,4fAs+dI .!Waa +Z~4_bsYyἼ{!  䮻23(-+g. 7|7!zѩw?Izyyy}f:+-WBRӖ*\9s2w77J]VՇڞZJ;_֢c/I2;|ךx>A=?9~#$Gޱ@_z446mB V@w44WNr1 ]ʾF^ ¶vrg .g޶^Q;{w/|HNgٲDEEߟ_x !য়擓3ѣlJ- 0jPrõ3%)F JV^OiY9.OLL3g=n3..H@U}tdY /3ߎ  !9y+VhQ$hQť[7dw&؊^zfYt55uv-xҩww7ۢ_3@zzVި3gr## 1ۘRRAtWTϿnaDFn&v$qرsvۛ~'qYz5ZeЭ+YܽMs՚uP(6tM,_q`Ygkn` i7S[W{sUU^䂞dF#9i˖Ͼl{ӴpqfWoF_\̳/s CIL&^J0ixlEsưs $ԂJ M#ёx&Np=R0$7:Zg$ ;ԗ[oOm]H6>Ɍ~TB˘>y2ř3gزufNGÐl EN>jdU锭ir;33n'-5aCb^FXX03%KOŠu6JxxӧMU.U{ us5~+`uYf\zmMc$%#P_yaf^`-}zf gfq|9Qwjo@}]=IGxxxu :zߓ %[?ܝ0a<-CqpP>v饷|CC#*!,!ߏ뼬0<9(2 nRWW@[Zu!(@2YT[˱c'$^z?ohhg3洓a ?$?_s͟ƨEF' BHD<@Y g~GrG '2"YԼϗ1?<9}dee+ɾG{S:eow=@uF^:dS;3_UUVn *\/]s!yV?G&MFB|70;wvOp5Mn,X`oNzYYurC㮏Hpa;$/Bŝ\k3VZK֠ ML`@K[Gq1&$\]]yv3>\γhp&ϬAvsۮkؚ0џڟ;A\WW$lo/ pwwgؑDF?޴wIRPMcckTԧO,!!A˕ǟc /*bB< f (gmN+XwL@RbCvF"HMI PJDJڽ}_c#3%[aa$hKhj:y ܹڷ)r$IpI7W[[g5y!NN 6Z΂[8(Gn "!hhhRg+}F(`H6*WW_ϱqW9o]`|9J"9)˅BBfH$ޣ o*!_MoI;@9bx!eضmAAH<=m0@ EuN@]_Jı<mNHehQ>={Ϸ R* rihl ?{b7`YHS2Dؾ}j=zdŶlJS  7 k~_kMB|PT*Ï<._aRAG.U5YĐ! UL|^}TTLˎ0덄LHBpY~Čh:^emIґ/r*;+,'$n:uvv) zU\]!?hU*RШο#G#T-$%%տf(@eT?XN:}ڢrJ,ڃ/Il׫FlDњkrTl;l shh4BA~`ugh庨$7DRTόn,N6{Xߋny+K0c'pqvBR{I|O_[BAnn Ysyz!,$dyj'i> ll'ke0sVH9ϩ^¢|$!_z͟-`==ӏ۰n 55Sߣ"bժ#mf73<,Z~qPڦ⭌^ĵ׌ƻgOVY;}q9X@sphٲZI_x:ArIpoF("#YToB%ZwUnu .\ 7\Ó?Ȃijl"./xnT xzzүooƍExx(onSW:(BEs77W ryOR6J/\\ߐ}O]JllU!l߾&{NHINdSzZ n,Z-?]]$4FS~OmݝK/rt//\\\prrBNJCPHm -[%^|5Z.Kzk>CXەyadGa!2||GFOfχ͗,ک)I?[E|ޅJ Jg;8(x}ܶj$ptrҩى7E\ތ;P~<; ,6 .\_t~j؄k7**mw@s釥;RpwgaG{ I'a NTjؕ%:NӠ+tdd΂_L?kp7Z-{ ''cJjEm/ 7\ǓO<Ȃijj}tpu|)pђU1$uPA~Yh]ލNCҸX`>`cG8;gu1^^˵F;~lu!ʛY;FjH#BkO=z|V\ ZMk]%ɓ'"W(ֈMOKÝE 狓.L5tKOpp7SWWOfF*ΖQ9\ηhۀ}A$@QYY\Ê1x{`W,ѹGVr5!`|'Ns/SWWg:%ʡE`iNF3&:}299Y|7,U gB]3_|_~٦aYS[ GG~ l3< Z fѽ;4?c>z2$$zq<˯n&;g g ,_D$YfRO on=>ݳCc.u\u k?_R0{ ߓwE]]=߀־ܜLew'M ֠ᅜ9]p馾5f8$+mvsi˃וLX_gx^XOTTNrha>B%XtߝdJ}};v 11PS=HKMBmd ‚\r!;+uM*kYקz䒞7AHBS%+,QSS~=pww {2poo"񦩩Ik7IU-_h tBN:˖-勄Du55krg =fO_]]=ܝ2e"N^6C:UePX= BP[[_OFF*=8keE9SX6s vOgg]Mrl+E:sFKיMsvߏKk0aD.i1T*),㞻nC 嫯g`F*>>=aJ#y|f}+[z쥢|@$Q_fb iͻJ';k2Z/z(?wvvRo60Z^kd99YLe.^~.h!dּ8:VOѣ;n465أ}_HjLBIra^6}29ju7lJ]߿/KI֞<%u/nA|շ:qkƍW0G4Iǖ.]Z ]O_}=gN<ںz֭pE晵LxXt!pl}a;bۭ:iK]r[{l 4,SU'soSww7r8Z.]^1d__6Кikjmd&Lyf필p5677iIIֲ{>uJmDTR]Vm{ %ZZTڵqܹ1ё%İ| Ï0 X ϛ~kGaުH귆'IΏf=?̏?'88JKqpp`I--j q}qss񿚚Z$ΎRX漺vCն P \͵*D[u554_D&o++!Z ,"orwsE&GK,Wo q@<;vLFjJ29du/Iw9$v_}éSghllG8fNvdH֝DÅP=''GTZT-~G-tCïh; %POhhU wFF[LL.΄HB|\gT$!>SOVU }MM-BRk7 j5ʩ׿(*:%\݂\!w!8$MM[?(--A*a'BN:Cpp^^Fψ4w+rYSS BI- A $)V1ye[CpP.ϗ ZZ.ӦLBբ2)gk0>aAxxzֻ28.]j1"oooe66cZןqO^S(mbOcHjJZM#Ν$-5Դdol?Z5u2۶/1=> |UzdF]_(gVo[ 8JaAC mve3G ٿzΝG"-5$ 70a-y -ۍڟj{W3((55W+,ʀ?$ Ϗg0]U{k;o+DmzoڴiS'\&yR x SoDjJs~Ghh0>,^ɭ‚7hgΜ<.\ŗ_1`C?p/ALfO ɚ#@!Ϟ!mε qDv_mvB]k~[U0--BɊW[|鳕d2n4\Ϗ 9{[>ElK*}}1g+EU9]3쉶lNcyҒ9F%Y;2K7""$Nԩm >1}ʌ:A43ٳ䒇;8~& .^IhnZ?4ou&t#amju[7u/?N_}K-3rDzkw:.]jߗ#rLN9Tt؝U La @жtC  %˭(+?EPp>f(BF?f{y#lLm74p_Z.]jߏ#W|}AHlX A|_ؿ oEGΆ /Ihܭ~*!8.JOKFd sig[$lɎ!=-_|~?}< Pzp}s{;>>=uEN *A:b OXSHI7>4>.g-Ԥ<8˲8]QA@iym z C.Z/c[fhͦy3C߯7>&O uҟjc)epM7~Ǹ kMyσ3U=RW_wBcXM_tt$P\?qfNDXXr\o&u};1IOInJA8ȗ_GnNSLR56Ǹ('kP&o}ۦ5gmm--.ˈETc'#MW(mϾTWZ 0LLlY'`@hّ&IrR~$'"1y[OPMW?AzB/_EaAAGqVG;eaᲞ0-VT|?_usi2igewwnXfF*M/2{\y{Rڒ"$$lNk hiQe6RS:DK1& G Xh}!eqD}-lݺԔd {}U_bbYlKD.|ܴߡ]N얖S6?ggvӵ?x? xłݦ[m%>$v_`h[ݪ'zG\IaA.!AD7w sm{^aݶm'O?<}HB@w83o!!eq }i !I&(2TTΠ~viccg>kLx񸆿Ey,-cUfط]0ZEEq\{KnGBCɳ/=6PQ[%UK B%8tgv$1{\;܎:bDB*:./NNNhc$ -5$***ԗ.iѷ,\׬]O12ybR*ͻߏs:OsKKkfejtss3VbhJn`Ο?֜UZȮl%899QP ׍bE>K];A6݁isaI{r?WT ٱbZRRScm!W49rh}>xFp@!Wh~_CjJ2u :~𾶛ϔ&3]?3 9?]rCCjL~6_$O[frFrr2 K~(nC X7a?/yդ&QGɓef{a7ʚ {@Om;[|"eX.L~<<´nf\?~/,/j[/OE涳]eD/?X.6_OJwXo qwƼ%gy#GY/pZ.1\ HЯe@//.GFǯg'gkk3#f~]׮YO^͖K7ٺ}'oY;'TF,ǻ>No6SQT^v=?m?~Kw ꋱKzvU Iw綱yOKsyvםӈmٶBݟ7uN4.դ%Q_WoЃၐ$r23Riiiat]rI!TF.Ff„xXdNյ$'&p$?/XdFI0b[H~n62v4b4?O\<<ݙ"ڽʪ*{`(Jay:o/_Ehpy'Yjuu#|Rkb{yyrߌ;Q:(شq p#WYv#W~5׀߿/AAxyz"$˦#GȎ^HZJ"׎EϞ=ؽgnn {wO`|3rUiH&$% GdIV)Anni)8:9rqy#zD@||_֭đǐ$238[QeMaz3Ď(޴DV6oފ/Ê hni/3Yzt$PSfSyv|:t-|<<=d/H.z$JJNje2Gcې+d $8$^}+taBnPK+UB)gl'}}}40]8BCC ::Kfݻsٝκptt -5ޱTTHLLvv1G¶mP:(<={0wa|~ I@^`9rq4!iiI\3n4={{>=ˀ\Ҍ`䈡yvLG˗$$8‚<^xIV^K]]=dLY=i֛}|z"FڗבzGFzJJJuюٴi ) ?? Bs%4gǎl,֔ӖZL }ch"1ic=zMHlEQƠiղnS"#LzZ2NNN9zwئ'c 1ocovͦj9])޼ ??_ ҥxn69ߺCBC~_{~ e)I٣;ݻz ---4461喉oꜼ/Foݍҩh/?{k4Ѷ;Q&==''G9;~)#Zױ#ٱp$I٣G8%̑G^iuqqf"kj;od2@.ӿ. PڽsUUdǎ](Jayw ڽ*ۍR̞=.-w3x 3u6r%#׿ecHEbRvm{yMff:g+GqӶ U At:AmjxdV;G.V"8$=:80G|ȀTq9J]]=$TɴT464r䉭В>?rrr9e_]]=v6nG@Rr<%%:q޽{qɨP-Llu/}_}kvkinT/3%7s<`z988hP݋ۦBP-S&5҂4ر/Vwͱ[ Ԉ_̵׎חmvw~kl(P}업9wF"+@@Uu +W__|CSS ~KS/2c&OmEnFv/^dsV 7-n~ i)ɤ&!Whhl"!! KtW:gUU5O="n~%}VWW_|s-*LAHB = `FUU<߸i NvV&-*e_v۴KOZ.@ݓo|>$M[u +rwf5V#G3eee?X}Dm-śm2ԹsU^AճtJB;2喉d$ O[_ᣮo[[wS&O$##TTi>VS?_}|1b(mLN>}zѧO/@bS'''e~w,tH,E53zͬPl>\3n$rYf#Iիi(ϟ?^{;oJFz*iD 'ۧ'7I P|7v$oQ*z%=x` `_M˥';2(3AaEz4_⩧_`ƌHII*!XcB}w42L]zCgDkV3rkD۷P踎L22Su>>zoLjKsrBw L|#2$?:6!wc{~[i<~xRɶ;Yfśvlɡ 6q옕 MVIdS͔<(z-[a)V'>}{I%~~jvrk4D$p"}?;6 oVXR|j=hRLJ۶f̗?vFK߾H':֧P(xP*l$,cͅ?,SR|* B]C=6tNPm-&'DUaCSﯽmBjJ"iv̹*;ܺ4^1Q7trNIsbKTB̀Cbj9Δ'08+$!<;3`5׌ Ui(_B7\mD|7x-$kKQ2?sO?"7x- qd'ɿz[, \&SoٟtAk >jCe}Lj\Ҡ-Yf¯Ŝ<ȑC~8r9fժuG//OdAZOp<MRR2s1ms<nq;-&/K"/`upP",ڡ?/G!((\&sy鬜?wJo?d;S,ћ':5Rp+|&gİB~_>y !{yBC]΋=[\osl=i.;5ߕzӃ3gGRtf]?~,cF EwյeNp7RPMnqcǎ;v7rҎ;'00}E;v˹f(f -O?ٵcǎ&zz䫯cN䁵ӥ:xyyrӤ((ȥxVm=vرcE;vlOii477%c I%كvرAITD(.bŚ;F9([5j(7I[[ ;v#b vرSy'ǧJc;vر$*2BeN;6̝;MZ ގ;vt9ǎf9-رs{p2;v9 So;&破cǎ;vرcǎ;vرcUÞҎ;vرcǎ;vرcǎ;W {Ҏ;vرcǎ;vرcǎ;W {Ҏ;vرcǎ;vرcǎ;W {Ҏ;vرcOnvSع*?v3رcǎ;VbPڱcǎN!IN@`n;tc<@\\<<ܯvsعH7NL~;rR`{رcǦ(v&Ǐ%q@<|=N:s_'ÇB=d姮vرc# rMs"w3 .\&?~,Iy9un?<_տɾ}vع!xO@HL2 \%ˮvEyD!>쫫ݴ rӤ8wm{رcVtyRPp ,_#GU&:*t|}V\Km]MAHpr0f>0/wVVrIe_]Uf̖8p2#&: ΜБ]!ra!$&$8r㠉:CPP II DGR]]Yn͗.uI}A$WYncէ!33`ljr4$%%wjkjٻ +WŋF) &OeW-?窪P j7OITD!Ae &./?33 br0**ޱ1"9xv&HrRȉbccwvϻg [!\̜uX}׭af$k`VpevVfFl@v4BCl~>jkLۑEyxuBz# 6nGm$r3{Om0GG%e億3^{]9o cnj$kqrt"%i-g=3j0P/zұ'$@9`@aٲeYeO '4.ifY~Lkczh;!ɨ4So"7103C x $",],Lj% 8u L"Bh]zS(7vhl:ϹJehAi·:vtviHOO!/7jzlPVaz_H20=*>_z&cOҫh:Hs\22xil-IxxV]g $I=GEl*Cn vˇ}Fee2x}m}L۽! u%4$ر |eeۛ:֮ۨbpRT2fpF$II#3fAҀxΛ9PTr2ܜ,rõ:GuJljf6ϟG$"#Ù>fn?ӧϰ~&=_ݙ5kBO?"kFs͸QLe"~my/3ϼߨaHJK 0+4m$DZj:>ל?GGGb{Es_TO˖4˹sUW j$#wb&=9WQ`R1#9I8YRFPPHOal޲>sppPȴ)7qS9}Zѥ3xٗɉQ\sr"#=cGuv>HNi7q և .^_}{E@.3i75WߙUfH~ڹ?smv̙wsݷr=t,-9m/0}ugk;Zώ~3IRLc؟j==wfwӹ 4wsmWn9_՛ä=ѧ.O%$"sΟW/\LH#BشѪ$Ibaǻ'Ne/XDmvޓlƌΊ'c 2^x \Σ?v,$8m7 19M`FVatUK eǟٰ`@7qpP"PY>x?[@iiS @nOzZH>&(([nH^1quvvfhQ>APqΧx|!JJJٽ{/'ۧ'wտGNvNΎ̟+}MصkOQ2zD!`߾:o[ZZؼy99'uv67ϭv\52\]m\Z !#=f;goAbcHlSshzG5<$!cI&/(eԈ,^ ~\$^ۓ(xrf#31IR%.ё^H>ts?(9ig3v ׇSٲe;?_H]]N 7^GzZ طP\rˤ)Q[cH.91hqq}@JNl#Z{aۇrl//T*eeylh4"?6 \OOSLс>}by=gV7]9ؿ-g{qVeAK0\627+%"&& Xc18@ݕr~qquӵ% ]g̗x 'NҷogaEHſuѓvoh> ץ:Bٻa {}zbNIX4!K,d I -ں:vCB8|})9Yj..dpKu1s $: _7Q#Z(̝:~ bH381Py?bƒ]=Vl89P_R7jP4ѣ-Лϗyj?0l %%e޳7ۻW,7' GG,XwS^3_tT 8ܵ :ϴSeڎ^1${ӯ{LL2d\dY߇ ~RRZgO /æeJ//ORS9qԠȎ &9y+~_ـ47ӊc QS&O 88[dF /ׇxG]{2ug PȆ [546uB d'LG3Q#r qs I&s=7?_Sߏ'GGVZGYY9..N@LhfzK6TDϜ͕Nf6 ~YU?_Xw"#Nj{ '';ѣltQZZ־嚩g?_$!Q'pPYQ znv;@=]`..xxsgV}BJKKYp)1ج=ЮoĈBJN%&,6wP̚0ǥK-lnrqq6+?Z~&qĠad vlŔ'=xell !!lܴYg ^pݻ^14U.9},\];~}{S#ϴ|sӈߗXf驌^'NKP*HM@DF.݃;v"&&ʠ\$`Z.r߽wͷsX˯zZ*@2y"AlڼkIKMR#??^{m8j0r53w/d2Rw|~fԄ 2IFmm-~!&Krt ]\Pq\||zRAN VHii,ZB/ 儋:^yܼ1_$ڹvV7赳tI9KMg5-Nޱk7aa!$ ` KHOcCvePVVή]]ъfPVzJo}>. 8٣jli$59':40rv=%~~&.bccxrFmɓZ:rr[wr%rjۜUׇ'5T-J:Xd8%%'9y9z޲.\`W뼐^T{<&11+VNB8^|)~Z@N@Fʲ+t9?]޹m...$Ae$%%O0N$ Z{yCRR<˗"228^|iPOb,[R˿'իQZV3~$%%ЫW4pX]f"IW7w?@ Pw0[1h`:',כ _?$lEI ~H3g9|Qp]))B'ane9>kFNdd8oC$qkؾsv[ίq͸QZrYYtMD٠6{yٴ?W^3 a ohbPe[vkn <,0OںZ+5rIIX|%|e sOpucYf=5G[ͅg}cOʀ8 9O? ZTLt6 P".*1'o;Ԅ@hMHRb<'#h͞J˖;71xr֮1ϻ}b8},&*Z}܉ڻӒAU딭v9n}Lv̾}u~ߌ;HMMf!|6{FPoN i깳dr^x)f:ΨF.7Q[[s{*r)9i˖ҖKƴ%my-!Zh >II񤧧MƲcnm2}_xѬZNG?X믿C޽xY7i}t[ ~HG@+' syGB =njCݝcFBd)K.73Ԥ7PnWeР O:nvмHZr-Y3ҥHOw}oH^6J%~Kn֩/?%,['xu[Tj9+ ؞LFXHXP(cF '*2u6].;6zp*KRLveOkk ˿cPѮocnj ::RAII)K+iDFaCY骪r:}2~~$pM\.g^R1q k(7}Mde lK%oyYqyftH$aLZϐ%u;#@Ӵg-pu3]g qO?ڿU &M^ǿ<(n._H|nxMꄞ]K}ЈxyicN ISoF7SQ/.^js[nѣǑlSV/kݓUױN_\cnZ,@& -_K;\ٳeezٻ# ҮCƚH!̮npGrõ<,ePVM Radoˋ~zsD6u%/nn귐B~N'է$W8$mWJ~5"H0wO$Cٱc7w`[諯$)i)ɉZ;A(pc"ml>Ⱥi %kɳ<> #l\j(\Ai~oF/"DoV-|hzFuMA ??ιz#3g.bEvjZ#c%I|z_( [wRﾫ}K$ILy o pD <uuuZ:eSN "RiƁhvVfFκc*g%֓C/q@A|wm ¿{F(q#y'yrItkkջ|}ušG} l#<IH5^g^x{ģ>5\KH*us`񘤆Zd\ ο۷UWi3~RIQQ>3 !|wddӨ#RWWϿPb-}wIjjj GGu 9}4[n[7$59^ZSS$ᅜ:s>n.#50Y0󡡡p{Z;ZZZuo$&,*G9EEiI`j3/ g k$$dO;*ʆ$dɥWZ^IxO埾!WY^yt<=#+ 2B~ >>455ilEGI, hLxeYn!691bx!OՒKH|i $c:[syk,[;ك3$W4;m I[O&'g_~m[5vS?po+|-77_1qF O򫯱6K:˰B ysϭT|{tiҜ0(`olÆ~|{" Ayy+FV/}py:ߖdp@+٪?$d"d_D]~ {wߏKWշRT4#,{q2i,ly5;T7|T<ں:֭Ȳ+~XgGM1[H֪tF*>=4X0$Q[[˗_GfF>&~ Æ Aբbq\o]ѕ6PFEEFy)|}iT$9 qh)^1d_̏?ͧnf<̋6jᷗm Hk7ҷoR(e}k`1)JP]Ӕi+*EŮ] &޹sbHKK$-5msv - !88Mfg.2&T.if 4,V={psE&!8(MśooTH_h.?tOgsWiQQ>KV{>k䎆cO#w?D's8 Z>-L_QQ>nrRw?5g܅F),chQ>[/n@AxX\jMm_OkgQm_XjYз3Hғ|߹s7011&LQ]T'#YwhK[&R~ifHOrB!((NMwE>(@f@&IQK]]=w׶rH@qV;6n̔) E.bmYsɆέOl*”[&Ĝ7.YfrKt[by3F̙455ry^z5P8)ulP5o%@pegϞEB PqD۴gKҳj?'.?GzZ J+V⋳g+  $8d jkhiiϗ#8{,nEVZ/]߇ 9{Uȫ1BPQy=<~I4$ _uo[` A* gK}}=WlŖijj"=5oCl<,{&IꝊF&""dN%{Z|dPzxdy `gςO#rIRmeGW2'KyYΟmvEn$ڪ}\-Lsb3HId"tvGJz_M1W OllkF7mNA<8owNBm_/ͼm5Q_[wo7SrXtoڰ.`C/ALeӦĆ ZyPXٗ]TR]!5Ftrii)(JVڤ~6Pu"+yr֝<7?t?+*T`ЀB)8s픓PQQ$ۚؾc7 ;+MVRcT(䦿+ǎлO ={vWQXGHpa0(HV!$eٳ47Cn.444j}ĉoHF 'amқ̌TOm*__oT-I!!AfSr$+W5_[IOMf}-3)1:o`r(9Yj>[6o'%5 x}A2Bpqe`Ow|aV\…K/'? olKb C#smSص{/[[T*lNzjC xHJ@ ʉgXpy;~De߾&_YYպư%$Ξ0ΒwCX^r~Ib>OB'78[i߇cKSR~_e׿GoeiH铹xnAA tU~[BBfEjf*-*+!nUoo_iϾl1/s['mhH0y)9qFھ6'>-ڵv)еu]ALxEylJrk_kj짖řTOK̙3עrwMS=G9(k5pP˥ ٵ{ HIIb:1! s!HOa:''' @lj#kn 9)$RR8{¬㐧O!ѯ__.Zjk׭w^Le"֢W* ';%0K.JHfhf/_Iaa.Ch+y9<[[s!'9~u\֨_GZ"(,cx?Rk?ܦF`@ G.Ѓ rֱr-iiձq涿+:'K9r2y^<<=d}+V&-5z6nl__49YRf>O$I 7Q>dfD~g1rD~y!{*cL~^jiAW~ڂ5k֓T9pgVnQYA^:yAptP$fn\Jb۶F˚4H-VQTgX.#,裢|$TYܚua^{]]룣38;;!CmG||z>|-iYduv|}еWD}}GMlL %RLv3[oo ̌T.h$PCMU eel2,]a V_{|{vރJYm.3jo}`#xZO7Ly/v&1Z>lf؎V͸شm|z=Т|dja} \8/\O4XTY-H&ذCZCQa>nnΟ7}QwȥyevDg9}4A\>,2\ 2$kQ9:]lfF*---l#KUu*_$A85hD4 tw Ց?'*!{@nfna~ yp$  3ra >7uN|N$3Ix?N||?*+ ?hn1=_sဠ}6zhcٟr?x/HH(rq\h'~9354_ǟ|aRn:I:Yf&zے7f%B5uu|xuS,^Sڍx)9q/i$!1rPٲu;eǯsnen)ų;?[dV]rpw}n 0{ FU ++S() G<{^NȚ%#=A1QOTTDn]wɄuN6֌;~=y&A?.抪3z$յbw'L~Sixxggƌ.׍ǥUUMH`?7^F?-eu-[NP?Ǎ}+PYU/Çe`gký=nywyyy*:O ^{yzuq CQRSpg? 榛CLmm-EiA˅fއ oeæͤInlj9477A|,t:u0몶5G(*> ?{{;f^4o_/nΞ=(+ 4$q9 oY_ԩ:}UU5~W^q1>8?/n=+9$`,}h~wqunuLdK~ɸ/UU|q~ZOHJJ"i/2=ɉTVVfMOU_>]ˮ]5YèbOߴj^0tml9x0EkOvw6_g=wvr"kx&Y۽vh`ϔ)`ww~FCRBVV$irgnJIw;jIH̗_7ݔwƎ;Z?/1[m#{Ts5kLhhWf;>^lٲ{RQ^AHH99^6J_mYRFXVv؅5 q&{jp9M[c[[ǧ6{k?^j -5e6>榛f6먭euW-=g\\?zJI:R YUWGlǕmG_nEղafD7(P$wyX[kٺu;֬eƭ~וda;T.`6n?r2VZCVV&55,]:Ϻ̡C;~w}˵.KKXj-#FdR]U͒%YuW9̡C@N>(+2bx&,]k7eBۗ%b7hqbbggȬaq>s~i]H_ݍoO&֮ T~4@YVV#naӱA,hfIEG9w7Ay͚|PGrR|165l(V\cg*&^7=*ƢkYRx_ZCֈLx4`z^ii+Wed0jXs:4`j>|P80&k; q3IHLzzZ[WVY_/^FQ=Ld t<bplLےb'?ߧ!+k5U,]]~Zk~L:mmmC݃۶}Р(PU.u"&6]cRΧMhSQQkruuݝ'OZñ3/77Ng\pwRurrÝ&wHQɓŽzzjrT  =S4||9}ޖ򤬴[2h4(/{˓n ?+z_iiYlՁ=^TUVQR;)n8SXx`j=S=g>Cy.=q6pՕ0yx~[7zߢ'Kwn{ hHyEҹAUu5ŧlq-sML;וemՅ'_.BϘ©yw/8wgs}yu핌?{lٲG!D;=xqSXF Bs5jYFFhwccB%UU׿^GBښ%KGelܴBÇRVVNMqFLBqnݻ7Iccc!kP !B!B!A)B!B!7B!B!B P !B!B!(B!B!FB!B!B~#J!B!B!DB!B!HR!B!Bo$@)B!B!7B!B!B P !B!B!(B!B!FB!B!B~#J!B!B!DB!B!HR!B!Bo$@)B!B!7B!B!B P !B!B!(B!B!FB!B!B~#J!B!B!DB!B!HR!B!Bo$@)B!B!7B!B!B P !B!B!(B!B!FB!B!B~#J!B!B!DB!B!HR!B!Bo$@)0beeEZZ2~}(y~B!Bѷq9\}4ssihhC0.'k:nds5PWmw)B!oI Ap`6oeJC||Qpbuj6]Hp))(&ww '55p+ػw?׬KI"2%}Yk5,3@6meJMM"5% Ow**سgWӝZ[suWl iFiY9>Me娪JQu*U5q !B![cLz _Cll0f߯ZsםD]m=JJFe\aLBѱc>/zbcwlml/<=\پ#^|׃ q1̝;[ a`@77v>7¼yS'6ݷ8fycewtNӏ[ozznTVVy"1q09cYb 6l:7f5A~3vL6+Wfq !B!8 j̘>S'PXP?JZ_W_}Nʊg]\~LyC4ZkXl%(Bxx(7p ^|'Od V>w;.TEytf^8g]o׫wT|0.ߴ+(UԔ^-ð՗ߵ lmmPQLwW;ga_k?Ï<ʕQT⠠xׯ;Ԝ0BCٸq eeVK88؟lmlVwɨQY|,^ x{y1:;;acccyUEgpqqr0OAAy89ac0{%⌕{O!B!Dߓ=`ܹVtT {3Zk=jbXvf},--GQɱW7r0J;=ɰCeoߨQP}~ؽ1dfaɒTJWQ#P4~yiHS&`Nv#~<\0c #Fdͱټy+ HUUQ:o~TT}IUQko{ϾN򛍿<Fde2nBH~>GLȥ\Hxx(NNJsS3O7roN, USNA=E `=sP;{{P.xӦL@EA%KgFE3yxbp466g~>  `;Q{;;TEᒙ0mĖ@ ̟=KL{>>^<\PZPQyw:mz$'ccc *:U¾y|;!L^Щp%3:ub[3whvRxzxQrSm2y<DE{yzPZ!)(((~&&&Lvކ>456i3ooOm]]qss%}H2G سwg$&f-X!L27W7^~Mt ܵFl3kHYr IIHK/|(]XtlXmwC4vͷrӡGNkˊUk(lY[χ$"#{#k!ԲuvBB B}<[CGL槱"""͛sI '6vORRRj[vHDD6Wjh8MnGGGVy#eez!55paֲuvP!4$3zg;sZmח#oo/~`.NزuՅXnqf+V1*cޏ+PTx]`B!Bя$@Kt t6ᣠ( ts3zMm\]]֖ԔD??.r訪93ɑqFUU Zt( 5y*P\]z'?st(te( 7xIqsul޲?fisfcem6cdxշz< {Zߖ/gcذt~] PVVon-do`gg׶DA+;;[vO_n#vaΜ[Px7-2#2q0 O4xىnnFAR}#ODDxkm0hGsǝs3]sn!==Isύ{5DvF+++7XۻGGdeb?`/S/sƴIEfYx{w p{b/ P`eeEJr"7m1J7"+X|eB!Bqne:yk֑|AA\t4TMr"*ևyK.GA! fx;ZEQa?g(JԌ4}XnAp}m&ﶶt݅B!B>Ay] ((.V.s+(~3[͖%_7. ;3qޤtxpCC _6SWWG||YYCq#N {{;֭݀q1io;¶>h~6h^ym}3Ʀ{cc m:992>g4/U,icۗZ(v;a!lۑw6ꃏ>OwFjjiiɬ[ !88㏿w{vw;8p OOKjE_U5EU;hRllzu0yx.9VZÞ-^OTAECׁ4Slmmqss{;[TT,ɴԖ(73y8.hZ[iWQu] aahPXvC>C[Ý_#^B!lISŧH(oNW^Q{{:}t@>\Θbp,X#Zp7PYQɇ}t<<; PVUU޼Oh=f$f]şﾃ?bi9yxN?-p TVTZ~vݔ'Oϱ'ټL~ --}wԢ*N_/jHhss3?D"#ŒƍEթ,W|Y':ʪjtWʶJ'Y׌~ҡ+((:FQQm.gJrV8pWݷ x%nZ=*VYe y4['bqPښF3vL6>>(LKjQC\"y/1kŨYTWUo]֋bv EUNHS??7x#Ge12;n{wB!Bq$@޼{۹ʯ7_o]H``aceW6;~¢u:~Wƍ&>>''G;3wWEE%8::2>g NIP(鹿aEE%`ggoh^{9|tS3u5 [CDi/""`;>>^mI477c^+ Ҩ(I#NK}MOlذw28nC{>hoǎ\ӃDEFJFFƏe옑ּ\kGnm6ifއpIjkkqw3}M*Alբ,Ozp22HOe1=~z>u*ڂ؃OծǍe̘QV?O!B!Ζl+wg*G;## _]Iyyf&OPPg_ee%MMM0exO㍢BiiY>*}~~-,鐟PKkOUUJO6-3+:R|j p)*h}EuM )g:;;EEǻ},\l"jngժERrY#2)+)gGn>k'TUeݷ>QY̞} ou6ucMΰ28v߿ fٵhIEJAwrf vZ/gJJkзO:wo/<<RXYw~~,noQ6B!B"ޢDat,N7櫯vzoo/TÇ;!((G_PoWXYHʤI9;O&* 7l"ƎXI~SZf2T2ex|}~me{u?BBطҬ޸'8(P8g1lTѡM^Oi Ll &K`@YbLCG9,cٶmgj_V0n 5_>!B!}Ov8Ύi&qm7ěoͣ}>̹f<^6,?oXP]U EtT$"?1n\67\5ctr}p( -nrraVy6L2CV$&F޳ʪ*3f9p CGzx&<=lX p {TTnǨS,{{ZjTc^888Ы㴗8?חƦN#M-?cdBCغu'Z5Feη7"kжz BQ!kx&#GٸiqTZנ4~}5\r=ѣG<ͬPP#xkc9nn=Vll[TUUFR`VYZ(--#ap,6EkmEB`z,ݻR|qMY[[[3( 0;sognJʈnch$$WfMi?`ZwGqә%\]bղafK(ɉXkXz))+%>>ﺕsj[>q#2 T)08N/Kƽ'f/Յظ"xwYbQkZoL^! %)1++k֬]iB!B=+' ~oBuDGF;Add$Q-7k;lmm?!Aع/?ʪ*y>r-[LRbp 'N앝υp|kjι4>gOs\pB{XǼtřc;kZlmlz,pssݝzquqdn8[YYYOEE%e]bTB!B!J!<}}|s ?_n˄B!B Fѯx>pT aaL6{״Z-ǍߗB N !B!d!רݏ:ʫHYiU遭֖SN/ !B!IR1S^^Akf7o%)1rx9cǎ\lNsa(B!BA)B!B!7B!B!HR!B!Bo$@)B!B!7B!B!B P !XYYoN!B![}kǏaԈ|޽Gk.>>u{>>q3knc|DFK>OM?pT@jjjxЄB!8Irذ شi+4>OwrrF  jO7wsAacc߇" JQU99;ScsUEmx(?J@tRS{f:,$")/`Yd~vvdg nP JJYv=;6>c8Ѝo9~~&J!BԧJ__fp511JiiY7d J3IG7تsob`rƌbʵlذf5?dMuTVV,JرXb57l8~b~k??0JIW@MNӷ/Ç!ް~&t|8/(JܼC\l sƖBAff/JbcRXPDpp ٣L_6Op[Ic\ If,ۋݷ}W_u)1Qc//o(+B!I(Z-3fLfI@~A!~Qx |iyDJpP ))l߱+ "%5;rPuA&'c{!88$~vqZ-̘)Q(,,$ SUAŋ1O^|qqܻP_<f^4.7r9O]~ӸF%Ǒw ϿΎ7^{.~ƌOjI“B!⏫O6ə}5\8c*GUk7]QEP}ogg3Vgnu:Ymwwg'S*pll 膕U;vζ[izRvt;_)=o-vFtpphGo fLe<ziV\ҶJ]'΢{ŵ|4_.59r866|Ղ`!- *;Y7b66Zz~Pa EmC(8:ײwA-o*I<7΢󭣞^H!B~  d]\$TK9rNnFxѧ`Fd ۓټy; @UUQpLϠ456{~> -4@.98Z9v? ˗B5յ.(׎(̺ 9p M&՚7iS&,4Rg6Z-<4 Ox~ˬbРhKۅ1+o*88;93v{$::aCK'|w9` g''b $3sK󫩮EQiH]]=2+1Ζ~ 8!8#ѩ: fB6nb6]u%: %%wo3tLVk **)e߾|]]߅B!S( :|QU-W@g}xoqqq&(8nx6nŠ64ɓ˯eNceExD[l8p 66x" JJJMqn#7]+Wì$ghL'MϤW~FQHOO9g_`ﯩeF~A>^lݲ{UW\>s= Ph<}.#S ޞ֟G۷NCiiMͤ1ƊTu+^~e@?~>\زuŹe:ch42Sk-|j444:#|ؾm'QL(DuL'M]Da1]=!u-|' `Ζ{<3LJk+~*O&xzyPzSm2e<E|DDkyyyPRRj_aA?HB嗻k7ͪر3|XzC3λĉ}VO?(zlҒؽ{_NNdf Ow'~6Jza5)i}i__{~lllXr5qp_SR`]!B1] ʮnU3̘JddZk˒_9~D/~`(ْY3O?ΰ| ٳ;gqwy C0qb}8psp /b0ʊD6n23C]}e<7Jϥ\il8x.p:+V-MII)ӧO"<"k7e]V爬Lpя|ɗ9;;3͵n^i eڍXz!As먬䩧AYY9/<,&S[HOc>4 h4DEORR_%ya d>f>8 /OGLbb?ϜGpk䩿GPW`.)1.ՏKϿ߶>~3/nZOҫ2Z`慦+++v7]gurd1NPPl4PaEXzBv"xA.h+V6ٯ}=Y>붿<\lmo...]k<ȸoPUU*Z~ PYUc߸?oP]Us|\se籱r };r_IKMbm:q1OQ.VZGEa_]= ܭtB!BXO֠4jF/JfF_/o&Mg#!>wx^{$@uu -_Brbdr@%(inFǯٰqG:޴\~L&M<M'ƏJa޼Oڂ8uuu|;6ZGeu odpGv,BւTFeAҫ|JuMdrE!L{mIзG&2"d}*:2] TWVV]] ;V־6е^s/=OEP4~4yt|;vZ~j5¢cl߱뼘=iEmaCF7&_#!v0xp/ZyPc<?~ JKhV(Rv]`/Mbl.bժ(#h4 IKmvyoKHzPNfwVXt;rϋ~k6eevP1 m~)STt-A~9w?{>gf(Y1#iVu|~_\\j3(: `mmtB!BX̠TZ;r'UUU?~cnjYWs pK_Yxρy(xxyt `-`kgzJXhkmQRx Myl+8fbԡCG:kf)e3_[lܸɓ1s <=44Nk?_4Ç tssBUC'NUulɱcFrpìk?[KFiٙ{ft~*~&ƥP֮LYEe`358uYv#\}9|ŷmřſ,ٸ^BCC2_/&F!/ﰙ~?Thly]?1W^}[:0F+ՖJJJ~̔D^ymʱƾ)`EE=:e6n̔9s:\u`-L<3ΊUk-J'B!MRŢDٿߗ,#FLt$;vRA8/UVV ^J5ƍfQxo[vQXX0N}*bG gTp*X>MmHLiɬ-Yrnr`[vNCXY T6j;׳s9#G '""Hvy`ymTm-VV: RxxjOw89:QW_6~]dMˮǞ]~.Iuu5[$5%`A3SQXnw8;:RPCm9;+FcB~ZJEeU/WNha3qw5\ 8OdDuu _wd(AJy/@ExI}^ג=j8#SUUXYUTzz.5s=B!}#G۫-w&LU3f:)m&#c;sw18~ӏ ԽLqw ;;;g| Zg)l룺*hnֱsnMILVP7onwzp22Ƅc3zo~ĽIAo.brf[nMFzv3O۵@:Nw>#H%## 2v(x}VuO&yYawfOZ&ˏŢ㶶sUQFkBs>* $T G ۫-՛Xoe Te\j9ٵ+|A[}pܵ%2>:9,hU֒HfFovʉc'8p0q*֙3AK<;wllC@3}EE%( 8:`Ѽm&ph}ͳpё9cx3o;:NS[nƆF>Kz޼Odʔ7ԛ^s,v?1qXƌ[oNرQQ24}Əa̘Qiz$B!Dw FP44zsƂjc BFzǎjvvv-Dw v}j8;;snk&bohôUU;}b}5[`^ BBQ130-As?{,fp 7p m4 Ϙ2|gn O\EQ{bᣍ'OSWWOC}'@5ƝRiXԖ=?ӧAl,P,:ZۯtǥCㅇ@ -ϯUEAp-ۨc!|WD?/5{444lw5~S8U456(..1XGUR3{_s>L\E:P],["llm2UUQTqWn=S*lwE_UtoakcCha}\RQ%mdቫg6Zut kMTU𑣸 tV>v(Fc WU#GփqСhPkqUU9|47eDEc&9_ OwCڲaiz9KzAƢL~-۰eҤf.)ɉ;@f]wcfj;oӦm1i80D6l0Ǜ+.+ViV|QP9tp{^ԧjYF|wb|Ue˖_PוӭV'w!Bqn% aefjc(+xca6,8=j:֭ ^++/Gb#cnjEi{-[Q_؜фnti?;\u%&ZuUF7Z5~ωlx냟MM}(*=]prU%fPvWT1I>l:Ei٭ t}#:l ;ZĉbPnÉ'P V^̚uQ6ݯ/ٙC6hP4C7HNhnJ]e? dKyyEgOxSW^Y&%kmٺrr5~ZT믻G`{Y`*;,3d;@qNe-fNuAA!N%{7믻D*jXaScbI~Ayyͦ&''ٳb̘@UE5"4 rUU5S ߜUhP ՝a89;Y 6Lc𚣣#cG-ی&&6{]󥱩ut47ni!B'x=*qU\IDAT"ԔdBV\Ӗޞ/'[`}Wĸq/ܻ'm;j@^.vKII qY[;[2S?"طAڢ?q=w'fŊJ\l4,_ <O>& 4Hl ?n <+V __ U7&ؙҒ2bؾ#5 q||9^77Ws 6Z-6l`!*%)1k+kVYOmˮսig.J<8D՚3x,Lڵp#sҒ^"wRh8}f>'N$'GGIMI"::V˷ו:)DhhVĉmcǎ] AJJ"%%eٱcooODTt'OO8r4l466k""‰!%9xmm;|`D}}=7oۓHKM"<,f]3}5}Q}㌌#..DСF:fL̴p`@tt$ qTVV@} "shݫs"w^pD',^FUUaۦ$5[֓;S6oۃXRRHKM",,]s3~0a, &M!qƠe6>sNpӍ1(6ؘh\]]@Q $66A1Q455 PCl,)ɉ$'&`kgKޡ#fgלga"%%xlMK߯Ӓd~]QQɉ'p'sh驸PZZN||,VdTTRv"󱷄ruWNTT( xyAtd8**kml?[O{Ǒdط Nh"( DGEKUeuؑ~d Jڐd9yT҉')((ɑ3*:k{h Fi3IKM!::q0<,nA11F (0hP4bchjj2{>>6(&ƦF^=; mǎ]h~=Y̟>|ސt\ҏTTTtkykFCϼ<)++f,g젠@?ߔ;;[NnsOO9Y|hdGZ?_NxcOӿB!}8oCA>@)y?燖YB=DEǟ!B!&9絳[\GѺmC]=G^accCXx >!B!:@tX!̈ښߖj@C߻PUB!quqO4Z^!ڳhhillrM8!~/4hZin>+B!BC(B!B!B!B!IR!B!Bo$@)B!B!7Ʀ˧Ð /9B!(ii1̘>7|}:|3&  ;rqbƌ)yi6cd^|Yi!B?Od\h|<ڞ p`\hjj9~dWYW\>}no|jԀ;ں?MMy{1`fS[W/ЏZcuB! jy'`o]f9;;Sggg˂ 92'w>6,@6n.6mʾn++ 񃉎 '00ⓧ8wիuO∎$(0'9x0:I7~[UAQ@EAAo,>rcނԔ$RSt={|*N6K==n9H@9 4n䫯6 g쨶Z5Ӎ#&:`9 ;v坚/ww+;a,v`GtTXIMM":2 Ϛ5ilj63coLϐ RR  EáCݵǢ= $"#)o-46v|'`kgw LIXXVVV?nkkkf]{%K]N^n[8iӹς9yu:.gĈLȑ|/_MeU4g{ !Bs^(3vL6+WfJ36+?_9*t:9Ύ rW肂t/gggDŽ Z ZۯT waWBiiEtQ87ZkkVRT)b?a 3+oR[[g2ݜ9H]]=%J4(2lX} FFXH0i9O 8iq_<*3ښ?vi5STxH@ӱtr42uDPU*PCjr+SLDUUtͨ>JMEᒋg0c**!-5K.^ӱZwNRR+*zq0O?s)6mS3Vˌ铙6u"F!??ڢ]>uEW]'N7̺Y\~LyCn!5%o/4Hw=l~E1}nν bqqb\=ZYr  ɎLpˬ~^Ƽ>@_!̘>[QZZn} :Or0tw אݨNa=~%&~4!ʁy3RL7r0ll|w峵23X\>[[&uk֬穧_6/6nFQHLiᄅiʻ<7\ÅLl-@rr"Gq#2M`?SRR Nc܃3ai {.B}2+.ahF*w>^ymBQnۖ&(0s4ۂᒋ/dڔ*{, 3h (*^|ӦNl'UnFzG#=\yťx{3w%.BF֞~Ͽ1Hޣ<{khfÏ>ňLƍCHpV+ yw8r$ߢ;f$.NSLأ_HnnR<ٵ{x%.BF- gm2ɓ3ib5(:~^/RP\\7#cƌɉ?d"ÙGyӧ ^K.$<<''GÞBSSMMi!B'#GZ>$;Nؾ}'Q44~鮩eBA~.wQ^5lݺ &<"T8 oo/RYt9$&&gG|dggڴ,]S%miعkwD||j;eBPPoi,_U+אOR`.t&_]ښS&PQ^ɲe+L/ORYlʧSf"Ge1}$.͠|ӦNfRXtGѐ1$O?`򴳳eۋ[{>||K֠Mj+(gٯ+̾OceEDx8[l8@ll x<"zmEw2+5*drPLA۰(8?8 Xa۷dPl C3Rپ=7ߚi̵ߔg<777HIMbٲ#91gyUUv"Gf1m.[Nq"""-qIK\?=aT/MM|~nu)SƓ_X?,&&:^9cUh]8AIq ᇟ[dY;L@EyE1sQ23͕T :2>g*UUƥR@}kwDZj2jر 77D|JJocޏֆPXx {|HII&**>j6-Bq>Xz!!qk⩧4dJJJy>m2Yſt)tezJ_#G &11<7kjt\}y}zF!:*K_Ƌ?Cll4vvvm3rp\]]/; )88/OÇKJGce_~tj3W_yKJK/b\^xm3Q'.Ɗk(/0quWł?g_C`gk%F[={q]9>Is ^;qNPP,ˌ4V4]qm36{y +ov]QgzpȓO&%&`eeO<\}e(ǝs3]/i& 7w7?r)|7rWS_+իA8Fn7euO >$ǎoev*7WW9Of2]MM *nnX"g(l6w5j8nnkߘpuג 'Nb˖m|ɗ3ZK~~!jSPpqi/"5G Ydŏ :bu?_oJJKP 7;pD1-Vō?l;>|EQqЏZQqqqTjȸ1翯]]L2vl66Zk~-)\y%w~\lCrrFU[vǟ|iWEF(g~Fk5͞1}2~[7xZ03.-_#2q/˨曮ٙW_{[οhNuZ=Y:?_刬L88pя|W@77 N !woנTFkM||,/j:GPSSc>{n@97UUW}֗#/-eU+yգ}WUT^=_񛛛9|$5a~ӧM_xÇ w Spjn(y|b\]]=_ ٣ hZkEEnL+++MLUuu3g堨|}*.V!i)TVWuN\]\ Tq ۭKuN7&995Yϴd;o?2쟊ʡg _g`^>+?)3pw磏>:|$q֖laFްi 6m2XV~BE!*U$wpSheޡ#t:RM 䢋gfZ3jVlwqF; Jn~^+L]sn5s :QǛrx每˭HgԨĉ9<˓Q#SRRhaNMM'҆^'9X4L6N;tfJ~ȅNE4/n.u evQpquh֌MmmɺښW_y6E̳Nܮ.w1nN}C=yu:m'FT2j֌=VۙzPl4 ̱oBdzԴdi;C[EAa唶[gޖ}#B7>: C,8 EUPM׳P_gtii5/kP<<&OmO(*C-WrČ>>Eh;t?5|(._ vv_v\uCo3?x Ƹ7( +Ukye kQ_F:UEt*׋+١S ^{xAs+~~>lٺ͢a_~_~ϵ ғCj444p3yX'IcLjkqttT%oⲋyX>]||#R[[FL DCe砾_w=.yzz_c\sn5Ï>wFZjCҒYp#G xSUUc0[rQ\pw&O=q&jfY(\wݕXY[gߘ|; ̶qzI!--u̯?nrL{^-z2<+:eNN˯g멪63Eގk3͍f^8А ^~-66ZN7)߸mu:YoE5w( ͺ +kk>kkh_ `ЃI/~rяg_se3[ƥ#>>3츔H`?m!q-yL~G1Y]=TU7na̜9OwVZ˞{)!BҧJUXutYFQQ*JuTK"`;kjֵo>3Fi㧟v8qv@}mCF@ r4+PZvJYǾC_vY> 3xuZ:cSٶc'ɉ2HEҲ #:*`8`{F-j?]J1<'L{i7nL6^>^mq:y,^ ƠSw?aT-rLP4]ns Vk̈́qc[@Q䣏?#33/O7 Ve1q(*TTVG3,3O3:4)Yϋ>_O'׿_58_%$$ng<\7FFDx(1ё暄;h:È (˯n7Ͱ^jAcNjK&%$$f6@:Z0@2al[?:_ݍKEE%(`2icʔ \tyqٻ@S&TWSoAܿY5QYTVVf:.]Nl#B߱> PjəRZfwu~ﾝAL(ujji0U1>E5}L Hׇ.0 XZkUAl3Af;vSPXhF447|ͤix1˧(vddsn?Imm-y每uV\KJr"C3pQ4 i)?~Lߗ}͆غm'1tx&y{w]or\j=zMFF{xO9~ęzy1ꬶ$%ƣS@(⫯]͙0a,w~>ӃAFU[v;_o]H``acA׬3;s\nN匣~fگ?.uEE%MMM֚VRR*t>JDx8^4#G20qbngLJJ˩SvZ& ace Ќj_***A{{7~ N]@3c gC7g{:~Y+e?''GNj+**QT{;0~^{L8: םXGǍa҄l>50BC9v8>^lʊx-<r4YצƥFlϢ"5:ʊJ occ#~ n}-W^y)O}2_,Cxj[Z߃ӧ򅅅ʱm0L3cm14s~11Q8;;w:+|VZKN(>ҲRrsw_STd~33k._~1FUE_ !==cEy/׋}.NjW_}/Sزeyw|}93TU֦my}ѣm֚e4ڠt6VZ-<QQf,uY}4?ʩS%f7@E{.f09{$j$&?ԭv>[nΝ{xv_nϠ?_BlIPN򇯎rփu\jl8m*dUUh(..63GUUeٲMPp!v!BQ⍪/O 񃻷݂㻽34Z|sdj[g foq>ȢE?[Z@`kk?,uf]wѮZk`@{eeЌ! MFFjutጩ466-*^Yy91ց;f`3VZ ΐ;Hq)E%""oo/ppprc .Bci.ɢ&Ў\ ˲rPUDdNt޼رsWߗ/iٱ'`n44UUU/:&B`O:MKlۢRYYŁy&Ds,褕ￛ\oyޙl6ͼ{pjjrSju8R>DAC)Bߧ>A0?\Ѩ0f(k;d]28~06ښX;9j2]wh$$ͦ 4~6"kж YYDDrHo쐿$&&,$/t+ORAc4=pΗ>8i{0~yQV\CUU5~>  6BxwxGc2$NoXwqUw?wFWKlUrd[el  Y“!d !}B@ &`0q/X`Uuԥ1lyfb0|yǺ:ssFOmZ,a<${ؾc% ȝ=&N`ƌi~g =z&X _ܲu;z3W+Nr顼7z;vxLɞě@wT8{1ILJz7vptq>fϤ >r_ &.'zؒg{pUkx9:z>&LHge %sra$!Ir+r`r AU)q@\\qCYMߑM˙+YpZ3W`DDQZZ}b)ԾưbRZNoP<=vo} omb핫d}X6V5)geeDDs-7FI?zV&OĕW<G||@ ;;DDs-7ʾ=z|~\q*:Ïx={&_ \.::sC9 g_:r }Jq22y9 KLe@ GGgf(,X׾z7{'==k^g{a{,$韭ϙ3Q?ضm7eeY3XVF~>=QX8|%qWg_Yn9dO 3/vtvv;NnyzGW.$%%YB\}&g~V#J~~ /s+oaw#::EQ*^}m/4/dma4sVBB<صk8Nrr`v7i)|O݀h`f%pMl#AiM7]Oky>J%j̳/Ţ[1 mRQQɓO+9 =˧jnZ0 Z3!#;xg={|EE`'y#%%Ro4Mmɧ>S~$&$`ZڬdOb)̜14׼?#;~ʗd,-ZmrI?׼rb-ϡGٸa3ϽWEu Y> RSRګ<9yYI^lijtejjgPn˝Yl蛚ywp:;ذal=ZC?o>s K`\0ǎ‹/Lyvt:ٰa=~p<0Mz{86ʊEO|zO\Hx((0g{7xaجVJb[2j1MG~K\wK.h1`Rs'쨿6W,}v4k LdÆM[(-`n3{܀V'{ᩧ|7u,!!`"LL o-zzyO]yrh)gYΛ7v~Etw(gxۭb7illO]gnճPn7O_.t{i{?sʂys)ZR8AyovJG=kчpl%$ēDKK+MoXO}\cw/7&993gj|0K\\TW׌yyax7A0 a8aw{O߽vw4W^,|>6~g ą8.rVjj MM;=ܹyFsRVZA{Gmfb43nɆ[J/""VILL &:SgBsssPO$&&ͩS?AᤥύY,2'J[3CXX7„ zz{˝Ń;.E)4750;713FfV&mqq)1 Dboz|!9Css˘ljnc i0 vӫ;^hmm5en wx?niD.ڡ.EK ګxrA'>8ə3def9CFAB\LӤgrbELrcG\~+د* DSS3MMAbolq(. wcgn7UT6v^.S r.E} z*4ihh @BKG~]zzڨ{]S u5F4mTط>,-^U~vN:~x|2] @/ """""JP#=wcEq~q9  %90~B/"""""""Iȇ` %110GN'-Y{ RRDDDDDDDDDB '"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!"""""""""2JPH(A)"""""""""!MPZf/@JFL"""""""""" S:knO_w?uֹd$Kj{Glt2&%I|j%'(#_7 L^M]6uRq~w@lI{[/}PI.1Q1'Ϝ羾pZ;j%:6Sؽd_DDDDDDDq;+D@ocQ''pvat /ˡd{9GQ- c^O&:.?<;*>ioMpTJUrdPWGDDDDDDD>d0hvb™8-U'cb7P{ի]ZE`;iGxpsȿl avqADDDDDDRd K|;ˮA]xX˧=tfMK};&Dš]U4wgrz _|`5ibؿ;8UHY2dƓ>f%Fs?bBv<'pp)Ieiam_Z945to[%umLIdъ):uūr85؄pg8۳D8{FI8g?ó妒Ll94Pn$}XqL6gK{6q8 .ˡE>%FW>1TAJFϸVc49Y&Fp 4ֵX58[}ޯO=Zٻ&'SpT\~q׷.cBvհws)=},riYqXmoyUu.˯f%"*W`uYylf-^b:!h%ʹ[HHh1z{։Y'm-d-BooW?[u,3>'&'/LR'E2{Q%*ฌelV4:Z- iuX㿿x"-30o^EbJeG뉉 G<lf@?KˌpTĔ(^9j9)jZ cbN&q`G=]xIˌhr\LM#/?Ԩv"wmADDDDDDR53(MF\V[FNn8)1f9[Sgi])ѣN[PMd-o͗  6!#"7Vo}G>gC_3Y2سW;4 t|Y}c.wT#bXL' |W3ef p=chIvN~ﭡr7]܌\qNG GUT.Ux%"߯ "2~X\Z;y}\;̜>Ů cf`s8yv^=ynȥG=c!1ly(pp<κZ"/-VNxdVc零& 5>YɁOJ sr<7+͓.kNPfL`ϻCsMyQ9@x'~Օ-LN`Ƽ4, O:z1&Wv>14\xv,㯵ixɚȡ]U>/qdLJƿͧm ]|W tx8\l=^3x?5W?+v$"?0f`|R'xq"""""""q؃ғMi?ΎL "*lW2, 1 XmLpP]\^A]psy4>VwhT~ʑa[:ط{ū|3dWuU VI>a/?]ܒ50,?(Ǧ׎b[YX<;. 2.2Oo59V룞fpŔaelv+f?vj1̋76le9ľ壼f%'7A[Kǻ|d,X94}-m6w :^™ALBEX0_orRyxs-Y¬,\19XIjV5ÄNgy`re{1 I( """"""rCrFۛ0 0Q0(Gty4\n 0r`x''#qǺV; $zfMN4-4]\b$Q19XHN[dv|zC=-󀜳=?;+vg ó¹U%û3w;7,g~*vx%F㠧/ܷҫ }˧QpTS=[NC7}~JMWr Qh13l8Ó `õ}a4M)e#Yt~Y_G0gZm ܜz69yZ#T\|ݬ6PHl{ &H=uTd[10q" 7ؕ{|̄=#34}t_Hh,lMn03VO i Å`ܽ,NJhmHΚT󋈈|r!9KY}IN!"2 WS'G}yw6D' YT<>vTy%T4C|R$hn0 &qqAMU@\|4ޓ0lvz7o,%-*x=951v77:1Mh?9~ siԞsȔb2>>s;VWQ9ds};=]v>&LN vaxzoq9$g՚Wv>{-5+N/Di\FVlaV~9SьiN u[:sED!?S1S3(Etg&5Mj%&.ȠbwӴ057x=}1}ֳPI>;4q8^^ulʵ4t&)-o?ðP{jxyu=e|g2\0X};2 >PSJLBp!cb;vޞ~ W琑u}b}.n.niîEFr ==}?P=3Ϲ24SQaXu f3ce\uNL;+Xs2z:[=Bt‰îMB^s^|cɛAswS)6WLv-2:SDcGӴ\Xߠƺv$'/ȄyΟQ,lt[<#+\pT0=4L畊?)ZDDDDDDe|x1q\{0 >1Dc¨q_{dbj4NÀIIL&T3CebE 9&:dMM` , wWO]C=;~9">8\feZ^*tg9/WRNgI;l<_vpfPw4rfTy 6'Xb1˦fʏ-+dP?#*A)GǶT?9z3/2iyi46W>'Xb3xs;k(^A.DʎA|r$޳s+bd]f2iZݲעus~m^EDDDDDD>!Ai`&Qa,Y3EkSU-;+0r<0ó$vI`11M KP:[f67¬%vsomOA)Y<)A{[7o!>U/~b-fɘn&s7c`$9ly _^Owg3祳yKRM+Zx~wAeS[81M nֿ|g\uwOrӝO 7?gKIi1^ 'O=Ke 6oh6gMU+fmݼNc3?F@7)b7Xy,؈ 5gK t@?sSUȖ7sxi2C_{ˋ0{Bxs?MwI^~il_ X| A@<xcƼ~yhg{ޞ~V>B,Ĝ11:c6 Q"f/_> sW|ѳ}l~B6 K$:.7,V8ۺqtTfCsCLj> "'EP㤷g%+n->\l|qIv79} 'F(iNx0ASCIIScreenshot b~|%tEXtdate:create2023-02-03T11:13:51+00:00/ Q%tEXtdate:modify2023-02-03T11:13:51+00:00r(tEXtdate:timestamp2023-02-03T11:13:56+00:00tEXtexif:ExifOffset78{'tEXtexif:PixelXDimension1556UActEXtexif:PixelYDimension560nA#tEXtexif:UserCommentASCII...Screenshot+ȚI(tEXticc:copyrightCopyright Apple Inc., 2023 tEXticc:descriptionDisplaytEXtxmp:PixelXDimension1556RtEXtxmp:PixelYDimension560atEXtxmp:UserCommentScreenshot|IENDB`ripe-atlas-tools-3.1.0/screenshots/ripe-atlas-measurement-search.png000066400000000000000000001661531437041663000256270ustar00rootroot00000000000000PNG  IHDR(  iCCPiccHPSǿ{oz%"%&H'ZW! JbGX *"@WE\ kE"}Ae],Pyy;3g/'ss*$4X tq4ϋ gJ!!Awxr\,fBPNdQ>KD,ɒs3t) 9i9a1`&"2Ǔ&@ayf6? աxl-(KPvOO|eSQY If\KY&-ʔ[zljc)R04~jF sX$d39qS,yצ D/WōbaOK3{%J9)IFB\?'9"zEQs835([P8Nzp\-:#+0 >QA.dY@ r| ( $H ɠ:*ʠ : ]n@B_`tX6g, 8 ^ y&ue  d! HHUHRT"5H#҂Ez!3aK+ccVa0e#:L3.3bX,M.cKgW~pX\ n9WkFxY|.1E|@&l 8K(!%\ tD%хL7wQ2ɄF ֒JI5Ǥwd2YL%kȥ^g Ŝ¡̧(()((T1ՓG͢nVQPR?)  u  FlŅ9%()8JhF&&צ歭-߶n]{ {^499:9Jk v;uV3y9..Y.']ttMu=bl샳xnn=Lx=z 25΁6\ -II_Bq!lV 9Qi,)J1j~TUh螘Y1+cnjƊbqQqF1] L,]pc´).-:?̫$pv' 9WOvMX,HtK,N|䖴-i0#$yHޤKz8u,-:6~V"N7gd,hXH%=]X<, ʄ2d6dT^֛]iIԒSK^fl㲁ߜc7[vEJʊUЪUM V_ZԵZ_1O;oM^z ACF6~/,.,)Z/͏?mJԺq---][=)V.)6g[vw,qľdNNΞҠ҆]Z\YU^[kt[O{_/EWUUW>`X?U%蒯̾5~x,}lL“&Fu81@kCyAO@ "%Nn`|$ܧf߉9}p~qT =g  6o cHRMz&u0`:pQ<bKGD (2: pHYs%%IR$tIME $q PzTXtRaw profile type iccXi*^r@83P"^D-69,[Q/RoUD%bҭtsreڠjY^U.?YEuc崾,J-k~\BsGǐqw|iuRVspGj?ue=]!jz_Ҋe ujѡM V|ajρBEwKKݡkw!վ;ek?d֦IZy=>q:()udݷ_QiD K~}QDƇ'j5byOl6hv󾴊ķ T( -ڀJv?3A~Ki)w_}H/_K3nI~L>Z?YONqi-%}Xk)"0A%Ⱦk|x)P츢wb_)IxwOUӯ 3hډJ[<ӌ栣g17fb:T:1;6h<3Agqp89#mNL;MhJT߶+Av >4<)/}%Ab: ^fƄ?H'Hs/ȽFD]I(:U#W:J֍&ڸfܹ\0!sARUH|-, (m#TЇooB4 jJiWa0Rt aR .Dc5XR_:޼v;C:@B\`g+3щuбe̪COz5|ImZk[皼k l 3itjq969gYVDz^Nt ЉP}ͫ 4%^r$ώq#'8SGXk,¾fk4AKNk_aMV ^IK;(wA+ Io!l$f$Q]1c[B8ULRbɝzivVZ1 u0= DPy(4}eIa"E[#5YɶٜXuX:r{TA%F^fQ;̼RT&0 }غǶ8Òh V$bO=v\UF#9pX=q:?s8qYpEBmƺKIDm rn}xͥKApkf&[)%MSZ)-U)^OͰ"c[ɭf}$S6XCw U2+xfyT`{"I'K;Eɖ N3 w:;\ &ɞbvdFLJ(S@(P=G1t|f;/| ~8#PОrYM=*"QGj(H qiG;gLBer8x`6'UdXN l :X`vB,$%!uhFj/8 :QfkP!.Z;;%GP2*^P b6G1HMhzZ4/ea4v 3`jYX5L-hc C 0-F(%\lVdL5SZZ($><{TJ]jJymO6Zj~u::'tGgCd槦lv{<Qcyd&4=Z F sd'I ✳.{lY[[j ٰ-Jd9bh[! (Qߨ,QD;QZ abCmd)s5dSt6^yc2 m3lHgoqa>۬-kron)nF!אg(v7JIKQc;yR[v!5$M0@3 =e&LWcFMF7pY,t;"oeUZawUv/4ZpH=iN^:U@4lwBҦt' 13{SQFI}"E(ڱ)Xtc c dȈz%T g|w`䩑1: N~/3UeXzQisr`Ø6 i q8*AT"%rSI^mE8ɎC  y6~0!PcHuL քNXYu d[,}[ZFH* oja)U 6+}{/: l >g9;;6Ǹ~go el ڔ->BxZ|ԅ.6l+6KGcu!վaMeou#|Lh{N.'v\PRpPw`kwmuy=ACi6j6a(ꄓDi8||&G .hrf??i_7?u}86?MEG\w>Η|} OGϯg_n>9zTz߳}y|9uۮ^FE75YzTXtRaw profile type xmp(S[r =C u=~W I%iE ?_xŲVZ5Bs\tQѮTw"aA!)KMv"+5Eb͕K" zߓ!D.6j"j¨«#7'ۊmxzj*Xh+\hPx7p0Xs(XXCSv;ӊ́іabKAPRIǽ9Oqem29JްW .nQjoÅ[o02nL.'Kxf~ލjz/qKcaNv}:IDATxw|TUߝdPjBB ]U+]ۮ못*vWq}AHJFz$s?& I&!1>:3gsνdsU!B!B!DtB!B!B/IP !B!B!z$(B!B!=FB!B!B# J!B!B!DB!B!HR!B!Bc$A)B!B!1B!B!BIP !B!B!z$(B!B!=FB!B!B# J!B!B!DB!B!HR!B!Bc$A)B!B!1B!B!BIP !B!B!z$(B!B!=F[qwӡ!Y$a!B!! JmzrG *jN=WʊÇӡA-aB؞G!B@orttG׋*G~5\]]6u!!AS^^SǵZT݃rN:?iMNN"""P?XӡL8n5,s!gϞo.y XYY5=B!„nMPFF`P@{***>|aa`h8ص{/ǎlx}3:/JKHK`Æ͔-С14RO#?tӵYmÝ ƃ@hq?_i~a}3z$>>ޔu~ G8y4y1Byqn=oIhh')$=#޽I-̙3gɑưz [߇e E%(ڞG2 {pג{:,!B!5A; IcYlEcccfp8PX\nr74 NHBBSN7#-^occÕW\ʔ)A)˞s V:9P\\nݍKfLƠzh  4NN3?FƏ iHHɔ)xs<غ~W\q)ӦLDY98r`e˾ty2xQ[]cV;l..μ{lmf]6gg\ܱr(&&ccftO&c-ر~2>tY; ?Ho>LYY9v~mh&&%1e G]`0cM!B_nMPz{zpLuuMyy{ozK/%3YI?NG̠(.k!JfDzfPtklӥ˨A4y7r+`m{rXvR ?ᣏZ܎'c18xY"ys|nV<(fw啗n:ʊ뮻J>^Yoyϵd92t`8ӡt ľ40=(**'V_pp Ct]3,|%]{s!B!~muO/[&#=<<5w ̺t:ǏE&%e  A4nEqĞ8x0NN mQǟ|>\BMM `\ĉT>S@1l6֗`vKqqe҉Ő!@o89;ֺ~7Sԯ3%LJw5찲TY[[l;TnScccKeEUfzllmX`kcy{ :<_^vvv8;;udZR u8RthlԻ766j͵R^mqZ>.uEEE(8i+RzY[!B_n豅X[Y酃O=0( M;[["'f+[s[XҴvo8;aPp2T3c^3~EEhq'O.eAi&뗑Atd[|jR8SΈ`Ӗm*gooϔ4(>("##/V|ΝoW}|xlӌOce#=-oOZZcN:Sqss dg_m㌎$,/6PgM2ٞ!XtgdZgP` {[Pp啗1sc(Vk68<Y3\vtFNǓ\vW_GyyE/"/Ӧ%9pvi;W#Geg*߅ۃq2sdb7&Y iD쏃C/@Q[[#tQ`?fdH lml0(;ʗ+!++kddp@q x];zGi%e~-x#J7Bx9|z%o/rr-^}nnn d_; QrA (o?.M: WW ʸ<_.]L}yg04ӳL8c(Jq2cbŷ^Xi8ٹysƉr8DLL$dffuB!BtMG ^oEQ[W-nP^Q9s\yy9|#*z?|'O=x54>g#1d`֭c'LՅ'+3Eq9y2==<Fn^OM7\Npaݺ;nqiP__oQMӸ[43߰\"8gϚgDi޽۶~pgfӉҙ3pWRTRڵ9q$ALHZ8q0qx ΰa&cΞ=g2_xk&cƱW/fL̥3qe2d֧*k.gdqtl(wt.|Κ8a}quue3[nGӌ}ӝMZgg'rs󰶶͕;v]{`ذ¤%<<2e"~>{HONcmTWWuYʩ4;An^yfϤo[n^L<}}.3'<"QfڽO=lڴM[9yuu C!i]urٳg c/6lEɡGprMٳ|O-z<==?CA\\`=ĉDۛѣFoz g^fΘµ\AQq knĉTI0l﬉ Ӧ%glj\!_8lڼdٙ3r5RPkNo8r~ݺ/ 㮩8O5ęoG{'yoƌq"ЏaCڡqǛqas]B![fP Џ[ȗ_|Ŗu|=jIbL3ṿ73jL<݄?^Kii9&\z;[Qgf6as u]'/M0?ZإL߇7|l9eN'0ϞƔͭ,Ϝ1Mq~|>q嗲iVqnLقVL:ʆ5Ku/SkkkNHUe%k֞OHftkM3֧<؟suC{FhݞE|'8s}aj/!Aܿ **V}۰v=rw`6bc1uD|ϵT5,Ay1{8o%.v8ƌW/l'޸Z4NXjӦmlڴ B3ލ̳/RT\K5H-..w>l?2ooo >zy'HHc݆V׋_ξSOg K/?Oҕ8p`?/z8'fe3ٸe:]9t:#L'ڷOi'Vg$!!CDIi) 6B!BtXA -fx{y P,6-''E&55Sy饿?^`PLO/ٳּ+kq^LI=ɠAfآ?s25)S'K?_ &:'E[˼Ϋ,u>|#+fY..8;P\R֡rIǢϿnOBo؄Fτ L4&h(j8Q}}=Og `mN0nlӬO[_]]Êߢې8uI ,|e8fSZ3D+-g(WYr~ 7l}Bϖar6՞XmZuڜvLh}z)PQQP :fz4M# jkWـB k]e6 ?_]l\B@Jkf_Vˆ 4CL\/I4eWo[g_8.]ЏNcmmz\JNNJGK[ǹllmILe0q"-+3;2Z .8lؐh'JK4).B!%t_ ?LǼ#3U,3th lٶ?mXҎ{{;nή]{9wg;n#Gɉ 7Eޘ0#-=?=Wxp(=ysn@7y!1}.~Z nO۲mvs5\>kwG,uCD=^Ol4saM@INTVU19{>}))-%ČSj;&7D:|JA@`{I.LJkXŰ[)PԘjJ@6?Z)ڼ[I܉ĉT<ݻx(vvīaI"T&eEhhvnFs _ou>h竧lhч%^v* /7\::_/JGSRZn~ fƥ*4V&QhHmK ?i SUVV)u[#ǩL'ㄧOhB!BmXz{yRSSbƃ'g [>ke2&ƏG|?o^>=gg䅿bv= ѧXY?n,s\}_JO< Vny{}pD5 WYر p8Ժ~hRau͚5{b1̝{{;}ʙ"ᎦicYY%e4L$gjzLE5<6Jgu#0M)c<&eۢ.qJSf77 Ypn= O/.^oͤ0!1fUiZ&Bv iommMLHq+Gұ'y78v)/+gY. MCSZwߢįPKYcoyA;߭'ڭKcдV?6HMU5>8.i)4aeCSde"s(\u_i'|λ?dxzzi;B!]ޞ@*+ZzCQQ1c7b LƸєÏ/nk?= z&#*z {;!4,,>}fk9vʊ1׷J4t۫E~a7r~nw%O/ԯ~㉊Ъ~C)E^N>PTTn;{;Pv7)laj@\quU&3Nvv(MgveP Htf6\ TSZuL>(elXhhD4g8p>^Jnn>UUU3Ŏ/Ne4E4n_0cܸнPo`aQ/GkYb@V:g,NNvz7HK .v8Q9rX/((o/zjS"==;hf5}Rӧ3?wΜ)^C^TVV]gtFq:u7 SUgTCSsͫ&TBCCP";YAA$CFF6n6SpP 4;Yf.^+ לNYvHM=m:N%R] Oh,؞Ɛ͆,HK)Kkmࡡ!hRJq:=un lAe~d21 W)EZZǥѱim\3+Z/WYYgÛz4 ;˲d-֞?B!]wP칳423̢f 33LYGB)c^1m2`L,6]wފ5%ĩVrNH5O]]=zNH%ac0().!YB)#rd]U?)'ثֲvFz=S&'xѱPs={MTa00[A97]_sFzk&OxA$KuvwTWfm.qƲh EFcsz90.q ^ww3iR7Ͻc;kfBR"6zڒ[ #;ܲ%vrեt lEk?_j4 Ʒ۞-uѴvIfz{*iV0Zw6k.C$ns=II%33Ooڼ4ez\ Ύi-Mwo @( lF<1(9'ۑB!B2e/OcR]//4gΘ-ø14MaCpwwYlLT,? I~X|{1th Æ&##űE1|`bEe6RS4#HHz\]Fޞ+._/#G)))%$$IQU]K/ު~˹+y'XZrsq݋!Cb>t0|u 6A"ټe;N7 q)(ׯ}UUU,_9sc),lyeV~qø|%xzxr!47bZ-nfjx5k7II<lܸr}}HHzU};gӝԻ7qus柯E^8i DE3d3&fD,ҁ),.&:2{^[[3hP$˖03[WKѧO0{Gד8 O7VSggٝi)L!q-lٺ[[[b3p@%fv၃(**fP@{??ڊAQ,|O}$w-۩#O0~iχw}>Ζ00[=w-@ocIM=MYy9a}08&+++6oNU$qqriўEgLjD***HM=6fO{{{1zȦ  ƌ' >DRuu$k@!AqÝ+'983cdJJX.i !B!D'f\鱆G ߺɴiM_n7:؟h[$(G 9c*rqS8kjcѧTWW(n} N榛eQs>())PwjV]]͢ǟ?\Nl08r8K.4eG drVV(%%e lPn} N3k;z'E)rv͇u~Zv&'9y<[h3qgXp<F1fL<'Sؾ}Z+~3leUU55ne#F !vPE%xy/჉4*+Y:қ<θXFE)ű'Y3xzzpw0|qԟ皫`pL#7q]^^K>Umύ۳nhq8KgNE7߷dK04ʹS 3iwSJP6ve΍נ4-ÛRy{5CGs՗i:6g-OyEEYca}diø5^4kTZ:>lr::˸Ʀ9i8PZR8u_{yǸPljF]z9I!B!~4C=?9zkk(--Ģ2VV:|}}9ẁ*nn8:"33ݝ[ϟ_uy4yE-*%LRގxxٳ}q8K\]]p"GtT$>Y9J^~Av򤸨آ_4Mgg'rZo^ %3OO*+/0nlqPQYiNi3e=t.cOd|I/zLoj 8/ww7JJ̏Gd@~N]{%Ӧ&~&yߝH!BѭߏEޏx湿M[>=}DE 䡇!#9G'*j 2&;j\1V,B!R]IyPE{{kd\sg_4BCCaZIN !B+-kP ('7z_H[# a)V~:sR7. B!vNZB4v:R^~gNNNwIN !B kP !B!B!zA)B!B!1B!B!BIP !B!B!z$(EקCB!pՕ8vTO!B!DIPnӫ>Qqvvp2VVV >?ߞE M[n")ilO#B!=؋G?_^9rCpuuaڔINyy5YnI Ã2NnMNN""" TTVKz:_Is ,gϞ鐄74ͽk+k~\B!sݚ@t@{***>|af8صk/ǎlxa}=&_ooJKKIK`Æ͔-İ14RO#?xӵ]mvrrnnMG4رc7'O2]eeaæ6J ʚc'Nr`!NwZHHH//>ڭ- awқ3Eeqciv9;9QPTHzz&N{4rgJHE(eet8B0l`;e9r 7q\] qs[' aޗR=-ۨk`7řo<B!5A;D/_XQӥ͖a0?E%&(|#ǏA HBB,SN7#-^ockÕ_ʔ)AAvv 6+/W/rŷq$KIqI 1 ?g2AX?P8Noi\yť\zt4QTZÆY,~}6o-}ȐADEdݺsj֬8;;i֦mmmۜ=62c7GJbb0!پcwO bqlܸ;vO.ӥ˚%;랇(++`0\V_LLƑSomͽh dggF| knc?\πEQqQ ȁy%3;@%&>~/zI7\[C!Bc5Aə3E-~ 7/z=^23`& 'c|h?~Haa:AQzkkbEvF2jjj4}0Yu6=yruu}ay4~ߝDFf7~,|.eGKk>>` EE>l(noG^^ٚeeeu\EUU/ooȁ(+/c˖-k+he#*jel@_ZpPÆİ!1߹7^t~+/8(aC;ߏ~ h6lҿ_8c5~9c*Y;Zp](OyNHٗ0{Lnsoa/8SWrݵW1~Vˌ|!BCuO/O[:aa-TVVgx%uNH%OHvCqqIq;Wٳg[N~~rs['o oWQXԼ~9pNNmY[g+ޔ8w[stFLLTqfMQvvvXYYu vv*RUYݡY*z[=,:ԞFÒ`gg'4kד찆ҿH zullv[3׋aKK]:#ㄦ5zv8Ȩ=~755Ξ=t<}t8fSVpN; -˗lJNڀ8,!%e+zRzY\!Bn$豅X[[A/{{zi:lll8?O>0<9P-C4|o3[/ITd$Z=gn"ѱN(V]S'O@t|jsqƠ4N_ZQpݺ~G7~;vfx M 6mޡrLiif9m$N+ʠ/Vmw2y"Eַ"33/W|3q6MvAit25f'ߗ؞I5g `w {{@+/c)4Vk֛>^.Θ x{(/Ee 쇃:\mG?.#=#U)+/ӧ 5_sJ|dDx_MK&r`ùZ9f6F̞5a׃Rq V.kkq#8z~̝sQ^Vmwߢ>r 44\.LXij\vtFۋl_X**;T?^LwZա[5M[2|>_|coGF{n?.ohUٙ@ϻlظM[EL o4y̙3p.';'+A"6vw}^Kߛy :#G_ӻwoGpݷg7ت܋/<h:>>>wH2&翚,(_o}WYsdlϛo$6n7l&%e E3xpW_u9/e*>PDxP23h7i `m7Ν{ؘL3nOgeExXG^^>z900?QQyɇyf`7b} oX(Y;kfל&`Zg߰PvOtt$O5'װ{rCml%+'{{|>t0skg Ke;>}©#~>Hx=תٳ8t8* 덾قyDs^RR˴iSpuu7L_/3gL/';++6鈋wROzy702n86l&efbb<(?\5hn\MVv_nNGa},]W_:ى@qwMlܴ( 6Yf($$}"#+qɉy͎٘Xs;Ϗں?98SUUݥ(++=^^^QPp'ͷ߭_p,d) WB!gtK΀xbBl5ΦK;KkA3~m{ 3*soϏ~ZKiY92N{})e*?wd'Jgb䥗Lߏ7:T^o?ndm̘̟w#~j߄soXlYEiz*2YΝ;gq32|`֮{,ij_3O?_¦M[))-mYP)tq٣V嗞'r@Zj>8%z߾ʿnoxG|%lLBII͜9CcXn#qS}#<8WξM)ZŹ1e X[Y1u$*+*Yvcٹ&ecz52J֭݀j9t5N#_>$OK3p`?n֞E|'\:s*aa}ٲmVm` 4 8 jOky'IǺ lg#Gqzn#.v(SLd'-M=SXw%VK׼P9r2筌f2N1qp|ϧ.k񜓓n.]شy6o#$8>}Be /P\\/=Guu5RKZshN)By`\/O0*>u[_/cA^~_M3Wxg4#y?^y9lc\,?K/7zfϞƔ-⼨I3iXl~>lٺU?Yf,:Wg`T|Y~~>tƵ(EB^~{'.Wڙ? JQlhގL4W_[LEyZ,TRRvc݄B!0֠D)E^5(=Aav Vhac?S6m<Eԟž=,omm7^w^cm7ͷ󗿾lvL5IIcbSϠ^oͤ㩬 %e5/5SN⥗@LLO]x^ǎLQݠ3vu܄1(,IڂB6߄ &&.ؐ~cmmEk$''4> \ 6z=[9~ WL!6nBocDq;~ee,ly?6n2.+Kl РO?Y]zPR-fs:-kkVk,0{~yXMIJoHA)ݵu4aho}TSrti19m.Nkkk@QSzײ2NwG666DEE.nZW)BOBc[^6nB1xp%99 + >zTWWogw5oj\:}:q GY×+ҸpJ[|hr֛_@ixDUㄍ nTUVЃ;l(Ukpg}׭ݼOLvv{YR8Y|2P __nB!uc ]dbmC &0Џ[wj:@ΞތOزu;vZf͚]w[[Ӌ9޽Yqs],Y2IB|ά[nC & 0vuh7Xp[kisn++ks [xxxkrGS5BS܌ V֭H :~=曌cq>~=5@Ө6બBVmLM YV)@3y8ˣ[jkk!٢4] ԙs1yԙf8@nFsnAqs8:],k֮%nU(«[3sO xz^BC).-3|2)w~&ƥ>}B(--7?.gETQa~JkL#(4jζo< Ϯ'<==@gfjkq] ysO㮅޳Ç0bnl;je/L̬fsO^&˗W>Jqc;zg?Z~r ~4{}9:eevnǻeKK6mXԯ]EtLVes]̙"jkkpG4s`1Wj&i]RZ 2~ql-O{l\ eqA#0M+--ECë/Jk;6JvLgakl>Mu034L*5'gbҸh\4T.Gv7hdmmM$&$mHHk](xrI^x2&Ǎ"1qelٲ5k7u䴠@j10NE̟rݍގGo4ДqOOwm3jz\rrtl >@A]BӽCB[x,ĩu`2bFet8QYY2\b}}}=?C.\yۨveiih)9}j2y3z9PY~71gq!B!R'(#"pp'8(ʪ*7χ"DGnn~;5#bzp%~< vmm-_~ %e̟w#^{Ov㯯7uL4HzvlChXX(}7>g+gDG $0ȟ;vsLa c\] /yRSLd}|]t[RJG`P.mcggiԙ-U 2wkC|6Xc $K]}=$d(| ]_/f>[wϡ4Ք5dC[!+lo*kƂ7ђOͧ ww7}'Gve-Aiw,GlpMo׽6hEI]k YtmNNh(srhhqo(;;;b4c; 2`Ibcˋ/Uq6e[G|3ƍͼ93ض}']Q`Ju2E=h^NNhb՜Px+s~o|~~UU5={JI #5>c>:r@s󏝝'R)3J;rǂhlz|}>=3u~qoohj{<=a~6!B!['(_[8;~fn {oغu=! fnWM:++ X`0Xb<翘,CiˠH28rXkMt䛩Q#s9p0/zvtbٿݺq#ں:|=ˡaafhݠJ)׿m^mg9|}Ʃ|\Й w2ץqW[APo 5rdByoo@Ə!#3 6]W5884HM=ez'keh(uMۯeI@N6@kn$yRAAݶDPP Ə%#3mguw. ڿ&4 3?Cu0!i,Y_3sq\Jifӓ%Š (\B4q#rs:$?_.xߨq9.7{ gꔉl$1(wxvvٺZs-B!.ϹON##3,р'OEYY]8 bűᶦfL ʘXlׇ//VeSQe8jzNH%i1O2 MGzm9p07}d44~~cGඛٻg?/nONiL<^}}mm-kmƆɓ'xёPS}N 3L"l~?43V_sڍmlb"Τqc8{\;_Mmra sj @i0&Z<ޫ`0(5ߞVV:z'&1IJk%h@6)iص9D^^>Jӈ--)ɹٙYMqs,Jn|M@@k??ڼEJÄ;zƛo4a|RKfPj(q2Tq`S6P7]ۺMYve҄q̝{CV5M3Lټ̸̹N욡LG 8=qhy_|ASZ{1tH ÆűE1l`bؼe;NF4gTHΜ9|ءz+jۙSoƌIYY9[6oo=+tqWOcc{1th ÆƐWߴ߀喛7dO4nѰGKv*-_91c~2_}q#rKt#8;&))7WW^}m1yvoex kn$(0y'ؘr|}I- |aV~#1{L<=9p0NNNL+||tf -Yv%l\@}! =wƾ[4(eVlLi b8OWVԆ]MqvvxۯCS>JAAq|l݁-qq?3;1hP$ܽ}fР(kf$&;oemӧO0>Jaa!nq-lٲ[;[b3`@%%Յ;vs2ehټe;UUUfctvv٥wCQg!fP~t0~*+HM=6fO{{{1zȦ D)=*0iiܵ8f]vtBCBf׋;+V|k򇡵6O M]Ob(~{ hVUU_[;b8#QTRwCc"_ͬY3kRlJWybR6mex*+*XfԜWm%>>q =~E?'{;Ç 1l9ĎJl0Pkn>Ç &_( ~Zź55gyYp\G >~8`t"c߳ bbA-e|d)Vm=S1fL<啬Y 'q쨦咙4IPz2{%-WԌ3׵?eV 5̺l7tq*شikK>+V[5pt/lү]6m˜#h]}ܸ1NtN Ƅ|f82ΡĎ 1k297^a8/c葌1 4ENv.铍PS9?@رsWRs^OBFEӌڒkgkc/~C=)B!z//Aom?XTJ/Ν#p]Nԗկ'4x湿mQ9^/gڜՕzvÝ\;ߗ_.WW<))-L>rQQy'w7W (/X^^[4 77Wiqz=66TTV>n.{SRb~8AEEEúזm7N[***͖uwwى3m&̶gqqos}~\pߡ3'ڥqeqay'ɾq3i_#NG%.ctW2}j27lwmr#>!B!~)s JǢGǀgG'*r=d(cOdD}x(D=k&Ͼ5k7K$9)B!z\o#DlyEjkLnF$/_xC\17Z̋4>!j$'B!įFA)D<| ,\oS~hfIMnZtRW%&B! N”S3(..hG!NS\\"ir޻$'B!įA)B!B!1B!B!HR!B!Bc$A)B!B!1ޞ__E!W\FQ=B!M$A)M^XӡL8g8{lO$<os\?Za !B߹nMPFF`P@{**+1|aa_Po0Y>!!v'=^xX_ƌǛR3ذa3e[[sMװvFRSO[TLxx(%%e=z-[S[WgAёDD@^A'Oi6Rm/0aޗR2ξrqlnŸ+vߚ'Μ9SDZF:N{4n,?^vɉ3e۩7Ǎinn 󡨸T(*.(/+57x-kmsAOI#8K7|Wx Y!_j{xY2ncyiccCvvA?X^ݒ2dё[®?wͺl.μ{lmf]6'''\ܱr(&NƍپcwO=KJdcʖveMt~o]>LYY9v~m?c?Ɣ_w i4%%%7|"(R#/7\5-zZB!1ݚ3<<7z^ϥNchdffƑ4n4w>NG̠(xNnka3''O5k7[/ww7>p7xĉT.} gdx[!9oX|%+++ιrUyOL )ǻyuexn,\x7(պlq^ +++***xg]޿uVV:"#SVV-[iif9m$L+u99|l۶ӂ8# 2ԓ͗+yN幔 cll$HOb[3((m@S\ue̜1!'Xw&ߗǟx.x{?Q^^e˴iDO^(qGOVeXNP`+3rŷiiYx2}j2#4E:=c:F̞51գ 3E?~/W|KVVv\ȑQ =oK@7Ϲ~a(-);hQNj+tjh(`8fZ/OxzIǓdfftB!P$(qNrjP(zv JJ˩Er=$4$#n]JDeEܖˆC/O ((8ideݷNHHPr>>ޠB+zv$~d,ݳ|oU9g''7FFgMlB̠(bbټ?Ms挩\}lrrtù[YW_Nȑwg2q3b ywNOOKr{i<ݚoo/_АIOOOΝ3A~̿F↲a6laРhDf ڳ{!! CzfV/N9,m11Qܹ-$2}$\]yw~:++Bٽgy8r`DEɰx?5nTYUŞ=EHH0aa}"YN߅,4feeEXx({%//^DF'*rO>0?T8?)[?__Lp_.+--5G #OTs9s*Ç aM3Ln<+.MRRZڲ4#O.^W^~cggV1Yw_W+V~SO>Y3٘Ǜ9cJCx%'y1qnLٌVL2 6Kg`JJ챶fITVVvF.l.YїG{=jj~La4z̩ۇ[w꧵ Xx5꧵<$DZn/Ƒ#Ǹ[=~];S&x>\T}غm?~-jYȑci2[n2N16prrե˒6ocmѧO̻r~oߟ%-־-s}HH _p<$Dzn}JepL4l;K+V~SOfRTThrm烰fW~OEiY?x~ZJJʸeލ\{U<盞 OH0ٹx{tνiV M}]=` ѱXMɸ^P:l//&00za0Z͞)iHIysMst셦Y$''xq8JJL':C)En^PTTnkz `7z5ܜu ehBBr;;[0A) j{;45㷗PДq`Gfm8^WY4:9p0})TUUs,}Sbi$n\0p7U{ޯ:||>m2gΰsמ}|)(jcR7 kolQCYYx̘L~~)4Z5>- y{ֱYN!(//Of6rqv 22Z?35'?^^g@avN5?WAѹ/1yUSb|CfPR5_CCC9\^|ktUQt6Sʢad7q6f Sq ;K>c̛ܸ{;[o54N,mqNE4uP&6/5g;/5fv濹g 555.T[[˚f-sttdԜaOڙ-lHNi6@cM׶[g2u6כ3ih֜c;7EƺmE5-vhIݣ+|[HHmp^Kػ|{ZYY0ix͹c;P*AՑi~J++?t;6۳հjg/Qqɏ֐c/agd[fva<}c®]{fIձdgfˆc9r8vvv75skf! ۋSLo߾ܾ#(7uDqvVUU˗`M1cd~ye;bcqxxsaHJJՕW_[L^~ٳe~km (ȟ${ 6l?ⰳaCOJY3C89911i,.nj[q]/=RӔ/д q!=wƾ[4(eVp:- K/NH~޻^ϸxxbŷ& h섳30hAf_{Qg;QTRF`afg8xbr ط@kfϞ7５[Q[WO>6 j q-lٺ! NIi)tuuុ[cnNݻކqptgoM&֮HP` y'ظq3e- zfθ87] `6IwϮ]&7Źr|HHԨښi|[cՁ(,*&zP$ܽ`mgР,[DZypILLÃ+e" w14^K}ΈCpwhy{MLiY)+V~B!cݒ4%#==ݍIyyz2c䖻#3`4͸GqɌ)\ultVh JJKؐ;=R̽:c9ipӍmmͣ<^oޟiv"Aaxo3wu9#42{&MK5k&7x-P))[YykiF5k֙}mMY^z_v뼆R;~O/Ovl6ATsJ숡h@Q>сChTV꧵-9_~nKƱE8v,EO<;sG8KxOsW0hPq#f񕗕ǟڕt{nex+*Xf}7qcG54.d (_}} J/OfϺif #)[L$(56fh^ Mm_//YJUU%cb+@ZZ:EElL˜1 .r~R5Gs՗7̢U:av\jI 4>c~𭪪8c;|(4͎ .]6nM3niӖvljb$;5t@i 8رcw zI!Bѣ4C=?JK(..t:()-h]聜:FEEeGIek]/B`?>VϽHVVEz=~isWWwsJ-qsuÝR 0Zgf{~"#O#DPIDAT nP^^a񱼼<(..hMpwsى[ckkcQtuuݍR3OO*+/8c MpssŹqjPVޱIqQ1u]y-7;tt7Kqq7l2Եqev|x8.Z+>=7λ6ѠB!eѣ`03ϾŘp‡jzwĴgY3Yv#DB!u=w-++g}ZB4@&~uPzQ:viFhH?Z'I!B-kP ('7=AݯvQ嫱$Q~6ׄB!B$A)$')NSTRBeec/3(.)Bߕӧ)..$9)B!~md J!B!B!D5(B!B!=FB!B!B# J!B!B!DVvt(B!~2ǎ0B!DՋGy8;;t8B!~4Mˋ[ĄĞG!B {:ѱ>r~~9rCpuuaI ÕJROא~ <<)+-v/INN_D8h hhTTVKz:4!D7QJƛ0wuXYqڞK!Bхl<|]o99}*s>18|(J6'$1jHΝ=GaQq ˥LgԉDGIn^>gϞk^oܹQZZFqqE 'iXfΘJdd{`0V:bbI;iS&#Y]9wEr~SZZjq.Ipb? E2(z !cXn#eef=A3eA]b/g'g00gg~UO&DQҁc+!>ѣFre݌c^dwIʝ0`@&E(B!~:2.v(IYlEccnj"<.;ww9Y38r.|M[0v |QeM4M[bh0pWsB!tѹD׮% M9վ̦0ib*?B>25FvM,Frzv!uhÖrb =i( eS^z4͛'I؟Bb%;vZys౅;&ɓӈՕTTTR[SG^oV/(rb}ǰٰ!RSScsze@?#d^>Ṽ<= l/(dժݓrah`iqI) f^AA!; 'yPr j_[ED)Q+b[4Mng>KLJøy||շ掹ޟf@s3mCLLsLVV4p7x-/w25 @\\, =W@^Dʱ'ח=AIع8LB@.ɓy"7?NtJS896ix\]/*K2@xX(uYML2sT yM#LWE>^MvV+*-{B3G}R5k7^>xxxXL54(n}xoֺ[K|af_sP^^aYYnQzfѳ ګFyyM[͍i&QS] L+,,šODuMcFE˵Zq1<15ya5h664u6YaѢ\?{YY[$~3gNe]lޟkgYO*eXRE+G>cZFbڍ:+))dg͜NBBwl5G) 4>NuGիO0*e6ZơZ{eoJFsogHYY9/Ν\ᦛ˃G7Uٺm'wh;>e߫g_(Og27m/)MTi\kiͷ7%'kؐ 1{ aPJɓ[}|*JXzݻ3ie^rtƳho/Sr yٸ.fKțo}`JnT԰13 . LiCuGlL4gK!n <8k`i\w>ڝf>W2SXp};sx&"آsskp6//O(*:EMSDEZ44Mf<5յhY&:RQYAѩ?~ k˓ NC?(mnՌd\R-)sVvoJ&YKPp EEQ@TTrl?3\g(F [K\1A!A-8mmژ\.x/#!Ų34MCsqAsoj؈_5(4cӧB)cAHH`5s~c缗gK6֠twׁ.͟+0?4\㝃Si:w$G!B+A/jFLsbTY[:?YGS={&/<zeY􉀲iRjEEE_2Ot]zPWZ"\kt:Lo MSTVV˨Q\\czzhk6̖).)…4ͩ8GGG0+*Pʅ`+ e  Ƥy;Cm9{S5 Ipy!:*WZgSC$ڰs'4cڕQYU /IEGGQiclEE%!~8etpMۄ[;^Gs}u6GC3V4""##+l!psuc6h {zz;1XduJcB4(v(OO ֬`ZH3-Mwӧsv1>7z5?^BpP((*:t!B!OW'({Jӓ(jk.Ne <<2%%riN:ۻWSPQU7߮5^__˾;Ϳz~BB7'O7]X]gؖА ¢S.!B! [~ 6Ƃ5j>C dJ>_wgܙcuގ;Wꊾqp ahJa0e tJ􄅅1=3gJعs}cSY=D)EnnGF+6f;7]3˦0,X0ƵŒ,OUU5w}[nRXt(BBJPm\ ~5ɚyGغ>Tc8s,ΝO/;ݮgA\[b=}Q˳ x;lj? 䉟/hE2iG^_=gQNix\SFny/1eLY}'b4I?EQX>IMC>]deocҤT%2fl e%e;pwiYf7#ӷ9M(jZDx8aa<`k S]U]9odnڵ }0fdsl1;w5n4(-un`^B!6~P1\r\]1bPMoo:4 4رsS5*%; Xxs8^g^݇2-td#F c@>>ÿ?[\BzBՋZ{ƤՎ8⭔\MPP %N/\ ,4j=⻣)sPSu 244a@)Ϟ-0˷,wpq%|=ڪmLL'OfftN8&`zڄ=YqB;D6alӾMӲybb?O» ZP䩦5`J?7N|| (p?ggl<܏Os}ixzvax0Nog2M=7=<#;(,jB!Btv~t2J_A1 rx2B>|hjs32AS|ʪ*=f}}GܐRezO^Ջ;a]\5ss ޿)-s<Ⰹri  pNYfULMl5gLtnLMdwW&ܹ6vb4޼[oH:tnDEFX uqROoOǹӸ-. M[͠fuc09ߙGM⪳/&:ݍ;w_TQYNՕϤIsH0~e{p`ӧO)߹ *Qa,z=|υɍKݾ~R_ ɡ!xyyՁ){w3hZKg\7b`0c'~-asޠAk7€ ٸ1KDӋ}wl>e">>z ΝwB!⧭C61NR韦 LDxǏ)#;JaChܴ$//MY[Leq/8u4 !gʯ[e޽رsÇ ɮ]{ eZ$ |lMѝ 1rp̸ӠtӵA8q2?"9TǞxywe̘; 2c٪%}ߪLAxrM(0ڼK/A`"=ѣ3 1Vf.Q#3fʠv5}FWo/B^@STհfiMJKر)TWհn݆VwO2㥗]wC>|(hZ&/W^}ٳfp7_7ؔf/;{+cƌu2}k#1.u1Ii\uUh/W~c7AY[[#>Mt nnDӣGwIhh(_,[0rL#?mǰ)~Òe)Qnh:_{1(CJmLmM-~Sq ^x'+ QWT8 7_O)dnwݡB!WL 8сm]`0@n xأ#hџNxHhUU-NtF=;%8___pĬrm +ZT˥RG}4j[s|]#1=?#G~xȑ),8Mdd8]z(yu98f^6~W2`s-g$c֭>B!Wv$G&<܋47K*~4M9|It<͸eYsr+..!{,W]5 //Ot:S&J^~O.9"i_hF|X]^B!B\⧥i| .4Z: $ٮ'ٔcF/SZZNUE^ŝ3%ouvUʍagPJ񷿿/B!h?N?'NRVVN>O݉]qڕ{wNqw=9{։(}teƯ3 !B!cW&9B!B!BYR!B!Bi$A)B!B!4B!B!BtIP~[:*B!~nRǍj!B!:$(Eڵ+=Ϸ#gH4BB[B!Btή2y{{#'<<>CgW'# i&C`P ;voWrucOͷ]IҧѻWO AMu qgWMAR{̹W]-!B!D;e}؏+a3!o)znQF99ك1cR ylLeUò:77n&֯ıc'j_TT$ÆW#lټe\]\8pz%3x8ٛr꼣F 6&KpP &oL4?ƅ XdSlsq1<}(>>;8[\B^n>>ޤe݋/gKJ;iDzv[nDD)")-+cz3g:,Ra׮=`0LA)8B!BMPHJڄ|2kƎW>tra̽W9LP1פRpqbc=zӧN7vˏ9񩔗U8Ů>ckf_=#GcؔBժՔƑ99{9x$YgBwe=;l׸йXd)9 lRY///J"7/}4CCuu5cGYLf_s38r(.|MY[5.c eݜ;wUյUeҢ2^^^wx=u:ݩmѨ΍.T_B^^/m)Z''[ri2t>/ϖǡr]ݺ8unFӧwOƏo~s2!Ɩ}N4Ʈ YkٳbرcSϱ˭9Ñc<3demVYY[0\wd)m!B!>nnݵ+O=0GSO>狗!|4u$'|рxdnۧi4YΩRMaҤ}di`^ q#9z=v吚:~}{eWf20,i[1GٳghydjD&'!'?VsewQQo>'Om2 ",]ζ631q=QJOn^˖}4Hk3n{%*2O<ճ2;&NfXrUUՎgw^_e+ŸGBw@~74P-Յܼ||:Eӌ ?뮻Se_Y]wxp>~1a8m?՚曮ga(>zUUU},Fsuאooo@C74P_@qI1aa>s}c7/ظ\]\7E^ 6ϸE7H>`hEN>e" 'yslֺ}eU")iatvB!m! suꂋ UQQYNmmzެ\AA!_МIO¾=aCac{ }O gG˓ JK8{zFF:Z{cV.4,MAU/%%%hYg/ 3 eM#Z*2" MiqhƼng:t%KMJJ2w|?[r~~DG2w-1MBRR"f_a3gLM_⢑<駟bVy]3l`Tϑ#N=_vk FXh01͡A|~Og gаPUc]8Xk-???bbc 8)k RH' ^z=aC8tK0op?O>j,]RF|7+T!:&;BrP6en&+{Iԟow25 ..%R?a|~DG3$% `NcRRɘ>?^{vk_kￓ'sH>qxzzǗW?\~<}.ۻz3bp=; .8Qs'KLLsalܔŦ-$ LdРV?'jjkq1HA^AyyMϏh=ܵ͘cK>Xg|)T~=$ ODx$(B!tH򥿽J߾yYKӺyFwGqؙ/QN-cRc-DFFfz**͝oG'M٨YWM'*2jPT\Ǜɓ+oSYUT'rn~VQSSJ`}ˮqb\geгg:+yy^S8>F ER{-H0̜1C~]&}i骯װ虅\w,RQQi>EIIkn嗟_>xxxXL54(o;}xWMk.[xkg_Ŧ-WjT  yf\ErݵW rYYꊛӧMu7/,2߳ Ydgo~9cÇf݆M~ry\w,Z3X@Cѫg}2kno/@-R>5s =uV;1M.F\\ <,sO2jT22mٛyq1tιRQYų^u-ygde۶<=.VNShF^ P$̟$׆#w<ۺ_*+ExDhg7C!B:lu`@qia!4ff4!d˶TW0*e8]w^=N9|5f!{zx.7f{q=M>14@HpM%u^>Ҳ?<_-hXvi֞v1lGN9r8~>>瘧G.o]75xh8xcOڿB!Bˮ!!!ՙ lq&16)cϑ;︕Ա|'|Z>gdLkfOpԬ\zDPk7鉲e@Cýqdƴ)>SеRTTZNG^kt:iwPYY_RR r2Ai(u927v4 ݓ}KJih'80иqBx+*4Ep/^L!0>>#0~GV)9ꊦ 8|HR6h ]Д P2ϲ<<;#_:ά`pПo:f Gk\e4Rx-kfc5.?|?  ߏCi7}g6;`]cPT$$Ca)BC 5s-'SzR Fa\E!B [ 4AFteYt/Y1}ٳ ص+ꈽ;v1_=WWS)"< DЂuʔq8ZmTWUs׼ߛWYY02Obvcz?,, R+LQ<1 699ݹpޘ8rPk¢" v*Ayl1.% 5E'su$64̙q9nٳŠ7^O?4 7/Z\RZ k%ML, Ym􋯱_r왳;*fYZ^=rבg)x=꫾l tugnnY[4qC7&rٳ%_'44]׎G|w4MYOTiTSd, j\ګJ=/8c̎cʠx`عVх =hhh}B!Bn>}Σ0n8_@^~1_@eeGk vb(H>oHGC#}fWVUq1 =zcOXscjoezO^ݓ|,לW͜o﹃yCT8?JI&9yz%8`>d TVU>ux\6scj$6a,.X߉NfH5f ކApm7[FT,[ ]zz6aϟcI4:;E=j]ve|X z99Q}}=ozreYas,ΝcOwv\QQN7Յ3WMא<}ڸAUUPXY\\xh}Lʜ9bk?]KbP.$$˫}7ilM3FKN qs;b7m6zTf۳ϩc9b9oϱҷm%c!}D|ժ՜;wuB!Bt&9!!h-.6{ q aOKӤ=aC P)kLUU5|97t/<$߮^ǩSgʐI 2ܼ|Vwva=wkw0-}>3e{NڄHÃ߱E#//߬_<==YÇ&MO]]-/jǾKVpm73#c*~a+V1bPf_3@t:7RS܍e˾_r#F abZ*7)gāaB8u |ӧ瞜ý [lAOq9Ϗ?_͑bc  e$&ػo?:7e8k~DMifN{\ 9@-SECà AZ{% @TTݺ4iR]Sñc'8dgtVnjƏcΟ\][w^m؟c߾8"~( MYWe=rs1~ܨ}i7~p2-0ƏcϱX<Ǭ$## -%B!h' g\LFgڞRLFvhڝ>  ;vWRZRʌӸkLS+̿?:'7pۤBʫoqm"ed2)##eN>;͍>΍}doΝ{l&RĽ(\w߯/;v6뗺sߧZ5.S4;v;LP7ի+o󁌞B! ybtnnDFEPQQي)-BTTNM[OL'ҭ[`08DEEأi<_(((tN#2"3guL[xHa)Οw ogԳ=Hߗ?IAav TUUwh?3g&0)+-3)/#g~<8tġgB=>h(*B!Wv$G&E<_hoh\TfKlsw\utי$9)B!ĕ$G!B!B!kP !B!B!:$(B!B!FB!B!BN# J!B!B!DB!B!HR!B!Bi$A)B!B!4B!B!BtIP !B!B!:$(B!B!FB!B!BN# J!B!B!DB!B!HR!B!Bi$A)B!B!4B!B!BtIP !B!B!:$(B!B!FB!B!BN!ۗ1eXIfMM*>F(iNxڠASCIIScreenshotn2%tEXtdate:create2023-02-03T11:20:30+00:00`%tEXtdate:modify2023-02-03T11:20:30+00:00G(tEXtdate:timestamp2023-02-03T11:20:36+00:00zS9tEXtexif:ExifOffset78{'tEXtexif:PixelXDimension730iotEXtexif:PixelYDimension166d#tEXtexif:UserCommentASCII...Screenshot+ȚI(tEXticc:copyrightCopyright Apple Inc., 2023 tEXticc:descriptionDisplaytEXtxmp:PixelXDimension730s"tEXtxmp:PixelYDimension166~ %tEXtxmp:UserCommentScreenshot|IENDB`ripe-atlas-tools-3.1.0/screenshots/ripe-atlas-probe-search.png000066400000000000000000003514051437041663000244050ustar00rootroot00000000000000PNG  IHDR(G iCCPiccHPSǿ{oz%"%&H'ZW! JbGX *"@WE\ kE"}Ae],Pyy;3g/'ss*$4X tq4ϋ gJ!!Awxr\,fBPNdQ>KD,ɒs3t) 9i9a1`&"2Ǔ&@ayf6? աxl-(KPvOO|eSQY If\KY&-ʔ[zljc)R04~jF sX$d39qS,yצ D/WōbaOK3{%J9)IFB\?'9"zEQs835([P8Nzp\-:#+0 >QA.dY@ r| ( $H ɠ:*ʠ : ]n@B_`tX6g, 8 ^ y&ue  d! HHUHRT"5H#҂Ez!3aK+ccVa0e#:L3.3bX,M.cKgW~pX\ n9WkFxY|.1E|@&l 8K(!%\ tD%хL7wQ2ɄF ֒JI5Ǥwd2YL%kȥ^g Ŝ¡̧(()((T1ՓG͢nVQPR?)  u  FlŅ9%()8JhF&&צ歭-߶n]{ {^499:9Jk v;uV3y9..Y.']ttMu=bl샳xnn=Lx=z 25΁6\ -II_Bq!lV 9Qi,)J1j~TUh螘Y1+cnjƊbqQqF1] L,]pc´).-:?̫$pv' 9WOvMX,HtK,N|䖴-i0#$yHޤKz8u,-:6~V"N7gd,hXH%=]X<, ʄ2d6dT^֛]iIԒSK^fl㲁ߜc7[vEJʊUЪUM V_ZԵZ_1O;oM^z ACF6~/,.,)Z/͏?mJԺq---][=)V.)6g[vw,qľdNNΞҠ҆]Z\YU^[kt[O{_/EWUUW>`X?U%蒯̾5~x,}lL“&Fu81@kCyAO@ "%Nn`|$ܧf߉9}p~qT =g  6o cHRMz&u0`:pQ<bKGD (2: pHYs%%IR$tIME - PzTXtRaw profile type iccXi*^r@83P"^D-69,[Q/RoUD%bҭtsreڠjY^U.?YEuc崾,J-k~\BsGǐqw|iuRVspGj?ue=]!jz_Ҋe ujѡM V|ajρBEwKKݡkw!վ;ek?d֦IZy=>q:()udݷ_QiD K~}QDƇ'j5byOl6hv󾴊ķ T( -ڀJv?3A~Ki)w_}H/_K3nI~L>Z?YONqi-%}Xk)"0A%Ⱦk|x)P츢wb_)IxwOUӯ 3hډJ[<ӌ栣g17fb:T:1;6h<3Agqp89#mNL;MhJT߶+Av >4<)/}%Ab: ^fƄ?H'Hs/ȽFD]I(:U#W:J֍&ڸfܹ\0!sARUH|-, (m#TЇooB4 jJiWa0Rt aR .Dc5XR_:޼v;C:@B\`g+3щuбe̪COz5|ImZk[皼k l 3itjq969gYVDz^Nt ЉP}ͫ 4%^r$ώq#'8SGXk,¾fk4AKNk_aMV ^IK;(wA+ Io!l$f$Q]1c[B8ULRbɝzivVZ1 u0= DPy(4}eIa"E[#5YɶٜXuX:r{TA%F^fQ;̼RT&0 }غǶ8Òh V$bO=v\UF#9pX=q:?s8qYpEBmƺKIDm rn}xͥKApkf&[)%MSZ)-U)^OͰ"c[ɭf}$S6XCw U2+xfyT`{"I'K;Eɖ N3 w:;\ &ɞbvdFLJ(S@(P=G1t|f;/| ~8#PОrYM=*"QGj(H qiG;gLBer8x`6'UdXN l :X`vB,$%!uhFj/8 :QfkP!.Z;;%GP2*^P b6G1HMhzZ4/ea4v 3`jYX5L-hc C 0-F(%\lVdL5SZZ($><{TJ]jJymO6Zj~u::'tGgCd槦lv{<Qcyd&4=Z F sd'I ✳.{lY[[j ٰ-Jd9bh[! (Qߨ,QD;QZ abCmd)s5dSt6^yc2 m3lHgoqa>۬-kron)nF!אg(v7JIKQc;yR[v!5$M0@3 =e&LWcFMF7pY,t;"oeUZawUv/4ZpH=iN^:U@4lwBҦt' 13{SQFI}"E(ڱ)Xtc c dȈz%T g|w`䩑1: N~/3UeXzQisr`Ø6 i q8*AT"%rSI^mE8ɎC  y6~0!PcHuL քNXYu d[,}[ZFH* oja)U 6+}{/: l >g9;;6Ǹ~go el ڔ->BxZ|ԅ.6l+6KGcu!վaMeou#|Lh{N.'v\PRpPw`kwmuy=ACi6j6a(ꄓDi8||&G .hrf??i_7?u}86?MEG\w>Η|} OGϯg_n>9zTz߳}y|9uۮ^FE75XzTXtRaw profile type xmp(S[r =C u=~W I%iE ?_xŲVZ5Bs\tQѮTw"aA!)KMv"+5Eb͕K" zߓ!D.6j"j¨«#7'ۊmxzj*Xh+\hPx7p0Xs(XXCSv;ӊ́іabKAPRIǽ9Oqt6l=1W5j[;ixwԄdfpLGrgd,ᙍy7qY{l'GL\caNveIDATxu\]wwwc $$Xmᶥ_K{[Z[7- Tpwqd}]aH~>ʜ;?DDDDDDDDDD,.QRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDD٬\8k29I.F6/wiZZۙx4y}ߍ/d\ o i P%Dto6x78ZV5}Ye5յuw').IOFJ3?kſ~EJB,&fw`LkXy{$FQYSOGg=QJWStf^x-='_}];M!"""""""""8K _?445{ZoҊ!h^ʑ9̟>wm=}M!"""""""""^&?CK+,$NZONa!T{#BijiH|Rshe$/ia—~GVo9h_0 rU|SKzݣso-W/֫/">& C%O;kw\sv.HG_0 &^zGTrΛZ@Ӂi-b=g{X bع0=nn%@i8ydۇp8ߺfZgQ8-}%|kwO,VEsýw#p:\4{ cs /? a,_IchkkH~t:xwAd%`D&cβ/W~%/NJ ۇ7"""""""""i P }eye Pk?Ļ޿J}- ?^?~}[uA{;0>Ss<{7V+,VKYe5-+"<4=xkёa$DZ,>0|b=( n {%~x?y꺆`0$ݩ~(a >͍/bXo N46>f~ȳ>2pڙ5y n:e5-V[~͆a46{/jꩪ﷼].|8p^#""""""""rSMj)&abi`.{S 4rڍiq#2Hǵa;+L\&<[''S_LW_ϭ,7]AJB O>k5#K7t|✦^eZ_CPq[hnmc=?>zR2dݬۺ]eye ][TyEa@UmmWſ^xF^\v;ZDDDDDDDD1B'|l>y#HIe}ΞfwwAN[ lŠș P#82Y!vV}P5'c#"9 ~>F̛J\~۟ڣe}]<(VInj uB1 UlWIE;d@άdLM;jG7(爹EďӤh^xH$"%0hkn>қ&`$S )ٺGhk6S.&4!۲ζYJ便3ΝJkC3%wR[r( F=EDDDDDDD>3~=I 8k}f 9s#]bGstNv^oe =str:kHN`_w0kLKћ]-oxRe9aRce;ChB #/M{K &v ]}ҴS[RNxr14Wiԏʋ;l~5* MdNvzo˟?pľkOH Zܽ޳bRə3cl~U\]٣VmdҲdMH鶽^^ `@XB Շ [;Ȼ`aZߵ=1YdϙL#l~\˖=c"e}ODDDDDDDT}6!,#(U챬tRƏK[(ٺJjH/)+&wz=el8^f#<)v=N,6+QIly ܷ3 :[=[=32> ڨde%>?pwi_<.e}/eQ9twppզ>ךj.>S'v7x՛m$YO49b#]4WQ}ﰵK=WG'Vo߁`zC``͕}NMX~'"""""""reXb e;tJSumoD5K(aHg3CGGkibZ}̡'{_iW~/U(<9gp0{ `}T qy FKMm^H)1}/8:BCyY;<-DC{c u*0M ܇maoaߞ<-33/{ 44!V+'"""""""r*%a q&}f%x4io$Yygo{Jr4.WC3e٭ ۫#LjH!$6 ޏq#2`XMS?[|L"COJiBt&!`51 0MzmX1^NSHLLZZ|r|@X@ژxbLts0 I '"""""""2Tg J݆iC:Qc``v2rr G!{^w@k𲿹 := xKَ`ĝ;./jﾉ6 04+갃ab.u6M \me܍3/Waa,ruQ}( efs]׳Gb^qav{ƿ 1\?9;3(+ ' `C js3ˤ&0"#lt }ԗUF@XMֺ0 A^;0U}^o0|z::`ÿ_Z LAg`t/6NJWOg{;]lODDDDDDDNg L3lNq.\_a`z '4^m4ˉmT!$:r3K}{á0>Ӥssu-&&Q^bt3gHa!\W0HtOsua}૷`xCY~""""""""PV?LG{')񚫳waYH85{`Ilba͘D&y=&'~g+:4n7փa21O0 iqy5RWr|7@tvt$wl.,6]LcE !Aďs-2-.o>=v L:vLf1ao˶fWZLQz^\A| DDDDDDDDDNx QtP^EҨ$' ,Pr3ɞ5hk x9ĎH'0"Atf #$0,m/Eݱrۈ"$&F`xS ȜZ@CE5ΰ`ʶ便O# ȆtNXB e;\y2OIr&$.ADr+q:IC܈LA$b䅳I-Itux?0 F/aaZH2[mq7"Պ38)Ȟ1ֺAn~A$A w>_rHJȩ:-4VVctF\NXmVHɖ]{'vwPs?qQdETzuX=c΋ƊjAD'L\n&[}&r2(J3pn 4>|(]]]T.!<9dbӈNfS_^cƴB2 9D&JGs+4.!ёDă^[A{sˀNj@lv#2HNj &nDqyDg$\Uǁ)zCIC\~!lZL:p0 #qbs3LNݯۖ'OGk+{^MGK۰~ 뗗3$/-ʶT8 APd G?"ZW} %?axO=w,BbhojyPi,6+ё>4'a6xO7gH0!768p2h(d?XvAKmà] lN;uN@`xMUCUF[CӐN-?U@NM\Pj4kRDDDDDDDN.@)'otR'fRe?N'3$&C'3OywSeoO97)@)}d=g2d˳o &i\A!`m&&IMUu PH/->bOC4W*#( 9zStuԞ""""""""s"""""""""7 P(@)"""""""""~"""""""""76@D rbAj8""""""""rʘTR GQuIɶ};SEE0rL"Ӓ0F(EDDDDDDD|2$.tX &&;]OJB2H0 MDDDDDDDD>g,6Sa8S'/=r,fR}zIDDDDDDDD)"kҰڭ`BK}#)^ 1 :A֬ Mݴ#x'#*={ tvQ}ok :`dϜDFxLLߘȆ@sM}kɶަhv>4,v&uԖsKt02jNrk6Sue8AQLn V{itALN: ӿpuztSY|0 %")+vI}Y, IT;HKm='QIDg$l)~>i:کLM&<)j*ݳ 9  xNv: :32(*Znt*k;EADJ+.'11>4қ*kh<1PjcL={Ck5}9qyZdL-$<19aǀ)?q\@\~&iƲU>˜V@DRwsdA4}EɆדbtrhAK;qј%Ĝ1osa]ڛ[h(f,-(vtN Bb"sH{,c9a)iXWՔv/>Lӽi""""""""3~=I< t^j3/)+m8C8:였i\C#Sfo{>e,3'B}CjCpd\CnSTxeݱr6eF]8qy$ͣ8y54A/+XLMJH#1 kKOp0!B}]f;z$#y\>M-DZMkcNv4H""""""""r:U#"%,3I8Q|~'p\@0 F_<,jc+in|p62co{U8{pK|^q=R0/{r'rDDDDDDDDgEG2jU$cY\8]Ÿ1_ 1$gTU>铀ib aJG丷jhgOipi osH7iwb{L q1@]Y\*n6{6K6,0Amj,3F2q 采-3JzrvPT8]~[l3S̫ LDk)#62 3Uֆf0 259gk xv (*5>c/9«3K||Tx%ΐ ]zV]/8b0,eLTF .OՁ#XlV3Rzʫz[sֆB^ZiWʚz\.שU:,7.>Z(aCǘ46KΛFcϿ"qKWw81[4,'^}cE%īr3(VT}Lz”ʅwvs O,s xM-82.owHsҙ?}"htN:(d-_~'Z="""""_ڃ#p:섅yt& 0KtDN) 804M=yzʫj>G9,sc>ʩ=)M(3No휝A``a`;M;"#ύL? 8ZZoy]9|?&mW/fQmmٺ;6?+ocp >ރ<;wE~+3zD6`ǾCR/.Oʃz0xO?to깗MW,׆  ufN,.p8JoΝep-p|FdbZٵ_0å%x_/x#N-ZZz]}0 ԫ=yQ9|櫘=e,N-_^|C 3yrp.v7<ͫϯ}'qݗ>׾s2͙?H7"#E~+0zD{i<㯀i{nۯ{Y}Mr~X<Lu[wq@nF ?M0 ћfKKo?qO+ƅ|?$?+'W]w߃iBhp _JzBY2CsiƄф :Yy7=adv+`p-Wq`&{;g\>yױxT=v˹`jNce>EDDDDD-l䱹d&pMe2RxkFVoEVj߾cv{ ͣY9x ff1Lcߠ#]vj"#0ɓC $'-&2il.s>::: gdv?-Wk3SۮᆯtX|~x\s\)G22'd)*>-GWnб2CQ8YoG0Srܳ! S˾C%Ă2&˾LGg~ '?;Y-≗WW0h<ۮꇵ[k, ^|gM$@Nz2 O[_d$/IdhoĶ= gkœ'asIڼ_)CYz4p߃п=`LT8l!$z Ψh"<{h種7Wm0aLnG8 ?cuC8v.;yYBtDo̤qo_2>ܬ^ZVAyރ<{=8$Ϙy|54檍aOQvwluk~'~.\^8ٓ07e_~kl՛IA~6 w~ёa$xBI<;k1BIKbe_s9,}62 -HI=OW{~b0GIcXx7O7x_2p4A45K?lؾ rS1 ^#mvj"%UXV~?7r^Q1*9Λ+7k!<45BB3fr }=n Κc/7G=K迒*˿eK)oO>`< ycGd06/z+Uu\u(aX9\r ;Q8*1lsE'ϼjl"=Xk>wKQ9j>~?q=.X[,.5^ɳ~v;Zz><iF1{m~<ܛ`gơ{~G?ls F [=~}axnQ- ΙLMmoZAR|4 hVlߟ~@nBusLwV{,OtݒrߞshYyi9N\r0`={鿽q:lj;&eoxo4M͞6Yihjv20݆^3uR|n@1`6& sPDDDDD Pv31 0'=fe46{!(IfJ c&_J~ۘZ0emd]C3.nϿ.70V4>p{kxKΛJlDO.',; <= Agξz\|+nc:10ɒy}EV{Cjb,,ͤWɗ#ߙ|ycϜȅ&[9gϿziBHIHi]5[{gy 昸700!z}0MB7icϿMYeu˟ҏ뇿x oe\4opT1:;{^yo.K7]Ͼv+S F y?AwlzN\ [2(9p~/kP+syt(G"""""r8gxtS^f xӢ{7aseY<2 0L=\WoEs9T5ܛ+ys𨯆82}tvua7WS;k7s}.S{f77]&x)aqe X|2SOhq>pW_Es7W o/칳g]:Bc5ky{f.ѷ.[ŀ'_\]Єi8t_Y_| M`BPT0 *^ 51㚁G;@yy:;xzmCcb%'?jOWm cLY1g`^nEsT웫3Z0~HI3̞- ?w~6Y4kurP""""""g?Ma8I? ::]$bow\FIy57|)m~fpn+Ӯ++tuuq yrق>ә ap*Q~=`,7 ph-e}0*18\FFJ0yS n2oj& Roao*nϘ^r;o΀]ŕ_}:;]tŅl 컕g<OԞ~p)eﯨ>X{+dl^ְ1(ЉeH0,&]ޟ[z ϶6wFwB/͓)̠4 Ki}y捕`,,fOLnԫttЏ|>= ܟ=JnY .E~gQb[ }tW~듯M/?>s'0X| .7p\^Q|SYʩkɽt{ɺ7Pt_Zﻚ'sr\ܽDkgOf%a`*W_o?Ȱ`BCOwâ@ _)oz`Y={, 8Lj&ǎWzZR,U5u -{`.cHiizlT8s!7&ݟ^1\>] gԇCh+ﮣPNZR/k͉+l6 ?CF'yE?R IǟgC6Y=k+7~6 YG"""""rNP9GY^r6|F夃 wz©i./Gq:1*>s%%1\< Oz~^.qٝ;ǥwKCS \v|?-;|>.bc8Ҿ{3XoYsB?L4MŇK '=ڌ 1M`a+0]3'tew@xh9x\3]8A%uvI[t4~g"\&&5!fZܬRh{y3oڍ+!`\~f?u6Q9.0`e`2Met8< ]vt0ngZșGna0PsWְ(qQ\|^DyEúaye E#eK$0,sƓdDF%͎9=ǔ.9:Κm9RZUlܱ ;tزxXV^Y {Ӏ@k!'=N xbi8  sѬɬ߶g?OӅ]uʜ11Yi簕UiimK3&7ў'cw"+uϥ7WoH۳}^`.>c>H= S/ș]Sg߫ g2;ȱc!^}}t?C}6F'1fMÅP|4+rzNWoyU:Y4#9^UG^z ~۞t1wtyeZ6*‘̛Zf7WR5_Aexyϙ—nX`;1\|⣣_sXG~m89V^y `z!b|=ﾃfWF*fM7ۂngΔ'پ`ϝ2b#1 떜GmC#[vg]뛫6/ >*?fgyýwtxyz6OuM=rϻ³o (aq.XN=4y͕yRZ;NgSs~;,7 i=\t[O?|^;[EX<70U]W~^4MWw!+.NdV4yq;? hd L.+^kp~˲i\{<^u<\^Yâ۾/u?+̦b<|׼{sG/૟0S|c2S)㳏 At 745s~}s,=Es&iPVUKVJGyE\}ќۚ|Kb/*@k f}cŀi.|O1h<WӨ{fnƢ9ShN&gs~Yzt7. >fNt~͙Es`^ٳob¨\z>peG^f*F1>.߼:gi F?l9!4MFDӚa$Eރt pR[Oh#8\rz7kX!*åge?Oum%ǫ>k%5!wkJp X7*Q4fRbm(@)q~۵XW;xG@{imkwJ~gԢ~ΛZ@^{=wqDDDDDDBDDDDDDDDD(@)"""""""""~"""""""""7 P(@)"""""""""~"""""""""7 P(@)"""""""""~"""""""""7O+.at0toR|#ݕ NNoH7zvf/r W\8B`5=pYНߕ`b_Lrł- WNoߓt={r^ۿ~K|ӳ{ gzm }^ۿ'=/v9{O }[כN=@}ABWxOSKkzә=/zgF>[~`w_!'6}_`r?}^`o[;"4h]=HXpW{zmm!B{m-3$k{^{"4ߓ{zm;'ڷ=Nf_yOϟ] ]}ϟɟ`~ۈ %7]pҨ}k7_e{?&+ysJ3G~}}g1}+tbaMίnMeC{~O|~^p\ڿ'r{vf0Nj~Sϟ?==zODDDDl4$p{ӽ{C|VKNtiIL+NÉ ܻU@`k|.7?WX=z)gOwM/սՔ+ #{ԳՉlQ^ۿ'{՞ G{m}`g=n^ۿ'@g~ڿ'%#O^yO^Oz>LOQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ(EDDDDDDDDoQRDDDDDDDDDFJ <iL8T ؾ.''\2ӱZ[m;8xy$3qB#rc\Ni ƍ!77TWTP+V4M7 ?App 023< +/Ქ1MںzNw|/p:(9ZJ`PQlݺtttxl|3qx[$>.-M*"""""""" Je?~  Z[[1 Ln\}%gu}M:˖.fæ-<R]]`B>{[(/?yFGG{i½}\~nqo0a<>"O<. M7.cY\{<IEDDDDDDDdڃRz555/ퟴ`&G`t+W?)﩮ְnF/5ٳ;yg{NӧM!((O sQ䳸\.Y&(@)}t󱺺 Аw(<01nuz_ s>v;ӦM&/70صs^]]]`NQ#ݜ""""""""2(ePFdǎCJ;@bccŋrh /&i}'ăa5jLLbbbl""""""""2(_NӦSWw~^~!1"Ly\ 0 z_ a< ւi'ݡCG0y675|f \<ϋ/Dm_b3{:UUbpLI ŋRRRƦM[HIIW\t~? b7pViM:=y?nS'][[\{o_zƎ̙hin&8$ʪakﺝLn'';=|axk?>a| wogDvo=W?oߓqmϞ~={#;;k~Oϟ@o OK }z`}򫭧W[[GeEe%?(N-:**3f;|[q 榛>}Wk?~ +Wz]lذ 0 w_x;ojx0mdbb5@YW[*^gm=Ay>'qVOEeUrʯO^7_]]=UU^ۿs[=?/^:*?飜^ۿ'w/ߓqOzDDDDDbFHF$$qǝ_y@ qb-◿z7@dd8p?~u'z|W{Ajj2]]];Va~jw:7CȠUTVbRS|gi|3ײk^~|'$1)ŋPq7^OH4 }4M>ʱcL-V*8)"""""""rPR-...^Ϙ1v۷bÆ8,h>O?{_n'fʁL6[>{m ]Ap1{.q ])""""""""9$G//w&g1Z0 \ϘBEe%oF[oEsS37i=ս?=fUnٲu70e>|F putgys37o6SN"@M)""""""""CrTnSdfekh`yq"p-~xz)ahm೷~Vn4SN&0 r?پcrl6|Wm66mʊkXF݄""""""""2 PWV9~cbDm] 8p&7"(EDDDDDDDDotH"""""""""7 P(@)"""""""""~"""""""""7 P(@)"""""""""~""`cksIHwQDd\1ıiDLJTFZ68HSC۠ҏ+J#>5]K8i$GTs`WŀKɊ"#7H,V GWG9k3.9drimJ9Lgg gLi9ħSSı9inaMAlkh Vp|u4շRv딬h2rcHJj;+L"=;taNscu(r%EP0=P +T5R~-l$Mϭ'?䜂7LdL0MJDp::3mLB(K>38 7}GbwX9LT$<*ӄwz3 81^@C]+NgW')ažf%glwN 3XzDλt4UٶHtc2gQ>7?7P_ӂa%0Nx#T{IJf`6G?-ż#Ӆ<鮾}*,q'o?jpB&dcy nS6yn6fgG9\v m ?tdǸ/ۦ'39ًٽ?XrDerwtp{#ս7w(.^V3[,xŃa,kq;TО Z;qؘ03SR,mwQ( i,Hx{``bBDDDDDNrA7>0YꪛpLl)ens(ͫabY{?NLW6I鶮9_~~%5-twuavn<ܱ ^,ag'NaaܔT}Hzzf.;HG7F Bݤ,w|"aakxqϼq q]Ɓ] nV}VΡ Tٱۇ>> $̉:g~fN5>x*ܚ """"IsΠ 0,2+h-٣ vx\{^%yφd/_{4 ^JP$eDz^8#LK~Nfqhw1ʺw{`ppwծ.60aF&l]{3QXL,?ZK֨X3$"lDzud#KC{|Fw% 330&*rc3%'ߙ&6)Amu3<LCXd.,v}QWK|0 p&vMۏ3s1&h\GYNvn[~):/H,VudEDZ)a7OKGrx@>uTf,.$<^?UZF|J8;@ ,{+yߛٻp_1gYg^«/`ٸz&w|2v;ٸ NKni}-eRBeY#Kس=[Jٽ5«v{m\}4f(ic-eVw1R;kƌ|t ʍ+2~Z00־6.q!ah^yp5͍m`TP-&ޗp6c!nSq!Hg N\z$x禕(%O$61u.a!NAӤoM\Csgn?,^V@T\ｼןpWtzODοl  nw_g1KFi!Z]E9I|J8V9̋/Lb{x^^n1l^}Ɠ4X }D ֽS]Hf~,[2{_M']tc1~~<.>>|WjZȮfU7?ZOJf[alܱ \pn/y2oH6{) {fcwش}'9;?~ fwo)op@./fۃ™U7{~1hi։iBhyJlv+㧦ɻ/s;5 l omB[Kﾰ JLWQpޡ}i't>OV5CmVHgb`&O?7-+JbYHɊSbjzMWt~{|>s|/sCضr.;78+:?0xK9 QNةtttK'?Vq}_ %@^Aq)al[uc+W|v2!8`gXBGksM axY6ןFg=Ê tvg8r^˟1=mvBks3%ܱ \txnZ:1PWaJ| CvrWf cj`=Rfm8..xl1{uG{69YWWwL{lezMDp6401MpZ-DD{n͐{F2{ $(A[KO9jD-ϭc\䜜A6"2ioc͛w£;\xոAE2Y~ԓ=* FwK)/=z\BL>e1u{_}~y?JFn .IUYg1LEN^v+ nl]ύ؝V0a_}`?O@cݙnb`6[m.jMNwAk!s0 pG'[\^Ɠa9㲏 9Fgʞh . 0L\ 0ruq^'q8gk̾4M.;)9ܷv3|CO㈈'9925۽'׮MǼ(Q|fIX,WsNuE#qIa$S΢k 9<߶kjhf,̣Ͼf=K[|4H]fg$)QM%>1|z}gjV4ikc?>3(`Z:}jzX`H-g# }|!:> *xyOIpʞrv1U`@pC΍ok3990NￒL A]MsR3({DDžr^ge7Obr{u{?Wɮ-8V]0w^k~A"&s;;%KnDGGo?u]]3MŠi3|&z4.i2v\Lvo*`cB߃A'a4 @bJ8gPðxt&#,0Kzn Ǐs`Ka6f-[puxP_2P֟Xwt)\Ln{"w`¨ ǵ^/ٽG+b~RŐ#;pf.enmzB39ϵXFON9k˚C`eZ~l]=+B{{S/eSNsEgG=fa9}`¬LںӽGL'+{cͲvCeC7IL޳:@AG0PΆ#$39șI߅uw Ɍj@ڈh.ŤG7zʬO8jNxB#,;>S&1cA.fgLhxəQL?y<ƾʌXs:ir`59cYDIWrɚ&SI͈&&!¨ \tm먩D8%+yKGs͓16C5qpw# Wb!$,E:^|tm-}uu?1;AHӝn;upҸ̋;gZF' oI$1rKΌ"&!33U$ BHxr%h"$U[C8?5I86C;9KnĤYl\qpЁ`x4S~DFNHftHH^=q }(;ZةiO$2&gQ,"cBxOk8#iDbٚ7>(9qut"Y>I$gDeti':>SҸ䆉Lu|67SzqELADt01,L0o(j|~5Զ2nZ:)ħFd'-;cC5875(1SR䆉L9: 2/Hjyt5:ټ9'Xkya_1=Mc<QlOO5qʏ#kdc16<*نRrR0=s21c>XbP0-{_mɳ_4Mj.^6S3% ,k~@.F_neR6>̮%/j0hmaӪC>PW X,VV6:5]hD &,ֻ{|[00ioR;%^xdŻUz(;R3c̹x$ <$>Oʹ6w0b\" GLCu6Ã7Џf,Lb, \Iey#<IPƒ?x?;S(Nhq￲x<|}{x_hin'o|"ejx >meLŘ)L6xzޒGnɌa@}M 񡔞t +D[s;YpX (gّZ~x=Sa[ykI«w|| j'Blr8u4ԞKjFG{6b1M 799vAa4ֵ i|~㺷Z[Hxv*Ot'AT5 |86"bZ *Jxn%61&Z;X Sig@Xd QA4ֵRW=O"""""""""7!9"""""""""ɠ"""""""""7 P(@)"""""""""~"""""""""7 P(@)"""""""""~)XpXn\R]WmlQX‘UJ_D~a4ַrpOVt6E9vU6i$AjwU ؞)YQdƒj*(py%1 h[8kb1OZN )T4q` [W4M7C&84wq4IL`z!X,PYHZI>BBd9k1 ,bi0fY16WIEi=iь2Y~ӏ94ԶJyf\ I3g] λt4s.iBc]+It_ֱeaff`wX('>5 333%@fۧWD[KuUMdQt~㦤CkhmwYCVv7Nd\QfIsS٣9Fğa#&0yNVbT JDDDDPVf/cEc% *&2blWG7։i#mD wNf6cX^1w mdF7mݑ>LNeT@}M v,D.e2U9v3ȧix辷8Z~ϼdg#wL%o|"ﾰݎebZXB&dcyݤr3114SdIXJs;8N6&dT*K]3JBjyI>bB"""""@g%8Z\~WD fpd_%mmuo[0$Gc1j[ â~/iMH-o= Ww_uuxiil`F:!anR9>c`sVWAcl_Ϟ-mz}/-Z3zj_vsC $,e0ߺi>ª ;vܚ&""""""8g ^l^^B?>iPQ阆7 =kZ0\zJXdDy^8#0, u2i^6Uɩ[^{=-'bJNbcLIF^lOM edƂU,~'KL?@\.ʲ~nwÀ s~!wڙzA9I͎29^RvseW2p)ΔsHJb#㽕s#yy36)T6`9x|L%Ip/̏ؤ0\ƀ@ Ј@FOHH&3/,p`WŐ\ih'"&fj*z_0cu|mBbZdt!`>u-D pڸ ȍeR^VwqBQYqUik`X6+W>jCjv4ᑁxI\vdοdis;Y@s3zM@BJKȢOJ^fl9NBJ8;]rKEpho%/g3+,̋Xx8[;x]xuvkn/w|FŅpWf7.}YN6<3%7Ndܴ>om`2l)ӴP~=[K_/`Mjmm.VS}qǞ-߭,gU51uP\?ćR_Ղa1䆉HXD U \ƫBWلfagE&ᴑWȂqxo^;Y`hHxa6A!N 6Kb&^lmn B|\ ὗv[{__ng6vKis&rcػwf/▯eޒl^yc{I|r8g3/gTa{ww]2ͫ BjN4 YN1wB2cqzIg1IˉF]uKtyMƲ{9nn<-u|;3 VsCI5BDvn;K(Ԭ(=š޻9wl/þezMxY!Q!.+spy9'Ev ZbԄ$w歽:(:?nu0¤ٴ4we͇ˇ3GƑ=:6Vj)%\ydV]'jL *r 4}8r\ԳgK)&K` .${쵖%01hLVɻ/=}ێL[t~/=϶ m-ٔ6™xAScNes;l?Q[;lL4Zu}op[Vj5O78ٓp-Vk:4yM6 gfz=)P;'8ٓ (O]b]t^^z|srv]Vf2nj}qgk ^"""""IrM#ώ` 9#JW^+5wNcTa# vWc&`{{p1gݘ3ζ "kd,s$)='O}1 bZx^=2tv>(yٽPMӽ\f;L:ym,b,7m.+^M[K'٣?-U5#5wL#53ϩ1&&ܧ>::QP }5txysvbzMumT7z\+9TaBLB(^8V L:pˊk[<]%y\3Lf㬹0ڼ6h2=[Hک*

sy)B!nF\ґ akИ6e? hr1Oovxr  ]n=~[@iVWou.ɨۛITӰy_Bsm0x7ۗ(Zf~'6nqPDrmIDATxt:4(㿃ؤ`4叚,cz188v]> v)P !Bqs &Бa;nG b7gO !61nB#F3g`TDaT5vM횣{*(ZBH|^!=(Z /iOy|_o~ץsG'Y@yNy;ʈ dtTR߅ld˗ @k^I[bHq=f4P>> xlbA+F횊fl}ymݯ]<ݮd L1ɀ֠ShzTSQ:PNӭgj|t鸑nͮ;ghsl6|:UB!q%(cyIޣ5t~0_ksN…EhkƦS|+Ƿg*:Z $*>rSv&r9a|Lo ##FlS-N,FXQ|X{A:{If^ Hg؍^n{0C#<éGKEyMJfFfihEn[ϫq5$d[8wQUwe%(ԗpt-0CC#GFkyR4]tu=5?F)7i 5$eD̸6Tw[OʼH.nq:>ߵ ܖ̙@AM{!B!;N5{˱˪fL׍FhZ݃\l+m\l (G\lcEsY#-(hTNڛ(GNJנl~hJ'omxԭB!sڜAOdtƩNqU]AѺ4|͜?Yh yqj)O4NgM]BZȉQJFnQ`w=T\78杗OyLgOԓ]˽_/zB#o`tλx¢,(eמ=vW!n<[϶,"<ڟ.RG2 ֦}|e)\UvONq^^&~?=8C{K/_.` .kGd\ aX|0Y|鉸O=OXlOpbɚ|xhov'֨tsq׎O.DѺ4)9P'`s韭C<2Sr+6}H '.57;ʩn[YLWGّ|KtHH>~, 5w ֥UvmeaQ"/_϶,&,:ziّ+?'B!BȜOP|S& ;``l"HɊ@)?^3X,\Xûp3,sىO/S_[ՎoO 'nu A);h$8ɱAsh1zZk~!SONcK[S;_8A9k]Mϫ0 \8HΝzqBLGcm'o(Y9 Rt G gc}a2sL 5|$'orK>b͖+c*? ִ5t2t=4УP{O=WܟL)N`HS}}Cd,s?ECCM^<~~%kRXPOvz39z9,b bJOhKr}dFr}(Xcc gܖ>FTVo ڳGI[!B!P֬[`gc&$܏!l^8 gxh1I͎ޡit!>k7>fZo`wx_A6v"7?0?FEKC7#S/aa2 پIZ-͸ zltwlS C} އOW>}+B!HR!B!B1kd!B!B!Ĝ& J!B!B!ĬB!B!bHR!B!B1k$A)B!B!5B!B!BIP !B!B!f$(B!B!FB!B!BY# J!ݗ׾.b6ޗN[!B!n6.ZnQQ񁔟Rۤ5iQ$@GK/u)=\֓'>5e=DCm'W=8UE'CT| E}U皩>RBI#6)@meghdŐFwg?58}A riZT (gEBZ(~ހm#L[Hh?M=4]Qzz'qsx_ܷB!BLneX?[\@rfuO4 &cY7ϰo98`ݶlVmBme$+/毎RzyS"x-&ZmDhe2 O02<(&3/l$gEP>ܢ~?I 'qt~5f]DNQ"(}N ͪ;3yGF\ %kR9uuS +B!ildLV>4Mu6"{bưw9v,vh4pC,Z{s %kR(XDEYo8|Q<2F!wv|&Qw_+ep` 69^/˙Nq Y}|Εֳtucև%5Pw圁!lr9hͳ?+ݚ͚-|1f1 cٷo_mhOG4)rEPw=;ʩ^& V&`I ݳ]9%:!h.mB(aB!5(~wͧ㇔LFn4W:3펀Q;;_ytBig?ȳ?I ~͚-F,^3Fn*xa0LFЀM'*}| B!MhΏT5Qr18sXm0 EV&GG;UOd9}yJ7teyZSY_[V¥&=^< eikӨJBZ9K9rxBZ|;YObck{>I(hcr-.ۘ EjZvg](7e+cx} M A4wwG9'OkDeK#&>e0TgX"b?$oi"ӈBMW<Ǎ[v[6⍶CkC7wL?Xm>iّLFFF6vsK_4 2.O.Gi@io[;2A;VH9]ﶜ n.]>i9c`ə>,hc!B!eΏlHN:hG`+}=GAC`˱Mh`^A˱̅ riO.)34\>28_ Yy-o3~tv;M48P H+<_g\AnOxx𯗑4lz`!ً@y]yG&>u_d6NjYyGl_ .%`jl4w(V)KX-=;82>|[KY)mߛȸ~xw|)ڋR.m$2. .pCd|[.Jx@6ޛ㱬+r] Fx|#yAHGvY c(karN̶GpiX 544۸Pӎ:Yܵ=+{^?=/߮#4#',L/=bdw5[s@5ݶپDqȸ@.w8vYdp|evp|b.ֱn[6%jqiw E|Z(??b؞J?NJf8^ަi׆)4 i~0ȱ=|n'C\zNYųWs|a> ||ͼ8f4X͹F&^yg)!>RˑSgFN4Y3kXe%\ʹy{>V>u{߮W!B!njs~;Sު@jźȚq\ngm|?f2D>Bil_d?{n}_vGmOB_Q(pZm ZP(kWu`ʋq~A2gfS3l$8Q{}KCg?Jfώ2':[{9i&5)n""cIp,YQ_Ӊl$nHxG'q5q1`N9ρa:b`EK\X"9Z딜?g:N r}>2'0<4m}rB! rS/?48‡oa9|3?LZv &07U6>3/ȸ`g&yl ?{3ǮMrVk'&1מ=ȔJ)6?n&c!zQ.ן=4fs}hp,[́?^`H&17>ğYLlr@iZvR7~ug35v}$߄$mX}uZAHu/Qa6A)ge -YGK}faתʊ3'Fh:Ӏbp p|iHwq}Chq1IAtwUQnBҜ0詿ELNBh EgاG!Bgr%(5zZ{H4F!WK-'(ܗvݏ,f$yC:;j)7ez|??}=z$bѪ|9/}k)OFqJJߨkcYio|cdm7:wa6(\(4=݃)r~O6Pc ѨۛIDlya_fFx;WE P&kތz@k|3,".}9>%g3:'Pn_\+0/y;9ݮlm.ӛ⋯7r*&>^WCB!6C;h B!B|~n%q՞ػȸ FGwa"yFBzV&=.M>2<ޝbn _gdv=M%-;_פ֥tC:KxcD^>|֥sG&}|-#<}}b*ʚkMHF :Z{QJ~.k7 y5N+Ͽ<Ը:#<3՝DK w8w\5K@LU-= 3<8?zn4 kV"B!BtnMr>cGNarJ]sd=/ 6dgGTƬ1he뙎x=Qv}vZ1BxԍVQQi! x}C\<݀˙v\gkvB#;~cNcWG419՝θWuФ̋ktuazh 56A3ښz@k=߷ޯg!B![.Ai]xyXyg~a[9vfX|\@ߞ֚ ] 7$,ʟ/&8XnQa^nwu{\$Z!Kx޺'WwWGO&eFs]uU GercE w~BDwMWlXY$Xrf8K=~Ԕwmht5 DIJ #CoHgj]-^&l(Qtm1V W%348…NlC)<S#(]9]}Yr4g?ϗ4088B4]ǧi|\{sJAZvڡp5wm/p_XrvwTo/};B!bElgYeGIB}1Diuq!;/|u19Qt?-n5<4 b-`4` "!-[xU M6vCorY,-)Mlb0K7fZ{ӇqNP&eWZ];FؤDCf^ edGK/q%h`^~wB q)!:m_YBƂh'o?!fE+Sʋd2` f ݝMgK//JG;b bx 0])_5D| tFV^ bYX@dlQAKrX ZSY~u+&0P?|̤fGxGr DX9q cN Z]&Ǒݗ\>3LN|򊓘WDh~d1פpS3DCM'yEH&(ԗ0?ǰ2^o]HT|qAxZHH a]imvِ? ˿K,Y.嬭h'y2Yy&^,-wgڋV!B1{!~,ߔyh@CRVIYᠡdT;M*LfO7Rrs'\olu ߳Nݶ~Nr$'&|:e`>y˒X*tR~]=v]ǀ PJ4ѱٱxK֚=}*`Aa9K@[c;_vl2t!|m K[֚+m|yʎ_q{.DǝIvљl^)aoh6ޗRck:33aI!gIz g^x΁a~|+(EH,+"=7`Oc,m¢;B!jʚUSjv$UPd <6 ݝ֔bA6`PcV&-;~B̄5o37;ՋP_Z\U|,^&0- ݌ O=d6OGk/}7"2.Km[mr~V!BNP !B!B!f׭IB!B!bΐB!B!bHR!B!B1k$A)B!B!5B!B!BIP !B!B!f$(B!B!FB!B!BY# J!B!B!ĬB܀տ[CT|lE1Mk]-B!7lO!.%0b1 VQQDCMFnQedM?4(+R(4C~M/KVuSܵbʏ!(ԏޮ.pj5ãc"bʋ!!-~/qf$e f8$:!Fn(=X}K[ߛtoB!Rn[6Cmy1ټQJN3¢3"@ilJP%e94[ۖ 頡 ? ch>z}]│uwgz|cmb~~ l1Jx2U#M!nN舦0r vͱ}%ϋࡿ^bFT\V%[KOo[h% [lG[︟Fg4Ux#3B/]zNKVp`5ef7ϗWB!BtrxVmDžvp~#cE"ښ{zf#bheFxLf6js+nD)Es]7ӈ L&#i 8I%4#(!b6|!uN.(L`y;;X!\rh?+Zu>k箇y\1y8ݮ1 P>V&vxbVs+i`χqז*G.C]ݗO܇>WfEdDq`5;_</aT5 e?}̕JGfIqQJIΊoQ}MH&0ֆ.D.5nAܷB!BlKOpLa-=\C+6vzK?`5j+>\-hgn!x$#h W*y畓h +?%=~v(?QR˒0[ى$˄BS)Lfn4MWl|vGÍIz{[5{VsSY~e?1RFՙH^q5mc :hpg'z1|vDre@)MnaKU&Z4޾fl_idËS.6L|&pË746a4دYňk!HyS)5 azg ?>S9o52R!BɜA P}Nԑ,`?yM%3FO+ɻ8Lɡhuu<я|=Cى:znIrŒ5T]l#11ʉ ia(_jrtL"9+G&^O^!oyzHO@r<|,< <&#[Ҹi4/z0pPޝe)ɧx/ۘβ2A5 QcWfJ2(~v(L4sK AkMS}{wS~{+$"6-Mh}Q Am\dL?,\HTbQFEs>nܲ2X1`oGlfSϨ o&5;ȈNkC>NkG(mX-cKQb߮r nƮ)Iomm}Q<B!&3xZv&F].4jʴKR9=uz"hε(ׂ};x މחݖAs_ )=$^hyHt7+o_ h*3=b0?29wj<:>fwj2hq $韃ă?.4P}Ш6ݟIL6ޛCkc'wUc0(/'|پ4t|(|u Y1Toa2|Y_}s)|g &2.^ű:Pͩd,"-'¿}MDB[. {qu[wdGNxC wVc5sNH͎dۣKjN,PҀBH\JMu6mWuɊ;xZdW5ʠ^OV>}Kăa!V.n|+aVn?ɀ9L!BqӸe0Ńϵ9?(QDh6ݟKv|pqF!(ܷ54I_E3D/N ȁ~\/)!?g xjs iMFl]A[S8w#>5HcąEZjEw?hh|I4Σ( =WžV/ ץ3Rz֧˧OO~UxYn?62rp*y'&F&{52tfuvmة#̎O>E:m˦P =׷(>6%˱=v$">%3Gk9bȉb8>ZnGɁ*rnޞOH#yg&^?EU74u^!BuK < [{%jsɷd1w6}?]'ikvWOhbt%{/}k) WpiwhFF'گp]?{xmhA£Ǧ3vS#&1ښ\wy@)KnX,FP0<X (JkNץηbSq.Ǵrl5f@`hrw9\@0Zkq1I].28_Z?i;?{Z(\ʛkA2(#2.QMK}f-4֥R!ok$>%?*fWA\j!VeO#ã kk )!NQZmrTZPوBauSF$&#jO5eM4pp$߂f@_nag$/ =@q?_h2a׎ m:9eĵӭgJVhr1/N*GlMu68|fխjB!s-[ 3{@Hc-6ҭ^"b \-MοZHŖ)ۡ{H+7e봮YH NuqF|vδ:%4Š+n&Z 0=wǴg?;@9ܠ=NfVֱ*#<ܷ5B!B?9_=_-F^~f<5Uܭ12,ʟ/&8ujcnQU纻m$BΗ۟LN|z;%"3HLJ7uU /o+NJ5ɨS$%/mQ)'{Q ieGOkC۸uu۽ 2^7 /Bkw*!DdRFauM~7kx`Iӱp,SP5wm/pd20ۗ'&+x}WxXu>VFG9H4Z-,ZKݜQ}=9㷏8Nښ{@j%jQ̬ݝ4_8wB!B)əl{t1Z⮇ ?)QkaQ,Z<@C`/hbjh V$OM d9l:P\Ff~49Qa&[9욁vxK\ҙ&O3 ^Dz"Ogtdw_9屼q)!,ZBNa,^{MdRf8w? :?_?|̬;H?Η&Ru~)\@0}j|̬;H+J|GGKn:8u)?Y_Dd| R2kKg(;Q8z!Nie F3IoWJqG2TCM'{k;yWG)ZΪ;P(zycB!B\5/aD1C",ʟQ:Zz?s*""&zNޤeGRWA4~샯BS]z8h(Lhlӟ*o0(c ܒ7k7>fZg>BEP/ݟy Rx h4K5F£heox/aR7? FETl ]twlY`C| `k֦_7Rr !B!>?B!B!B̚9IB!B!bB!B!bHR!B!B1k$A)B!B!5B!B!BIP !B!B!f$(B!B!FB!B!BY# J!B!B!ĬB!B!b֘f擔@$&ģPT^l9.^<.)$&ġ˗)+;?e\ZZ YY$'a2p3g˨qq,.###N_# v5 !B!BiP֬=ۅ7}6F||  -z{۸｛o F?SJqwsݛM͆7>>GG/~Ł=7{~'XKpHg~lWB!B!f sٽg/(HMM汯}Fcs3u]|.qhrx ۶mR~iob1xq}!WijjKYCCC ҥJg+|a _v~v !B!B)-a0ۅ7aO1rYrQ=SpzRFF.JgΞc׮?訝:cILLs\zf߽&^%3#h`B!B!&9;1ou{v׏= @JJ۸U4N6_M,f.]2)B!B! J1-ePv 2QZSVv~Fq>h0Ziiix}󝛸rw~B!B!MbR^^^,[Z }i-]ZȃčKOOE)r9z{'^ᶵN:;;kE``lWB!B!l#2L<j捷vkSh2ɏNvւg崵C.ǃQhz{&(7߹N*%.60(B!B!p$('HKKPe箋{QR(ڮyvi)nO?+ΞumkM-Om' -5m_~?y'B!B܊nEKk;JgkPh$lnPz/c1c*pir:А6VcT8m9;m^@8ǵ\65gةeFk׬+>7?o3)}y,Ïvsalx68q??߉:Su}u}'Zeu,n_CCq.ZZ\w=~-ߟuhnnu[T6?~~iz}hmiu[nFsK?РowO!B[fc_?H\l4O|?34im#riGO 88~|cs7?p]mB!B!bIV4f7dq+W,/]'?}crQ"|mqɉQ}L!B!BLAb"#zEDc܊|rl9/kU9~^y|s'Z_`!9zlWB!B!$(ń(ljw9lY11T\Loooxzr:u?q;{GgeeN:*+fJB!B!nMrL`Q 9p/Wb^VK35.#E.qYY,_ZDy2yGݎ =f.*KKp O6022 /:)B!B!A6Ny䑿"%9 ٌ9"y%:=}5.ń]OliC_{Ny4{h+<ҥKF M/rlWB!B!IP F 2hgY bcꞭ*B!B!7@B!B!BY#!B!B!f$(B!B!FB!B!BY# J!B!B!ĬB!B!bHR!B!B1k$A)B!B!5B!B!BIP !B!B!f$(v__jf(Bix_}8EB!B\4L|0*v\V~ Y c k _l_gDf^ u۹|ڊiE Tk2..%pb1 VQQDCMe +/;5g? b `pC !:. Pw3hؤ` 7twR_7 {vQğQtBy G4(=T}K[{.B!b$(,ZLwg&/eFG4]$(5V%Ⱥm,ݐ(ZlxZh>|};=oLǠk"n棷ΰo98`ݶޜzlLˏat47u5˛COl6Ed|V&$~z9(6[{KoKh_3YOmoH xʋF͇oe.sC66σvx*aI!%+O.eFT\ +)祧vj!Lf#w?ܢx@3jAG+ן=2e_\Œ5):PC+R4z+B!BB@4#cX"s(_ߞdhp0*ʚfrnd$}AUkA)Ma#Yw6M=9ZʼnyR^/,%nxVm|I;^}C<Iץ5\lݗOyyn_.qr pL#O(k)?^i9Qn˚<8;xENa޾ٮla|s} /khOj(;VAAƂH,eB-p=r- Jo_3fq/ALS4Roߧ\(mF8En&9^&5k>q޾f̖Oo ƙ$V78F !B!|GPO GvWL˓8ѥ9Ӛj+)~V[ݾ^veI%=" Pxߋ%kRLbz9K9:GOVZ ZݯOֱpY"1)!nHBqi5T]h&13|N@xL瓜(:[{ػ$n`نtB|vhnbe=6;[Ԕev(L4D4ػ'B"?$oi"SI`P4^sGit{eM#*1Hcmo! nL# m״6v{3*>۲I͎h4`͡.rr5Z_)"ymBYww6o_'}M4c=}4qftgg SB!Ea8kmT_hVLX?Q;N^}5FM&93eE5TkQ4赼}̄ak北w2h&:!hO.)3jh}-(ut0+]NlS-6~p!*!xgXLΗO3:zj20۾CME?8MR[:q!(;n\hJ_K֥3{߭b>o 6̤ۡ}qRCZQW~5}WGZ(Z94sw k'^?E*?B3rY.mٺ<52tۦ^VB|"lq;ʏ'HxË<ۖMɡzkwBa !=8o6ML3wb$x[{ոq9Ql'Kgx<_/k=O_ _ ,8f4\MIQ>vxwf#Ƭ(!gx'ayr)DZ|yoWeB!7ؿLNoC'gF6l6K]M_+ pM?LΒn (ԏ=}h')&7kŽfe)wd6 fаgG9x~F;9"Ύ>Jm Fo7eÅ"b&7M݅=h??/n,O{ۡkVv0,,N`hxe..5,mlѺTR)iu/$EF+/@k;FN^3˙^Nbm,Y?usۢyW&vj;C\JMؔVcɉN-%.%2EP vvsEHfrqDqHSrre;]tmS>ew^*q-sx+{}4~& 'L B!B_K{sjCW6^>sA~h"61QwvsG)\IY1s\m+cx`[ESnmZΝghh5[s޴A) _?6f6Ȑ㘯ՋuQ0ٍlp6sp>GYsiÙgpΚ3m| FbDr$|^KeGRCkV`£Q`c;щhkr幾",2`/QaQgǒAa6vO{-(n4CnFH`4uQ ρ!s0:1^۠4FZ]$P9zckOw ȘI#"$u}p{*f$B!B|>fOxC4Ozik՟dvXAhRC937dK'0 ,Z]o-qqŢU)ly(ʸqq! "95ngr: &v< Knt 5Yfhz<|8u+ݶr tC۵甞Ҏ_ZC`k9cMg[/7blO /aʱ:4Nu匈 D)#[!Bq3ABtR݄FXIω"c/fEFN4#z3?РH>Pؤ);Q;GTREjvǝ]욣{*h"-;bʸuioHKʹc |֥ggĔJ? ڮn죎l&e a,iC*K7swƒ8Amjp}{io? Z1gl15N_D8JFmWh+f?T7O1=]}(a~3x@)v1[cu SfCFOOr4 #SGè}f[MiLǩF=T޲h*϶P]9f7::I"RJ!B!n6#(ãQ¢<WGuhvx|{D֋5}Q#h溎^c|yw@T\ v[ȝ_ZHV~av]ieL:Zz6fǭhIc\lqwc[_w3SCQ;,ߔIgKS;EZQദ\ hTn-=  144:hUqs(knפ h4L{=^cܫJA!K?\C}ay3UFZ e;_ JOrbh`ohmeas.x]HJ!B!n& A|݌s0B}l ڿTC\(m$3/WK(Z6K MW\{ڱzdI7?;XPOH.iqjAe&}9r5 1RZrpE)B!M/rwo mVq+cetTs;opzh4 UZfoHX?<^Lpܢ¢\lwڵj\$qU</O➯-Bi#/xIq'>֚aʎ_NbFu6.vސ(xs;DD8ڡ];x Jev PZ?v8 mvH#!5zuUs;i͂%Nǒ3^qZj6oht5 ;͋{+axhY:ĚK˘79jaP⚰WJma,B ӓ$.KWcӹL"b% dm щA.SC'ЊHp5 }uwtņՋۤp,wL}B!BT"GPNfbUsix9wI4@}ssmPcH_EZQHLcaQ"}cqdŒõWu"13EtK gۣ5}CPr)5?/iD=c녜;UOH+t3JH sgv$RWՁAAbF8Etxl̼r"i:{x7="v;#.F)1??{!4 v;,&,ڟ.RG2Q,m %:Ld\ Rys` G[b'#ݷrs]{s?^ĖY)l}D5y/eQYބߛESէf bʸs|e(\StϢ^&~\gkc7<}O.u=%hCpCxWG9uy+˚#-;/}s)6a2Hˎ?u~|e"c)^Uc'(ȏ>z㹣|{WOsC7i#WK[S7vRB!B*IP^Gۙr8e+S{\Ka'>;'oYKV'Qv Pv ~{''>摷,%S@+zz(;ߞpg bD ϻ&CP )L4M|fٜ2l~eI,^2hzlCߞ:|Gܚo:qA>.'8տvȔSONa< hmaoOpykތkmcoHey~^¢@^)aoh6ޗ36TPmNHr&w_ݬ21,Z (]ƱN1ݝݝ3:g@lsY+}9g~}V!BB!B!bEn#B!B!9HR!B!B1k$A)B!B!5B!B!BIP !B!B!f$(B!B!FB!B!BY# J!B!B!ĬB!B!bHR!nr߭!*>h"kߕV!Bi [@T\ NSS}Aa,YBQ(4P(.sk0(DJd\ -}]np-Zٮ,:!"P@}U皩>2b `+۹|eʸ2‰I hTVSQDCMe $+/;5g? 2 :^ag:nbd,ݘhZ5:gٻm,ݐZ5>z,v)ezsZ+z0[Lˋc cXޔ?HK}QqALfAa=~,FcYovdʤ9Ss|!nMf]DNQn{(PUwf/LW/bNxݬCI^Y!BΜOPFVmbY(i""&`8#%\;/x̼,cʰ5F*`$6ޗÎNvX]DrJ})#(!"amͽ9Z}yqq!lkoq[$՛s/ȼX<{[B{sW.50ćOswgܵ=~sl!-'{Ps~ ʭ\lg!VCcB ޾f2schonw [5{ ?b 'qԓ+J MV^۸gׇx9w^9v]N+OpL/=\C+(Hωr[ּeI->CDR l1Vk*vx곍w_>~&Je| aӇkyOiaG;L&v}ƹL pLf˵if:}͘-پ1MEHɊߧ\(mF8EG MsM7kl1bw7klyTJa `}}+H9oeԳB!79?wSqCd.FOcj: ia`Z]FG픟`e2Y>R;|ZWG eqh~ꋭn_/?YG޲Db/XF9MpM ՗IH'gIfקElZڮibrO|cDO#:!e0Tk_sZqQkm4N2X!?Nk}7wM?X-H&#6pË_sd\ ۟\ ЬVܞ96Yzm,ۘZCk}ה `|3Q :Zzٻ\< !Bq#([&xQxрi{q[{? Ǵ[MrfZ).kqZ8ׂVZ>fu;MwsD'v%g !+ T@;(YtLpvvX~[-6|pr-^&239_J&6=EZyG&ep`}α0|bVܑ9ۗ&Wڻs>RS6v00MR[>q!h;_ޫ\}^,Y>L_ Jm'8'OO~ % Lhݬ:wd}߿uwgSr]iAABz(?;8'p;Yxy&;1(B[{#no%$gȉb=9\:O?9ce ḳ@KзWk敧P~~h sa(Q[{;^<騟;K ̑Z쮘>3rx\ί}w k㔛rno?=Վ@B!79?ҽ Ph,#E&7Hvͼ5Xu>(&dsd?6}2,,Npܷs:ͥ3M>B!s #8SiM_ϠhūSP[.'{)348‡oe= ߭/0?Ljv$yKׂo켼͜9Z7)"Xs|bBx4|IK g'b Fnj&fdkh]*Zk eP)"Y5`^{Ȕph >fEv덵Ѩ3tzQ6ׯikV `v#3n>nbs}u% 7i^Z>fChmr$BՅVߞITl1! BF}\_Z6.&13;Mhk9cB5zڛ$m|9[uU Zx !Bq)8c{+_D|jaT59sM֧q @_ZBnaa~te_ ^rL3Wp|O;3(JSƍ IώKqJy,|SmM=?k4]s$P>_R}vxǥwsIˉۡkPߖN{KKkAi4@4Lǽ'M`/~y;y#qPپDFmjQ\D\ (6ݴck"Qd77Oź!{1?̣YH*Rh0P(F(tst/<;+œs|v& !B!>?^R;qCj;O !$2wggqjZ0[ly=ݎ죚#{*(\JH|^Ӛhkh]*iSKxCKxS5,>f| ץs&FYt3e~$V }=C3Kf;,ݐ΅Qx==]sfG|ttOcF=~d_ZRh zDSYL 7`NЙmvm v/wv>P xͥ'M+_ɹ2 cVK([ͨNEYus|4ӭgb,:EXZ_,ZḏFT5Tos3hSQZMB!B׭T{Z9;h Wa68I-KDLq\><c}\޲DR+OSיB" z;ZzaphuQƿ IB!B_ύP}uZ)gۣaʦ3GXX1p]P}e1˛xGLFݮ9WҀ2سiM̅1VݮiP­hiq7kQS X,-=;7ʋA+(;^\ԃF2&U jluIN}N7!.4`1iu12?dR1(ʜxǹFH;hm|wfr oOL¢bݬ[Ox?um =1.hT:9y|.'>V;H5Č02iQW5DbOG\Ǹh\p aeP!vH#1=NgJoHwg?uz")3%qh~t]ڞdd "&qzFXv[KVxXu>֫%GG92fiNZX2Q.498Rl$+5n4kJy|I=CM!:1x|j(ioEKp>\R̨ݝ4ٰx`Iӱp,ֹB!9?;,ʟcHRBʋ% 4^Qrz"̺ rqY/Otb0kS⥧{|ksvʏ%}AG 0[>]37]_w,r78+2Ѽmyǿm_YBxt ]͏"+?^"'rLD\ERqVweUE{ l = wnnMroI60$!c0`{{m:u#ɖY2Ey?13ss%19k_ im$618NkŨ]}u+n)bβ\NBJi9фtY_;dDDt0GUE?{ٿQCb<fcħ3Yi9zڿ-;I L,NԈOz6(IDAT!yEfL t߼A20!5kNBZFA=-Nl>z`a="0:!9efda4u⟶ xq$""""r@B.kP~Y)?@{OPPl1atwP}Ժ&fƎJP?AV6soO{DcT4}-N;4ԶqֶcO !5fW#$,2 Z\ۆ|Q[(A)"""""""""<$GDDDDDDDDD. JPȨQRDDDDDDDDDF"""""""""2jQ%(EDDDDDDDDd(A)"""""""""F J5JPȨqvdlb$$jĉ]s͛M||M&JObuË;x\M͔Vy̙IzZ [#|""""""""2LFH^9ڕ;oa9zhBCitx?deܗt+cJcw睷x|L=NL_yF" 11/q3'biXfPDDDDDDDDI3(eKx%[Ïzl6SLoo|+|cWܢ ؽg/<qwwocx<7)S&st:z\ e'+HNM4FEDDDDDDDd$ RT80y7v}.OXxٙ^q}qݳq6vE>-\s >ƿۏy݇""""""""%(e0 =\ɓ@Hpsa`'O !!qaZw)q/:=G'0'""""""""%(eݻK0MiŅ^L{J,˸‚) Lv`uy>`݇\""""""""b8ڕ ={TUWIZZ*#^qu ̘VĜ3 ?ˤЪG-6Du鸴w9L<]pȱs^DDDDDDDD-^Bη!;+ hmifÈä sąo L~θ3]b97uȅb̜}=wa`4Vz%-2}0MLz"޻TeyEVVc cP2045G'&}T_wyEQTRٸq3-̞=@K<2ÍhiieάăCM!-5 œ3 8wO ~޻<^O[U/}f=qǿgh.!< w/!~.3,ۿϪ923,w/߲{FVVe~Ok$(].jk? |0/n8ښZzOOWWwyM֞~}@(ߪF5}|8_UyF55u0guy:|/KēoSeŕq͵WW8x;n|xAqW^ḱ-ǟxx{pu+O/f}Pd]TY[&jjj1 9gM gjkj0oYsl婧U=OӲEm]e3О>Y[k[___[Z?t\Ĵ[?.M&.gXp>_9|uܝq1~ß/45.+_CggO<Z-"""""""r)2 '' -[wx% 6mފ&## fge\FYq,$3#mC@)""""""""%(e@]]ϛaSW@ozl爳6՟<͠^(A)-61`篼b&&;v>+nnd"BBرspܞLdb+cnE\p~1?JEgg'Ӧ1gtv;aaafsuWxN,ǟ;nZ!sfFnqxXM/d}兒;>뮽 pT=6<ZOȤ yF;IMM!?8qjUDDDDDDDDCrˬXq夥$c6{w id\b9ivs={ӟ7s4Vd}q .{(`j>̚|g驛lh7 A JpDCC)w剈ȅK J5:$GDDDDDDDDDF"""""""""2jQ%(EDDDDDDDDd(A)"""""""""F J5JPȨQRDDDDDDDDDF""ҿ,$!5b""tܩVDDDDdqv>)Qˍ%i\$vG8RREʼns'3 h:9qO>gl^ayIDDAv+w#K͊`v:!4uPyuimV\T|-*O1ܸ9DŅTL#!59qnO>Iύ!8"Ĵ aNصtX'dl 'MȘsA'( _3K4:WIvm<3>#/FMy G t['_{S5+o"='&[HVZDL0Mʎ7N4f_ljq/4xLg!N?;+oԙ&Iks'90M<&NͰLN`,vn8NֲQimEDDDDƠ :A9yz* 2^zb;M 8L(LfE\UPv+6<* #?}SG=2ȢYqS!/ie+o+&wJ<;6AzN GJFY> #%U-۱ ''p=s3w^4M T6w. ~qu\LTvFysN; cT5֗4h] {璑GYi҃5tvh^3Rh^P™PѽVTRDDDDdܽ$] 45ˮ'(Za@N~eltNkw 9 4!VANpGz^|l ]=tuphO%n?5ӄuoUiS &8<(ܩ7zǕTf7~j"&ڗ 4sI6ii*a[x58׬ώȿC< 'Nǧac^0O=[ӸO\.j-/~9i$|h8 6hYp?frp-91OOe{G0 >i%$ ,gVl$kBA!~^υap*̉Ygڬ;H8˸_?*v~Y?~j".6)+X@X x)~sҙ8HlvS.^f*O6#.lA)?joe9Y:Ш5jaτ\3I 6zzUaA+4=>% ӄ%WOf<ޫrڳ9{iAIue9#}[ȸ}[{/`bsAϠJ`\@Ș`\ 4Զ<>gY.eM{ ^1aN.Gz{P$ں8{J ӴHG[{0 EqSio)oHN3LS+ncߜCf^Ts9RRŲ2qZꐓ(_>7N_7t:]Ѿ4!%3 *O4R]4XÀ4LvK{Q£g1wYe\Hxq˿0x;9p.>qE\Ngwrho%i\zduwx8n־!&5^Ytb}glB( շ@HD -Uɛ d3uN:+o+&69kշO#$ԏ^kw+`8O\R=JkSW>^xduR sE%iQZO=#lF)+o* *._;w<̓K'wJ"K=wN{^~ YxDv/1ڗ(gO 4xc]G^a??W/f5 Zwf[]l~(t9y8gz nKx^;#{o ]•30ȏG`g~~ЌPFA_xm̿"(vo:ɦw=sXzd.dUiQ7kus,1梜ABt\ m^B0 hoxlԔ7spW]=`Bhh8NXtyL(JȾj69fs]{ϱc ]˷~v9+ș?}*|x5{i.t+ɞ#?Y3d?zS}irOw6O'pڙ:+־s5*WF|, +OHtw8K !pX5}A&䝿p^ulΌ^q&iG7$z{TlᰑmY m;q3d{_{Wp)ž-ٷ ?cs$0xբｲëYtwճ&^"""""cE70 [獵t=ό99Ojuvcv_g^E\{k:.i\$-N˟ D[Ϥq&Q~ tRz$C$*~p=cC8VMg{oKP.'dzx5-Mnp{N,f,|wy2l##W3qoIC`% .90ivx9p*£۾`gv A}b@I<67Y/_l'My[X$L8w76QA&i`Yv @qQxf/?zQ_OϗP}\솁Adzo}o`\\.Y̾4;+x>_1cq6恥i>a-MCWg0 HɅ(-'6wthqub8G~fP\ ښ:aqogϤk㮾埛?]3dSEQ~^ˎѮ'c`+ҟyu [Sj&#>K "G0~yN6q-Ɠa:iIHsx}ξ>܆aM^TSS=>1hk~ <#4Mzp2r:=c/hqDDDDDdLhsҹ ?Xh!OkS==DLJ04Զ O+*.0ij(YT߆ >?țnvV\;=Co29 ғ1jS±ټ:aPQ",?ƺ6z{&0{yxJf`RcP?|Ϡ=>dM;EjE=+N40zV )#oEDDDDdt] ʢK8f]n0 ֖NJ=CZN,eMo{p>͍Tj"$gO>,n؝K1 +o*5)D: gWa#$<9I4Դ 'h?JcBa~CɟշMcڂL;>/TE)yL(JftHH`l8S8 \JcD"cp51n."2&ȉu^GTl9J[-BOM"1=Oxf]0;ȸ`6s.qx+3>20>DLJ?#o+f%Y㳭LNѼqDD̄$^;EWMʓ?w;2;ĔS#rlJ?> aTXG'S4yvB{xHCmsAA9fct0wӠ?+4MCVTH4&H0>}o{p;(Ƅ j*yٝlX}h#YAۘ6gNZSc<q![6޳/9! ɾmeP:M*ʓff-0LhiG6²\y3;h&gJ"}n 3*J]yq^vVOaUPD%&MڪG [Ϊuw`4 69u^?ޭ_^`m|1r=.OM&cm@eio?< 2<#nhk䭿aS>h߬;1845JʼnFןAg[S| Qʓ-Z͂y4u6|!"""""/#$3f3M 1`ښpշe|]:hnthqu>8OCHxNj+GODt#W?15t{i'61V:ںQ9iħ4aG>[ϏrߊȧG J5!9"""""""""rRRDDDDDDDDDF"""""""""2jQ%(EDDDDDDDDd(A)"""""""""F J5JPȨQRDDDDDDDDDFc+ 9sfm;8xȐFQTSSqq9RRV\@NN.8Ć7sXm|5C66&KiaIWW7Ͽnv9%(/r yL0ohs_&1mZ7M{W|5ib(++'=- 1{ ~=d]g͜ihlw5TVWᇛb;bb?VruWq7# Ye˖e;kq&&o'=(/Rw~v `1DLkkǞ49|(~YX.X0??'?$?0{t|EƸtlNCC/CDDDDDDDD.`Ayzٽu>pʰ{o7X>`\0L6m:XXh(K,dC0{t~=e- Xfxh1׊ȘN0lPRr빠@bckv+Sڛ`z߱Ŝ8y B """"""""͠,9?ES?ǡGx^ u.]o0--IxxeK,nz;] y?q9&aa\s͕dgt88yoCeeh gY0_p8o~Ahp0&e^y ˓#"1 hi=eTTTc.RR`nƁ'N#--uөGm]=qqL4Ey]v9}EvV```ba?oժ[pܽw99O.3=0 LyFYw]dgg>00LsP|eee.ۙ[chUt``~H&MkW1.?:;;ωaBW_244K.)UάY  Wzߠ2nJO?)-TVV jon?zYV\rv.55_3.zVZUy&jj-ۿ.˸:/ߪt!yE:j3??͛o$47 < /?+W?硇emNou?dvv&? |ꯃ>/awD;nK.Ǟ⭳""""""""2):RIKKaKΚ%1!W,-[<5 zD$)1oWU ?îgwW7isP3fxt9~Ġ{{l۾ӋY~<y lc.G?,r?ůqGT$ l8pSn])%(?Cs&y/P]]39sfCGhmm}1f6m:x^^.9uGijnٲ.=a}&̞AOo/6mxnn6S&Hyyh7^22DGG'O6 ČfZTN9v8a˜3c#,o׮l޲Ӌ_f$$ij|Rz{ώ{{ W;)FҸE߿hw ɹH Ljjay6~?KKKq9`OYnobPQQc=ޒ%6஻  3 dž.93>ϱc""""""""2 JP%FRb"]]^˽fDESSbGTT$!!:U=*EDDDDDDDdt)A)"""""""""6.%(EDDDDDDDDd(A)"""""""""F J5JPȨQRDDDDDDDDDF"""""""""2jQ%(EDe7sw>Ua|ݷ"""""cc+qH͌"=7q6NHI'KL`|A )6(;Vϱ5w}}}qL(H"5;Wkٽ==s:6b![xÐ fLL i@wW/d˔iħs`{9'3Φ& (i?&Mõ8~xe|mDt3eۿc>aeGF: IL`v:6jꔋ]Ju?OzN aoEDDDDƒ :Ai,XI ®'~v_3ٗj+# t֋{Y~븫'1\LLj*#(b k_72HLB(WRĸX \m>\2ki59+Lf1&ome̋{S]DBJ8s1yf*On==ݽCuT-Ƞ ʰ@.4 n@vKhSPqy1v ʁ4f/Ld95/!Yf^_wN&)7)S=tRe3 ʰ ^>60Dꇏ燐1OiۋɟM{s9W?l_L590Slt*aߢȘqA'('OO+8NSC;N EI\u4t[8uVᰓ=9vуa@rFWVk'S_ʞ'r݃nƒk'Q_7N; c\0 +O 0|gS;9ض֢]n-fɵ醇SG=mhDȊ y-Cylz&[U!^}fh76y0 f†qəV~ۊX|DjZسɺno. ~Ģy\us;G?ZMo0d;Gx Dat\2&Qvw_G:;zpP4?Өh^P<9r*a.=(wo:]eƓZa3OkobՏ'x&:ZϫO -ۼvgv` +o)撫&pH-vn(2>$02pN:~N;c@R H% ԬhERs^'16g+&rH--vl(4!Z~XmuNpM98v{ɠ~p11<~HLd۩ai๞vý 'N}/Ai,2'XSY]bgGV⑟M{[אn?_N?{O>|ǧac F0h?/Χ^9~踠gP||SI#i\kjh$(,`qm@Puܧsz8#C Y>_0w& Zϴ?TCzN SQK0Mk<_ϑ8gƙa@Pu?d멁ǂC0kIύ!F*ߵYK10Αa_A TlR+n*l`4Զ`oΥ9̾, ^ڪfG {V3 l<`o>sDNf-&grəQn7ͼ>m^|Wf?ZMtf,&)5f LF/O'.)ә$ A)q\˜9F`w^:LH`5ɞaMme3:̎u1M0/ɒk&3ޫw@=/!,2j*xglRW~`jx咁>OPIϬqcGa#Ԕ7QS4ظq`±5^: FCmsRSĆ72.'ĴdRq*\>Vyc~ U>,˥Cbj{F2(ʓ͔~?I?_B8jeٍS 0|ώx^OmE￲f0iZ2,V剅h"8HY\&Qzw_*!8ğ|ټ.ֽq+.$40Rٱ;7@^?'w\x SqOr|ux.>&vR)٬>gT\߿`?쪤p'%pŘn7;֗C*11IJ$e\.ʚv-by}-obzNKwk";s J²`] GDDDDD.Zm253s&? YvNeCÏȲMġa}La/G:[\_Hx&|zcP?gm٥3fawNϞ\pEIa%cqyWֵx鉭3ׯ>׾Lb'hwl<7p{XQd?10X~qշ dO`u9|e?wB]530ȏG`}mNMdYD]m6_Grf7,D.n2TzZ;>B_5{ʛ v΀?}DDDDD.XGS0/6 B0Mw_*ay'Jw_Ǻ73n#:q]I` y}0h?rhஊCaLB,;6/ɠ]>%cB C\ISHIc]qdNgڂLy`=Vv[2#_\I`w{|zC !^i 2l̓Ǎ#1u~0 )ԏ`2'Q|81pɟFWg/k_y 9W9Dܬ9ذ_v ݬ}e?LWIӒaev 9_2`ƒ,0lN}|k#ΔYitwo+)3n}+""""".AiW~w3adE91+'slgȸ=OH8^5qd/Q,8v0 GóB05M[?X˼fhf㬣 ϗkk4.vy P(L`s'"_HZ\Uy^^@T(61ıg\/ E\)d'#xokտf3(^U7g_?d+gŭ='-s}-$ N,̰ ZZ w/?ΎNz|{G);Hsb,g&)_m5ήٺZ:11q%.ˡu@s̰YKst{a<|ÖR8wѤĎ~pLb9n2-QA:\wf1A}bLťcbd=^Z\@DUb)=Xo9!TuM z|mYpx&3y\$k|_xTAtvxwI~0Mco],""""tQ?sqrhW>cn'QV]La@폫)o"{b<\n=20~r 7GK(?1xP0QGOP5 ʂ9\O8T_Wm>SjZM '>5bDy7ԶF|J9ͻ3&4Զ}}MDŇ0\kZwA q!`^cB0؄`nּ烼rhog4zvwbbveQμni#.)^Cl< gCL|(?no7&Lno>-1zvwa{0U-&njiѾ #%UM s$Okm0Lì 9s }ͬ4zg=<#奍DŅDO8\whϚڻ_UBmeP09 |.Yi\st߭ |EŅMeNq 6<8MoGJEcx_mr`{0\æAKs 0 (:x߲C+ykXxz1g O'4)=X;z C?|Dqt\07S4dr&0{i/qp? l=5(J;߳o#N'Ƙᨫj4 .%~#-dBEicmxʘše7ڳ;XFwPܷcF31W'.ͳ*K7>nxSɜǡݕ#n[wLH܋7L*NH3zUiU~RDDDDd̹xǵwrIƯ"26)3ӈI zۺ>3.PN`:qOelpNma&m͝rcCuyeŴ6wrh='qh'sh=uc9ushYg28h'Am c*L~ȟFLb5xOm ZXP]DYzz{=3 O}CxZ\cΥS.B<=usc4=gvh`<vl/c줧YKsvI~8h^=ig֥ك^ǴtuppgwX(0KO`&Wp|YAgg3g|jVZ_݂a@msc)+n*gw=۩*woy>3hm?m*/=' ILN`o2ef* uq!&1ygR3 IDDaէ\P:]&&} ]߬4\5-SEɶ2&%sWfG9Qq!̾4^F'Gtx$C8cjhquEtwo׍vx!!#293+H",**scC^a2 x3lrbȟFcm/>Vo)&%sWfp`G9Q^MOמY? 5ZIJd,:ZyjzᏛrӈM L,JDֵLjO`֒,\NbØ:+ ~ Z;GX#4״U[,cqշθp:m~~@gRq HDT0GWER_cqiŅϻY9)[#>%YsKرNbØ23 gl?{] Tr@83ۣ<;ђj\ dM_U8ٓXT5;c$D0cqw} ;63!)U0j]dMgBQ2U͞ݚE)""""2\ ʐ@ n72{\l<{dWg|p2g(?_,`N/Ĥmev]\ySsҙvI&h 1]نoiB82(V6(Aiv`@Ks'hU"g2yF `PWO~8h0ݾvw\B$LXnG<`-hwgN#cBF?~(/m` (ه62ma&S) t {س2;ڻy7iL,NfRq2`Nt|WgvEΔD.3IIgF^|l33dsɕy6hvu#IaS?WG`$C_qvPzGw8v鏍M $a" 񣺬#4]xOur<%A!DDQ[= p)A)"""""""""F J5JPȨQRDDDDDDDDDF"""""""""2jQ%(EDDDDDDDDd(A)"""""""""1OFlL4K.SS)*. 7'bÆMt jf}]]ݖ$//̌qv>%/=1d9v)&=-Z91M"er.Bg}4q{1Mc909vßYNw}~~WHdd8v_nD[:Sx ּv s_\ Acc#UdM>˺ޯQ\4jkꈏΝ{> """"""""+ \6~aEGGq ?8|(_뮽/~e_)}z):::g)zYӹ+ض}=$ 1mZ_ҭ/SU]Ñ#Ǽb. ⋯ vc۹㎛Yt<><'GDDDDDDDDE0F>9v99y $'={AAA^qi̛;#Nvڃٰa?~~{bMl޼ ÀS&{QXɓx޻{,Mxxhw%#Q^2.L6m:XXX(.Yāp:̞=+n%so^ceC߼e;&Y㼞foA&{{{ٺu~N?&N[DDDDDDDD΋-@r8ځǯb'x7@oO7[l~+(8fV)1!fغzb>X ø+sdzjpLZZZ % W Gx/NLLf_S mw񗧟wR玗"#"-c[^s ʋ<9k .x/_Oߙ?+$""Lhi=eTTT}n::;0>(ILLmmm|cƴ"k er=_nq,X0z>XG5V\RAsshØAy_#'+ 01 41MV=ޒkdgezZ4Fɪ쌁DƠW=dQ޽_#+3sidP[޻4<d&^]Uz$?yմ?yfFpHuK[zdge U[{﹋쌾o9>S3b0`x޻o?g՞˴lSUjzZꙝa[iYY_O?"""""1t56 {hb`}r1=坬jljy\8ښA[5ekll<̾!gojl+[ŝ>kֲ`\3=%raJ˨fa`r5 zV *yp 9 Ckxm y-7})^u7|K/dٲ%|_fyg={1ke[q梦n?c.Eu_y샒Ļ-rQ[Skࣼz7W[[gC?/W{Y.ϐqt n'""""r12BFxγ\&.Yc=[o;xdd/8v_~͛PX8}oU Y=NWy /~/Evپcua&리??'646FEDDDDDDDdcf|z:w`SS=$&s˨ar'${N;%iaY^\\ `>u`z?q!~/ĉS>ktNּ""""""""=f˶rۋ`'N4`Ӗm^Y^QEDDI^M8 8xe}ΝWz;{?tttu͞=|6:;yv30(Ay3{3f{=M4\Wz={nZٴyyyԉ2= W^lvS'aM?wɂ|kwcnF|r?>NCChw x_cǎFƥtBe]{ٲe;Ӧ񍻿֭;HHgtSZ=vz.]BPP [n3RSSxg9vtP̄ WnM[[;_fL0 ?^'UE 5k;v?**F DDDDDDDDdtHE* /|zfΘFXX`Gy罒gl~̙5 ä{%}r-g9 pSQQkz37a /!9Ύ=8V=k;vf݆lٲnz%(?" ԩa>`HIN墩yqLY|'rX)--h'G J5:$GDDDDDDDDDF"""""""""2jQ%(EDDDDDDDDd(A)"""""""""F J5JPȨQRDDDDDDDDDF""w1Ua|}+""""28Fel"041&ok>Sf΁8R7ڗ5 ":鋲wQ3>.9 ɤfE:vo%3qcIJn78y#%UTh {Ri$S_Jzvm ?UOPbZSa3hŮ úel 'MȘMPI')- iaR_3AU71./1 b,ib``PQ31M`g?=~== .1D^7ͤ0yZnd{G0`5YpE&-N&{'|u]_LWG7dclghn ,201q?}y!cB73??5$S4oS7;9^IMy9LmeU?LyAKc~&%wv +H62☵$)31  @.N?;WV̔iMKK'9<͜C?Ǻ/dRJJLݲ"""""cg6AaOߜCV^,x=pYpe0E\rSx>}^{zǰ£龹`<5:I.z" Ȋ yO[,cɉ\_Om?91)zi\revUhjh3(qÝөn"If3 KpMv+n*hAސKOln0L6}WG73xp' hDȊ y1~Xyk19 v?rɕ8:A~Y/Lབྷ{1Bg|^~r'!Yf73 qkJ(=XCgGg0yz*ͣ] JBjyS8ꣿy2Lc>{Pvw 28qɊ/6`2 An~W\@TrŽ姶EtBF1_=~;ww 9 d _NtNA??Ϋm+ðr&Ru5/<N[K'Esvq,t8~# ȉ>ڗ 4sI6hm~]tvxΎ6>#?]C{[אn?_N?;~#|8#a6{yƟ"""""2v|fgP2{i:dHI;?,y͛ٿlw1r- g,J֒>>l~w2y`l|e̗CVFtEz=-{{^F 2bٽL<Ļ-:rcȟ泖m|1uV:>f8(h^&yqElR+Xȸ`3hi彗KsŚsY./!,2mR[;(aS}Yar0~֦8ui9HΌ4MO5ٷzY_A\r- 3sq PuLF<ؤ0jIglSñmTr͹4ٗzƧ馶w^:LH`5ȞaKMe3>uO { d5wyu}e EalsGIa\B2bhm㽗K<5RDDDDdΠT4[.)oHNq9fPIDour.waAp$Ex&1@pQ?f):>ā4gPdN@`\maβ\jNX ^{_?aW?Եaoe\^ wW_wqt_}n %cIxn ]ݬ}e?8iwbGćh"8Huyӈb sK{˖we@BJ8+o-/Pz{HH '[[ C*xwsd_nʤixfPa,N}><ƒU21H͊S]bӚ#U{/_ ,nk=p gƢ,j#m-z$Іa3o/@k97w?65;2'Ј@؎.LAHx B&6sr [O/ g V+o+&7?Ј j9p O?CC7uMDkX׿y_s)mN~"KPI%Ovik_ϝ]ȢعfWh_%.%À#wy 1^zb-e5a)-gio|!ݣdXf>40 h~ոQdZ'S_~w Y|DvnA~r<xط!vSfx)> #9#ݛOisgn~"K*3y/wPmvÛ; 8/mDDDDD䓡}3f 'gxe0  :>YKsߗ={O0 [N_ޏib|NBtB{/d[ِ_03da^w={eN1eV*]m3V?Y >3 `XSuG~m͝fKN$n)[ߠw94\iZ&"6Ĵ(TLo߇מ?=$&%g{7`XA//al&kRSgM`umʓg9hK2Y9oNށ~(t?ƈ`0 "9TR}t?.pl WTfc eCv?t7(qr!M 0 Kl~abg&G꤮0MbBGłӿC tLmEaSg:~g|v IuZŵucX%Ge9(iaUcdž%E>2nb361 a{ ~(""""e96a0 bcpjgG'y=彣GJf91l; 9riruhDGk`R_³|8p|!r$}O!{R<=g~N;3gsfi"f*4֎~bl~H'%#ڢ:00q>gY.u5 O?L f}`à~u[ɝ0~Tr&'#^?άY|310hmgw?#1(>qɞ.3@gϞ "8ԟnn΂=slv1Gxkuy`ťc`x/$2&90nN1}L94cc< $(ԟnn ?İy]q4ֵr~aHp?=na |A6ɞpsc}ڍoEDDDD>㔠&F'S r8@Jfq!cv0<3B(=y`dP`4_KS&ݖO<32"3g1տ8u{pz{Mjʛp:Ӎ嬛򄋔0pC&{t@?a^}C}+lf/r^}uwtkS'=nCsY.m<Ć$izBqXgƐٗxV0'k몍iPyISp:l}?۳۫:!:!X>B0M V:d?0t?NGi86g1'u[ 5-t|/CFHI5dcۆ}TCgVadZ?7DRrF:ۻ_Q۔6JDt5#֚&h <"P˸/@]SKov\cm==nC >%:e\Pi134́|6x Ӵ'\(m0NL)oea#gmU a5OPYl|k{O6>HeRqidOAm4m5uRt"2=7˚(;K%emLN0US``p0vǷ-}3I 40hkrcHQ4l=P8w9*x7ο.̠?ehnlEpXz.c|,g)yM^F\R2v̾4ix`ʉ;7b+n*<f,&1{ԬhR_݂aBaî'0>Jgsc;U\{3deDDDDDdL/'vM]CrPg gd£02;֗u:Y|d9cii$1=߮=}O1(2;ʉ azn^}fe\69Œ9ٿFtRy]Ӌ0n|,+(5hʛ Z,;,gdF1m~&'x=i=dIDŇppW%VAbzڻyw>aO%[˘X|F?{k찌+?w0sqΠ~(ןcbܦI{{7+n.|oEL&OO/Ayi=%q1pY_;i),Z9`&8ԟd_f̾>Ӎu&2|\]_ʎ im$61;,gme3>!7;"vn(Ј2HɌonhI5v&gsxO%Iq{ 'ꙐΌEX_Pg7|ᏛsӈI d}A """"2|rc1-k {`-[2bȋ m;5 nj.!)LI҃5~~WiuՇ)L U5C9go?'sҘPdj="a` fqԃ陕jBgW|WaopphO;??`-}~~0!a/NsҙXg54"07ƻ}/s`w`?|'y-Z͂<7u#IeٍS}ƾN:ۺɝe7L8D/W1r^5 E'`-*y%lY{tPLsc;-s:SgQ8':>x{Q};}1!")Vh'TvI&R$*I_@pBtZ.?"l\DcT4}-N;4Զ=ڗ06A|J8-NGCXD A:pշ gܷ"""""'(EDDDDDDDDd|ѣ%(EDDDDDDDDd(A)"""""""""F J5JPȨQRDDDDDDDDDF"""""""""2jQhW@>yM}tuu3vΜu:22l!bccXL wuu [vb0`}m9zl_DDDDDDDDEpoMݔUͬ3pn֬Y3611/}f&a`R0ebbwq&au C&("#ݸ{ݘ$1L;i?2ұ&`izRAUe""""""""c;５StttOv)q:\ Zq9PV^FRR&r`:UNJr&bz}m??0w(y`^DDDDDDDDG{P^R?o6GDGG'ܵmwnkVp{??0dpnkWpQ1|!9 `3uuuh&MΝ{^s ʋ% &og2K/ƞ=%|C rٽugę \z/_ÀxcnQ$(AyJNN[<H[[qeeUx=~ِee唕șG fPZ eYUv[H%&&RW߀a;o jض}yޛFY#`x2 0 <扫iחC? UdgoD_˷޾z41 cPVq#66 tvgzzzxNqq!ӧx7\fpΙ'N'̓fK.Y| w~3_f_~@ww3gLCy7mx gCbeg|3ƿi9233n ׺|ʴl{";+ò_̬ в] /ߪ{9_U/߲]t'""""rQ3 JA#``0iejt@x8Eum_=_d3˷gc55}9pچ @r7|dgg;Aiτ#D5keGGz51rss)y򥘽&o~ció56UwwY3x9,㺶v?=S~WlltQ[[7&:V_SS3uu_UyM.5u<g碮βU^mmeo.NgVDmMeԳt'""""r2BYE0 ボ:u?wUw_ߓC"!$3aoDWZWm]m{mmkmk]ZuVmD@9s2 !=׹9W1w/wEty\~rӼ;n )C̛;$ozegepם~w}1,""""""""B{P1+#,<,UyXV?1xy`o@I sTqq)!!:]w޽E?>܄xvscšڵg{PDDDDDDDDJP^|e-%/c0ưs^ZA^]͝I1"H074IDATL***(,,E+Wjh#C].6mӃϓO>Nb5szWcgq#GYfrڿNIc , S|x2bؼy+;wa?ou7vyAALϛBUU>Z.~Pח0!,(.*'co, ZzhFH221Xlܰ)Aɒ ;BZ.#̌ 6lSx_ɓ&0vhصk7<$jQ#0VZMSS3""""""""r)_~~~DGGQ]Uͱݜ. !00#Gb{U F}}/""""""""QRDDDDDDDDDF Jq%(EDDDDDDDDmQRDDDDDDDDDF Jq%(EDDDDDDDDmQRD_ߟEPw7EDzi\ƭ`Kh?gba0XX `M-N&M%d_Oر(Gw-KG8DSSȡ=l^OSSKeGON$fh(;?=JcsD{s!u].4ŸIR1inl1"eGMuvC45.CCص}}CoYÝmd8vrnAM""&NJj(>Zu47<飀 GDh܊ 2_ep?i;0eAaqqÈ 2Vkm %5"!iHˎbdMJa] bU9 XTU\H PueGv07(8%4e#1vlP!X͆*F5q(nzÕ9 K*Ayzz_pKb0v`X>2A1[ra9rn`5ɞ9YDjf Xy//&ٱa),""""2|iH|~^{zsbY/\<+Ɔf}LO&kb"EnY%&1cؿX?| JC,>Z(vV̱w1CC}o7¾m]%qhwSFe=w9ݥmqػm!w#mfqx2rLW~]zu R^y5˳zlg- zϊE^6k3|{lr~qsSʼn<8Y~uoe[{{|_O촴}ʞe|{dնYE@5 ۺ}~럦yqY"""""ӗ6AXjaJT/¸X1C7۬Y;JaFmTrfZcX=@r祁eX7X0-l|qH`ws8[^WraX/Zd\0K:Q *;zS[0iao1Wv}wߖt`4ŔeJV;e+nDT|0یMbTbCl6J *y T\l6J *y 貭y F;/Nya5ﾼgP\Ijf46Z[(/᣷|L dtB_T|}=܋hdoE _t4 h@yaU파 #yd$'N+;5YDDDDd&( ` P6& ȇ(+r-26]@E}]S (+ի<D#IVwDKS >qcIwą)PxOe&>.=ey1zR"ݔ[78 !:! Oք>Yue2";+x8 %&Q.sbbaDV go׸lF2oE6EUNlEƄ6>x}raQ\s ٳͅLbؼ.MZ"61(9ZI O7+(-WwaYdNoMncv!ZDr¢Yph<=lJR B_%F`/3bp<,JV}Z:qp4ԻXmHL EZGݟ-"9=e1];m%<ޟbQlߛ+; _/ÇcbfV'?utm}ch%<@v^,f-f9ګ h4G;rnW[98`̔DǸ}ʲjm+u"""""N#(.?ښN&+sXzuM{،?{r"|>fpF`Y!Qʯnwo^1$$ ؘ^V}:([j* Sr~Me="ƴ~ji1Xf[!aP5p$ -e16ުNe㒇`%K[;뚸` 9a6LhDl[ոDDDDDd`}ixw԰)Dk~`;jinS_r[Z, ~XX^3N 2aQ4KɈ&:! e]ơcU!=??aPEn<ąkš[Z?kSѺ7(ӕ}*r]w||=m'[{ZX`lt6]$6<z{{+}\?k'jhkݷ!}G -0<=[8Q~, q~ (*tfǮS}vv8=Mlhh_YB) b'jhoWem]5C3(]2DCJu?wo)It}hJ89^z H] ,zJVKġ%$kb|/֗rse޼")ؤ!LB}}#Oam|Dme}LϤN<'/vo.f1njQq!|vk)E3mX̰a`ԸxBXJVbș 8b,sPrNbβ ¢سCqeT=a0NV5r [0ep|S fs[i>㇇ar w, /=R٩?O/0< ^3paaQq(ؤP&N8HM_k'LiQ1XI\'r6>HTB(c˺Cn 26Ixz+9Y[?~%7NaU9-T#&!ĴpB|>k/dg֒LB8 &J&x=˜O_"]^G]iABr3"61S?|Y^\ͳ|Lƻ|JTKh᥿np*בeeb<==H͊m}Y7>@tB0e|NV7h'y |\xx"b(+"eT4)/!zh~ H}) ME0uf_eErz㓣c uM<|*_MFfbluS[/a{gId峛YžaL]r̡JNr,ѷv}Z蔠  oZ8}+Ș8qX=e¶n4"c8GqA/=sS~(, NV_>&"&Eg6PHX\2%'[V1{i9qoIi{y'ߩLuEt]?1Sn8r8훎\rf9%=k_f M‹OcAQ~/.ߟ{#83ѓ5= 8YmC׿kk'1>K5uG:%(Yjp%䲝MeXEMU=z"bYtXb|<@oJVxH/o,ry:`EXTՍT+;CJ'ݺe;HmuYңx_|]@B)/>\IhDeE47X˃ NݷЭ?m6TWSzyo#$̟z*{Myƭ|q#""""""""""""""""""6JP(A)"""""""""n"""""""""6JP(A)"""""""""n"""""""""6JP(A)"""""""""n"""""""""6JPx w \p:Z3XXiE g` QNjG~Wcaqw]Xm5cuw.h:elcY_p,cm/ۉjc e^pou;E3\[]_km/.w+Mwmw΅3][AWVk_\[ s~Ypo7* yhiii߹8DDDDDEܶA`+ǿO;۾7S8O.lr|8r3A~X`j>UW[eZٱp?:ѡίr~öN:tu.VwWVo]6s]SOOiu/wv?sc>ˈ%׮XȴY Xc 㧕[ĴZN( [1YG];>%-_ȴ iN]P뺾[jg7u|V[G8U;;Xo\s>ġC}k,zc;s\"h9է>_5/"""""OP&Ƒ;.֭ԮLq*K,e:<`92rqd`?.ʥ&ő7.Qea2V|]ޟuj/N/%))Fuhim|\q` Ʋ8Ul2\[ݕsmOG2][=o{tmXrs2\[s VQ.~?.sjƟ;ǟȹH{PhJq%(EDDDDDDDDmQRDDDDDDDDDF Jq%(EDDDDDDDDmQRDDDDDDDDDF Jq%(EDDDDDDDDmQRDDDDDDDDDF Jq%(EDHMswSDDDDDDdx""^Gsq镫߾_t nQt~bF$j:c/"w7ODDDDD@ Js'gN"{D2)bB>پ6msYfRHr2:{~`q&w7X6/$\M ̟6 #)=v ߫>ݷdLp;LQ1'<4,ÓyyYGaIyFqE,-}H JPRD,{GdJ{=v<ͲHM;_y씠thͼEʎ x{y Eo/}2x,<ˆxzK\T8v.|c]~m9w۵/j ߫u6Io/nr7}e)bF$?/=,{;SgN-̛7y쟴xzzpqY˸Ǻ'`CrDDbdLfC:P1pO [gY6~> ~xzz+zקNFjFų՝7ɿ!).z@;;W_ħ;xͬ֋ۇ_?B{r- 2߷Oqׇ3:wM;x͵C74R[_|Ly9)T&8П9y9Wss wQNTVqɢD qYODDDDJ3(EDbXRc'~c,΍Of0<=llߗrY,ߏ.^ĬٌHn>pxk6vz7._.Z}z6stVF'3PS[@rB ]8w>ڼ7fł|m|2Sٱ/eٌ$åIO!,4}]SK3C~a O̚ /y75J Kϛz}c\y<6lQ\0''sM`׭X̉L®G]qb>~?|D/0)|ŋxN&dfY|e洽&[xc'\x2x}""gOd-9RY67il 2vrO _o)c6>| }[Z:,X8}<}>"a!A\0g s?SW۟_R~0F$'(c"Ø o~ОIp,]ڲG2,!on.",Q8$_\c5e wx_/M cYa w/54X :CG;A hq ٓ??:G6liYMLG[vq/ҹS=q#Og_u*">2 cY,Gyf+-v?E7'`NZ  f+(dæbÉj KHpyhY_y~|Gųx5f#'{(m #Xt(,=\ɺOrB )>xSX©yw׏'O㺋y͵`Ǿ Ǵ-Wv6ÅƚM[;WR~ۿx^v, Y#Xx]f?~CL}9Y۹WҾ4w?bݧ;xǷ{r F`CEթXXHW_8y` 2κOQ]}_Y:uܟ{}}js} G^^\}<*O|h6vLOkR5]4b\.Y4_o%p݊x?cg_DDDDD%(EDʌ+o\ͲlL^z.N'6reC Ήb"9XPLq rmޅÇ?bgߡ#d)f*kjJK )> CҴwSr<*k=/ ,Gf၅w|.}}C]cyXHW_4%Ǝ%+(1,(";1@zߝ ?~Vl^<{]2^[CBy?9̞2*T:fPm]ю\xO}L{\~۽]ۯqs""c 6䶟=̄7?; r2n.X\gpLNq$26e+0Fuz|JP? 1lߛj'qX| XNKʝܶo_Oﯹw:(=VCG cbNɶ=hjnu.P~.B1OT H҇+]^/k}|hlddCr\Tٯ ,/~e $D|_\0/{$e8"AyOuZç;#qA)"r>Y^|R,6t1+{kϜv}`Ge9KMy KžC'(ƻW˼~c[~ ONŝzx3&dddZouđ41$8k/{?}uhPyǪ`צ>?lXe* ٤Od .g?ÇCGg߻`AQڻc!r2RÚTVDDDDl9[ijn&+-?_%@Ӣ]%\' ʰ D0*,,njɎھMDXvcgä$8$ph)8!۲L/M]% ;楷rղ̙2 STv??r_;QISs3bSPT5ۯ''Ҟkq DwwwݱeǟA*{x}t%&ɳO鱊> :!,""""rQRD6|h ^wNN#_cHqM K!$(1Ή]caH!51CGJ9YWY dH&9.ͻ\^&6Ellnl1_xDXz-vZ gNK{tp`Y\a@t&Ǻ{z @ JGXm,mX<3'fc_>oկw~&~?\~Dr`XmYlɬ){\Nm׬1ҕW:hhlWۋV,tmHp W?ںzVӵW0,!ѣcAv<&f$*2xϦ{ &6Btq)9!7*aZ>ۯ{},c8QYo|t&Gز4^y_/O9_Y:=0bYw'tv-pe?{?{M/7]qM464_BcINO)=Vyg늈 A)"r=1yO~.v8LAQIqKR\4淟|:e"j=CO♓$Fvv"%s [?%Nvg|"ybO>+gLf.3Gsi_g2 }=j'/u%\t6/>m{Ko X S ;* ,>p, v/7t*f# Ow?>İdM>`ma0Ϝ̭_[NBtk?qs^:KS|dTlikʆ|4߫qRʒ,3?_>w N;M߻v 1n3mAJҒTWq`Y'G$ 8r3xwOR[\۽ Ǝ^I οSY`vcg}<+a6_G;0kX9ux0s`ׁrIqzr,̛ebY`[kʹ&!bVdZ\%62 Od&¤ѷ׀01./]Һ 5gf7.a嚍N Jc 7{۵\07es1((OH8~/1v>ٶG:/NyN^Ny2,x} cFa/Wyyyoˋw>̿Zll=)޵:x$L ճ~.3|) Lw3":ba?\D3^IRUss4^|TUגsѷMB}F(iNxASCIIScreenshotE %tEXtdate:create2023-02-03T11:16:23+00:00\%%tEXtdate:modify2023-02-03T11:16:23+00:00K(tEXtdate:timestamp2023-02-03T11:16:45+00:00VtEXtexif:ExifOffset78{'tEXtexif:PixelXDimension794CtEXtexif:PixelYDimension682\#tEXtexif:UserCommentASCII...Screenshot+ȚI(tEXticc:copyrightCopyright Apple Inc., 2023 tEXticc:descriptionDisplaytEXtxmp:PixelXDimension794tEXtxmp:PixelYDimension6827tEXtxmp:UserCommentScreenshot|IENDB`ripe-atlas-tools-3.1.0/scripts/000077500000000000000000000000001437041663000164055ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/adig000077700000000000000000000000001437041663000212132ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/ahttp000077700000000000000000000000001437041663000214272ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/antp000077700000000000000000000000001437041663000212512ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/aping000077700000000000000000000000001437041663000214052ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/asslcert000077700000000000000000000000001437041663000221272ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/atraceroute000077700000000000000000000000001437041663000226252ripe-atlasustar00rootroot00000000000000ripe-atlas-tools-3.1.0/scripts/ripe-atlas000077500000000000000000000113311437041663000203730ustar00rootroot00000000000000#!/usr/bin/env python3 import os import re import sys from ripe.atlas.tools.commands.base import Command, Factory from ripe.atlas.tools.commands.measure import Factory as BaseFactory from ripe.atlas.tools.exceptions import RipeAtlasToolsException class RipeAtlas(object): def __init__(self): self.command = None self.args = [] self.kwargs = {} def _generate_usage(self): usage = "Usage: ripe-atlas [arguments]\n\n" usage += "Commands:\n" longest_command = 0 classes = [] for c in Command.get_available_commands(): if c == "shibboleet": continue cmd_class = Command.load_command_class(c) classes.append(cmd_class) cmd_name = cmd_class.get_name() if len(cmd_name) > longest_command: longest_command = len(cmd_name) for cmd_cls in classes: usage += "\t{} {}\n".format( cmd_cls.get_name().ljust(longest_command + 1), cmd_cls.DESCRIPTION, ) usage += ( "\nFor help on a particular command, try " "ripe-atlas --help" ) return usage def _set_base_command(self): """ Sets the base command covering cases where we call it with shortcut or asking for help. """ caller = os.path.basename(sys.argv[0]) shortcut = re.match('^a(ping|traceroute|dig|sslcert|ntp|http)$', caller) if shortcut: self.command = "measure" sys.argv.insert(1, self._translate_shortcut(shortcut.group(1))) return if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help"): self.command = "help" return self.command = sys.argv.pop(1) @staticmethod def _translate_shortcut(shortcut): if shortcut == "dig": return "dns" return shortcut def autocomplete(self): """ This function is highly inspired from Django's own autocomplete manage.py. For more documentation check https://github.com/django/django/blob/1.9.4/django/core/management/__init__.py#L198-L270 """ def print_options(options, curr): """ Prints matching with current word available autocomplete options in a formatted way to look good on bash. """ sys.stdout.write(' '.join(sorted(filter(lambda x: x.startswith(curr), options)))) # If we are not autocompleting continue as normal if 'RIPE_ATLAS_AUTO_COMPLETE' not in os.environ: return cwords = os.environ['COMP_WORDS'].split()[1:] cword = int(os.environ['COMP_CWORD']) try: curr = cwords[cword - 1] except IndexError: curr = '' commands = list(Command.get_available_commands()) # base caller ripe-atlas if cword == 1: print_options(commands, curr) # special measure command elif cword == 2 and cwords[0] == "measure": print_options(BaseFactory.TYPES.keys(), curr) # rest of commands elif cwords[0] in commands: cmd = self.fetch_command_class(cwords[0], cwords) cmd.add_arguments() options = [sorted(s_opt.option_strings)[0] for s_opt in cmd.parser._actions if s_opt.option_strings] previous_options = [x for x in cwords[1:cword - 1]] options = [opt for opt in options if opt not in previous_options] print_options(options, curr) sys.exit(1) def fetch_command_class(self, command, arg_options): """Fetches the class responsible for the given command.""" cmd_cls = Command.load_command_class(command) if cmd_cls is None: # Module containing the command class wasn't found raise RipeAtlasToolsException("No such command") # # If the imported module contains a `Factory` class, execute that # to get the `cmd` we're going to use. Otherwise, we expect there # to be a `Command` class in there. # if issubclass(cmd_cls, Factory): cmd = cmd_cls(arg_options).create() else: cmd = cmd_cls(*self.args, **self.kwargs) return cmd def main(self): self._set_base_command() self.autocomplete() if self.command == "help": raise RipeAtlasToolsException(self._generate_usage()) cmd = self.fetch_command_class(self.command, sys.argv) cmd.init_args() cmd.run() if __name__ == '__main__': try: sys.exit(RipeAtlas().main()) except RipeAtlasToolsException as e: e.write() raise SystemExit() ripe-atlas-tools-3.1.0/setup.py000066400000000000000000000043271437041663000164360ustar00rootroot00000000000000import os from os.path import abspath, dirname, join from setuptools import setup __version__ = None exec(open("ripe/atlas/tools/version.py").read()) # Allow setup.py to be run from any path os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir))) # Get proper long description for package current_dir = dirname(abspath(__file__)) description = open(join(current_dir, "README.rst")).read() changes = open(join(current_dir, "CHANGES.rst")).read() long_description = "\n\n".join([description, changes]) # Get the long description from README.md setup( name="ripe.atlas.tools", version=__version__, packages=["ripe", "ripe.atlas", "ripe.atlas.tools"], namespace_packages=["ripe", "ripe.atlas"], include_package_data=True, license="GPLv3", description="The official command line client for RIPE Atlas", long_description=long_description, url="https://github.com/RIPE-NCC/ripe-atlas-tools", download_url="https://github.com/RIPE-NCC/ripe-atlas-tools", author="The RIPE Atlas team", author_email="atlas@ripe.net", maintainer="The RIPE Atlas team", maintainer_email="atlas@ripe.net", install_requires=[ "IPy", "python-dateutil", "requests>=2.7.0", "ripe.atlas.cousteau~=2.0.0", "ripe.atlas.sagan>=1.2,<2", "tzlocal", "pyyaml", "pyOpenSSL>=0.13", "typing-extensions", ], extras_require={ "doc": ["sphinx", "sphinx_rtd_theme"], "fast": ["ujson"], }, scripts=[ "scripts/aping", "scripts/atraceroute", "scripts/adig", "scripts/asslcert", "scripts/ahttp", "scripts/antp", "scripts/ripe-atlas", ], keywords=["RIPE", "RIPE NCC", "RIPE Atlas", "Command Line"], classifiers=[ "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Operating System :: POSIX", "Operating System :: Unix", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Topic :: Internet :: WWW/HTTP", ], ) ripe-atlas-tools-3.1.0/tests/000077500000000000000000000000001437041663000160605ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/tests/README000066400000000000000000000001501437041663000167340ustar00rootroot00000000000000How to run tests Make sure you have nose installed and run from the main directory: nosetests tests ripe-atlas-tools-3.1.0/tests/__init__.py000066400000000000000000000012321437041663000201670ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . ripe-atlas-tools-3.1.0/tests/aggregators/000077500000000000000000000000001437041663000203655ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/tests/aggregators/__init__.py000066400000000000000000000012321437041663000224740ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . ripe-atlas-tools-3.1.0/tests/aggregators/test_aggregators.py000066400000000000000000001254151437041663000243130ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from collections import namedtuple from ripe.atlas.tools.aggregators.base import ( aggregate, ValueKeyAggregator, RangeKeyAggregator, ) class TestAggregators(unittest.TestCase): def setUp(self): self.results = [] self.probes = [] self.Result = namedtuple("Result", "id probe rtt source prefix") self.Probe = namedtuple("Probe", "id country asn status") probes = [ (1, "GR", 333, "Connected"), (2, "NL", 334, "Connected"), (3, "SE", 335, "Connected"), (4, "SE", 336, "DisConnected"), (5, "SE", 337, "DisConnected"), (6, "SE", 335, "DisConnected"), (7, "IN", 335, "Connected"), (8, "DE", 338, "Connected"), (9, "DK", 348, "Connected"), (10, "DE", 338, "NeverConnected"), (11, "DE", 340, "DisConnected"), ] results = [ (1, 3, "127.0.0.1", "192/8"), (2, 34.0, "127.0.0.1", "192/8"), (3, 35.0, "127.0.0.1", "193/8"), (4, 6, "127.0.0.1", "193/8"), (5, 17, "127.0.0.1", "192/8"), (6, 15, "127.0.0.1", "195/8"), (7, 35, "127.0.0.1", "192/8"), (8, 28, "127.0.0.1", "192/8"), (9, 48, "127.0.0.1", "195/8"), (10, 28, "127.0.0.1", "194/8"), (11, 40, "127.0.0.1", "193/8"), ] for index, result in enumerate(results): prb = self.Probe( id=probes[index][0], country=probes[index][1], asn=probes[index][2], status=probes[index][3], ) r = self.Result( id=result[0], probe=prb, rtt=result[1], source=result[2], prefix=result[3], ) self.results.append(r) self.probes.append(prb) def test_value_aggregation(self): """Test 2 tier aggregation with object attribute as key.""" keys = [ ValueKeyAggregator(key="probe.country"), ValueKeyAggregator(key="rtt"), ] buckets = aggregate(self.results, keys) expected_output = { "COUNTRY: DE | RTT: 28": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ), rtt=28, source="127.0.0.1", prefix="194/8", ), ], "COUNTRY: DE | RTT: 40": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "COUNTRY: DK | RTT: 48": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], "COUNTRY: GR | RTT: 3": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: IN | RTT: 35": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: NL | RTT: 34.0": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: SE | RTT: 6": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], "COUNTRY: SE | RTT: 15": [ self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ) ], "COUNTRY: SE | RTT: 17": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: SE | RTT: 35.0": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ) ], } self.assertEqual(buckets, expected_output) def test_value_aggregation1(self): """Test 1 tier aggregation""" keys = [ValueKeyAggregator(key="probe.country")] buckets = aggregate(self.results, keys) expected_output = { "COUNTRY: DE": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ), rtt=28, source="127.0.0.1", prefix="194/8", ), self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ), ], "COUNTRY: DK": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], "COUNTRY: GR": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: IN": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: NL": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "COUNTRY: SE": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ), self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ), self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], } self.assertEqual(buckets, expected_output) def test_value_aggregation2(self): """Test 2 tier aggregation.""" keys = [ ValueKeyAggregator(key="prefix"), ValueKeyAggregator(key="rtt"), ] buckets = aggregate(self.results, keys) expected_output = { "PREFIX: 192/8 | RTT: 3": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 17": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 28": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 34.0": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 35": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 193/8 | RTT: 6": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 193/8 | RTT: 35.0": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 193/8 | RTT: 40": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 194/8 | RTT: 28": [ self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected", ), rtt=28, source="127.0.0.1", prefix="194/8", ) ], "PREFIX: 195/8 | RTT: 15": [ self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ) ], "PREFIX: 195/8 | RTT: 48": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], } self.assertEqual(buckets, expected_output) def test_value_aggregation3(self): """Test 3 tier aggregation.""" keys = [ ValueKeyAggregator(key="prefix"), ValueKeyAggregator(key="rtt"), ValueKeyAggregator(key="source"), ] buckets = aggregate(self.results, keys) expected_output = { "PREFIX: 192/8 | RTT: 3 | SOURCE: 127.0.0.1": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 17 | SOURCE: 127.0.0.1": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected", ), rtt=17, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 28 | SOURCE: 127.0.0.1": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 34.0 | SOURCE: 127.0.0.1": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 192/8 | RTT: 35 | SOURCE: 127.0.0.1": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "PREFIX: 193/8 | RTT: 6 | SOURCE: 127.0.0.1": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected", ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 193/8 | RTT: 35.0 | SOURCE: 127.0.0.1": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 193/8 | RTT: 40 | SOURCE: 127.0.0.1": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected", ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "PREFIX: 194/8 | RTT: 28 | SOURCE: 127.0.0.1": [ self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected", ), rtt=28, source="127.0.0.1", prefix="194/8", ) ], "PREFIX: 195/8 | RTT: 15 | SOURCE: 127.0.0.1": [ self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected", ), rtt=15, source="127.0.0.1", prefix="195/8", ) ], "PREFIX: 195/8 | RTT: 48 | SOURCE: 127.0.0.1": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], } self.assertEqual(buckets, expected_output) def test_value_aggregation4(self): """Test 2 tier aggregation with probes.""" keys = [ ValueKeyAggregator(key="status"), ValueKeyAggregator(key="asn"), ] buckets = aggregate(self.probes, keys) expected_output = { "STATUS: Connected | ASN: 338": [ self.Probe(id=8, country="DE", asn=338, status="Connected") ], "STATUS: Connected | ASN: 348": [ self.Probe(id=9, country="DK", asn=348, status="Connected") ], "STATUS: Connected | ASN: 333": [ self.Probe(id=1, country="GR", asn=333, status="Connected") ], "STATUS: Connected | ASN: 334": [ self.Probe(id=2, country="NL", asn=334, status="Connected") ], "STATUS: Connected | ASN: 335": [ self.Probe(id=3, country="SE", asn=335, status="Connected"), self.Probe(id=7, country="IN", asn=335, status="Connected"), ], "STATUS: DisConnected | ASN: 336": [ self.Probe(id=4, country="SE", asn=336, status="DisConnected") ], "STATUS: DisConnected | ASN: 337": [ self.Probe(id=5, country="SE", asn=337, status="DisConnected") ], "STATUS: DisConnected | ASN: 340": [ self.Probe(id=11, country="DE", asn=340, status="DisConnected") ], "STATUS: DisConnected | ASN: 335": [ self.Probe(id=6, country="SE", asn=335, status="DisConnected") ], "STATUS: NeverConnected | ASN: 338": [ self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ) ], } self.assertEqual(buckets, expected_output) def test_range_aggregation(self): """Test 1 tier range aggregation""" keys = [RangeKeyAggregator(ranges=[10, 20, 30, 40, 50], key="rtt")] buckets = aggregate(self.results, keys) expected_output = { "RTT: 10-20": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], "RTT: 20-30": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ), rtt=28, source="127.0.0.1", prefix="194/8", ), ], "RTT: 30-40": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ), self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ), self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ), self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ), ], "RTT: 40-50": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], "RTT: < 10": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ), self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ), ], } self.maxDiff = None import pprint pp = pprint.PrettyPrinter() pp.pprint(buckets) self.assertEqual(buckets, expected_output) def test_range_aggregation1(self): """Test 1 tier range aggregation (1)""" keys = [ RangeKeyAggregator(ranges=[10, 20, 30, 35, 40, 50, 60], key="rtt") ] buckets = aggregate(self.results, keys) expected_output = { "RTT: 10-20": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], "RTT: 20-30": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ), rtt=28, source="127.0.0.1", prefix="194/8", ), ], "RTT: 30-35": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ), self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ), self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ), ], "RTT: 35-40": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "RTT: 40-50": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], "RTT: < 10": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ), self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ), ], } self.assertEqual(buckets, expected_output) def test_range_aggregation2(self): """Test 1 tier range aggregation (2)""" keys = [RangeKeyAggregator(ranges=[1, 5, 10, 20, 30, 35], key="rtt")] buckets = aggregate(self.results, keys) expected_output = { "RTT: 1-5": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "RTT: 10-20": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], "RTT: 20-30": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected" ), rtt=28, source="127.0.0.1", prefix="194/8", ), ], "RTT: 30-35": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ), self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ), self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ), ], "RTT: 5-10": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], "RTT: > 35": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ), self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ), ], } self.assertEqual(buckets, expected_output) def test_mixed_aggregation(self): """Test value and range aggregation together""" keys = [ RangeKeyAggregator(ranges=[1, 5, 10, 20, 30, 35], key="rtt"), ValueKeyAggregator(key="probe.country"), ] buckets = aggregate(self.results, keys) expected_output = { "RTT: 1-5 | COUNTRY: GR": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "RTT: 10-20 | COUNTRY: SE": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected" ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected" ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], "RTT: 20-30 | COUNTRY: DE": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ), self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected", ), rtt=28, source="127.0.0.1", prefix="194/8", ), ], "RTT: 30-35 | COUNTRY: IN": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "RTT: 30-35 | COUNTRY: NL": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "RTT: 30-35 | COUNTRY: SE": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ) ], "RTT: 5-10 | COUNTRY: SE": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected" ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], "RTT: > 35 | COUNTRY: DE": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected" ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "RTT: > 35 | COUNTRY: DK": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], } self.assertEqual(buckets, expected_output) def test_mixed_aggregation1(self): """Test value and range aggregation together (1)""" keys = [ RangeKeyAggregator(ranges=[10, 200], key="rtt"), ValueKeyAggregator(key="probe.country"), ValueKeyAggregator(key="probe.status"), ] buckets = aggregate(self.results, keys) expected_output = { "RTT: 10-200 | COUNTRY: DE | STATUS: Connected": [ self.Result( id=8, probe=self.Probe( id=8, country="DE", asn=338, status="Connected" ), rtt=28, source="127.0.0.1", prefix="192/8", ) ], "RTT: 10-200 | COUNTRY: DE | STATUS: DisConnected": [ self.Result( id=11, probe=self.Probe( id=11, country="DE", asn=340, status="DisConnected", ), rtt=40, source="127.0.0.1", prefix="193/8", ) ], "RTT: 10-200 | COUNTRY: DE | STATUS: NeverConnected": [ self.Result( id=10, probe=self.Probe( id=10, country="DE", asn=338, status="NeverConnected", ), rtt=28, source="127.0.0.1", prefix="194/8", ) ], "RTT: 10-200 | COUNTRY: DK | STATUS: Connected": [ self.Result( id=9, probe=self.Probe( id=9, country="DK", asn=348, status="Connected" ), rtt=48, source="127.0.0.1", prefix="195/8", ) ], "RTT: 10-200 | COUNTRY: IN | STATUS: Connected": [ self.Result( id=7, probe=self.Probe( id=7, country="IN", asn=335, status="Connected" ), rtt=35, source="127.0.0.1", prefix="192/8", ) ], "RTT: 10-200 | COUNTRY: NL | STATUS: Connected": [ self.Result( id=2, probe=self.Probe( id=2, country="NL", asn=334, status="Connected" ), rtt=34.0, source="127.0.0.1", prefix="192/8", ) ], "RTT: 10-200 | COUNTRY: SE | STATUS: Connected": [ self.Result( id=3, probe=self.Probe( id=3, country="SE", asn=335, status="Connected" ), rtt=35.0, source="127.0.0.1", prefix="193/8", ) ], "RTT: 10-200 | COUNTRY: SE | STATUS: DisConnected": [ self.Result( id=5, probe=self.Probe( id=5, country="SE", asn=337, status="DisConnected", ), rtt=17, source="127.0.0.1", prefix="192/8", ), self.Result( id=6, probe=self.Probe( id=6, country="SE", asn=335, status="DisConnected", ), rtt=15, source="127.0.0.1", prefix="195/8", ), ], "RTT: < 10 | COUNTRY: GR | STATUS: Connected": [ self.Result( id=1, probe=self.Probe( id=1, country="GR", asn=333, status="Connected" ), rtt=3, source="127.0.0.1", prefix="192/8", ) ], "RTT: < 10 | COUNTRY: SE | STATUS: DisConnected": [ self.Result( id=4, probe=self.Probe( id=4, country="SE", asn=336, status="DisConnected", ), rtt=6, source="127.0.0.1", prefix="193/8", ) ], } self.assertEqual(buckets, expected_output) ripe-atlas-tools-3.1.0/tests/base.py000066400000000000000000000033251437041663000173470ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import sys from contextlib import contextmanager from io import StringIO class FakeTTY(object): """ Basic simulation of a user terminal. """ def __init__(self, file_obj): self.file_obj = file_obj def __getattr__(self, name): return getattr(self.file_obj, name) def isatty(self): return True @contextmanager def capture_sys_output(use_fake_tty=False): """ Wrap a block with this, and it'll capture standard out and standard error into handy variables: with capture_sys_output() as (stdout, stderr): self.cmd.run() More info: https://stackoverflow.com/questions/18651705/ """ capture_out, capture_err = StringIO(), StringIO() current_out, current_err = sys.stdout, sys.stderr current_in = sys.stdin try: if use_fake_tty: sys.stdin = FakeTTY(current_in) sys.stdout, sys.stderr = capture_out, capture_err yield capture_out, capture_err finally: sys.stdout, sys.stderr = current_out, current_err sys.stdin = current_in ripe-atlas-tools-3.1.0/tests/commands/000077500000000000000000000000001437041663000176615ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/tests/commands/__init__.py000066400000000000000000000012321437041663000217700ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . ripe-atlas-tools-3.1.0/tests/commands/test_alias.py000066400000000000000000000135701437041663000223710ustar00rootroot00000000000000# Copyright (c) 2016 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import copy import unittest from unittest import mock from ripe.atlas.tools.commands.alias import Command from ripe.atlas.tools.exceptions import RipeAtlasToolsException from ripe.atlas.tools.settings import AliasesDB from ..base import capture_sys_output class FakeAliasesDB(AliasesDB): @staticmethod def write(aliases): pass class TestAliasCommand(unittest.TestCase): ALIASES_PATH = "ripe.atlas.tools.commands.alias.aliases" ALIASES = {"measurement": {"msm1": 1}, "probe": {"prb1": 1}} ALIASES_CLASS_PATH = "ripe.atlas.tools.commands.alias.AliasesDB" def setUp(self): self.cmd = Command() self.aliases = copy.deepcopy(TestAliasCommand.ALIASES) mock.patch(self.ALIASES_CLASS_PATH, FakeAliasesDB).start() def tearDown(self): mock.patch.stopall() def test_no_arguments(self): with capture_sys_output(): with self.assertRaises(RipeAtlasToolsException) as e: self.cmd.init_args([]) self.cmd.run() self.assertTrue(str(e.exception).startswith("Action not given.")) def test_bad_action(self): with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["test"]) def test_bad_target_id(self): with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): self.cmd.init_args("add probe a b".split()) err = stderr.getvalue().split("\n")[-2] self.assertEqual( err, "Ripe-atlas alias add: error: argument target: invalid int value: 'a'" ) def test_add_args(self): for alias_type in ("probe", "measurement"): with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["add", alias_type]) with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["add", alias_type, "1"]) with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["add", alias_type, "1", "1"]) try: cmd = Command() cmd.init_args(["add", alias_type, "1", "one"]) except Exception as e: self.fail("Failed with {}".format(str(e))) def test_del_args(self): for alias_type in ("probe", "measurement"): with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["del", alias_type]) with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["del", alias_type, "1"]) try: cmd = Command() cmd.init_args(["del", alias_type, "one"]) except Exception as e: self.fail("Failed with {}".format(str(e))) def test_bad_alias(self): with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): self.cmd.init_args("add measurement 1 bad+alias".split()) err = stderr.getvalue().split("\n")[-2] self.assertEqual( err, "Ripe-atlas alias add: error: argument alias: " '"bad+alias" does not appear to be a valid alias.', ) def test_show_msm_ok(self): path = "ripe.atlas.tools.commands.alias.Command.ok" with mock.patch(path) as mock_ok: with mock.patch(self.ALIASES_PATH, self.aliases): self.cmd.init_args("show measurement msm1".split()) self.cmd.run() mock_ok.assert_called_once() def test_show_msm_ko(self): path = "ripe.atlas.tools.commands.alias.Command.not_ok" with mock.patch(path) as mock_ko: with mock.patch(self.ALIASES_PATH, self.aliases): self.cmd.init_args("show measurement msm2".split()) self.cmd.run() mock_ko.assert_called_once() def test_add_msm(self): with mock.patch(self.ALIASES_PATH, self.aliases): self.cmd.init_args("add measurement 2 msm2".split()) self.cmd.run() self.assertTrue("msm2" in self.aliases["measurement"]) self.assertEqual(self.aliases["measurement"]["msm2"], 2) def test_del_msm(self): self.assertTrue("msm1" in self.aliases["measurement"]) with mock.patch(self.ALIASES_PATH, self.aliases): self.cmd.init_args("del measurement msm1".split()) self.cmd.run() self.assertFalse("msm1" in self.aliases["measurement"]) def test_list(self): path = "ripe.atlas.tools.commands.alias.Command.ok" with mock.patch(path) as mock_ok: self.aliases["measurement"]["msm2"] = 2 self.aliases["measurement"]["abc"] = 123 with mock.patch(self.ALIASES_PATH, self.aliases): self.cmd.init_args("list measurement".split()) self.cmd.run() mock_ok.assert_called_once_with( "Measurement aliases:\n\n- abc: 123\n- msm1: 1\n- msm2: 2\n" ) ripe-atlas-tools-3.1.0/tests/commands/test_base.py000066400000000000000000000061651437041663000222140ustar00rootroot00000000000000# coding=utf-8 # Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from unittest import mock from io import StringIO from ripe.atlas.tools.commands import base from ripe.atlas.tools.version import __version__ class TestBaseCommand(unittest.TestCase): SAMPLE_PLATFORM = "Linux-5.4.0-91-generic-x86_64-with-glibc2.29" @mock.patch("ripe.atlas.tools.commands.base.open") def test_user_agent_configured(self, mock_open): tests = { "Some Cool User Agent String": "Some Cool User Agent String", "Some custom agent\nwith a second line": "Some custom agent", "x" * 3000: "x" * 128, "Πράκτορας χρήστη": "Πράκτορας χρήστη", "이것은 테스트 요원": "이것은 테스트 요원", } for contents, expected in tests.items(): s = StringIO(contents) mock_open.return_value = s cmd = base.Command() self.assertEqual(cmd.user_agent, expected) @mock.patch("platform.system", return_value="Darwin") @mock.patch("platform.mac_ver", return_value=("11.6", ("", "", ""), "x86_64")) def test_user_agent_mac(self, *mocks): cmd = base.Command() self.assertEqual(cmd.user_agent, f"RIPE Atlas Tools [macOS 11.6] {__version__}") @mock.patch("platform.system", return_value="Windows") @mock.patch( "platform.win32_ver", return_value=("10", "10.0.10240", "", "Multiprocessor Free"), ) def test_user_agent_windows(self, *mocks): cmd = base.Command() self.assertEqual(cmd.user_agent, f"RIPE Atlas Tools [Windows 10] {__version__}") @mock.patch("platform.system", return_value="Linux") @mock.patch( "ripe.atlas.tools.helpers.xdg.freedesktop_os_release", return_value={ "NAME": "Debian GNU/Linux", "VERSION_ID": "10", }, ) def test_user_agent_xdg_present(self, *mocks): cmd = base.Command() self.assertEqual( cmd.user_agent, f"RIPE Atlas Tools [Debian GNU/Linux 10] {__version__}" ) @mock.patch("platform.system", return_value="Linux") @mock.patch("platform.platform", return_value=SAMPLE_PLATFORM) @mock.patch( "ripe.atlas.tools.helpers.xdg.freedesktop_os_release", side_effect=OSError ) def test_user_agent_xdg_absent(self, *mocks): cmd = base.Command() self.assertEqual( cmd.user_agent, f"RIPE Atlas Tools [{self.SAMPLE_PLATFORM}] {__version__}", ) ripe-atlas-tools-3.1.0/tests/commands/test_loading.py000066400000000000000000000066301437041663000227140ustar00rootroot00000000000000import os.path import unittest import tempfile import shutil import sys from unittest import mock from io import StringIO from ripe.atlas.tools.commands.base import Command USER_COMMAND = """ from ripe.atlas.tools.commands.base import Command as BaseCommand class Command(BaseCommand): NAME = 'user-command-1' """ class TestCommandLoading(unittest.TestCase): expected_builtins = [ "configure", "alias", "go", "measure", "measurement-info", "measurement-search", "probe-info", "probe-search", "report", "shibboleet", "stream", ] def setUp(self): # Create a directory for storing user commands and insert the dummy # command self.user_command_path = tempfile.mkdtemp() with open(os.path.join(self.user_command_path, "user_command_1.py"), "w") as f: f.write(USER_COMMAND) def tearDown(self): shutil.rmtree(self.user_command_path) @mock.patch( "ripe.atlas.tools.commands.base.Command._get_user_command_path", return_value=None, ) def test_command_loading(self, _get_user_command_path): _get_user_command_path.return_value = self.user_command_path # For some reason the command classes are initialized in some envs # but not in others at this point if Command._commands: Command._commands.clear() Command._load_commands() available_commands = Command.get_available_commands() # Check that we have the command list that we expect self.assertEqual( sorted(available_commands), sorted( [b.replace("-", "_") for b in self.expected_builtins] + ["user_command_1"] ), ) # Check that we can load (i.e. import) every builtin command for expected_builtin in self.expected_builtins: self.assertIn(expected_builtin.replace("-", "_"), available_commands) cmd_cls = Command.load_command_class(expected_builtin) self.assertIsNotNone(cmd_cls) self.assertEqual(cmd_cls.get_name(), expected_builtin) # Check that we can load the user command user_cmd_cls = Command.load_command_class("user-command-1") self.assertIsNotNone(user_cmd_cls) self.assertEqual(user_cmd_cls.get_name(), "user-command-1") # Check that load_command_class() returns None for junk commands unexpected_cmd = Command.load_command_class("no-such-command") self.assertIsNone(unexpected_cmd) def test_deprecated_aliases(self): aliases = [ ("measurement", "measurement-info"), ("measurements", "measurement-search"), ("probe", "probe-info"), ("probes", "probe-search"), ] # Check that each alias is loaded correctly and outputs a warning stderr = sys.stderr sys.stderr = StringIO() try: for alias, cmd_name in aliases: sys.stderr.truncate() cmd_cls = Command.load_command_class(alias) self.assertIn( "{} is a deprecated alias for {}".format(alias, cmd_name), sys.stderr.getvalue(), ) self.assertIsNotNone(cmd_cls) self.assertEqual(cmd_cls.get_name(), cmd_name) finally: sys.stderr = stderr ripe-atlas-tools-3.1.0/tests/commands/test_measure.py000066400000000000000000001357311437041663000227450ustar00rootroot00000000000000# -*- coding: UTF-8 -*- # Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import copy import json import os import tempfile import unittest from io import StringIO from random import randint from unittest import mock from ripe.atlas.tools.commands.measure.base import Command from ripe.atlas.tools.commands.measure import ( PingMeasureCommand, TracerouteMeasureCommand, DnsMeasureCommand, SslcertMeasureCommand, HttpMeasureCommand, NtpMeasureCommand, SpecMeasureCommand, ) from ripe.atlas.tools.exceptions import RipeAtlasToolsException from ripe.atlas.tools.settings import Configuration, AliasesDB from ..base import capture_sys_output class TestMeasureCommand(unittest.TestCase): CONF = "ripe.atlas.tools.commands.measure.base.conf" KINDS = { "ping": PingMeasureCommand, "traceroute": TracerouteMeasureCommand, "dns": DnsMeasureCommand, "sslcert": SslcertMeasureCommand, "http": HttpMeasureCommand, "ntp": NtpMeasureCommand, } def setUp(self): self.maxDiff = None def test_no_arguments(self): with capture_sys_output(): with self.assertRaises(RipeAtlasToolsException) as e: Command().init_args([]) self.assertTrue(str(e.exception).startswith("Usage: ripe-atlas measure <")) def test_bad_type_argument(self): with capture_sys_output(): with self.assertRaises(RipeAtlasToolsException) as e: Command().init_args(["not-a-type"]) self.assertTrue(str(e.exception).startswith("Usage: ripe-atlas measure <")) @mock.patch(CONF, Configuration.DEFAULT) def test_dry_run(self): with capture_sys_output() as (stdout, stderr): cmd = PingMeasureCommand() cmd.init_args(["ping", "--target", "ripe.net", "--dry-run"]) cmd.run() expected = ( "\n" "Definitions:\n" "================================================================================\n" # noqa: E501 "target ripe.net\n" "packet_interval 1000\n" "description Ping measurement to ripe.net\n" "af 4\n" "packets 3\n" "size 48\n" "\n" "Sources:\n" "================================================================================\n" # noqa: E501 "requested 50\n" "type area\n" "value WW\n" "tags\n" " include system-ipv4-works\n" " exclude \n" "\n" ) self.assertEqual( set(stdout.getvalue().split("\n")), set(expected.split("\n")) ) with capture_sys_output() as (stdout, stderr): cmd = PingMeasureCommand() cmd.init_args( [ "ping", "--target", "ripe.net", "--af", "6", "--include-tag", "alpha", "--include-tag", "bravo", "--include-tag", "charlie", "--exclude-tag", "delta", "--exclude-tag", "echo", "--exclude-tag", "foxtrot", "--dry-run", ] ) cmd.run() expected = ( "\n" "Definitions:\n" "================================================================================\n" # noqa: E501 "target ripe.net\n" "packet_interval 1000\n" "description Ping measurement to ripe.net\n" "af 6\n" "packets 3\n" "size 48\n" "\n" "Sources:\n" "================================================================================\n" # noqa: E501 "requested 50\n" "type area\n" "value WW\n" "tags\n" " include alpha, bravo, charlie\n" " exclude delta, echo, foxtrot\n" "\n" ) self.assertEqual( set(stdout.getvalue().split("\n")), set(expected.split("\n")) ) def test_clean_target(self): cmd = PingMeasureCommand() with capture_sys_output(): cmd.init_args(["ping", "--target", "ripe.net"]) self.assertEqual(cmd.clean_target(), "ripe.net") cmd = DnsMeasureCommand() with capture_sys_output(): cmd.init_args(["dns", "--query-argument", "ripe.net"]) self.assertEqual(cmd.clean_target(), None) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_ping(self): spec = Configuration.DEFAULT["specification"]["types"]["ping"] cmd = PingMeasureCommand() cmd.init_args(["ping", "--target", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Ping measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "packet_interval": spec["packet-interval"], "size": spec["size"], }, ) # Test using positional target cmd = PingMeasureCommand() cmd.init_args(["ping", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Ping measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "packet_interval": spec["packet-interval"], "size": spec["size"], }, ) cmd = PingMeasureCommand() cmd.init_args( [ "ping", "--target", "ripe.net", "--af", "6", "--description", "This is my description", "--packets", "7", "--packet-interval", "200", "--size", "24", "--group-id", "1000001", "--include-probe-id", "--spread", "60", "--resolve-on-probe", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "ripe.net", "packets": 7, "packet_interval": 200, "size": 24, "group_id": 1000001, "include_probe_id": True, "spread": 60, "resolve_on_probe": True, }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_traceroute(self): spec = Configuration.DEFAULT["specification"]["types"]["traceroute"] cmd = TracerouteMeasureCommand() cmd.init_args(["traceroute", "--target", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Traceroute measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "size": spec["size"], "destination_option_size": spec["destination-option-size"], "hop_by_hop_option_size": spec["hop-by-hop-option-size"], "dont_fragment": spec["dont-fragment"], "first_hop": spec["first-hop"], "max_hops": spec["max-hops"], "paris": spec["paris"], "port": spec["port"], "protocol": spec["protocol"], "timeout": spec["timeout"], }, ) # Test using positional target cmd = TracerouteMeasureCommand() cmd.init_args(["traceroute", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Traceroute measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "size": spec["size"], "destination_option_size": spec["destination-option-size"], "hop_by_hop_option_size": spec["hop-by-hop-option-size"], "dont_fragment": spec["dont-fragment"], "first_hop": spec["first-hop"], "max_hops": spec["max-hops"], "paris": spec["paris"], "port": spec["port"], "protocol": spec["protocol"], "timeout": spec["timeout"], }, ) cmd = TracerouteMeasureCommand() cmd.init_args( [ "traceroute", "--af", "6", "--description", "This is my description", "--target", "ripe.net", "--packets", "7", "--size", "24", "--destination-option-size", "12", "--hop-by-hop-option-size", "13", "--dont-fragment", "--first-hop", "2", "--max-hops", "5", "--paris", "8", "--port", "123", "--protocol", "TCP", "--timeout", "1500", "--duplicate-timeout", "500", "--response-timeout", "500", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "ripe.net", "packets": 7, "size": 24, "destination_option_size": 12, "hop_by_hop_option_size": 13, "dont_fragment": True, "first_hop": 2, "max_hops": 5, "paris": 8, "port": 123, "protocol": "TCP", "timeout": 1500, "duplicate_timeout": 500, "response_timeout": 500, }, ) """Tests for the protocol provided in lower case""" cmd = TracerouteMeasureCommand() cmd.init_args(["traceroute", "--target", "ripe.net", "--protocol", "icmp"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Traceroute measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "size": spec["size"], "destination_option_size": spec["destination-option-size"], "hop_by_hop_option_size": spec["hop-by-hop-option-size"], "dont_fragment": spec["dont-fragment"], "first_hop": spec["first-hop"], "max_hops": spec["max-hops"], "paris": spec["paris"], "port": spec["port"], "protocol": "ICMP", "timeout": spec["timeout"], }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_dns(self): spec = Configuration.DEFAULT["specification"]["types"]["dns"] cmd = DnsMeasureCommand() cmd.init_args(["dns", "--query-argument", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": spec["query-class"], "query_type": spec["query-type"], "query_argument": "ripe.net", "set_cd_bit": spec["set-cd-bit"], "set_do_bit": spec["set-do-bit"], "set_rd_bit": spec["set-rd-bit"], "tls": False, "set_nsid_bit": spec["set-nsid-bit"], "protocol": spec["protocol"], "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) # Test using positional query argument cmd = DnsMeasureCommand() cmd.init_args(["dns", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": spec["query-class"], "query_type": spec["query-type"], "query_argument": "ripe.net", "set_cd_bit": spec["set-cd-bit"], "set_do_bit": spec["set-do-bit"], "set_rd_bit": spec["set-rd-bit"], "tls": False, "set_nsid_bit": spec["set-nsid-bit"], "protocol": spec["protocol"], "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) cmd = DnsMeasureCommand() cmd.init_args( [ "dns", "--af", "6", "--description", "This is my description", "--target", "non-existent-dns.ripe.net", "--query-class", "CHAOS", "--query-type", "SOA", "--query-argument", "some arbitrary string", "--set-cd-bit", "--set-do-bit", "--set-rd-bit", "--set-nsid-bit", "--protocol", "TCP", "--retry", "2", "--udp-payload-size", "512", "--timeout", "500", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "non-existent-dns.ripe.net", "query_class": "CHAOS", "query_type": "SOA", "query_argument": "some arbitrary string", "set_cd_bit": True, "set_do_bit": True, "set_rd_bit": True, "set_nsid_bit": True, "protocol": "TCP", "retry": 2, "udp_payload_size": 512, "use_probe_resolver": False, "timeout": 500, "tls": False, }, ) """Testing for protocol argument in lower case""" cmd = DnsMeasureCommand() cmd.init_args(["dns", "--query-argument", "ripe.net", "--protocol", "tcp"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": spec["query-class"], "query_type": spec["query-type"], "query_argument": "ripe.net", "set_cd_bit": spec["set-cd-bit"], "set_do_bit": spec["set-do-bit"], "set_rd_bit": spec["set-rd-bit"], "tls": False, "set_nsid_bit": spec["set-nsid-bit"], "protocol": "TCP", "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) """Testing for query class in lower case""" cmd = DnsMeasureCommand() cmd.init_args(["dns", "--query-argument", "ripe.net", "--query-class", "in"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": "IN", "query_type": spec["query-type"], "query_argument": "ripe.net", "set_cd_bit": spec["set-cd-bit"], "set_do_bit": spec["set-do-bit"], "set_rd_bit": spec["set-rd-bit"], "tls": False, "set_nsid_bit": spec["set-nsid-bit"], "protocol": spec["protocol"], "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) """Testing for query type in lower case""" cmd = DnsMeasureCommand() cmd.init_args( [ "dns", "--query-argument", "ripe.net", "--query-type", "txt", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": spec["query-class"], "query_type": "TXT", "query_argument": "ripe.net", "set_cd_bit": spec["set-cd-bit"], "set_do_bit": spec["set-do-bit"], "set_rd_bit": spec["set-rd-bit"], "tls": False, "set_nsid_bit": spec["set-nsid-bit"], "protocol": spec["protocol"], "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) """Explicitly unset bits""" cmd = DnsMeasureCommand() cmd.init_args( [ "dns", "--query-argument", "ripe.net", "--query-type", "txt", "--no-set-cd-bit", "--no-set-do-bit", "--no-set-rd-bit", "--no-set-nsid-bit", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "DNS measurement for ripe.net", "query_class": spec["query-class"], "query_type": "TXT", "query_argument": "ripe.net", "set_cd_bit": False, "set_do_bit": False, "set_rd_bit": False, "tls": False, "set_nsid_bit": False, "protocol": spec["protocol"], "retry": spec["retry"], "udp_payload_size": spec["udp-payload-size"], "use_probe_resolver": True, }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_sslcert(self): spec = Configuration.DEFAULT["specification"]["types"]["sslcert"] cmd = SslcertMeasureCommand() cmd.init_args(["sslcert", "--target", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Sslcert measurement to ripe.net", "target": "ripe.net", "port": spec["port"], }, ) # Test using positional target cmd = SslcertMeasureCommand() cmd.init_args(["sslcert", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Sslcert measurement to ripe.net", "target": "ripe.net", "port": spec["port"], }, ) cmd = SslcertMeasureCommand() cmd.init_args( [ "sslcert", "--target", "ripe.net", "--af", "6", "--description", "This is my description", "--port", "7", "--hostname", "ripe.net", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "ripe.net", "port": 7, "hostname": "ripe.net", }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_http(self): spec = Configuration.DEFAULT["specification"]["types"]["http"] cmd = HttpMeasureCommand() cmd.init_args(["http", "--target", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Http measurement to ripe.net", "target": "ripe.net", "header_bytes": spec["header-bytes"], "version": spec["version"], "method": spec["method"], "port": spec["port"], "path": spec["path"], "query_string": spec["query-string"], "user_agent": spec["user-agent"], "max_bytes_read": spec["body-bytes"], }, ) # Test using positional target cmd = HttpMeasureCommand() cmd.init_args(["http", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Http measurement to ripe.net", "target": "ripe.net", "header_bytes": spec["header-bytes"], "version": spec["version"], "method": spec["method"], "port": spec["port"], "path": spec["path"], "query_string": spec["query-string"], "user_agent": spec["user-agent"], "max_bytes_read": spec["body-bytes"], }, ) cmd = HttpMeasureCommand() cmd.init_args( [ "http", "--target", "ripe.net", "--af", "6", "--description", "This is my description", "--header-bytes", "100", "--version", "99", "--method", "a-method", "--port", "7", "--path", "/path/to/something", "--query-string", "x=7", "--user-agent", "This is my custom user agent", "--body-bytes", "200", "--timing-verbosity", "2", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "ripe.net", "header_bytes": 100, "version": "99", "method": "a-method", "port": 7, "path": "/path/to/something", "query_string": "x=7", "user_agent": "This is my custom user agent", "max_bytes_read": 200, "extended_timing": True, "more_extended_timing": True, }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_measurement_kwargs_ntp(self): spec = Configuration.DEFAULT["specification"]["types"]["ntp"] cmd = NtpMeasureCommand() cmd.init_args(["ntp", "--target", "ripe.net"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": Configuration.DEFAULT["specification"]["af"], "description": "Ntp measurement to ripe.net", "target": "ripe.net", "packets": spec["packets"], "timeout": spec["timeout"], }, ) cmd = NtpMeasureCommand() cmd.init_args( [ "ntp", "--target", "ripe.net", "--af", "6", "--description", "This is my description", "--packets", "6", "--timeout", "9000", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 6, "description": "This is my description", "target": "ripe.net", "packets": 6, "timeout": 9000, }, ) @mock.patch(CONF, Configuration.DEFAULT) def test_get_source_kwargs(self): spec = Configuration.DEFAULT["specification"] for kind, klass in self.KINDS.items(): cmd = klass() args = [kind, "--target", "example.com"] if kind == "dns": args = ["dns", "--query-argument", "example.com"] cmd.init_args(list(args)) tags = spec["tags"]["ipv{}".format(cmd._get_af())] includes = tags[kind]["include"] + tags["all"]["include"] excludes = tags[kind]["exclude"] + tags["all"]["exclude"] self.assertEqual( cmd._get_source_kwargs(), { "requested": spec["source"]["requested"], "type": spec["source"]["type"], "value": spec["source"]["value"], "tags": {"include": includes, "exclude": excludes}, }, ) cmd = klass() cmd.init_args(args + ["--probes", "10", "--from-country", "ca"]) self.assertEqual( cmd._get_source_kwargs(), { "requested": 10, "type": "country", "value": "CA", "tags": {"include": includes, "exclude": excludes}, }, ) for area in ( "WW", "West", "North-Central", "South-Central", "North-East", "South-East", ): cmd = klass() cmd.init_args(args + ["--probes", "10", "--from-area", area]) self.assertEqual( cmd._get_source_kwargs(), { "requested": 10, "type": "area", "value": area, "tags": {"include": includes, "exclude": excludes}, }, ) cmd = klass() cmd.init_args(args + ["--probes", "10", "--from-prefix", "1.2.3.0/22"]) self.assertEqual( cmd._get_source_kwargs(), { "requested": 10, "type": "prefix", "value": "1.2.3.0/22", "tags": {"include": includes, "exclude": excludes}, }, ) cmd = klass() cmd.init_args(args + ["--probes", "10", "--from-asn", "3333"]) self.assertEqual( cmd._get_source_kwargs(), { "requested": 10, "type": "asn", "value": 3333, "tags": {"include": includes, "exclude": excludes}, }, ) # Try 20 permutations of probe lists for __ in range(0, 20): requested = randint(1, 500) selection = [str(randint(1, 5000)) for _ in range(0, 100)] cmd = klass() cmd.init_args( args + ["--probes", str(requested), "--from-probes", ",".join(selection)] ) self.assertEqual( cmd._get_source_kwargs(), { "requested": requested, "type": "probes", "value": ",".join(selection), "tags": {"include": includes, "exclude": excludes}, }, ) cmd = klass() cmd.init_args(args + ["--probes", "10", "--from-measurement", "1001"]) self.assertEqual( cmd._get_source_kwargs(), { "requested": 10, "type": "msm", "value": 1001, "tags": {"include": includes, "exclude": excludes}, }, ) cmd = klass() cmd.init_args( args + ["--include-tag", "tag-to-include", "--exclude-tag", "tag-to-exclude"] ) self.assertEqual( cmd._get_source_kwargs(), { "requested": spec["source"]["requested"], "type": spec["source"]["type"], "value": spec["source"]["value"], "tags": { "include": ["tag-to-include"], "exclude": ["tag-to-exclude"], }, }, ) def test_get_af(self): conf = copy.deepcopy(Configuration.DEFAULT) conf["specification"]["af"] = 100 for kind, klass in self.KINDS.items(): with mock.patch(self.CONF, conf): for af in (4, 6): cmd = klass() cmd.init_args([kind, "--af", str(af)]) self.assertEqual(cmd._get_af(), af) cmd = klass() cmd.init_args([kind, "--target", "1.2.3.4"]) self.assertEqual(cmd._get_af(), 4) cmd = klass() cmd.init_args([kind, "--target", "1:2:3:4:5:6:7:8"]) self.assertEqual(cmd._get_af(), 6) cmd = klass() cmd.init_args([kind, "--target", "1.2.3.4.5"]) self.assertEqual(cmd._get_af(), conf["specification"]["af"]) def test_handle_api_error(self): cmd = Command() plain_error = "This is a plain text error" with self.assertRaises(RipeAtlasToolsException) as e: cmd._handle_api_error(plain_error) self.assertIn(plain_error, str(e.exception)) err_obj = {"detail": "This is a formatted error"} with self.assertRaises(RipeAtlasToolsException) as e: cmd._handle_api_error(err_obj) self.assertIn(json.dumps(err_obj, indent=2), str(e.exception)) def test_add_arguments(self): with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--set-alias", "\\invalid"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --set-alias: " '"\\invalid" does not appear to be a valid alias.', ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--renderer", "not-a-renderer"]) self.assertTrue( stderr.getvalue() .split("\n")[-2] .startswith( "ripe-atlas measure: error: argument --renderer: invalid " "choice: 'not-a-renderer' (choose from" ) ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--af", "5"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --af: invalid choice: 5 " "(choose from 4, 6)", ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--target", "not a target"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --target: " '"not a target" does not appear to be an IP address or host ' "name", ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--from-area", "not an area"]) self.assertTrue( stderr.getvalue() .split("\n")[-2] .startswith( "ripe-atlas measure: error: argument --from-area: invalid " "choice:" ) ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): PingMeasureCommand().init_args(["ping", "--from-probes", "0,50000"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --from-probes: 0 " "is lower than the minimum permitted value of 1.", ) for clude in ("in", "ex"): with capture_sys_output() as (stdout, stderr): for tag in ("NotATag", "tag!", "not a tag", "νοτ α ταγ"): with self.assertRaises(SystemExit): PingMeasureCommand().init_args( ["ping", "--{}clude-tag".format(clude), tag] ) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --{}clude-tag: " '"{}" does not appear to be a valid tag.'.format(clude, tag), ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): TracerouteMeasureCommand().init_args( ["traceroute", "--protocol", "invalid"] ) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --protocol: invalid " "choice: 'INVALID' (choose from 'ICMP', 'UDP', 'TCP')", ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): DnsMeasureCommand().init_args(["dns", "--protocol", "invalid"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --protocol: invalid " "choice: 'INVALID' (choose from 'UDP', 'TCP')", ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): HttpMeasureCommand().init_args(["http", "--timing-verbosity", "3"]) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --timing-verbosity: " "invalid choice: 3 (choose from 0, 1, 2)", ) min_options = [ ("from-measurement", ((PingMeasureCommand,), 1)), ("probes", ((PingMeasureCommand,), 1)), ("timeout", ((TracerouteMeasureCommand,), 1)), ] for option, (klasses, minimum) in min_options: for klass in klasses: with capture_sys_output() as (stdout, stderr): test_value = minimum - 1 with self.assertRaises(SystemExit): klass().init_args( [ klass.__name__.replace("MeasureCommand", "").lower(), "--{}".format(option), str(test_value), ] ) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --{}: " "The integer must be greater than {}.".format(option, minimum), ) min_max_options = [ ("from-asn", ((PingMeasureCommand,), (1, 2 ** 32 - 2))), ("paris", ((TracerouteMeasureCommand,), (0, 64))), ("first-hop", ((TracerouteMeasureCommand,), (1, 255))), ("max-hops", ((TracerouteMeasureCommand,), (1, 255))), ( "port", ( ( TracerouteMeasureCommand, SslcertMeasureCommand, HttpMeasureCommand, ), (1, 65535), ), ), ("header-bytes", ((HttpMeasureCommand,), (0, 2048))), ("body-bytes", ((HttpMeasureCommand,), (1, 1020048))), ("size", ((PingMeasureCommand,), (1, 2048))), ("size", ((TracerouteMeasureCommand,), (0, 2048))), ( "packets", ( ( PingMeasureCommand, TracerouteMeasureCommand, NtpMeasureCommand, ), (1, 16), ), ), ("packet-interval", ((PingMeasureCommand,), (2, 30000))), ("timeout", ((NtpMeasureCommand,), (1, 60000))), ("destination-option-size", ((TracerouteMeasureCommand,), (0, 1024))), ("hop-by-hop-option-size", ((TracerouteMeasureCommand,), (0, 2048))), ("retry", ((DnsMeasureCommand,), (0, 10))), ("udp-payload-size", ((DnsMeasureCommand,), (512, 4096))), ] for option, (klasses, extremes) in min_max_options: for klass in klasses: lower = extremes[0] - 1 upper = extremes[1] + 1 for invalid in lower, upper: with capture_sys_output() as (stdout, stderr): try: klass().init_args( [ klass.__name__.replace( "MeasureCommand", "" ).lower(), "--{}".format(option), str(invalid), ] ) except SystemExit: pass else: self.fail( "--{} for {} should fail for value {}".format( option, klass.__name__, invalid ) ) self.assertEqual( stderr.getvalue().split("\n")[-2], "ripe-atlas measure: error: argument --{}: The " "integer must be between {} and {}.".format( option, extremes[0], extremes[1] ), ) @mock.patch(CONF, Configuration.DEFAULT) def test_account_for_selected_probes(self): spec = Configuration.DEFAULT["specification"] cmd = PingMeasureCommand() cmd.init_args(["ping", "--target", "ripe.net"]) cmd._account_for_selected_probes(), self.assertEqual(cmd.arguments.probes, spec["source"]["requested"]) cmd = PingMeasureCommand() cmd.init_args(["ping", "--target", "ripe.net", "--probes", "7"]) cmd._account_for_selected_probes(), self.assertEqual(cmd.arguments.probes, 7) cmd = PingMeasureCommand() cmd.init_args(["ping", "--target", "ripe.net", "--from-probes", "1,2"]) cmd._account_for_selected_probes(), self.assertEqual(cmd.arguments.probes, 2) cmd = PingMeasureCommand() cmd.init_args( ["ping", "--target", "ripe.net", "--from-probes", "1,2", "--probes", "7"] ) with capture_sys_output() as (stdout, stderr): with self.assertRaises(RipeAtlasToolsException): cmd._account_for_selected_probes(), def test_set_alias(self): path_aliases = "ripe.atlas.tools.commands.measure.base.aliases" new_aliases = copy.deepcopy(AliasesDB.DEFAULT) with mock.patch(path_aliases, new_aliases): path_AliasesDB = "ripe.atlas.tools.commands.measure.base.AliasesDB" with mock.patch(path_AliasesDB, autospec=True) as new_AliasesDB: new_AliasesDB.write.return_value = True path_create = "ripe.atlas.tools.commands.measure.base.Command.create" with mock.patch(path_create) as mock_create: mock_create.return_value = (True, {"measurements": [1234]}) cmd = PingMeasureCommand() cmd.init_args( [ "ping", "--target", "www.ripe.net", "--no-report", "--set-alias", "PING_RIPE", ] ) cmd.run() self.assertEqual(new_aliases["measurement"]["PING_RIPE"], 1234) def test_spec_valid(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", '{"type": "ping", "target": "1.2.3.4"}']) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 4, "description": "Ping measurement", "target": "1.2.3.4", "type": "ping", }, ) def test_spec_valid_target(self): # Override target on command-line cmd = SpecMeasureCommand() cmd.init_args( ["spec", '{"type": "ping", "target": "1.2.3.4"}', "--target", "5.6.7.8"] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 4, "description": "Ping measurement", "target": "5.6.7.8", "type": "ping", }, ) def test_spec_valid_description(self): # Specify a custom description cmd = SpecMeasureCommand() cmd.init_args( [ "spec", '{"type": "ping", "target": "1.2.3.4"}', "--description", "A real cool measurement", ] ) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 4, "description": "A real cool measurement", "target": "1.2.3.4", "type": "ping", }, ) def test_spec_valid_file(self): # Specify a valid JSON file with tempfile.NamedTemporaryFile(mode="w", delete=False) as f: filename = f.name f.write('{"target": "1.2.3.4", "type": "ping"}\n') try: cmd = SpecMeasureCommand() cmd.init_args(["spec", f"@{filename}"]) self.assertEqual( cmd._get_measurement_kwargs(), { "af": 4, "description": "Ping measurement", "target": "1.2.3.4", "type": "ping", }, ) finally: os.unlink(filename) def test_spec_valid_stdin(self): # Pass valid JSON to stdin cmd = SpecMeasureCommand() cmd.init_args(["spec", "@-"]) with mock.patch( "sys.stdin", StringIO('{"type": "ping", "target": "1.2.3.4"}\n') ): self.assertEqual( cmd._get_measurement_kwargs(), { "af": 4, "description": "Ping measurement", "target": "1.2.3.4", "type": "ping", }, ) def test_spec_invalid_no_type(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", '{"target": "1.2.3.4"}']) self.assertRaises( RipeAtlasToolsException, cmd._get_measurement_kwargs, ) def test_spec_invalid_unknown_type(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", '{"type": "funnytype", "target": "1.2.3.4"}']) self.assertRaises( RipeAtlasToolsException, cmd._get_measurement_kwargs, ) def test_spec_invalid_no_file(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", "@/this/path/does/not/exist}"]) self.assertRaises( RipeAtlasToolsException, cmd._get_measurement_kwargs, ) def test_spec_invalid_json(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", "{lkdsjf]]"]) self.assertRaises( RipeAtlasToolsException, cmd._get_measurement_kwargs, ) def test_spec_invalid_not_dict(self): cmd = SpecMeasureCommand() cmd.init_args(["spec", "[]"]) self.assertRaises( RipeAtlasToolsException, cmd._get_measurement_kwargs, ) ripe-atlas-tools-3.1.0/tests/commands/test_measurement_search.py000066400000000000000000000210141437041663000251420ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import collections import datetime import unittest from unittest import mock from ripe.atlas.tools.commands.measurement_search import Command from ..base import capture_sys_output COMMAND_MODULE = "ripe.atlas.tools.commands.measurement_search" class FakeGen(object): """ A rip-off of the code used for testing probes, but a little prettier. """ Measurement = collections.namedtuple( "Measurement", ("id", "type", "status", "status_id", "meta_data", "target", "description"), ) def __init__(self): self.data = [ self.Measurement( id=1, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 1", description="Description 1", ), self.Measurement( id=2, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 2", description="Description 2", ), self.Measurement( id=3, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 3", description="Description 3", ), self.Measurement( id=4, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 4", description="Description 4", ), self.Measurement( id=5, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 5", description="Description 5", ), ] self.total_count = 5 def __iter__(self): return self # Python 3 compatibility def __next__(self): return self.next() def next(self): if not self.data: raise StopIteration() else: return self.data.pop(0) class TestMeasurementsCommand(unittest.TestCase): maxDiff = 1000 @mock.patch("{}.MeasurementRequest".format(COMMAND_MODULE)) def test_with_empty_args(self, mock_request): mock_request.return_value = FakeGen() cmd = Command() with capture_sys_output() as (stdout, stderr): cmd.init_args([]) cmd.run() expected_content = """ id type description status ================================================================================ 1 ping Description 1 Ongoing 2 ping Description 2 Ongoing 3 ping Description 3 Ongoing 4 ping Description 4 Ongoing 5 ping Description 5 Ongoing ================================================================================ Showing 5 of 5 """ # noqa self.assertEqual(stdout.getvalue().split("\n"), expected_content.split("\n")) self.assertEqual(cmd.arguments.field, ["id", "type", "description", "status"]) @mock.patch("{}.MeasurementRequest".format(COMMAND_MODULE)) def test_get_line_items(self, mock_request): mock_request.return_value = FakeGen() cmd = Command() cmd.init_args([]) cmd.run() self.assertEqual( cmd._get_row( FakeGen.Measurement( id=1, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 1", description="Description 1", ) ), { "values": { "id": 1, "type": "ping", "description": "Description 1", "status": "Ongoing", }, "colour": "green", }, ) cmd = Command() cmd.init_args(["--field", "id", "--field", "status"]) self.assertEqual( cmd._get_row( FakeGen.Measurement( id=1, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 1", description="Description 1", ) ), {"values": {"id": 1, "status": "Ongoing"}, "colour": "green"}, ) cmd = Command() cmd.init_args( [ "--field", "url", ] ) self.assertEqual( cmd._get_row( FakeGen.Measurement( id=1, type="ping", status="Ongoing", status_id=2, meta_data={"status": {"name": "Ongoing", "id": 2}}, target="Name 1", description="Description 1", ) ), { "values": {"url": "https://atlas.ripe.net/measurements/1/"}, "colour": "green", }, ) def test_get_filters(self): cmd = Command() cmd.init_args( [ "--search", "the force is strong with this one", "--status", "ongoing", "--af", "6", "--type", "ping", "--started-before", "2015-01-01", "--started-after", "2014-01-01", "--stopped-before", "2015-01-01", "--stopped-after", "2014-01-01", ] ) self.assertEqual( cmd._get_filters(), { "search": "the force is strong with this one", "status__in": (2,), "af": 6, "type": "ping", "start_time__lt": datetime.datetime(2015, 1, 1), "start_time__gt": datetime.datetime(2014, 1, 1), "stop_time__lt": datetime.datetime(2015, 1, 1), "stop_time__gt": datetime.datetime(2014, 1, 1), }, ) def test_get_colour_from_status(self): cmd = Command() self.assertEqual(cmd._get_colour_from_status(0), "blue") self.assertEqual(cmd._get_colour_from_status(1), "blue") self.assertEqual(cmd._get_colour_from_status(2), "green") self.assertEqual(cmd._get_colour_from_status(4), "yellow") self.assertEqual(cmd._get_colour_from_status(5), "red") self.assertEqual(cmd._get_colour_from_status(6), "red") self.assertEqual(cmd._get_colour_from_status(7), "red") self.assertEqual(cmd._get_colour_from_status("XXX"), "white") def test_fail_arguments(self): expected_failures = ( ("--status", "not a status"), ("--not-an-option",), ("--af", "5"), ("--type", "not a type"), ("--field", "not a field"), ) for failure in expected_failures: with capture_sys_output(): with self.assertRaises(SystemExit): Command().init_args(failure) ripe-atlas-tools-3.1.0/tests/commands/test_probe_search.py000066400000000000000000000477071437041663000237450ustar00rootroot00000000000000# Copyright (c) 2023 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from unittest import mock import requests from ripe.atlas.cousteau import Probe from ripe.atlas.tools.commands.probe_search import Command from ripe.atlas.tools.exceptions import RipeAtlasToolsException from ..base import capture_sys_output COMMAND_MODULE = "ripe.atlas.tools.commands.probe_search" class FakeGen(object): def __init__( self, ): self.probes = [ Probe( id=1, meta_data={ "country_code": "GR", "asn_v4": 3333, "prefix_v4": "193.0/22", "status": {"name": "Connected"}, }, ), Probe( id=2, meta_data={ "country_code": "DE", "asn_v4": 3333, "prefix_v4": "193.0/22", "status": {"name": "Connected"}, }, ), Probe( id=3, meta_data={ "country_code": "DE", "asn_v4": 3332, "prefix_v4": "193.0/22", "status": {"name": "Connected"}, }, ), Probe( id=4, meta_data={ "country_code": "NL", "asn_v4": 3333, "prefix_v4": "193.0/22", "status": {"name": "Connected"}, }, ), Probe( id=5, meta_data={ "country_code": "GR", "asn_v4": 3333, "prefix_v4": "193.0/22", "status": {"name": "Connected"}, }, ), ] self.total_count = 4 def __iter__(self): return self # Python 3 compatibility def __next__(self): return self.next() def next(self): if not self.probes: raise StopIteration() else: return self.probes.pop(0) class TestProbesCommand(unittest.TestCase): def setUp(self): self.maxDiff = None def test_with_random_args(self): """User passes random args, should fail with SystemExit""" with capture_sys_output(): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["blaaaaaaa"]) cmd.run() def test_arg_with_no_value(self): """User passed not boolean arg but no value""" with capture_sys_output(): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--asn"]) cmd.run() def test_arg_with_wrong_type(self): """User passed arg with wrong type. e.g string for asn""" with capture_sys_output(): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--asn", "blaaaaa"]) cmd.run() with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--asnv4", "blaaaaa"]) cmd.run() with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--asnv6", "blaaaaa"]) cmd.run() with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--limit", "blaaaaa"]) cmd.run() with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--radius", "blaaaaa"]) cmd.run() with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--tag", "inv@lid"]) cmd.run() def test_location_google_breaks(self): """User passed location arg but google api gave error""" caught_exceptions = [ requests.ConnectionError, requests.HTTPError, requests.Timeout, ] with mock.patch("requests.get") as mock_get: for exception in caught_exceptions: mock_get.side_effect = exception with capture_sys_output(): with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--auth", "fake-key", "--location", "blaaaa"]) cmd.run() mock_get.side_effect = Exception() with self.assertRaises(Exception): cmd = Command() cmd.init_args(["--auth", "fake-key", "--location", "blaaaa"]) cmd.run() def test_location_google_wrong_output(self): """User passed location arg but google api gave not expected format""" with mock.patch("requests.get") as mock_get: mock_get.return_value = requests.Response() with mock.patch("requests.Response.json") as mock_json: mock_json.return_value = {"blaaa": "bla"} with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--auth", "fake-key", "--location", "blaaaa"]) cmd.run() def test_location_arg(self): """User passed location arg""" with mock.patch("requests.get") as mock_get: mock_get.return_value = requests.Response() with mock.patch("requests.Response.json") as mock_json: mock_json.return_value = { "results": [{"geometry": {"location": {"lat": 1, "lng": 2}}}] } cmd = Command() cmd.init_args(["--auth", "fake-key", "--location", "blaaaa"]) self.assertEqual(cmd._get_filters(), {"radius": "1,2:15"}) def test_location_arg_with_radius(self): """User passed location arg""" with mock.patch("requests.get") as mock_get: mock_get.return_value = requests.Response() with mock.patch("requests.Response.json") as mock_json: mock_json.return_value = { "results": [{"geometry": {"location": {"lat": 1, "lng": 2}}}] } cmd = Command() cmd.init_args( [ "--auth", "fake-key", "--location", "blaaaa", "--radius", "4", ] ) self.assertEqual(cmd._get_filters(), {"radius": "1,2:4"}) def test_asn_args(self): """User passed asn arg together with asnv4 or asnv6""" with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--asn", "3333", "--asnv4", "3333"]) cmd.run() with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--asn", "3333", "--asnv6", "3333"]) cmd.run() def test_prefix_args(self): """User passed prefix arg together with prefixv4 or prefixv6""" with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--prefix", "193.0.0.0/21", "--prefixv4", "193.0.0.0/21"]) cmd.run() with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args( [ "--prefix", "2001:67c:2e8::/48", "--prefixv6", "2001:67c:2e8::/48", ] ) cmd.run() def test_all_args(self): """User passed all arguments""" cmd = Command() cmd.init_args(["--all"]) self.assertEqual(cmd._get_filters(), {}) def test_center_arg_wrong_value(self): """User passed center arg with wrong value""" with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--center", "blaaaa"]) cmd.run() def test_center_arg(self): """User passed center arg""" cmd = Command() cmd.init_args(["--center", "1,2"]) self.assertEqual(cmd._get_filters(), {"radius": "1,2:15"}) def test_center_arg_with_radius(self): """User passed center and radius arg""" cmd = Command() cmd.init_args(["--center", "1,2", "--radius", "4"]) self.assertEqual(cmd._get_filters(), {"radius": "1,2:4"}) def test_country_arg(self): """User passed country code arg""" cmd = Command() cmd.init_args(["--country", "GR"]) self.assertEqual(cmd._get_filters(), {"country_code": "GR"}) def test_country_arg_with_radius(self): """User passed country code arg together with radius""" cmd = Command() cmd.init_args(["--country", "GR", "--radius", "4"]) self.assertEqual(cmd._get_filters(), {"country_code": "GR"}) def test_status_arg(self): """User passed valid status arg.""" for status in range(0, 3): cmd = Command() cmd.init_args(["--status", str(status)]) self.assertEqual(cmd._get_filters(), {"status": status}) def test_status_arg_wrong_value(self): """User passed status arg with wrong value""" with capture_sys_output(): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args(["--status", "4"]) cmd.run() def test_sane_tags(self): """Sane tags""" cmd = Command() cmd.init_args(["--tag", "native-ipv6"]) self.assertEqual(cmd._get_filters(), {"tags": "native-ipv6"}) cmd = Command() cmd.init_args(["--tag", "native-ipv6", "--tag", "system-ipv4-works"]) self.assertEqual(cmd._get_filters(), {"tags": "native-ipv6,system-ipv4-works"}) def test_sane_args1(self): """User passed several arguments (1)""" cmd = Command() cmd.init_args( [ "--center", "1,2", "--radius", "4", "--asnv4", "3333", "--prefix", "193.0.0.0/21", ] ) self.assertEqual( cmd._get_filters(), {"asn_v4": 3333, "prefix": "193.0.0.0/21", "radius": "1,2:4"}, ) def test_sane_args2(self): """User passed several arguments (2)""" cmd = Command() cmd.init_args( [ "--auth", "fake-key", "--location", "Amsterdam", "--asn", "3333", "--prefixv4", "193.0.0.0/21", ] ) path = "{}.Command.location2degrees".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = (1, 2) self.assertEqual( cmd._get_filters(), {"asn": 3333, "prefix_v4": "193.0.0.0/21", "radius": "1,2:15"}, ) def test_sane_args3(self): """User passed several arguments (3)""" cmd = Command() cmd.init_args( [ "--center", "1,2", "--asnv6", "3333", "--prefixv6", "2001:67c:2e8::/48", ] ) self.assertEqual( cmd._get_filters(), { "asn_v6": 3333, "prefix_v6": "2001:67c:2e8::/48", "radius": "1,2:15", }, ) def test_render_ids_only(self): """User passed ids_only arg, testing rendiring""" cmd = Command() cmd.init_args(["--ids-only", "--country", "GR"]) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() self.assertEqual(stdout.getvalue(), "1\n2\n3\n4\n5\n") def test_render_ids_only_with_limit(self): """User passed ids_only arg together with limit, testing rendering""" cmd = Command() cmd.init_args(["--ids-only", "--country", "GR", "--limit", "2"]) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() self.assertEqual(stdout.getvalue(), "1\n2\n") def test_render_ids_only_with_aggr(self): """ User passed ids_only arg together with aggregate, testing rendering """ cmd = Command() cmd.init_args(["--ids-only", "--aggregate-by", "country"]) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() self.assertEqual(stdout.getvalue(), "2\n3\n1\n5\n4\n") def test_render_without_aggregation(self): """Tests rendering of results without aggregation""" cmd = Command() cmd.init_args(["--country", "GR"]) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() expected_output = """ Filters: country_code: GR id asn_v4 asn_v6 country status =========================================== 1 3333 - gr Connected 2 3333 - de Connected 3 3332 - de Connected 4 3333 - nl Connected 5 3333 - gr Connected =========================================== Showing 4 of 4 """ # noqa self.assertEqual(stdout.getvalue(), expected_output) def test_render_without_aggregation_with_limit(self): """Tests rendering of results without aggregation but with limit""" cmd = Command() cmd.init_args(["--country", "GR", "--limit", "2"]) with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.tools.commands.probe_search.ProbeRequest" with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() expected_output = """ Filters: country_code: GR id asn_v4 asn_v6 country status =========================================== 1 3333 - gr Connected 2 3333 - de Connected =========================================== Showing 2 of 4 """ # noqa self.assertEqual(stdout.getvalue(), expected_output) def test_render_with_aggregation(self): """Tests rendering of results with aggregation""" cmd = Command() cmd.init_args( [ "--status", "1", "--aggregate-by", "country", "--aggregate-by", "asn_v4", "--aggregate-by", "prefix_v4", ] ) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() expected_blob = """ Filters: status: 1 id asn_v4 asn_v6 country status =========================================== ------ 3332 -------- de ------------------ (prefix_v4:193.0/22) 3 3332 - de Connected ------ 3333 -------- de ------------------ (prefix_v4:193.0/22) 2 3333 - de Connected ------ 3333 -------- gr ------------------ (prefix_v4:193.0/22) 1 3333 - gr Connected 5 3333 - gr Connected ------ 3333 -------- nl ------------------ (prefix_v4:193.0/22) 4 3333 - nl Connected =========================================== Showing 4 of 4 """ # noqa expected_set = expected_blob.split("\n") returned_set = stdout.getvalue().split("\n") self.assertEqual(returned_set, expected_set) def test_render_with_aggregation_with_limit(self): """Tests rendering of results with aggregation with limit""" cmd = Command() cmd.init_args( [ "--country", "GR", "--aggregate-by", "country", "--aggregate-by", "asn_v4", "--aggregate-by", "prefix_v4", "--limit", "1", ] ) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() expected_output = """ Filters: country_code: GR id asn_v4 asn_v6 country status =========================================== ------ 3333 -------- gr ------------------ (prefix_v4:193.0/22) 1 3333 - gr Connected =========================================== Showing 1 of 4 """ # noqa expected_set = expected_output.split("\n") returned_set = stdout.getvalue().split("\n") self.assertEqual(returned_set, expected_set) def test_render_with_aggregation_with_max_per_aggr(self): """ Tests rendering of results with aggregation with max per aggr option """ cmd = Command() cmd.init_args( [ "--country", "GR", "--aggregate-by", "country", "--aggregate-by", "asn_v4", "--aggregate-by", "prefix_v4", "--max-per-aggregation", "1", ] ) with capture_sys_output() as (stdout, stderr): path = "{}.ProbeRequest".format(COMMAND_MODULE) with mock.patch(path) as mock_get: mock_get.return_value = FakeGen() cmd.run() expected_output = """ Filters: country_code: GR id asn_v4 asn_v6 country status =========================================== ------ 3332 -------- de ------------------ (prefix_v4:193.0/22) 3 3332 - de Connected ------ 3333 -------- de ------------------ (prefix_v4:193.0/22) 2 3333 - de Connected ------ 3333 -------- gr ------------------ (prefix_v4:193.0/22) 1 3333 - gr Connected ------ 3333 -------- nl ------------------ (prefix_v4:193.0/22) 4 3333 - nl Connected =========================================== Showing 4 of 4 """ # noqa expected_set = expected_output.split("\n") returned_set = stdout.getvalue().split("\n") self.assertEqual(returned_set, expected_set) ripe-atlas-tools-3.1.0/tests/commands/test_report.py000066400000000000000000000632721437041663000226170ustar00rootroot00000000000000# coding=utf-8 # Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import copy import json import os import sys import tempfile import unittest from io import StringIO from unittest import mock from ripe.atlas.cousteau import Probe from ripe.atlas.tools.commands.report import Command from ripe.atlas.tools.exceptions import RipeAtlasToolsException from ripe.atlas.tools.renderers import Renderer from ripe.atlas.tools.settings import AliasesDB from ..base import capture_sys_output class TestReportCommand(unittest.TestCase): mocked_results = [ { "af": 4, "prb_id": 1216, "result": [{"rtt": 27.429}, {"rtt": 25.672}, {"rtt": 25.681}], "ttl": 54, "avg": 26.2606666667, "size": 20, "from": "109.190.83.40", " proto": "ICMP", "timestamp": 1445025400, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 27.429, "step": 360, "src_addr": "192.168.103.132", "rcvd": 3, "msm_name": "Ping", "lts": 377, "dst_name": "hsi.cablecom.ch", "min": 25.672, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 165, "result": [{"rtt": 87.824658}, {"rtt": 87.611154}, {"rtt": 90.99957}], "ttl": 48, "avg": 88.811794, "size": 20, "from": "194.85.27.7", "proto": "ICMP", "timestamp": 1445025590, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 90.99957, "step": 360, "src_addr": "192.168.3.8", "rcvd": 3, "msm_name": "Ping", " lts": 87, "dst_name": "hsi.cablecom.ch", "min": 87.611154, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 202, "result": [{"rtt": 40.02356}, {"rtt": 40.399112}, {"rtt": 39.29012}], "ttl": 52, "avg": 39.904264, "size": 20, "from": "178.190.51.206", "proto": "ICMP", "timestamp": 1445015502, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 40.399112, "step": 360, "src_addr": "10.0.0.2", "rcvd": 3, "msm_name": "Ping", "lts": 502, "dst_name": "hsi.cablecom.ch", "min": 39.29012, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 2225, "result": [ {"rtt": 10.858}, {"rtt": 12.632}, {"rtt": 20.53}, {"dup": 1, "rtt": 32.775}, {"dup": 1, "rtt": 47.509}, {"dup": 1, "rtt": 62.745}, {"dup": 1, "rtt": 78.54}, {"dup": 1, "rtt": 93.272}, {"dup": 1, "rtt": 109.738}, ], "ttl": 56, "avg": 14.6733333333, "size": 20, "from": "46.126.90.165", "proto": "ICMP", "timestamp": 1445025616, "dup": 6, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 20.53, "step": 360, "src_addr": "192.168.111.103", "rcvd": 3, "msm_name": "Ping", "lts": 309, "dst_name": "hsi.cablecom.ch", "min": 10.858, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 270, "result": [{"rtt": 28.527366}, {"rtt": 26.585862}, {"rtt": 26.393094}], "ttl": 51, "avg": 27.168774, "size": 20, "from": "188.192.110.111", "proto": "ICMP", "timestamp": 1445025513, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 28.527366, "step": 360, "src_addr": "192.168.178.21", "rcvd": 3, "msm_name": "Ping", "lts": 182, "dst_name": "hsi.cablecom.ch", "min": 26.393094, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 579, "result": [{"rtt": 23.201285}, {"rtt": 22.980868}, {"rtt": 22.863364}], "ttl": 51, "avg": 23.0151723333, "size": 20, "from": "195.88.195.170", "proto": "ICMP", "timestamp": 1445025521, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 23.201285, "step": 360, "src_addr": "10.69.8.150", "rcvd": 3, "msm_name": "Ping", "lts": 56, "dst_name": "hsi.cablecom.ch", "min": 22.863364, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 677, "result": [{"rtt": 40.71476}, {"rtt": 40.258568}, {"rtt": 40.316936}], "ttl": 54, "avg": 40.430088, "size": 20, "from": "78.128.9.202", "proto": "ICMP", "timestamp": 1445025298, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 40.71476, "step": 360, "src_addr": "10.100.0.25", "rcvd": 3, "msm_name": "Ping", "lts": 97, "dst_name": "hsi.cablecom.ch", "min": 40.258568, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 879, "result": [{"rtt": 34.319623}, {"rtt": 34.445575}, {"rtt": 34.376455}], "ttl": 53, "avg": 34.380551, "size": 20, "from": "94.254.125.2", "proto": "ICMP", "timestamp": 1445025223, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 34.445575, "step": 360, "src_addr": "192.168.8.130", "rcvd": 3, "msm_name": "Ping", "lts": 189, "dst_name": "hsi.cablecom.ch", "min": 34.319623, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 945, "result": [{"rtt": 61.665036}, {"rtt": 23.833349}, {"rtt": 23.268868}], "ttl": 56, "avg": 36.255751, "size": 20, "from": "92.111.237.94", "proto": "ICMP", "timestamp": 1445025494, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 61.665036, "step": 360, "src_addr": "92.111.237.94", "rcvd": 3, "msm_name": "Ping", "lts": 746, "dst_name": "hsi.cablecom.ch", "min": 23.268868, "dst_addr": "62.2.16.24", }, ] expected_output_no_aggr = ( "PING hsi.cablecom.ch (resolved on probe)\n" "20 bytes from 62.2.16.24 via probe #1216 (109.190.83.40): ttl=54 times=27.429 ms, 25.672 ms, 25.681 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #165 (194.85.27.7): ttl=48 times=87.825 ms, 87.611 ms, 91.0 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #202 (178.190.51.206): ttl=52 times=40.024 ms, 40.399 ms, 39.29 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #2225 (46.126.90.165): ttl=56 times=10.858 ms, 12.632 ms, 20.53 ms, 32.775 ms, 47.509 ms, 62.745 ms, 78.54 ms, 93.272 ms, 109.738 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #270 (188.192.110.111): ttl=51 times=28.527 ms, 26.586 ms, 26.393 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #579 (195.88.195.170): ttl=51 times=23.201 ms, 22.981 ms, 22.863 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #677 (78.128.9.202): ttl=54 times=40.715 ms, 40.259 ms, 40.317 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #879 (94.254.125.2): ttl=53 times=34.32 ms, 34.446 ms, 34.376 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #945 (92.111.237.94): ttl=56 times=61.665 ms, 23.833 ms, 23.269 ms\n" # noqa: E501 "\n" "--- hsi.cablecom.ch ping statistics ---\n" "27 packets transmitted, 27 received, 0.0% loss\n" "rtt min/med/avg/max = 10.858/34.376/42.948/91.000 ms\n" ) def setUp(self): self.cmd = Command() def test_with_empty_args(self): """User passes no args, should fail with SystemExit""" with capture_sys_output(use_fake_tty=True): with self.assertRaises(SystemExit): self.cmd.init_args([]) self.cmd.run() def test_with_random_args(self): """User passes random args, should fail with SystemExit""" with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["blaaaaaaa"]) self.cmd.run() def test_arg_with_no_value(self): """User passed not boolean arg but no value""" with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["--probes"]) self.cmd.run() def test_arg_with_wrong_type(self): """User passed arg with wrong type.""" with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["--probes", "blaaaaa"]) self.cmd.run() def test_arg_renderer_with_wrong_choice(self): """User passed arg renderer with unavailable type.""" with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["--renderer", "blaaaaa"]) self.cmd.run() def test_arg_renderer_with_valid_choice(self): """User passed arg renderer with valid type.""" # Mock AtlasRequest to fail run fast and test args validity. path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.return_value = False, {} for choice in Renderer.get_available(): with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--renderer", choice, "1"]) cmd.run() def test_arg_renderer_traceroute_aspath_with_valid_radius_arg(self): # Mock AtlasRequest to fail run fast and test args validity. path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.return_value = False, {} with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args( [ "--renderer", "traceroute_aspath", "--traceroute-aspath-radius", "3", "1", ] ) cmd.run() def test_arg_renderer_traceroute_aspath_with_invalid_radius_arg(self): # Mock AtlasRequest to fail run fast and test args validity. with capture_sys_output(): with self.assertRaises(SystemExit): cmd = Command() cmd.init_args( [ "--renderer", "traceroute_aspath", "--traceroute-aspath-radius", "blaaaaa", "1", ] ) cmd.run() def test_arg_aggregate_with_valid_choice(self): """User passed arg aggregate with valid type.""" # Mock AtlasRequest to fail run fast and test args validity. path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.return_value = False, {} for choice in Command.AGGREGATORS.keys(): with self.assertRaises(RipeAtlasToolsException): cmd = Command() cmd.init_args(["--aggregate-by", choice, "1"]) cmd.run() def test_arg_aggregate_with_wrong_choice(self): """User passed arg aggregate with unavailable type.""" with capture_sys_output(): with self.assertRaises(SystemExit): self.cmd.init_args(["--aggregate-by", "blaaaaa"]) self.cmd.run() def test_arg_no_source(self): """User passed no measurement id and no file name.""" with capture_sys_output(use_fake_tty=True): with self.assertRaises(SystemExit): self.cmd.init_args(["--aggregate-by", "country"]) self.cmd.run() def test_arg_from_file(self): """User passed a valid filename""" temp_file = tempfile.NamedTemporaryFile(delete=False) try: temp_file.write(json.dumps(self.mocked_results).encode("utf-8")) temp_file.close() with capture_sys_output() as (stdout, stderr): self.cmd.init_args( [ "--from-file", temp_file.name, ] ) self.cmd.run() assert self.expected_output_no_aggr == stdout.getvalue() finally: os.unlink(temp_file.name) def test_arg_from_stdin(self): """User passes results into standard input""" try: current_stdin = sys.stdin sys.stdin = StringIO(json.dumps(self.mocked_results)) with capture_sys_output() as (stdout, stderr): self.cmd.init_args([]) self.cmd.run() assert self.expected_output_no_aggr == stdout.getvalue() finally: sys.stdin = current_stdin def test_arg_no_valid_msm_id(self): """User passed non valid type of measurement id.""" with capture_sys_output() as (stdout, stderr): with self.assertRaises(SystemExit): self.cmd.init_args(["blaaa"]) self.cmd.run() err = stderr.getvalue().split("\n")[-2] self.assertEqual( err, 'ripe-atlas report: error: argument measurement_id: "blaaa" ' "does not appear to be an existent measurement alias.", ) def test_arg_valid_msm_alias(self): """User passed a valid measurement alias.""" path_aliases = "ripe.atlas.tools.helpers.validators.aliases" new_aliases = copy.deepcopy(AliasesDB.DEFAULT) new_aliases["measurement"]["UNITTEST_ALIAS"] = 1234 with mock.patch(path_aliases, new_aliases): path_get = "ripe.atlas.tools.commands.report.Command._get_results_from_api" with mock.patch(path_get) as mock_get: mock_get.side_effect = RipeAtlasToolsException with self.assertRaises(RipeAtlasToolsException): self.cmd.init_args(["UNITTEST_ALIAS"]) self.cmd.run() mock_get.assert_called_once_with(1234) def test_measurement_failure(self): """Testcase where given measurement id doesn't exist.""" path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.return_value = False, {} with self.assertRaises(RipeAtlasToolsException): self.cmd.init_args(["--aggregate-by", "country", "1"]) self.cmd.run() def test_no_results(self): """Testcase where given measurement id doesn't have any results.""" path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, {})] with self.assertRaises(RipeAtlasToolsException): self.cmd.init_args(["--aggregate-by", "country", "1"]) self.cmd.run() def test_no_renderer_found(self): """Testcase where renderer canoot be founbd from measurement type.""" path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, {})] with self.assertRaises(RipeAtlasToolsException): self.cmd.init_args(["--aggregate-by", "country", "1"]) self.cmd.run() def test_valid_case_no_aggr(self): """Test case where we have result no aggregation.""" probes = [ Probe( id=202, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=677, meta_data={"country_code": "DE", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=2225, meta_data={"country_code": "DE", "asn_v4": 3332, "asn_v6": "4444"}, ), Probe( id=165, meta_data={"country_code": "NL", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=270, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=579, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=945, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=879, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), ] with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, self.mocked_results)] mpath = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(mpath) as mock_get_many: mock_get_many.return_value = probes self.cmd.init_args(["1"]) self.cmd.run() self.assertEqual(stdout.getvalue(), self.expected_output_no_aggr) def test_valid_case_with_aggr(self): """Test case where we have result with aggregation.""" expected_output = ( "PING hsi.cablecom.ch (resolved on probe)\n" "\n" "RTT_MEDIAN: 10-20\n" " 20 bytes from 62.2.16.24 via probe #2225 (46.126.90.165): ttl=56 times=10.858 ms, 12.632 ms, 20.53 ms, 32.775 ms, 47.509 ms, 62.745 ms, 78.54 ms, 93.272 ms, 109.738 ms\n" # noqa: E501 "\n" "RTT_MEDIAN: 20-30\n" " 20 bytes from 62.2.16.24 via probe #1216 (109.190.83.40): ttl=54 times=27.429 ms, 25.672 ms, 25.681 ms\n" # noqa: E501 " 20 bytes from 62.2.16.24 via probe #270 (188.192.110.111): ttl=51 times=28.527 ms, 26.586 ms, 26.393 ms\n" # noqa: E501 " 20 bytes from 62.2.16.24 via probe #579 (195.88.195.170): ttl=51 times=23.201 ms, 22.981 ms, 22.863 ms\n" # noqa: E501 " 20 bytes from 62.2.16.24 via probe #945 (92.111.237.94): ttl=56 times=61.665 ms, 23.833 ms, 23.269 ms\n" # noqa: E501 "\n" "RTT_MEDIAN: 30-40\n" " 20 bytes from 62.2.16.24 via probe #879 (94.254.125.2): ttl=53 times=34.32 ms, 34.446 ms, 34.376 ms\n" # noqa: E501 "\n" "RTT_MEDIAN: 40-50\n" " 20 bytes from 62.2.16.24 via probe #202 (178.190.51.206): ttl=52 times=40.024 ms, 40.399 ms, 39.29 ms\n" # noqa: E501 " 20 bytes from 62.2.16.24 via probe #677 (78.128.9.202): ttl=54 times=40.715 ms, 40.259 ms, 40.317 ms\n" # noqa: E501 "\n" "RTT_MEDIAN: 50-100\n" " 20 bytes from 62.2.16.24 via probe #165 (194.85.27.7): ttl=48 times=87.825 ms, 87.611 ms, 91.0 ms\n" # noqa: E501 "\n" "--- hsi.cablecom.ch ping statistics ---\n" "27 packets transmitted, 27 received, 0.0% loss\n" "rtt min/med/avg/max = 10.858/34.376/42.948/91.000 ms\n" ) probes = [ Probe( id=202, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=677, meta_data={"country_code": "DE", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=2225, meta_data={"country_code": "DE", "asn_v4": 3332, "asn_v6": "4444"}, ), Probe( id=165, meta_data={"country_code": "NL", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=270, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=579, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=945, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=879, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), ] self.maxDiff = 102444 with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, self.mocked_results)] mpath = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(mpath) as mock_get_many: mock_get_many.return_value = probes self.cmd.init_args(["--aggregate-by", "rtt-median", "1"]) self.cmd.run() self.assertEqual( expected_output.split("\n"), stdout.getvalue().split("\n") ) def test_asns_filter(self): """Test case where user specified probe asns filters..""" expected_output = ( "PING hsi.cablecom.ch (resolved on probe)\n" "20 bytes from 62.2.16.24 via probe #165 (194.85.27.7): ttl=48 times=87.825 ms, 87.611 ms, 91.0 ms\n" # noqa: E501 "20 bytes from 62.2.16.24 via probe #945 (92.111.237.94): ttl=56 times=61.665 ms, 23.833 ms, 23.269 ms\n" # noqa: E501 "\n" "--- hsi.cablecom.ch ping statistics ---\n" "6 packets transmitted, 6 received, 0.0% loss\n" "rtt min/med/avg/max = 23.269/74.638/62.534/91.000 ms\n" ) probes = [ Probe( id=202, meta_data={"country_code": "GR", "asn_v4": 3337, "asn_v6": "4445"}, ), Probe( id=677, meta_data={"country_code": "DE", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=2225, meta_data={"country_code": "DE", "asn_v4": 3332, "asn_v6": "4444"}, ), Probe( id=165, meta_data={"country_code": "NL", "asn_v4": 3334, "asn_v6": "4444"}, ), Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3335, "asn_v6": "4444"}, ), Probe( id=270, meta_data={"country_code": "GR", "asn_v4": 3340, "asn_v6": "4444"}, ), Probe( id=579, meta_data={"country_code": "GR", "asn_v4": 3336, "asn_v6": "4444"}, ), Probe( id=945, meta_data={"country_code": "GR", "asn_v4": 3334, "asn_v6": "4444"}, ), Probe( id=879, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), ] with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, self.mocked_results)] mpath = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(mpath) as mock_get_many: mock_get_many.return_value = probes self.cmd.init_args(["1", "--probe-asns", "3334"]) self.cmd.run() self.assertEqual(stdout.getvalue(), expected_output) ripe-atlas-tools-3.1.0/tests/helpers/000077500000000000000000000000001437041663000175225ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/tests/helpers/__init__.py000066400000000000000000000012321437041663000216310ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . ripe-atlas-tools-3.1.0/tests/helpers/test_sanitisers.py000066400000000000000000000025761437041663000233310ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from ripe.atlas.tools.helpers.sanitisers import sanitise class TestSanitisersHelper(unittest.TestCase): def test_sanitise(self): self.assertEqual("clean", sanitise("clean")) for i in list(range(0, 32)) + [127]: self.assertEqual("unclean", sanitise("unclean" + chr(i))) self.assertEqual(None, sanitise(None)) self.assertEqual(7, sanitise(7)) def test_sanitise_with_newline_exception(self): self.assertEqual("unc\nlean", sanitise("unc\nlean", strip_newlines=False)) for i in set(list(range(0, 32)) + [127]).difference({10}): self.assertEqual( "unc\nlean", sanitise("unc\nlean" + chr(i), strip_newlines=False) ) ripe-atlas-tools-3.1.0/tests/helpers/test_validators.py000066400000000000000000000125301437041663000233040ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import argparse import datetime import os import sys import unittest from io import StringIO from ripe.atlas.tools.helpers.validators import ArgumentType class TestArgumentTypeHelper(unittest.TestCase): def test_path(self): self.assertEqual("/tmp", ArgumentType.path("/tmp")) with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.path("/not/a/real/place") def test_country_code(self): self.assertEqual("CA", ArgumentType.country_code("CA")) self.assertEqual("CA", ArgumentType.country_code("ca")) self.assertEqual("CA", ArgumentType.country_code("Ca")) self.assertEqual("CA", ArgumentType.country_code("cA")) for value in ("CAN", "Canada", "can", "This isn't even a country"): with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.country_code(value) def test_comma_separated_integers(self): self.assertEqual([1, 2, 3], ArgumentType.comma_separated_integers()("1,2,3")) self.assertEqual([1, 2, 3], ArgumentType.comma_separated_integers()("1, 2, 3")) self.assertEqual([1], ArgumentType.comma_separated_integers()("1")) with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers()("1,2,3,pizza!") with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers(minimum=5)("4,5,6,7") with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers(maximum=5)("1,2,3,4,6") def test_datetime(self): d = datetime.datetime(2015, 12, 1) self.assertEqual(d, ArgumentType.datetime("2015-12-1")) self.assertEqual(d, ArgumentType.datetime("2015-12-1T00")) self.assertEqual(d, ArgumentType.datetime("2015-12-1T00:00")) self.assertEqual(d, ArgumentType.datetime("2015-12-1T00:00:00")) self.assertEqual(d, ArgumentType.datetime("2015-12-1")) self.assertEqual(d, ArgumentType.datetime("2015-12-1 00")) self.assertEqual(d, ArgumentType.datetime("2015-12-1 00:00")) self.assertEqual(d, ArgumentType.datetime("2015-12-1 00:00:00")) with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.datetime("yesterday") with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.datetime("Definitely not a date, or even a time") def test_integer_range(self): self.assertEqual(1, ArgumentType.integer_range(1, 10)("1")) self.assertEqual(10, ArgumentType.integer_range(1, 10)("10")) self.assertEqual(1, ArgumentType.integer_range(-1, 1)("1")) self.assertEqual(-1, ArgumentType.integer_range(-1, 1)("-1")) for value in ("0", "11", "-1"): with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.integer_range(1, 10)(value) def test_ip_or_domain(self): passable_hosts = ( "localhost", "ripe.net", "www.ripe.net", "1.2.3.4", "2001:67c:2e8:22::c100:68b", ) for host in passable_hosts: self.assertEqual(host, ArgumentType.ip_or_domain(host)) with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.ip_or_domain("Definitely not a host") def test_comma_separated_integers_or_file(self): with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers_or_file("/dev/null/fail") with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers_or_file("not,a,number") with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.comma_separated_integers_or_file("1, 2, 3") old = sys.stdin sys.stdin = StringIO("1\n2\n") self.assertEqual(ArgumentType.comma_separated_integers_or_file("-"), [1, 2]) sys.stdin = old in_file = "/tmp/__test_file__" with open(in_file, "w") as f: f.write("1\n2\n3\n") self.assertEqual( ArgumentType.comma_separated_integers_or_file(in_file), [1, 2, 3] ) os.unlink(in_file) def test_measurement_alias(self): tests = ["", "\\invalid", "+invalid", ":invalid", "12345"] for test in tests: with self.assertRaises(argparse.ArgumentTypeError): ArgumentType.alias_is_valid(test) tests = [ "valid", "123valid", "valid123", "_valid", "valid_", "-valid", "valid-", ".valid", ] for test in tests: self.assertEqual(ArgumentType.alias_is_valid(test), test) ripe-atlas-tools-3.1.0/tests/renderers/000077500000000000000000000000001437041663000200515ustar00rootroot00000000000000ripe-atlas-tools-3.1.0/tests/renderers/__init__.py000066400000000000000000000012321437041663000221600ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . ripe-atlas-tools-3.1.0/tests/renderers/test_dns_compact.py000066400000000000000000000115121437041663000237540ustar00rootroot00000000000000# Copyright (c) 2017 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from unittest import mock from pytz import timezone from ripe.atlas.sagan import Result from ripe.atlas.tools.renderers.dns_compact import Renderer def get_fake_localzone(): return timezone("UTC") @mock.patch("ripe.atlas.tools.renderers.dns_compact.get_localzone", get_fake_localzone) class TestDnsCompact(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.basic = Result.get( '{"lts":92,"from":"195.113.83.16","msm_id":9211416,"fw":4790,"timestamp":1503927916,"resultset":[{"lts":92,"src_addr":"195.113.83.16","af":4,"submax":3,"proto":"UDP","subid":1,"result":{"abuf":"fViBgAABAAIAAgAEBTF4YmV0A2NvbQAAAQABwAwAAQABAAAAGQAEvmnCOsAMAAEAAQAAABkABL550oXADAACAAEAAVUJABUEZGFuYQJucwpjbG91ZGZsYXJlwBLADAACAAEAAVUJAAcEcGV0ZcBMwEcAAQABAAFVCQAErfU6acBHABwAAQABVQkAECQAywAgSQABAAAAAK31OmnAaAABAAEAAVUJAASt9TuIwGgAHAABAAFVCQAQJADLACBJAAEAAAAArfU7iA==","rt":6.45,"NSCOUNT":2,"QDCOUNT":1,"ANCOUNT":2,"ARCOUNT":4,"ID":32088,"size":199},"time":1503927916,"dst_addr":"195.113.83.55"},{"lts":93,"src_addr":"195.113.83.16","af":4,"submax":3,"proto":"UDP","subid":2,"result":{"abuf":"D/uBBQABAAAAAAAABTF4YmV0A2NvbQAAAQAB","rt":5.798,"NSCOUNT":0,"QDCOUNT":1,"ANCOUNT":0,"ARCOUNT":0,"ID":4091,"size":27},"time":1503927917,"dst_addr":"147.231.12.1"},{"lts":94,"src_addr":"2001:718:1e06::16","af":6,"submax":3,"proto":"UDP","subid":3,"result":{"abuf":"pqqBgAABAAIAAgAEBTF4YmV0A2NvbQAAAQABwAwAAQABAAAAFwAEvnnShcAMAAEAAQAAABcABL5pwjrADAACAAEAAVUHABUEcGV0ZQJucwpjbG91ZGZsYXJlwBLADAACAAEAAVUHAAcEZGFuYcBMwGgAAQABAAFVBwAErfU6acBoABwAAQABVQcAECQAywAgSQABAAAAAK31OmnARwABAAEAAVUHAASt9TuIwEcAHAABAAFVBwAQJADLACBJAAEAAAAArfU7iA==","rt":5.684,"NSCOUNT":2,"QDCOUNT":1,"ANCOUNT":2,"ARCOUNT":4,"ID":42666,"size":199},"time":1503927918,"dst_addr":"2001:718:1e06::55"}],"prb_id":4062,"group_id":9211416,"type":"dns","msm_name":"Tdig"}' # noqa: E501 ) self.noerrornodata = Result.get( '{"lts":42,"from":"2001:718:1:a100::161:50","msm_id":9386425,"fw":4780,"proto":"UDP","af":6,"msm_name":"Tdig","prb_id":6068,"result":{"abuf":"8RCAgAABAAAAAQAACGlwdjRvbmx5BGFycGEAABwAAcAMAAYAAQAABikALQNzbnMDZG5zBWljYW5uA29yZwADbm9jwC94Ob7xAAAcIAAADhAACTqAAAAOEA==","rt":153.425,"NSCOUNT":1,"QDCOUNT":1,"ID":61712,"ARCOUNT":0,"ANCOUNT":0,"size":88},"timestamp":1506557387,"src_addr":"2001:718:1:a100::161:50","group_id":9386425,"type":"dns","dst_addr":"2001:4860:4860::6464"}' # noqa: E501 ) self.noresponse = Result.get( '{"lts":11,"from":"2a01:538:1:f000:fa1a:67ff:fe4d:7f1d","msm_id":9386425,"fw":4780,"timestamp":1506681497,"proto":"UDP","msm_name":"Tdig","prb_id":11879,"af":6,"error":{"timeout":5000},"src_addr":"2a01:538:1:f000:fa1a:67ff:fe4d:7f1d","group_id":9386425,"type":"dns","dst_addr":"2001:4860:4860::6464"}' # noqa: E501 ) self.noabuf = Result.get( '{"lts":27,"from":"80.92.240.37","msm_id":9211416,"fw":4780,"timestamp":1503927938,"resultset":[{"lts":27,"src_addr":"192.168.254.254","af":4,"submax":2,"proto":"UDP","subid":1,"time":1503927938,"error":{"timeout":5000},"dst_addr":"80.92.240.6"}],"prb_id":30410,"group_id":9211416,"type":"dns","msm_name":"Tdig"}' # noqa: E501 ) def test_basic(self): self.assertEqual( Renderer().on_result(self.basic), "Probe #4062: 2017-08-28 13:45:16 NOERROR qr ra rd 1xbet.com. 25 A 190.105.194.58; 1xbet.com. 25 A 190.121.210.133\n" # noqa: E501 "Probe #4062: 2017-08-28 13:45:16 REFUSED qr rd\n" "Probe #4062: 2017-08-28 13:45:16 NOERROR qr ra rd 1xbet.com. 23 A 190.121.210.133; 1xbet.com. 23 A 190.105.194.58\n", # noqa: E501 ) def test_noerrornodata(self): self.assertEqual( Renderer().on_result(self.noerrornodata), "Probe #6068: 2017-09-28 00:09:47 NOERROR qr ra\n", ) def test_noresponse(self): self.assertEqual( Renderer().on_result(self.noresponse), "Probe #11879: 2017-09-29 10:38:17 No response found\n", ) def test_noabuf(self): self.assertEqual( Renderer().on_result(self.noabuf), "Probe #30410: 2017-08-28 13:45:38 No abuf found\n", ) ripe-atlas-tools-3.1.0/tests/renderers/test_http.py000066400000000000000000000057051437041663000224500ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from ripe.atlas.sagan import Result from ripe.atlas.tools.renderers.http import Renderer class TestHttpRenderer(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.basic = Result.get( '{"lts":64,"from":"217.13.64.36","msm_id":2841267,"fw":4720,"timestamp":1450185727,"uri":"http://at-vie-as1120.anchors.atlas.ripe.net:80/4096","prb_id":1,"result":[{"rt":45.953289,"src_addr":"217.13.64.36","hsize":131,"af":4,"bsize":1668618,"res":200,"method":"GET","ver":"1.1","dst_addr":"193.171.255.2"}],"group_id":2841267,"type":"http","msm_name":"HTTPGet"}' # noqa: E501 ) self.multiple = Result.get( '{"lts":64,"from":"217.13.64.36","msm_id":2841267,"fw":4720,"timestamp":1450185727,"uri":"http://at-vie-as1120.anchors.atlas.ripe.net:80/4096","prb_id":1,"result":[{"rt":45.953289,"src_addr":"217.13.64.36","hsize":131,"af":4,"bsize":1668618,"res":200,"method":"GET","ver":"1.1","dst_addr":"193.171.255.2"},{"rt":45.953289,"src_addr":"217.13.64.36","hsize":131,"af":4,"bsize":1668618,"res":200,"method":"GET","ver":"1.1","dst_addr":"193.171.255.2"}],"group_id":2841267,"type":"http","msm_name":"HTTPGet"}' # noqa: E501 ) def test_basic(self): expected = ( "#Version: 1.0\n" "#Date: 2015-12-15 13:22:07\n" "#Fields: cs-method cs-uri c-ip s-ip sc-status time-taken http-version header-bytes body-bytes\n" # noqa: E501 "GET http://at-vie-as1120.anchors.atlas.ripe.net:80/4096 217.13.64.36 193.171.255.2 200 45.953289 1.1 131 1668618\n\n" # noqa: E501 ) self.assertEqual(Renderer().on_result(self.basic), expected) def test_multiple(self): expected = ( "#Version: 1.0\n" "#Date: 2015-12-15 13:22:07\n" "#Fields: cs-method cs-uri c-ip s-ip sc-status time-taken http-version header-bytes body-bytes\n" # noqa: E501 "GET http://at-vie-as1120.anchors.atlas.ripe.net:80/4096 217.13.64.36 193.171.255.2 200 45.953289 1.1 131 1668618\n" # noqa: E501 "GET http://at-vie-as1120.anchors.atlas.ripe.net:80/4096 217.13.64.36 193.171.255.2 200 45.953289 1.1 131 1668618\n\n" # noqa: E501 ) self.assertEqual(Renderer().on_result(self.multiple), expected) ripe-atlas-tools-3.1.0/tests/renderers/test_ping.py000066400000000000000000000257141437041663000224300ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from collections import namedtuple from ripe.atlas.sagan import Result from ripe.atlas.tools.renderers.ping import Renderer class TestPingRenderer(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.basic = Result.get( '{"af":4,"prb_id":1,"result":[{"rtt":10.001},{"rtt":10.002},{"rtt":10.003}],"ttl":20,"avg":10.002,"size":20,"from":"1.2.3.4","proto":"ICMP","timestamp":1440000000,"dup":0,"type":"ping","sent":3,"msm_id":1000001,"fw":4700,"max":10.003,"step":360,"src_addr":"2.3.4.5","rcvd":3,"msm_name":"Ping","lts":40,"dst_name":"my.name.ca","min":10.001,"dst_addr":"3.4.5.6"}' # noqa: E501 ) self.no_packets = Result.get( '{"af":4,"prb_id":2,"result":[],"ttl":20,"avg":10.002,"size":20,"from":"1.2.3.4","proto":"ICMP","timestamp":1440000000,"dup":0,"type":"ping","sent":3,"msm_id":1000001,"fw":4700,"max":null,"step":360,"src_addr":"2.3.4.5","rcvd":0,"msm_name":"Ping","lts":40,"dst_name":"my.name.ca","min":null,"dst_addr":"3.4.5.6"}' # noqa: E501 ) def test_basic(self): self.assertEqual( Renderer().on_result(self.basic), "20 bytes from 3.4.5.6 via probe #1 (1.2.3.4): ttl=20 times=10.001 ms, 10.002 ms, 10.003 ms\n", # noqa: E501 ) def test_no_packets(self): self.assertEqual(Renderer().on_result(self.no_packets), "No packets found\n") class TestAggregatePing(unittest.TestCase): @classmethod def setUpClass(cls): cls.results = [ { u"af": 4, u"prb_id": 11421, u"result": [ {u"rtt": 42.342895}, {u"rtt": 42.220215}, {u"rtt": 42.40614}, ], u"ttl": 53, u"avg": 42.3230833333, u"size": 48, u"from": u"178.11.85.39", u"proto": u"ICMP", u"timestamp": 1446146495, u"dup": 0, u"type": u"ping", u"sent": 3, u"msm_id": 2882184, u"fw": 4720, u"max": 42.40614, u"step": 240, u"src_addr": u"192.168.2.101", u"rcvd": 3, u"msm_name": u"Ping", u"lts": 3, u"dst_name": u"194.88.241.228", u"min": 42.220215, u"group_id": 2882184, u"dst_addr": u"194.88.241.228", }, { u"af": 4, u"prb_id": 11779, u"result": [{u"rtt": 76.61127}, {u"rtt": 76.38997}, {u"rtt": 76.47354}], u"ttl": 51, u"avg": 76.4915933333, u"size": 48, u"from": u"79.106.99.242", u"proto": u"ICMP", u"timestamp": 1446146494, u"dup": 0, u"type": u"ping", u"sent": 3, u"msm_id": 2882184, u"fw": 4720, u"max": 76.61127, u"step": 240, u"src_addr": u"192.168.1.110", u"rcvd": 3, u"msm_name": u"Ping", u"lts": 127, u"dst_name": u"194.88.241.228", u"min": 76.38997, u"group_id": 2882184, u"dst_addr": u"194.88.241.228", }, { u"af": 4, u"prb_id": 17854, u"result": [{u"rtt": 154.118}, {u"rtt": 154.197}, {u"rtt": 154.845}], u"ttl": 55, u"avg": 154.3866666667, u"size": 48, u"from": u"134.202.20.3", u"proto": u"ICMP", u"timestamp": 1446146493, u"dup": 0, u"type": u"ping", u"sent": 3, u"msm_id": 2882184, u"fw": 4700, u"max": 154.845, u"step": 240, u"src_addr": u"134.202.20.3", u"rcvd": 3, u"msm_name": u"Ping", u"lts": 1, u"dst_name": u"194.88.241.228", u"min": 154.118, u"group_id": 2882184, u"dst_addr": u"194.88.241.228", }, { u"af": 4, u"prb_id": 3183, u"result": [ {u"rtt": 42.263816}, {u"rtt": 42.196233}, {u"rtt": 42.342921}, ], u"ttl": 56, u"avg": 42.2676566667, u"size": 48, u"from": u"212.122.42.107", u"proto": u"ICMP", u"timestamp": 1446146494, u"dup": 0, u"type": u"ping", u"sent": 3, u"msm_id": 2882184, u"fw": 4720, u"max": 42.342921, u"step": 240, u"src_addr": u"192.168.189.1", u"rcvd": 3, u"msm_name": u"Ping", u"lts": 3, u"dst_name": u"194.88.241.228", u"min": 42.196233, u"group_id": 2882184, u"dst_addr": u"194.88.241.228", }, { u"af": 4, u"prb_id": 3207, u"result": [ {u"rtt": 218.077484}, {u"rtt": 36.921608}, {u"rtt": 38.99444}, ], u"ttl": 49, u"avg": 97.997844, u"size": 48, u"from": u"134.3.245.244", u"proto": u"ICMP", u"timestamp": 1446146494, u"dup": 0, u"type": u"ping", u"sent": 3, u"msm_id": 2882184, u"fw": 4720, u"max": 218.077484, u"step": 240, u"src_addr": u"10.30.0.4", u"rcvd": 3, u"msm_name": u"Ping", u"lts": 70, u"dst_name": u"194.88.241.228", u"min": 36.921608, u"group_id": 2882184, u"dst_addr": u"194.88.241.228", }, ] cls.sagans = [ Result.get( result, on_error=Result.ACTION_IGNORE, on_warning=Result.ACTION_IGNORE ) for result in cls.results ] def test_footer(self): """Tests whole functionality of footer unit.""" expected_output = ( "\n" "--- 194.88.241.228 ping statistics ---\n" "15 packets transmitted, 15 received, 0.0% loss\n" "rtt min/med/avg/max = 36.922/42.406/82.693/218.077 ms\n" ) r = Renderer() for s in self.sagans: r.on_result(s) self.assertEqual(r.footer(), expected_output) def test_collect_stats(self): """Tests collect stats function.""" renderer = Renderer() for s in self.sagans: renderer.collect_stats(s) self.assertEqual( renderer.rtts, [ 42.343, 42.22, 42.406, 76.611, 76.39, 76.474, 154.118, 154.197, 154.845, 42.264, 42.196, 42.343, 218.077, 36.922, 38.994, ], ) self.assertEqual(renderer.target, "194.88.241.228") self.assertEqual(renderer.sent_packets, 15) self.assertEqual(renderer.received_packets, 15) self.assertEqual( renderer.rtts_min, [42.220215, 76.38997, 154.118, 42.196233, 36.921608] ) self.assertEqual( renderer.rtts_max, [42.40614, 76.61127, 154.845, 42.342921, 218.077484] ) def test_collect_min_max_rtts(self): """Test use cases for collecting min max rtts.""" renderer = Renderer() renderer.collect_min_max_rtts("min", 3) self.assertEqual(renderer.rtts_min, [3]) renderer.collect_min_max_rtts("min", None) self.assertEqual(renderer.rtts_min, [3, 0]) renderer.collect_min_max_rtts("max", 3) self.assertEqual(renderer.rtts_max, [3]) renderer.collect_min_max_rtts("max", None) self.assertEqual(renderer.rtts_max, [3, 0]) def test_collect_packets_rtt(self): """Test use cases for collecting rtts.""" Packet = namedtuple("Packet", "rtt") packets = [Packet(rtt=2), Packet(rtt=3.2), Packet(rtt=5.0)] renderer = Renderer() renderer.collect_packets_rtt(packets) self.assertEqual(renderer.rtts, [2, 3.2, 5.0]) packets = [Packet(rtt=None), Packet(rtt=3.2), Packet(rtt=5.0)] renderer = Renderer() renderer.collect_packets_rtt(packets) self.assertEqual(renderer.rtts, [0, 3.2, 5.0]) def test_calculate_loss(self): """Test use cases for calculating loss.""" renderer = Renderer() renderer.sent_packets = 10 renderer.received_packets = 9 self.assertEqual(renderer.calculate_loss(), 9.999999999999998) renderer.sent_packets = 0 self.assertEqual(renderer.calculate_loss(), 0) renderer.received_packets = 0 renderer.sent_packets = 10 self.assertEqual(renderer.calculate_loss(), 100) renderer.received_packets = 5 self.assertEqual(renderer.calculate_loss(), 50) def test_mean(self): """Test use cases for calculating mean.""" renderer = Renderer() renderer.rtts = [0, 2.0, 5.0, 20] self.assertEqual(renderer.mean(), 6.75) renderer.rtts = [0, 2.0, 7.5, 5.0, 20] self.assertEqual(renderer.mean(), 6.9) renderer.rtts = [0, 2.0, 7.5, 5.0, 20, 50] self.assertEqual(renderer.mean(), 14.083) def test_median(self): """Test use cases for calculating median.""" renderer = Renderer() renderer.rtts = [0, 2.0, 5.0, 20] self.assertEqual(renderer.median(), 3.5) renderer.rtts = [0, 2.0, 7.5, 5.0, 20] self.assertEqual(renderer.median(), 5) renderer.rtts = [0, 2.0, 7.5, 5.0, 20, 50] self.assertEqual(renderer.median(), 6.25) ripe-atlas-tools-3.1.0/tests/renderers/test_raw.py000066400000000000000000000240621437041663000222570ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import json import unittest from unittest import mock from ripe.atlas.cousteau import Probe from ripe.atlas.tools.commands.report import Command from ..base import capture_sys_output class TestRawRenderer(unittest.TestCase): mocked_results = [ { "af": 4, "prb_id": 1216, "result": [{"rtt": 27.429}, {"rtt": 25.672}, {"rtt": 25.681}], "ttl": 54, "avg": 26.2606666667, "size": 20, "from": "109.190.83.40", " proto": "ICMP", "timestamp": 1445025400, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 27.429, "step": 360, "src_addr": "192.168.103.132", "rcvd": 3, "msm_name": "Ping", "lts": 377, "dst_name": "hsi.cablecom.ch", "min": 25.672, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 165, "result": [{"rtt": 87.824658}, {"rtt": 87.611154}, {"rtt": 90.99957}], "ttl": 48, "avg": 88.811794, "size": 20, "from": "194.85.27.7", "proto": "ICMP", "timestamp": 1445025590, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 90.99957, "step": 360, "src_addr": "192.168.3.8", "rcvd": 3, "msm_name": "Ping", " lts": 87, "dst_name": "hsi.cablecom.ch", "min": 87.611154, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 202, "result": [{"rtt": 40.02356}, {"rtt": 40.399112}, {"rtt": 39.29012}], "ttl": 52, "avg": 39.904264, "size": 20, "from": "178.190.51.206", "proto": "ICMP", "timestamp": 1445015502, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 40.399112, "step": 360, "src_addr": "10.0.0.2", "rcvd": 3, "msm_name": "Ping", "lts": 502, "dst_name": "hsi.cablecom.ch", "min": 39.29012, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 2225, "result": [ {"rtt": 10.858}, {"rtt": 12.632}, {"rtt": 20.53}, {"dup": 1, "rtt": 32.775}, {"dup": 1, "rtt": 47.509}, {"dup": 1, "rtt": 62.745}, {"dup": 1, "rtt": 78.54}, {"dup": 1, "rtt": 93.272}, {"dup": 1, "rtt": 109.738}, ], "ttl": 56, "avg": 14.6733333333, "size": 20, "from": "46.126.90.165", "proto": "ICMP", "timestamp": 1445025616, "dup": 6, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 20.53, "step": 360, "src_addr": "192.168.111.103", "rcvd": 3, "msm_name": "Ping", "lts": 309, "dst_name": "hsi.cablecom.ch", "min": 10.858, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 270, "result": [{"rtt": 28.527366}, {"rtt": 26.585862}, {"rtt": 26.393094}], "ttl": 51, "avg": 27.168774, "size": 20, "from": "188.192.110.111", "proto": "ICMP", "timestamp": 1445025513, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 28.527366, "step": 360, "src_addr": "192.168.178.21", "rcvd": 3, "msm_name": "Ping", "lts": 182, "dst_name": "hsi.cablecom.ch", "min": 26.393094, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 579, "result": [{"rtt": 23.201285}, {"rtt": 22.980868}, {"rtt": 22.863364}], "ttl": 51, "avg": 23.0151723333, "size": 20, "from": "195.88.195.170", "proto": "ICMP", "timestamp": 1445025521, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 23.201285, "step": 360, "src_addr": "10.69.8.150", "rcvd": 3, "msm_name": "Ping", "lts": 56, "dst_name": "hsi.cablecom.ch", "min": 22.863364, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 677, "result": [{"rtt": 40.71476}, {"rtt": 40.258568}, {"rtt": 40.316936}], "ttl": 54, "avg": 40.430088, "size": 20, "from": "78.128.9.202", "proto": "ICMP", "timestamp": 1445025298, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 40.71476, "step": 360, "src_addr": "10.100.0.25", "rcvd": 3, "msm_name": "Ping", "lts": 97, "dst_name": "hsi.cablecom.ch", "min": 40.258568, "group_id": 1000192, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 879, "result": [{"rtt": 34.319623}, {"rtt": 34.445575}, {"rtt": 34.376455}], "ttl": 53, "avg": 34.380551, "size": 20, "from": "94.254.125.2", "proto": "ICMP", "timestamp": 1445025223, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 34.445575, "step": 360, "src_addr": "192.168.8.130", "rcvd": 3, "msm_name": "Ping", "lts": 189, "dst_name": "hsi.cablecom.ch", "min": 34.319623, "dst_addr": "62.2.16.24", }, { "af": 4, "prb_id": 945, "result": [{"rtt": 61.665036}, {"rtt": 23.833349}, {"rtt": 23.268868}], "ttl": 56, "avg": 36.255751, "size": 20, "from": "92.111.237.94", "proto": "ICMP", "timestamp": 1445025494, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4720, "max": 61.665036, "step": 360, "src_addr": "92.111.237.94", "rcvd": 3, "msm_name": "Ping", "lts": 746, "dst_name": "hsi.cablecom.ch", "min": 23.268868, "dst_addr": "62.2.16.24", }, ] def setUp(self): self.cmd = Command() def test_raw_renderer(self): """Test case where user specified report with raw rendering.""" json_results = [] for result in self.mocked_results: json_results.append(json.dumps(result, separators=(",", ":"))) expected_output = "\n".join(json_results) + "\n" probes = [ Probe( id=202, meta_data={"country_code": "GR", "asn_v4": 3337, "asn_v6": "4445"}, ), Probe( id=677, meta_data={"country_code": "DE", "asn_v4": 3333, "asn_v6": "4444"}, ), Probe( id=2225, meta_data={"country_code": "DE", "asn_v4": 3332, "asn_v6": "4444"}, ), Probe( id=165, meta_data={"country_code": "NL", "asn_v4": 3334, "asn_v6": "4444"}, ), Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3335, "asn_v6": "4444"}, ), Probe( id=270, meta_data={"country_code": "GR", "asn_v4": 3340, "asn_v6": "4444"}, ), Probe( id=579, meta_data={"country_code": "GR", "asn_v4": 3336, "asn_v6": "4444"}, ), Probe( id=945, meta_data={"country_code": "GR", "asn_v4": 3334, "asn_v6": "4444"}, ), Probe( id=879, meta_data={"country_code": "GR", "asn_v4": 3333, "asn_v6": "4444"}, ), ] with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, self.mocked_results)] mpath = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(mpath) as mock_get_many: mock_get_many.return_value = probes self.cmd.init_args(["1", "--renderer", "raw"]) self.cmd.run() self.assertEqual(stdout.getvalue(), expected_output) ripe-atlas-tools-3.1.0/tests/renderers/test_ssl_consistency.py000066400000000000000000002470031437041663000247120ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from unittest import mock from ripe.atlas.cousteau import Probe as CProbe from ripe.atlas.tools.filters import SaganSet from ripe.atlas.tools.commands.report import Command from ripe.atlas.tools.renderers.ssl_consistency import Renderer from ..base import capture_sys_output class TestSSLConsistency(unittest.TestCase): @classmethod def setUpClass(cls): cls.results = [ { u"rt": 737.834, u"msm_id": 1443369, u"from": u"210.6.135.152", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727294, u"fw": 4570, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1003, u"dst_port": u"443", u"dst_addr": u"86.59.30.40", u"ttc": 355.078, u"src_addr": u"192.168.1.182", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 496.488, u"msm_id": 1443369, u"from": u"218.254.74.122", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727295, u"fw": 4570, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1004, u"dst_port": u"443", u"dst_addr": u"38.229.72.14", u"ttc": 239.37, u"src_addr": u"192.168.1.100", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"from": u"183.62.4.188", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4600, u"timestamp": 1392727294, u"af": 4, u"dst_addr": u"216.234.179.13", u"prb_id": 1008, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"rt": 658.671, u"msm_id": 1443369, u"from": u"113.255.77.244", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727293, u"fw": 4570, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1033, u"dst_port": u"443", u"dst_addr": u"82.195.75.101", u"ttc": 324.6, u"src_addr": u"192.168.0.183", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 518.082, u"msm_id": 1443369, u"from": u"203.218.168.183", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727295, u"fw": 4600, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1038, u"dst_port": u"443", u"dst_addr": u"38.229.72.14", u"ttc": 244.924, u"src_addr": u"192.168.95.248", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 615.64, u"msm_id": 1443369, u"from": u"103.244.157.214", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727295, u"fw": 4600, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1047, u"dst_port": u"443", u"dst_addr": u"93.95.227.222", u"ttc": 302.403, u"src_addr": u"192.168.6.137", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"from": u"116.237.191.131", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4600, u"timestamp": 1392727292, u"af": 4, u"dst_addr": u"209.145.54.50", u"prb_id": 11572, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"from": u"116.247.110.182", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4580, u"timestamp": 1392727294, u"af": 4, u"dst_addr": u"202.181.7.85", u"prb_id": 11700, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"rt": 673.665, u"msm_id": 1443369, u"from": u"103.6.131.59", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727294, u"fw": 4580, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 12203, u"dst_port": u"443", u"dst_addr": u"86.59.30.40", u"ttc": 326.088, u"src_addr": u"103.6.131.59", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 768.923, u"msm_id": 1443369, u"from": u"103.15.180.250", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727296, u"fw": 4580, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 12208, u"dst_port": u"443", u"dst_addr": u"93.95.227.222", u"ttc": 381.856, u"src_addr": u"103.15.180.250", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"dnserr": u"non-recoverable failure in name resolution (1)", u"from": u"103.6.129.113", u"dst_name": u"torproject.org", u"fw": 4580, u"timestamp": 1392727293, u"prb_id": 12214, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"rt": 514.766, u"msm_id": 1443369, u"from": u"158.132.255.55", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727293, u"fw": 4580, u"cert": [ u"-----BEGIN CERTIFICATE-----\nMIIGujCCBaKgAwIBAgIQBt6X5R3DncJkjaxy3UEB/DANBgkqhkiG9w0BAQsFADBm\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBIaWdoIEFzc3VyYW5j\nZSBDQS0zMB4XDTEzMDEyOTAwMDAwMFoXDTE2MDUwMzEyMDAwMFowcjELMAkGA1UE\nBhMCVVMxFjAUBgNVBAgTDU1hc3NhY2h1c2V0dHMxEDAOBgNVBAcTB1dhbHBvbGUx\nHjAcBgNVBAoTFVRoZSBUb3IgUHJvamVjdCwgSW5jLjEZMBcGA1UEAwwQKi50b3Jw\ncm9qZWN0Lm9yZzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN1oOe8B\n0kT0l6MXsIOWiBiXqLfGCk8nIeX+GXc0TNez14HBWPOzLMmA6Kfj3h9kJ0hLCzlS\nGui3xsT1ca5ZXONP/2beDkIoxwF+7/MCS8gOu4Cyua0CjR0ce6YWemKYVKxoqJvY\nH/S2UnzMHaBI/bhJ+QK5kMYg/JXoMx9IMIJnjl9clFt3TE34UR5/NZTsytXAtCjI\n5qMSpzKRE31RREGv1kxwTqJq/g5UFJWzZEwISDEhTeFTVOru0qjbEAqaip4hQH9D\nITjDOFw7Upgdab4TN4gLwDaZuo+Qcz+CQR6vCSlP2KziQAH9nlU+qT81eYVv+NOf\njogvdu/Atl/q+z0CAwEAAaOCA1YwggNSMB8GA1UdIwQYMBaAFFDqc4nbKfsQj57l\nASDU3nmZSIP3MB0GA1UdDgQWBBSx87Iq0fmAeNURYjYpnSG8riduZjArBgNVHREE\nJDAighAqLnRvcnByb2plY3Qub3Jngg50b3Jwcm9qZWN0Lm9yZzAOBgNVHQ8BAf8E\nBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMGEGA1UdHwRaMFgw\nKqAooCaGJGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9jYTMtZzE4LmNybDAqoCig\nJoYkaHR0cDovL2NybDQuZGlnaWNlcnQuY29tL2NhMy1nMTguY3JsMIIBxAYDVR0g\nBIIBuzCCAbcwggGzBglghkgBhv1sAQEwggGkMDoGCCsGAQUFBwIBFi5odHRwOi8v\nd3d3LmRpZ2ljZXJ0LmNvbS9zc2wtY3BzLXJlcG9zaXRvcnkuaHRtMIIBZAYIKwYB\nBQUHAgIwggFWHoIBUgBBAG4AeQAgAHUAcwBlACAAbwBmACAAdABoAGkAcwAgAEMA\nZQByAHQAaQBmAGkAYwBhAHQAZQAgAGMAbwBuAHMAdABpAHQAdQB0AGUAcwAgAGEA\nYwBjAGUAcAB0AGEAbgBjAGUAIABvAGYAIAB0AGgAZQAgAEQAaQBnAGkAQwBlAHIA\ndAAgAEMAUAAvAEMAUABTACAAYQBuAGQAIAB0AGgAZQAgAFIAZQBsAHkAaQBuAGcA\nIABQAGEAcgB0AHkAIABBAGcAcgBlAGUAbQBlAG4AdAAgAHcAaABpAGMAaAAgAGwA\naQBtAGkAdAAgAGwAaQBhAGIAaQBsAGkAdAB5ACAAYQBuAGQAIABhAHIAZQAgAGkA\nbgBjAG8AcgBwAG8AcgBhAHQAZQBkACAAaABlAHIAZQBpAG4AIABiAHkAIAByAGUA\nZgBlAHIAZQBuAGMAZQAuMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcwAYYYaHR0\ncDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8vY2FjZXJ0\ncy5kaWdpY2VydC5jb20vRGlnaUNlcnRIaWdoQXNzdXJhbmNlQ0EtMy5jcnQwDAYD\nVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAQEAFfAsIxhBxzSVi5a9FpEp9JGc\n0wL5/4BVFv0lKYjHkRVoBdvN3gnAfGt2YXrAJZb7OCVwW3KFdSaTwm8T10eCVSXX\nASTrp6DWs6mHxw9HGIkVF9YESq6x5/ZGHDTovuRMCeHuIwn+nBL21z1WDqwozwcQ\nAxNXeRXJvXO4bOj301+26as9cOWjonGzkW9uc3WTWp89+YOpRo6RQ59Yc3UJlxjW\nHZR3Oqp/GM1jo2NPHnFeMpnFtVj+uuQBtNj7D7jiWhGtNxFIePizOBs8k+ao9lWO\nE2UHK5iM17YISRhBPNwi4YL+nf+jo5untE6WgvFYhEH2pwmCSKrIYBdGatbxfw==\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 13026, u"dst_port": u"443", u"dst_addr": u"93.95.227.222", u"ttc": 252.836, u"src_addr": u"192.168.1.185", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 868.668, u"msm_id": 1443369, u"from": u"116.231.230.67", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727294, u"fw": 4580, u"cert": [ u"-----BEGIN CERTIFICATE-----\nMIIGujCCBaKgAwIBAgIQBt6X5R3DncJkjaxy3UEB/DANBgkqhkiG9w0BAQsFADBm\nMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\nd3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBIaWdoIEFzc3VyYW5j\nZSBDQS0zMB4XDTEzMDEyOTAwMDAwMFoXDTE2MDUwMzEyMDAwMFowcjELMAkGA1UE\nBhMCVVMxFjAUBgNVBAgTDU1hc3NhY2h1c2V0dHMxEDAOBgNVBAcTB1dhbHBvbGUx\nHjAcBgNVBAoTFVRoZSBUb3IgUHJvamVjdCwgSW5jLjEZMBcGA1UEAwwQKi50b3Jw\ncm9qZWN0Lm9yZzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN1oOe8B\n0kT0l6MXsIOWiBiXqLfGCk8nIeX+GXc0TNez14HBWPOzLMmA6Kfj3h9kJ0hLCzlS\nGui3xsT1ca5ZXONP/2beDkIoxwF+7/MCS8gOu4Cyua0CjR0ce6YWemKYVKxoqJvY\nH/S2UnzMHaBI/bhJ+QK5kMYg/JXoMx9IMIJnjl9clFt3TE34UR5/NZTsytXAtCjI\n5qMSpzKRE31RREGv1kxwTqJq/g5UFJWzZEwISDEhTeFTVOru0qjbEAqaip4hQH9D\nITjDOFw7Upgdab4TN4gLwDaZuo+Qcz+CQR6vCSlP2KziQAH9nlU+qT81eYVv+NOf\njogvdu/Atl/q+z0CAwEAAaOCA1YwggNSMB8GA1UdIwQYMBaAFFDqc4nbKfsQj57l\nASDU3nmZSIP3MB0GA1UdDgQWBBSx87Iq0fmAeNURYjYpnSG8riduZjArBgNVHREE\nJDAighAqLnRvcnByb2plY3Qub3Jngg50b3Jwcm9qZWN0Lm9yZzAOBgNVHQ8BAf8E\nBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMGEGA1UdHwRaMFgw\nKqAooCaGJGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9jYTMtZzE4LmNybDAqoCig\nJoYkaHR0cDovL2NybDQuZGlnaWNlcnQuY29tL2NhMy1nMTguY3JsMIIBxAYDVR0g\nBIIBuzCCAbcwggGzBglghkgBhv1sAQEwggGkMDoGCCsGAQUFBwIBFi5odHRwOi8v\nd3d3LmRpZ2ljZXJ0LmNvbS9zc2wtY3BzLXJlcG9zaXRvcnkuaHRtMIIBZAYIKwYB\nBQUHAgIwggFWHoIBUgBBAG4AeQAgAHUAcwBlACAAbwBmACAAdABoAGkAcwAgAEMA\nZQByAHQAaQBmAGkAYwBhAHQAZQAgAGMAbwBuAHMAdABpAHQAdQB0AGUAcwAgAGEA\nYwBjAGUAcAB0AGEAbgBjAGUAIABvAGYAIAB0AGgAZQAgAEQAaQBnAGkAQwBlAHIA\ndAAgAEMAUAAvAEMAUABTACAAYQBuAGQAIAB0AGgAZQAgAFIAZQBsAHkAaQBuAGcA\nIABQAGEAcgB0AHkAIABBAGcAcgBlAGUAbQBlAG4AdAAgAHcAaABpAGMAaAAgAGwA\naQBtAGkAdAAgAGwAaQBhAGIAaQBsAGkAdAB5ACAAYQBuAGQAIABhAHIAZQAgAGkA\nbgBjAG8AcgBwAG8AcgBhAHQAZQBkACAAaABlAHIAZQBpAG4AIABiAHkAIAByAGUA\nZgBlAHIAZQBuAGMAZQAuMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcwAYYYaHR0\ncDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8vY2FjZXJ0\ncy5kaWdpY2VydC5jb20vRGlnaUNlcnRIaWdoQXNzdXJhbmNlQ0EtMy5jcnQwDAYD\nVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAQEAFfAsIxhBxzSVi5a9FpEp9JGc\n0wL5/4BVFv0lKYjHkRVoBdvN3gnAfGt2YXrAJZb7OCVwW3KFdSaTwm8T10eCVSXX\nASTrp6DWs6mHxw9HGIkVF9YESq6x5/ZGHDTovuRMCeHuIwn+nBL21z1WDqwozwcQ\nAxNXeRXJvXO4bOj301+26as9cOWjonGzkW9uc3WTWp89+YOpRo6RQ59Yc3UJlxjW\nHZR3Oqp/GM1jo2NPHnFeMpnFtVj+uuQBtNj7D7jiWhGtNxFIePizOBs8k+ao9lWO\nE2UHK5iM17YISRhBPNwi4YL+nf+jo5untE6WgvFYhEH2pwmCSKrIYBdGatbxfw==\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 13377, u"dst_port": u"443", u"dst_addr": u"82.195.75.101", u"ttc": 431.422, u"src_addr": u"10.0.10.39", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 471.564, u"msm_id": 1443369, u"from": u"103.247.138.60", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727304, u"fw": 4600, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 1386, u"dst_port": u"443", u"dst_addr": u"38.229.72.16", u"ttc": 228.561, u"src_addr": u"103.247.138.60", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"rt": 1161.992, u"msm_id": 1443369, u"from": u"193.162.21.10", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727296, u"fw": 4600, u"cert": [ u"-----BEGIN CERTIFICATE-----\nMIID/TCCAuWgAwIBAgIkNhPSsip1AJR2DEGtGdtSpPBb3qgBcuJXh2Gtln9+2aoo\nacTlMA0GCSqGSIb3DQEBBQUAMGAxCzAJBgNVBAYTAkVVMQswCQYDVQQIEwJFVTEL\nMAkGA1UEBxMCRVUxDDAKBgNVBAoTA0RTVjEMMAoGA1UECxMDRFNWMRswGQYDVQQD\nExJhcGFjLnByb3h5LmRzdi5jb20wHhcNMTMwMTI5MDAwMDAwWhcNMTYwNTAzMTIw\nMDAwWjByMQswCQYDVQQGEwJVUzEWMBQGA1UECBMNTWFzc2FjaHVzZXR0czEQMA4G\nA1UEBxMHV2FscG9sZTEeMBwGA1UEChMVVGhlIFRvciBQcm9qZWN0LCBJbmMuMRkw\nFwYDVQQDDBAqLnRvcnByb2plY3Qub3JnMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A\nMIIBCgKCAQEAoGZlXATizI+cktME+tx2rjLndU2i0ATLGmzuhlxqwQ6RiFasuMkp\nfJcQp64tETk7mXxRWFGWVHiUFjCoeSQtO9Y0gxUk4mLTHPuh5nE8V3BzaDQ6sO9R\nPBXhVlTnbUatAitvgKM5PZnAgT+hi3ZcByGERBys/eITyCI/Uh9HZFW7Q2mUBcjr\n3/u36xeQdKMSH8hyq06I7HpRRwZpmv3T67jBQC6vo62rBnfGQ3vTcSVOmDoUOjD3\nGF1P/Ko7ch4Ao2P9/+T8/tNooJOPBK68VL168PTYRgG9Vyeh4hU2ipP/dd9DqoR+\nt3UwNO6o8jQmNSxdB/rjMcUtS7enSy2P7wIDAQABo4GMMIGJMB0GA1UdDgQWBBSx\n87Iq0fmAeNURYjYpnSG8riduZjArBgNVHREEJDAighAqLnRvcnByb2plY3Qub3Jn\ngg50b3Jwcm9qZWN0Lm9yZzAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYB\nBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQEFBQADggEB\nAHEvFwq+/VeBSa56orsVzq9Af34ZuTTST7zAUjfpDSYr/VjmHB4n0Uq80/cRWlm9\nDhRafM36IEk7tYpCN5tK4MYyMVg3FUESDsx37ZNDTpUiVSQPYjxpWQ7I/1kz7Sua\n6f/WQElnghZqa8Fj0s7zL/z6OxhDQMBjZvUzxtlsPhWjryo14COmQhsxW9b2uQA9\n14fPo4AcoFcmze/NAz4oMGyhsGKXwbkXFS5S2fW3ncSTxZBKJV+h8uslvB3owLvm\nhyqTwMk2iY8Z0jWDzR24jL76hPM3MWdFSSZzSkRLASEAcc/M/B50BcLfIFUSizNq\n4UoEZ4u6z2ZSChVJ3nHHaI8=\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nnzi9veZZknp8KIDEW6A=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 2844, u"dst_port": u"443", u"dst_addr": u"38.229.72.16", u"ttc": 3.042, u"src_addr": u"145.218.88.254", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"from": u"210.22.91.254", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4570, u"timestamp": 1392727297, u"af": 4, u"dst_addr": u"4.36.66.178", u"prb_id": 3386, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"from": u"180.154.141.170", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4600, u"timestamp": 1392727296, u"af": 4, u"dst_addr": u"209.145.54.50", u"prb_id": 3909, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"from": u"180.154.141.170", u"dst_name": u"torproject.org", u"err": u"connect: timeout", u"fw": 4600, u"timestamp": 1392727295, u"af": 4, u"dst_addr": u"216.234.179.13", u"prb_id": 3914, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, { u"rt": 420.604, u"msm_id": 1443369, u"from": u"27.50.33.14", u"dst_name": u"torproject.org", u"af": 4, u"timestamp": 1392727295, u"fw": 4600, u"cert": [ u"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----", # noqa: E501 u"-----BEGIN CERTIFICATE-----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\nIb4p1I5eFdZCSucyb6Sxa1GDWL4/bcf72gMhy2oWGU4K8K2Eyl2Us1p292E=\n-----END CERTIFICATE-----", # noqa: E501 ], u"method": u"SSL", u"prb_id": 400, u"dst_port": u"443", u"dst_addr": u"38.229.72.14", u"ttc": 203.67, u"src_addr": u"27.50.33.14", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"ver": u"3.0", }, { u"dnserr": u"non-recoverable failure in name resolution (1)", u"from": u"211.68.70.39", u"dst_name": u"torproject.org", u"fw": 4600, u"timestamp": 1392727294, u"prb_id": 483, u"dst_port": u"443", u"group_id": 1443369, u"type": u"sslcert", u"msm_name": u"SSLCert", u"msm_id": 1443369, }, ] cls.probes = { 1003: CProbe( id=1003, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 1004: CProbe( id=1004, meta_data={ "country_code": "DE", "asn_v4": 3333, "asn_v6": "4444", }, ), 1008: CProbe( id=1008, meta_data={ "country_code": "DE", "asn_v4": 3332, "asn_v6": "4444", }, ), 1033: CProbe( id=1033, meta_data={ "country_code": "NL", "asn_v4": 3333, "asn_v6": "4444", }, ), 1038: CProbe( id=1038, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 1047: CProbe( id=1047, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 11672: CProbe( id=11572, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 11700: CProbe( id=11700, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 12203: CProbe( id=12203, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 12208: CProbe( id=12208, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 12214: CProbe( id=12214, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 13026: CProbe( id=13026, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 13377: CProbe( id=13377, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 1386: CProbe( id=1386, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 2844: CProbe( id=2844, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 3386: CProbe( id=3386, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 3909: CProbe( id=3909, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 3914: CProbe( id=3914, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 400: CProbe( id=400, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), 483: CProbe( id=483, meta_data={ "country_code": "GR", "asn_v4": 3333, "asn_v6": "4444", }, ), } def test_footer(self): """Tests whole functionality of footer unit.""" expected_output = ( "Certificate:\n" " Issuer: C=US, O=DigiCert Inc, CN=DigiCert High Assurance CA-3\n" " Subject: C=US, O=The Tor Project, Inc., CN=*.torproject.org\n" " SHA256 Fingerprint=36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA\n\n" # noqa: E501 " Seen by 11 probes\n\n" "Certificate:\n" " Issuer: C=US, O=DigiCert Inc, CN=DigiCert High Assurance EV Root CA\n" " Subject: C=US, O=DigiCert Inc, CN=DigiCert High Assurance CA-3\n" " SHA256 Fingerprint=21:EB:37:AB:4C:F6:EF:89:65:EC:17:66:40:9C:A7:6B:8B:2E:03:F2:D1:A3:88:DF:73:42:08:E8:6D:EE:E6:79\n\n" # noqa: E501 " Seen by 11 probes\n\n" "Certificate:\n" " Issuer: C=EU, O=DSV, CN=apac.proxy.dsv.com\n" " Subject: C=US, O=The Tor Project, Inc., CN=*.torproject.org\n" " SHA256 Fingerprint=07:52:BE:65:72:BF:02:D4:C9:E2:93:09:A8:E0:BE:3A:EA:D4:30:41:B8:49:FA:C5:F2:12:33:07:37:57:EE:C7\n\n" # noqa: E501 " Seen by 1 probe\n\n" " Below the threshold (80%)\n" " Probes that saw it: \n" " ID: 2844, country code: GR, ASN (v4/v6): 3333/4444\n" "Certificate:\n" " Issuer: C=None, O=None, CN=DSV Enterprise CA 1\n" " Subject: C=EU, O=DSV, CN=apac.proxy.dsv.com\n" " SHA256 Fingerprint=1A:B8:9E:ED:1B:DD:A0:E2:EA:67:89:C1:C5:4B:20:1C:49:9D:74:27:B0:5D:11:F2:9A:5F:C1:0D:F9:18:48:DA\n\n" # noqa: E501 " Seen by 1 probe\n\n" " Below the threshold (80%)\n" " Probes that saw it: \n" " ID: 2844, country code: GR, ASN (v4/v6): 3333/4444" ) path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() r = Renderer() for s in SaganSet(self.results): r.on_result(s) self.assertEqual( r.footer().split("\n"), expected_output.split("\n"), ) def test_gather_unique_certs(self): """Test gathering of the unique certs in sagans set""" expected_certs = { "1A:B8:9E:ED:1B:DD:A0:E2:EA:67:89:C1:C5:4B:20:1C:49:9D:74:27:B0:5D:11:F2:9A:5F:C1:0D:F9:18:48:DA": { # noqa: E501 "cnt": 1, "probes": [self.probes[2844]], }, "36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA": { # noqa: E501 "cnt": 11, "probes": [ self.probes[1003], self.probes[1004], self.probes[1033], self.probes[1038], self.probes[1047], self.probes[12203], self.probes[12208], self.probes[13026], self.probes[13377], self.probes[1386], self.probes[400], ], }, "21:EB:37:AB:4C:F6:EF:89:65:EC:17:66:40:9C:A7:6B:8B:2E:03:F2:D1:A3:88:DF:73:42:08:E8:6D:EE:E6:79": { # noqa: E501 "cnt": 11, "probes": [ self.probes[1003], self.probes[1004], self.probes[1033], self.probes[1038], self.probes[1047], self.probes[12203], self.probes[12208], self.probes[13026], self.probes[13377], self.probes[1386], self.probes[400], ], }, "07:52:BE:65:72:BF:02:D4:C9:E2:93:09:A8:E0:BE:3A:EA:D4:30:41:B8:49:FA:C5:F2:12:33:07:37:57:EE:C7": { # noqa: E501 "cnt": 1, "probes": [self.probes[2844]], }, } path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet(self.results) renderer = Renderer() for s in sagans: renderer.on_result(s) # remove cert key to make easier to test for k in renderer.uniqcerts: renderer.uniqcerts[k].pop("cert") self.assertEqual(renderer.uniqcerts, expected_certs) def test_bucketize_result_cert(self): """Tests bucketize of a single sagan result""" expected_certs = { "36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA": { # noqa: E501 "cnt": 1, "probes": [self.probes[1003]], }, "21:EB:37:AB:4C:F6:EF:89:65:EC:17:66:40:9C:A7:6B:8B:2E:03:F2:D1:A3:88:DF:73:42:08:E8:6D:EE:E6:79": { # noqa: E501 "cnt": 1, "probes": [self.probes[1003]], }, } path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet(self.results) renderer = Renderer() renderer.bucketize_result_cert(list(sagans)[0]) # remove cert key to make easier to test for k in renderer.uniqcerts: renderer.uniqcerts[k].pop("cert") self.assertEqual(renderer.uniqcerts, expected_certs) def test_get_nprobes_ofpopular_cert(self): """Tests fetching the number of probes for the most popular cert""" path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet(self.results) renderer = Renderer() for s in sagans: renderer.on_result(s) self.assertEqual(renderer.get_nprobes_ofpopular_cert(), 11) def test_get_nprobes_ofpopular_cert_empty(self): """Tests that getting the number of probes for popular certs does not throw an error when there are no valid certificates.""" path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet([]) renderer = Renderer() for s in sagans: renderer.on_result(s) self.assertEqual(renderer.get_nprobes_ofpopular_cert(), 0) def test_render_certificate(self): """Tests rendering of single certificate.""" expected_output = ( "Certificate:\n" " Issuer: C=US, O=DigiCert Inc, CN=DigiCert High Assurance CA-3\n" " Subject: C=US, O=The Tor Project, Inc., CN=*.torproject.org\n" " SHA256 Fingerprint=36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA\n\n" # noqa: E501 " Seen by 11 probes\n" ) path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet(self.results) renderer = Renderer() for s in sagans: renderer.on_result(s) self.assertEqual( renderer.render_certificate( "36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA" # noqa: E501 ), expected_output, ) def test_render_below_thershold(self): """Tests rendering string for certs that are seen for below threshold probes.""" expected_output = [ " Below the threshold (80%)", " Probes that saw it: ", " ID: 2844, country code: GR, ASN (v4/v6): 3333/4444", ] path = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(path) as mock_get_many: mock_get_many.return_value = self.probes.values() sagans = SaganSet(self.results) renderer = Renderer() for s in sagans: renderer.on_result(s) self.assertEqual( renderer.render_below_threshold( "07:52:BE:65:72:BF:02:D4:C9:E2:93:09:A8:E0:BE:3A:EA:D4:30:41:B8:49:FA:C5:F2:12:33:07:37:57:EE:C7" # noqa: E501 ), expected_output, ) def test_report_with_ssl_consistency_renderer(self): """Tests the report with the ssl renderer.""" results = self.results[:2] expected_output = ( "Certificate:\n" " Issuer: C=US, O=DigiCert Inc, CN=DigiCert High Assurance CA-3\n" " Subject: C=US, O=The Tor Project, Inc., CN=*.torproject.org\n" " SHA256 Fingerprint=36:13:D2:B2:2A:75:00:94:76:0C:41:AD:19:DB:52:A4:F0:5B:DE:A8:01:72:E2:57:87:61:AD:96:7F:7E:D9:AA\n\n" # noqa: E501 " Seen by 2 probes\n\n" "Certificate:\n" " Issuer: C=US, O=DigiCert Inc, CN=DigiCert High Assurance EV Root CA\n" " Subject: C=US, O=DigiCert Inc, CN=DigiCert High Assurance CA-3\n" " SHA256 Fingerprint=21:EB:37:AB:4C:F6:EF:89:65:EC:17:66:40:9C:A7:6B:8B:2E:03:F2:D1:A3:88:DF:73:42:08:E8:6D:EE:E6:79\n\n" # noqa: E501 " Seen by 2 probes\n\n" ) with capture_sys_output() as (stdout, stderr): path = "ripe.atlas.cousteau.AtlasRequest.get" with mock.patch(path) as mock_get: mock_get.side_effect = [(True, results)] mpath = "ripe.atlas.tools.filters.Probe.get_many" with mock.patch(mpath) as mock_get_many: mock_get_many.return_value = [ self.probes[1003], self.probes[1004], ] cmd = Command() cmd.init_args(["1", "--renderer", "ssl_consistency"]) cmd.run() expected_set = set(expected_output.split("\n")) returned_set = set(stdout.getvalue().split("\n")) self.assertEqual(returned_set, expected_set) ripe-atlas-tools-3.1.0/tests/renderers/test_traceroute_aspath.py000066400000000000000000000166331437041663000252100ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . from argparse import Namespace import json import unittest from ripe.atlas.sagan import Result from ripe.atlas.tools.renderers.traceroute_aspath import Renderer class TestTracerouteASPathRenderer(unittest.TestCase): # TODO: The AS lookups need to be mocked! def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.results = json.loads( '[{"af":4,"dst_addr":"194.0.25.10","dst_name":"194.0.25.10","endtime":1457447366,"from":"24.130.240.251","fw":4730,"group_id":3606560,"lts":115,"msm_id":3606560,"msm_name":"Traceroute","prb_id":12185,"proto":"ICMP","result":[{"hop":1,"result":[{"from":"192.168.2.254","rtt":0.527,"size":76,"ttl":64},{"from":"192.168.2.254","rtt":0.373,"size":76,"ttl":64},{"from":"192.168.2.254","rtt":0.325,"size":76,"ttl":64}]},{"hop":2,"result":[{"from":"96.120.89.13","ittl":0,"rtt":8.723,"size":28,"ttl":63},{"from":"96.120.89.13","ittl":0,"rtt":8.74,"size":28,"ttl":63},{"from":"96.120.89.13","ittl":0,"rtt":8.899,"size":28,"ttl":63}]},{"hop":3,"result":[{"from":"68.87.198.29","rtt":9.573,"size":68,"ttl":253},{"from":"68.87.198.29","rtt":8.938,"size":68,"ttl":253},{"from":"68.87.198.29","rtt":10.441,"size":68,"ttl":253}]},{"hop":4,"result":[{"from":"162.151.79.133","rtt":10.924,"size":68,"ttl":252},{"from":"162.151.79.133","rtt":11.039,"size":68,"ttl":252},{"from":"162.151.79.133","rtt":11.313,"size":68,"ttl":252}]},{"hop":5,"result":[{"from":"68.85.154.93","rtt":12.945,"size":68,"ttl":251},{"from":"68.85.154.93","rtt":11.193,"size":68,"ttl":251},{"from":"68.85.154.93","rtt":11.968,"size":68,"ttl":251}]},{"hop":6,"result":[{"from":"4.68.127.109","rtt":11.842,"size":76,"ttl":59},{"from":"4.68.127.109","rtt":12.573,"size":76,"ttl":59},{"from":"4.68.127.109","rtt":19.752,"size":76,"ttl":59}]},{"hop":7,"result":[{"from":"4.69.144.143","rtt":19.838,"size":28,"ttl":245},{"from":"4.69.144.143","rtt":19.709,"size":28,"ttl":245},{"from":"4.69.144.143","rtt":19.818,"size":28,"ttl":245}]},{"hop":8,"result":[{"from":"4.69.144.143","rtt":19.703,"size":28,"ttl":245},{"from":"4.69.144.143","rtt":20.591,"size":28,"ttl":245},{"from":"4.69.144.143","rtt":18.912,"size":28,"ttl":245}]},{"hop":9,"result":[{"from":"64.215.81.146","rtt":19.955,"size":28,"ttl":245},{"from":"64.215.81.146","rtt":19.629,"size":28,"ttl":245},{"from":"64.215.81.146","rtt":20.386,"size":28,"ttl":245}]},{"hop":10,"result":[{"from":"202.147.51.46","rtt":21.059,"size":28,"ttl":245},{"from":"202.147.51.46","rtt":24.6,"size":28,"ttl":245},{"from":"202.147.51.46","rtt":26.703,"size":28,"ttl":245}]},{"hop":11,"result":[{"from":"194.0.25.10","rtt":21.819,"size":48,"ttl":54},{"from":"194.0.25.10","rtt":20.215,"size":48,"ttl":54},{"from":"194.0.25.10","rtt":19.047,"size":48,"ttl":54}]}],"size":48,"src_addr":"192.168.2.91","timestamp":1457447365,"type":"traceroute"},{"af":4,"dst_addr":"194.0.25.10","dst_name":"194.0.25.10","endtime":1457447366,"from":"204.14.101.2","fw":4730,"group_id":3606560,"lts":25,"msm_id":3606560,"msm_name":"Traceroute","prb_id":22880,"proto":"ICMP","result":[{"hop":1,"result":[{"from":"192.168.1.1","rtt":0.824,"size":76,"ttl":64},{"from":"192.168.1.1","rtt":0.406,"size":76,"ttl":64},{"from":"192.168.1.1","rtt":0.359,"size":76,"ttl":64}]},{"hop":2,"result":[{"from":"192.168.2.254","rtt":0.547,"size":28,"ttl":63},{"from":"192.168.2.254","rtt":0.451,"size":28,"ttl":63},{"from":"192.168.2.254","rtt":0.454,"size":28,"ttl":63}]},{"hop":3,"result":[{"from":"10.32.128.1","rtt":12.876,"size":28,"ttl":253},{"from":"10.32.128.1","rtt":9.85,"size":28,"ttl":253},{"from":"10.32.128.1","rtt":9.656,"size":28,"ttl":253}]},{"hop":4,"result":[{"from":"10.32.255.1","rtt":10.112,"size":28,"ttl":61},{"from":"10.32.255.1","rtt":8.231,"size":28,"ttl":61},{"from":"10.32.255.1","rtt":14.477,"size":28,"ttl":61}]},{"hop":5,"result":[{"from":"204.14.96.221","rtt":11.434,"size":28,"ttl":251},{"from":"204.14.96.221","rtt":9.149,"size":28,"ttl":251},{"from":"204.14.96.221","rtt":11.625,"size":28,"ttl":251}]},{"hop":6,"result":[{"from":"204.106.235.2","rtt":11.714,"size":28,"ttl":250},{"from":"204.106.235.2","rtt":13.193,"size":28,"ttl":250},{"from":"204.106.235.2","rtt":16.916,"size":28,"ttl":250}]},{"hop":7,"result":[{"from":"206.81.80.40","rtt":15.283,"size":28,"ttl":58},{"from":"206.81.80.40","rtt":28.69,"size":28,"ttl":58},{"from":"206.81.80.40","rtt":27.795,"size":28,"ttl":58}]},{"hop":8,"result":[{"from":"72.52.92.157","rtt":33.901,"size":28,"ttl":57},{"from":"72.52.92.157","rtt":41.775,"size":28,"ttl":57},{"from":"72.52.92.157","rtt":38.496,"size":28,"ttl":57}]},{"hop":9,"result":[{"from":"216.218.192.234","rtt":31.631,"size":68,"ttl":238},{"from":"216.218.192.234","rtt":30.064,"size":68,"ttl":238},{"from":"216.218.192.234","rtt":29.304,"size":68,"ttl":238}]},{"hop":10,"result":[{"from":"202.147.61.206","rtt":40.974,"size":68,"ttl":238},{"from":"202.147.61.206","rtt":39.599,"size":68,"ttl":238},{"from":"202.147.61.206","rtt":40.409,"size":68,"ttl":238}]},{"hop":11,"result":[{"from":"202.147.58.142","rtt":41.353,"size":28,"ttl":238},{"from":"202.147.58.142","rtt":40.937,"size":28,"ttl":238},{"from":"202.147.58.142","rtt":39.937,"size":28,"ttl":238}]},{"hop":12,"result":[{"from":"202.147.51.46","rtt":41.58,"size":28,"ttl":237},{"from":"202.147.51.46","rtt":45.443,"size":28,"ttl":237},{"from":"202.147.51.46","rtt":41.242,"size":28,"ttl":237}]},{"hop":13,"result":[{"from":"194.0.25.10","rtt":41.256,"size":48,"ttl":45},{"from":"194.0.25.10","rtt":40.092,"size":48,"ttl":45},{"from":"194.0.25.10","rtt":40.657,"size":48,"ttl":45}]}],"size":48,"src_addr":"192.168.1.4","timestamp":1457447365,"type":"traceroute"}]' # noqa: E501 ) def run_renderer(self, traceroute_aspath_radius=2): args = Namespace( traceroute_aspath_radius=traceroute_aspath_radius, show_header=True, show_footer=True, ) renderer = Renderer(arguments=args) output = "" for res in self.results: output += renderer.on_result(Result.get(res)) output += renderer.footer() return output def test_basic(self): output = self.run_renderer() expected = """Probe #12185: AS4637 AS1921, completed Probe #22880: AS4637 AS1921, completed Number of probes for each AS path: AS4637 AS1921: 2 probes, 2 completed """ self.assertEqual(output.split("\n"), expected.split("\n")) def test_arg_radius(self): self.maxDiff = 1000 output = self.run_renderer(traceroute_aspath_radius=4) expected = """Probe #12185: AS3356 AS3549 AS4637 AS1921, completed Probe #22880: AS26088 AS6939 AS4637 AS1921, completed Number of probes for each AS path: AS3356 AS3549 AS4637 AS1921: 1 probe, 1 completed AS26088 AS6939 AS4637 AS1921: 1 probe, 1 completed """ self.assertEqual(output.split("\n"), expected.split("\n")) ripe-atlas-tools-3.1.0/tests/test_bash_completion.py000066400000000000000000000046331437041663000226450ustar00rootroot00000000000000import os import unittest import subprocess class BashCompletionTests(unittest.TestCase): """ Testing the Python level bash completion code. This requires setting up the environment as if we got passed data from bash. """ def setUp(self): os.environ["RIPE_ATLAS_AUTO_COMPLETE"] = "1" def _setup_env(self, substring): input_str = "ripe-atlas" + substring os.environ["COMP_WORDS"] = input_str comp_cword = len(input_str.split(" ")) - 1 # Index of the last word os.environ["COMP_CWORD"] = str(comp_cword) def _autocomplete(self, substring): self._setup_env(substring) cmd_parts = "ripe-atlas" + substring envs = os.environ.copy() process = subprocess.Popen( cmd_parts, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=envs, shell=True, ) output, error = process.communicate() return output.decode("utf-8"), error.decode("utf-8") def test_commands_completion(self): """Tests autocompletion of commands.""" input_str = " " output, error = self._autocomplete(input_str) print(output, error) self.assertTrue("report" in output) def test_completion_disable(self): """ Tests if autocompletion is disabled if environmental variable is not set. """ input_str = " mea" del os.environ["RIPE_ATLAS_AUTO_COMPLETE"] output, error = self._autocomplete(input_str) print(output, error) self.assertTrue("No such command" in error) def test_command_completion(self): """Tests autocompletion of specific command.""" input_str = " meas" output, error = self._autocomplete(input_str) print(output, error) self.assertTrue("measure" in output) def test_options_completion(self): """Tests autocompletion of existing options for a command.""" input_str = " measure " output, error = self._autocomplete(input_str) print(output, error) self.assertEqual(output, "dns http ntp ping spec sslcert traceroute") def test_option_completion(self): """Tests autocompletion of specific option of a command.""" input_str = " measure ping --h" output, error = self._autocomplete(input_str) print(output, error) self.assertEqual(output, "--help") ripe-atlas-tools-3.1.0/tests/test_docs.py000066400000000000000000000026121437041663000204220ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from sphinx.application import Sphinx class DocTest(unittest.TestCase): SOURCE_DIR = "docs" CONFIG_DIR = "docs" OUTPUT_DIR = "docs/build" DOCTREE_DIR = "docs/build/doctrees" def test_html_documentation(self): Sphinx( self.SOURCE_DIR, self.CONFIG_DIR, self.OUTPUT_DIR, self.DOCTREE_DIR, buildername="html", warningiserror=True, ).build(force_all=True) def test_text_documentation(self): Sphinx( self.SOURCE_DIR, self.CONFIG_DIR, self.OUTPUT_DIR, self.DOCTREE_DIR, buildername="text", warningiserror=False, ).build(force_all=True) ripe-atlas-tools-3.1.0/tests/test_filters.py000066400000000000000000000165101437041663000211440ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import unittest from ripe.atlas.sagan import Result from ripe.atlas.cousteau import Probe from ripe.atlas.tools.exceptions import RipeAtlasToolsException from ripe.atlas.tools.filters import FilterFactory, Filter, ASNFilter, filter_results class TestFilterFactory(unittest.TestCase): def test_factory_create(self): """Test factory create.""" self.assertIsInstance(FilterFactory.create("country", "GR"), Filter) self.assertIsInstance(FilterFactory.create("asn", "3333"), ASNFilter) class TestFilter(unittest.TestCase): def test_filter(self): """Tests filter method of general Filter class.""" result = { "af": 4, "prb_id": 1216, "result": [{"rtt": 27.429}, {"rtt": 25.672}, {"rtt": 25.681}], "ttl": 54, "avg": 26.2606666667, "size": 20, "from": "109.190.83.40", " proto": "ICMP", "timestamp": 1445025400, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 27.429, "step": 360, "src_addr": "192.168.103.132", "rcvd": 3, "msm_name": "Ping", "lts": 377, "dst_name": "hsi.cablecom.ch", "min": 25.672, "dst_addr": "62.2.16.24", } sagan_result = Result.get( result, on_error=Result.ACTION_IGNORE, on_warning=Result.ACTION_IGNORE ) sagan_result.probe = Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3337, "asn_v6": "4445"} ) self.assertTrue(Filter("country_code", "GR").filter(sagan_result)) self.assertFalse(Filter("country_code", "NL").filter(sagan_result)) self.assertFalse(Filter("asn_v4", 3336).filter(sagan_result)) self.assertTrue(Filter("asn_v6", "4445").filter(sagan_result)) with self.assertRaises(RipeAtlasToolsException): self.assertTrue(Filter("country", "GR").filter(sagan_result)) class TestASNFilter(unittest.TestCase): def test_filter(self): """Tests filter method of probe's asn filter class.""" result = { "af": 4, "prb_id": 1216, "result": [{"rtt": 27.429}, {"rtt": 25.672}, {"rtt": 25.681}], "ttl": 54, "avg": 26.2606666667, "size": 20, "from": "109.190.83.40", " proto": "ICMP", "timestamp": 1445025400, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 27.429, "step": 360, "src_addr": "192.168.103.132", "rcvd": 3, "msm_name": "Ping", "lts": 377, "dst_name": "hsi.cablecom.ch", "min": 25.672, "dst_addr": "62.2.16.24", } sagan_result = Result.get( result, on_error=Result.ACTION_IGNORE, on_warning=Result.ACTION_IGNORE ) sagan_result.probe = Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3337, "asn_v6": "4445"} ) self.assertTrue(ASNFilter(3337).filter(sagan_result)) self.assertFalse(ASNFilter(3336).filter(sagan_result)) self.assertTrue(ASNFilter("4445").filter(sagan_result)) self.assertFalse(ASNFilter(4445).filter(sagan_result)) class TestFilterResults(unittest.TestCase): def setUp(self): result = { "af": 4, "prb_id": 1216, "result": [{"rtt": 27.429}, {"rtt": 25.672}, {"rtt": 25.681}], "ttl": 54, "avg": 26.2606666667, "size": 20, "from": "109.190.83.40", " proto": "ICMP", "timestamp": 1445025400, "dup": 0, "type": "ping", "sent": 3, "msm_id": 1000192, "fw": 4700, "max": 27.429, "step": 360, "src_addr": "192.168.103.132", "rcvd": 3, "msm_name": "Ping", "lts": 377, "dst_name": "hsi.cablecom.ch", "min": 25.672, "dst_addr": "62.2.16.24", } probes = [ Probe( id=1216, meta_data={"country_code": "GR", "asn_v4": 3337, "asn_v6": "4445"}, ), Probe( id=121, meta_data={"country_code": "GR", "asn_v4": 3338, "asn_v6": "4445"}, ), Probe( id=12, meta_data={"country_code": "DE", "asn_v4": 3339, "asn_v6": 3337} ), Probe( id=1, meta_data={"country_code": "NL", "asn_v4": 3337, "asn_v6": "4446"} ), ] self.sagan_results = [] for probe in probes: sagan_result = Result.get( result, on_error=Result.ACTION_IGNORE, on_warning=Result.ACTION_IGNORE ) sagan_result.probe = probe self.sagan_results.append(sagan_result) def test_filter_results1(self): """Tests filter results where we have 3 results match with 2 filters.""" expected_results = [ self.sagan_results[0], self.sagan_results[2], self.sagan_results[3], ] filters = [ FilterFactory.create("asn", 3337), FilterFactory.create("country_code", "NL"), ] self.assertEqual(filter_results(filters, self.sagan_results), expected_results) def test_filter_results2(self): """Tests filter results where we have no results match with multiple filters.""" expected_results = [] filters = [ FilterFactory.create("asn", 3336), FilterFactory.create("country_code", "DK"), FilterFactory.create("asn_v6", "3"), ] self.assertEqual(filter_results(filters, self.sagan_results), expected_results) def test_filter_results3(self): """Tests filter results where we have success from one of the filters.""" expected_results = [self.sagan_results[3]] filters = [ FilterFactory.create("asn", 3336), FilterFactory.create("country_code", "NL"), ] self.assertEqual(filter_results(filters, self.sagan_results), expected_results) def test_filter_results4(self): """Tests filter results where we have success from both of the filters.""" expected_results = [self.sagan_results[3]] filters = [ FilterFactory.create("asn_v6", "4446"), FilterFactory.create("country_code", "NL"), ] self.assertEqual(filter_results(filters, self.sagan_results), expected_results) ripe-atlas-tools-3.1.0/tests/test_ipdetails.py000066400000000000000000000347271437041663000214640ustar00rootroot00000000000000# Copyright (c) 2015 RIPE NCC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import os import unittest import requests import shutil import tempfile from unittest import mock from ripe.atlas.tools.ipdetails import IP from ripe.atlas.tools.cache import LocalCache class FakeCache(LocalCache): def __init__(self): self.paths = [] LocalCache.__init__(self) def _get_or_create_db_path(self): path = os.path.join(tempfile.mkdtemp(), "ripe.atlas.tool.unittest") self.paths.append(path) return path def test_cleanup(self): for path in self.paths: shutil.rmtree(os.path.dirname(path)) fake_cache = FakeCache() class FakeResponse(object): def __init__(self, json_return={}, ok=True): self.json_return = json_return self.ok = ok self.text = "testing" def json(self): return self.json_return class FakeErrorResponse(FakeResponse): def json(self): raise ValueError("json breaks") class TestIPDetails(unittest.TestCase): IP = "193.0.6.1" ASN = "3333" HOLDER = ( "RIPE-NCC-AS Reseaux IP Europeens Network Coordination Centre (RIPE NCC),NL" ) SAME_PREFIX_IP = "193.0.6.2" PREFIX = "193.0.0.0/21" SAME_AS_DIFFERENT_PREFIX_IP = "193.0.22.1" NOT_ANNOUNCED_IP = "80.81.192.1" MOCK_RESULTS = { IP: { "status": "ok", "server_id": "stat-app2", "cached": False, "status_code": 200, "time": "2015-10-12T15:30:00.113317", "messages": [ [ "warning", "Given resource is not announced but result has been aligned to " "first-level less-specific (193.0.0.0/21).", ] ], "version": "1.3", "data_call_status": "supported - connecting to ursa", "see_also": [], "process_time": 561, "query_id": "196d2754-70f6-11e5-b8ba-782bcb346712", "data": { "query_time": "2015-10-12T08:00:00", "is_less_specific": True, "resource": "193.0.0.0/21", "actual_num_related": 0, "num_filtered_out": 0, "asns": [ { "holder": "RIPE-NCC-AS Reseaux IP Europeens Network " "Coordination Centre (RIPE NCC),NL", "asn": 3333, } ], "announced": True, "related_prefixes": [], "type": "prefix", "block": { "resource": "193.0.0.0/8", "name": "IANA IPv4 Address Space Registry", "desc": "RIPE NCC (Status: ALLOCATED)", }, }, }, SAME_AS_DIFFERENT_PREFIX_IP: { "status": "ok", "server_id": "stat-app2", "cached": False, "status_code": 200, "time": "2015-10-12T15:32:25.778643", "messages": [ [ "warning", "Given resource is not announced but result has been aligned to " "first-level less-specific (193.0.22.0/23).", ] ], "version": "1.3", "data_call_status": "supported - connecting to ursa", "see_also": [], "process_time": 818, "query_id": "7018b6cc-70f6-11e5-8bf8-782bcb346712", "data": { "query_time": "2015-10-12T08:00:00", "is_less_specific": True, "resource": "193.0.22.0/23", "actual_num_related": 0, "num_filtered_out": 0, "asns": [ { "holder": "RIPE-NCC-AS Reseaux IP Europeens Network " "Coordination Centre (RIPE NCC),NL", "asn": 3333, } ], "announced": True, "related_prefixes": [], "type": "prefix", "block": { "resource": "193.0.0.0/8", "name": "IANA IPv4 Address Space Registry", "desc": "RIPE NCC (Status: ALLOCATED)", }, }, }, NOT_ANNOUNCED_IP: { "status": "ok", "server_id": "stat-app2", "cached": False, "status_code": 200, "time": "2015-10-12T15:33:58.911309", "messages": [ ["info", "2 routes were filtered due to low visibility (min peers:3)."] ], "version": "1.3", "data_call_status": "supported - connecting to ursa", "see_also": [], "process_time": 462, "query_id": "a7d1daee-70f6-11e5-aaec-782bcb346712", "data": { "query_time": "2015-10-12T08:00:00", "is_less_specific": False, "resource": "80.81.192.1", "actual_num_related": 0, "num_filtered_out": 2, "asns": [], "announced": False, "related_prefixes": [], "type": "prefix", "block": { "resource": "80.0.0.0/8", "name": "IANA IPv4 Address Space Registry", "desc": "RIPE NCC (Status: ALLOCATED)", }, }, }, } def setUp(self): fake_cache.clear() self.mock_cache = mock.patch( "ripe.atlas.tools.ipdetails.cache", wraps=fake_cache ).start() self.mock_get = mock.patch("ripe.atlas.tools.ipdetails.requests.get").start() self.mock_get.return_value = FakeResponse( json_return=self.MOCK_RESULTS[self.IP] ) def tearDown(self): mock.patch.stopall() @classmethod def tearDownClass(cls): fake_cache._db.close() fake_cache.test_cleanup() def test_loopback4(self): """IPv4 loopback address""" det = IP("127.0.0.1") self.assertEqual(det.asn, None) self.assertEqual(det.is_querable(), False) # no query to stat self.assertEqual(self.mock_get.call_count, 0) # no access to cache get self.assertEqual(self.mock_cache.get.call_count, 0) def test_loopback6(self): """IPv6 loopback address""" det = IP("::1") self.assertEqual(det.asn, None) self.assertEqual(det.is_querable(), False) # no query to stat self.assertEqual(self.mock_get.call_count, 0) # no access to cache get self.assertEqual(self.mock_cache.get.call_count, 0) def test_nocache(self): """No cache""" det = IP(self.IP) self.assertEqual(det.asn, self.ASN) self.assertEqual(det.prefix, self.PREFIX) self.assertEqual(det.holder, self.HOLDER) # query to stat self.assertEqual(self.mock_get.call_count, 1) # access to cache get self.assertEqual(self.mock_cache.get.call_count, 1) # access to cache set self.assertEqual(self.mock_cache.set.call_count, 2) def test_fakecache_sameip(self): """Fake cache, same IP""" det = IP(self.IP) det = IP(self.IP) self.assertEqual(det.asn, self.ASN) # query to stat self.assertEqual(self.mock_get.call_count, 1) # access to cache get self.assertEqual(self.mock_cache.get.call_count, 2) # access to cache set self.assertEqual(self.mock_cache.set.call_count, 2) def test_fakecache_sameprefix(self): """Fake cache, same prefix""" det1 = IP(self.IP) det2 = IP(self.SAME_PREFIX_IP) self.assertEqual(det1.asn, self.ASN) self.assertEqual(det2.asn, det1.asn) # query to stat self.assertEqual(self.mock_get.call_count, 1) # access to cache get self.assertEqual(self.mock_cache.get.call_count, 3) # access to cache set self.assertEqual(self.mock_cache.set.call_count, 3) def test_fakecache_diffprefix(self): """Fake cache, same AS, different prefix""" self.mock_get.return_value = FakeResponse( json_return=self.MOCK_RESULTS[self.IP] ) det1 = IP(self.IP) self.mock_get.return_value = FakeResponse( json_return=self.MOCK_RESULTS[self.SAME_AS_DIFFERENT_PREFIX_IP] ) det2 = IP(self.SAME_AS_DIFFERENT_PREFIX_IP) self.assertEqual(det1.asn, self.ASN) self.assertEqual(det2.asn, det1.asn) self.assertEqual(self.mock_get.call_count, 2) # access to cache get self.assertEqual(self.mock_cache.get.call_count, 3) # access to cache set self.assertEqual(self.mock_cache.set.call_count, 4) def test_fakecache_notannounced(self): """Fake cache, IP not announced""" self.mock_get.return_value = FakeResponse( json_return=self.MOCK_RESULTS[self.NOT_ANNOUNCED_IP] ) det = IP(self.NOT_ANNOUNCED_IP) self.assertEqual(det.asn, None) self.assertEqual(self.mock_get.call_count, 1) IP(self.NOT_ANNOUNCED_IP) # now it should be cached self.assertEqual(det.asn, None) self.assertEqual(self.mock_get.call_count, 2) def test_valid_query_stat(self): """Test case for valid stat response""" ip = IP(self.IP) self.assertEqual( ip.query_stat(), { "Prefix": "193.0.0.0/21", "Holder": "RIPE-NCC-AS Reseaux IP Europeens Network " "Coordination Centre (RIPE NCC),NL", "ASN": "3333", }, ) def test_invalid_query_stat(self): """Test case where stat returns not ok status""" self.mock_get.return_value = FakeResponse(json_return={"status": "notok"}) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) self.mock_get.return_value = FakeResponse(json_return={}) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) def test_invalid_query_stat1(self): """Test case where stat returns not valid data structure""" # no data at all self.mock_get.return_value = FakeResponse(json_return={"status": "ok"}) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) # data is dict but no asns key self.mock_get.return_value = FakeResponse( json_return={"status": "ok", "data": {"bla": "bla"}} ) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) # data is not dict self.mock_get.return_value = FakeResponse( json_return={"status": "ok", "data": [1, 2]} ) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) # asns is not list self.mock_get.return_value = FakeResponse( json_return={"status": "ok", "data": {"asns": {}}} ) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) # asns is empty self.mock_get.return_value = FakeResponse( json_return={"status": "ok", "data": {"asns": [{}]}} ) ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) def test_invalid_query_stat2(self): """Test case where stat returns exception""" self.mock_get.side_effect = requests.exceptions.RequestException ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) self.mock_get.return_value = FakeErrorResponse() ip = IP(self.IP) self.assertEqual(ip.query_stat(), {}) def test_update_cache(self): """Test case where we store both prefix/address""" details = { "Prefix": "193.0.0.0/21", "Holder": "RIPE-NCC-AS Reseaux IP Europeens Network " "Coordination Centre (RIPE NCC),NL", "ASN": "3333", } IP(self.IP) self.assertEqual(self.mock_cache.set.call_count, 2) self.assertEqual(self.mock_cache.get("IPDetails:193.0.6.1"), details) self.assertEqual(self.mock_cache.get("IPDetailsPrefix:193.0.0.0/21"), details) def test_update_cache1(self): """Test case where we store only address""" details = { "Prefix": "193.0.0.0/21", "Holder": "RIPE-NCC-AS Reseaux IP Europeens Network " "Coordination Centre (RIPE NCC),NL", "ASN": "3333", } self.mock_cache.set("IPDetailsPrefix:193.0.0.0/21", details, 1) IP(self.IP) # we already called it above, so it should be 2 by bow self.assertEqual(self.mock_cache.set.call_count, 2) self.assertEqual(self.mock_cache.get("IPDetails:193.0.6.1"), details) self.assertEqual(self.mock_cache.get("IPDetailsPrefix:193.0.0.0/21"), details) def test_get_from_cache_prefix(self): """Test case where we have a matching prefix in cache""" details = {"Prefix": "193.0.0.0/21", "Holder": "test", "ASN": "test"} self.mock_cache.set("IPDetailsPrefix:193.0.0.0/20", details, 1) ip = IP(self.IP) self.assertTrue(ip.cached_prefix_found) self.assertEqual(ip.asn, "test") self.assertEqual(ip.holder, "test") self.assertEqual(ip.get_from_cached_prefix(), details) def test_get_from_cache_prefix1(self): """Test case where we dont' have a matching prefix in cache""" ip = IP(self.IP) # clear out db to test specific function self.mock_cache.clear() self.assertFalse(ip.cached_prefix_found) self.assertEqual(ip.get_from_cached_prefix(), None) def test_is_querable(self): """Test case where IP is quearable""" ip = IP(self.IP) self.assertTrue(ip.is_querable()) def test_is_querable1(self): """Test case where IP is not quearable""" ip = IP("127.0.0.1") self.assertFalse(ip.is_querable()) ripe-atlas-tools-3.1.0/tox.ini000066400000000000000000000002421437041663000162270ustar00rootroot00000000000000[testenv] deps = flake8 pytest sphinx commands = flake8 --max-line-length=88 setup.py ripe/atlas/tools/ scripts/ tests/ pytest -r a {posargs}